diff --git a/libs/image/kis_image_config.cpp b/libs/image/kis_image_config.cpp
index 6663aade57..014aef52ab 100644
--- a/libs/image/kis_image_config.cpp
+++ b/libs/image/kis_image_config.cpp
@@ -1,521 +1,588 @@
 /*
  *  Copyright (c) 2010 Dmitry Kazakov <dimula73@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_image_config.h"
 
 #include <ksharedconfig.h>
 
 #include <KoConfig.h>
 #include <KoColorProfile.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorConversionTransformation.h>
 
 #include "kis_debug.h"
 
 #include <QThread>
 #include <QApplication>
 #include <QColor>
 #include <QDir>
 
 #include "kis_global.h"
 #include <cmath>
 
 #ifdef Q_OS_OSX
 #include <errno.h>
 #endif
 
 KisImageConfig::KisImageConfig(bool readOnly)
     : m_config( KSharedConfig::openConfig()->group(QString())),
       m_readOnly(readOnly)
 {
 #ifdef Q_OS_OSX
     // clear /var/folders/ swap path set by old broken Krita swap implementation in order to use new default swap dir.
     QString swap = m_config.readEntry("swaplocation", "");
     if (swap.startsWith("/var/folders/")) {
         m_config.deleteEntry("swaplocation");
     }
 #endif
 }
 
 KisImageConfig::~KisImageConfig()
 {
     if (m_readOnly) return;
 
     if (qApp->thread() != QThread::currentThread()) {
         dbgKrita << "KisImageConfig: requested config synchronization from nonGUI thread! Called from" << kisBacktrace();
         return;
     }
 
     m_config.sync();
 }
 
 bool KisImageConfig::enableProgressReporting(bool requestDefault) const
 {
     return !requestDefault ?
         m_config.readEntry("enableProgressReporting", true) : true;
 }
 
 void KisImageConfig::setEnableProgressReporting(bool value)
 {
     m_config.writeEntry("enableProgressReporting", value);
 }
 
 bool KisImageConfig::enablePerfLog(bool requestDefault) const
 {
     return !requestDefault ?
         m_config.readEntry("enablePerfLog", false) :false;
 }
 
 void KisImageConfig::setEnablePerfLog(bool value)
 {
     m_config.writeEntry("enablePerfLog", value);
 }
 
 qreal KisImageConfig::transformMaskOffBoundsReadArea() const
 {
     return m_config.readEntry("transformMaskOffBoundsReadArea", 0.5);
 }
 
 int KisImageConfig::updatePatchHeight() const
 {
     return m_config.readEntry("updatePatchHeight", 512);
 }
 
 void KisImageConfig::setUpdatePatchHeight(int value)
 {
     m_config.writeEntry("updatePatchHeight", value);
 }
 
 int KisImageConfig::updatePatchWidth() const
 {
     return m_config.readEntry("updatePatchWidth", 512);
 }
 
 void KisImageConfig::setUpdatePatchWidth(int value)
 {
     m_config.writeEntry("updatePatchWidth", value);
 }
 
 qreal KisImageConfig::maxCollectAlpha() const
 {
     return m_config.readEntry("maxCollectAlpha", 2.5);
 }
 
 qreal KisImageConfig::maxMergeAlpha() const
 {
     return m_config.readEntry("maxMergeAlpha", 1.);
 }
 
 qreal KisImageConfig::maxMergeCollectAlpha() const
 {
     return m_config.readEntry("maxMergeCollectAlpha", 1.5);
 }
 
 qreal KisImageConfig::schedulerBalancingRatio() const
 {
     /**
      * updates-queue-size / strokes-queue-size
      */
     return m_config.readEntry("schedulerBalancingRatio", 100.);
 }
 
 void KisImageConfig::setSchedulerBalancingRatio(qreal value)
 {
     m_config.writeEntry("schedulerBalancingRatio", value);
 }
 
 int KisImageConfig::maxSwapSize(bool requestDefault) const
 {
     return !requestDefault ?
         m_config.readEntry("maxSwapSize", 4096) : 4096; // in MiB
 }
 
 void KisImageConfig::setMaxSwapSize(int value)
 {
     m_config.writeEntry("maxSwapSize", value);
 }
 
 int KisImageConfig::swapSlabSize() const
 {
     return m_config.readEntry("swapSlabSize", 64); // in MiB
 }
 
 void KisImageConfig::setSwapSlabSize(int value)
 {
     m_config.writeEntry("swapSlabSize", value);
 }
 
 int KisImageConfig::swapWindowSize() const
 {
     return m_config.readEntry("swapWindowSize", 16); // in MiB
 }
 
 void KisImageConfig::setSwapWindowSize(int value)
 {
     m_config.writeEntry("swapWindowSize", value);
 }
 
 int KisImageConfig::tilesHardLimit() const
 {
     qreal hp = qreal(memoryHardLimitPercent()) / 100.0;
     qreal pp = qreal(memoryPoolLimitPercent()) / 100.0;
 
     return totalRAM() * hp * (1 - pp);
 }
 
 int KisImageConfig::tilesSoftLimit() const
 {
     qreal sp = qreal(memorySoftLimitPercent()) / 100.0;
 
     return tilesHardLimit() * sp;
 }
 
 int KisImageConfig::poolLimit() const
 {
     qreal hp = qreal(memoryHardLimitPercent()) / 100.0;
     qreal pp = qreal(memoryPoolLimitPercent()) / 100.0;
 
     return totalRAM() * hp * pp;
 }
 
 qreal KisImageConfig::memoryHardLimitPercent(bool requestDefault) const
 {
     return !requestDefault ?
         m_config.readEntry("memoryHardLimitPercent", 50.) : 50.;
 }
 
 void KisImageConfig::setMemoryHardLimitPercent(qreal value)
 {
     m_config.writeEntry("memoryHardLimitPercent", value);
 }
 
 qreal KisImageConfig::memorySoftLimitPercent(bool requestDefault) const
 {
     return !requestDefault ?
         m_config.readEntry("memorySoftLimitPercent", 2.) : 2.;
 }
 
 void KisImageConfig::setMemorySoftLimitPercent(qreal value)
 {
     m_config.writeEntry("memorySoftLimitPercent", value);
 }
 
 qreal KisImageConfig::memoryPoolLimitPercent(bool requestDefault) const
 {
     return !requestDefault ?
         m_config.readEntry("memoryPoolLimitPercent", 0.0) : 0.0;
 }
 
 void KisImageConfig::setMemoryPoolLimitPercent(qreal value)
 {
     m_config.writeEntry("memoryPoolLimitPercent", value);
 }
 
-QString KisImageConfig::swapDir(bool requestDefault)
+QString KisImageConfig::safelyGetWritableTempLocation(const QString &suffix, const QString &configKey, bool requestDefault) const
 {
 #ifdef Q_OS_OSX
     // On OSX, QDir::tempPath() gives us a folder we cannot reply upon (usually
     // something like /var/folders/.../...) and that will have vanished when we
     // try to create the tmp file in KisMemoryWindow::KisMemoryWindow using
     // swapFileTemplate. thus, we just pick the home folder if swapDir does not
     // tell us otherwise.
 
     // the other option here would be to use a "garbled name" temp file (i.e. no name
     // KRITA_SWAP_FILE_XXXXXX) in an obscure /var/folders place, which is not
     // nice to the user. having a clearly named swap file in the home folder is
     // much nicer to Krita's users.
 
     // furthermore, this is just a default and swapDir can always be configured
     // to another location.
 
-    QString swap = QStandardPaths::writableLocation(QStandardPaths::AppLocalDataLocation) + "/swap";
+    QString swap = QStandardPaths::writableLocation(QStandardPaths::AppLocalDataLocation) + QDir::separator() + suffix;
 #else
+    Q_UNUSED(suffix);
     QString swap = QDir::tempPath();
 #endif
     if (requestDefault) {
        return swap;
     }
-    QString configuredSwap = m_config.readEntry("swaplocation", swap);
+    const QString configuredSwap = m_config.readEntry(configKey, swap);
     if (!configuredSwap.isEmpty()) {
         swap = configuredSwap;
     }
     return swap;
 }
 
+
+QString KisImageConfig::swapDir(bool requestDefault)
+{
+    return safelyGetWritableTempLocation("swap", "swaplocation", requestDefault);
+}
+
 void KisImageConfig::setSwapDir(const QString &swapDir)
 {
     m_config.writeEntry("swaplocation", swapDir);
 }
 
 int KisImageConfig::numberOfOnionSkins() const
 {
     return m_config.readEntry("numberOfOnionSkins", 10);
 }
 
 void KisImageConfig::setNumberOfOnionSkins(int value)
 {
     m_config.writeEntry("numberOfOnionSkins", value);
 }
 
 int KisImageConfig::onionSkinTintFactor() const
 {
     return m_config.readEntry("onionSkinTintFactor", 192);
 }
 
 void KisImageConfig::setOnionSkinTintFactor(int value)
 {
     m_config.writeEntry("onionSkinTintFactor", value);
 }
 
 int KisImageConfig::onionSkinOpacity(int offset) const
 {
     int value = m_config.readEntry("onionSkinOpacity_" + QString::number(offset), -1);
 
     if (value < 0) {
         const int num = numberOfOnionSkins();
         const qreal dx = qreal(qAbs(offset)) / num;
         value = 0.7 * exp(-pow2(dx) / 0.5) * 255;
     }
 
     return value;
 }
 
 void KisImageConfig::setOnionSkinOpacity(int offset, int value)
 {
     m_config.writeEntry("onionSkinOpacity_" + QString::number(offset), value);
 }
 
 bool KisImageConfig::onionSkinState(int offset) const
 {
     bool enableByDefault = (qAbs(offset) <= 2);
     return m_config.readEntry("onionSkinState_" + QString::number(offset), enableByDefault);
 }
 
 void KisImageConfig::setOnionSkinState(int offset, bool value)
 {
     m_config.writeEntry("onionSkinState_" + QString::number(offset), value);
 }
 
 QColor KisImageConfig::onionSkinTintColorBackward() const
 {
     return m_config.readEntry("onionSkinTintColorBackward", QColor(Qt::red));
 }
 
 void KisImageConfig::setOnionSkinTintColorBackward(const QColor &value)
 {
     m_config.writeEntry("onionSkinTintColorBackward", value);
 }
 
 QColor KisImageConfig::onionSkinTintColorForward() const
 {
     return m_config.readEntry("oninSkinTintColorForward", QColor(Qt::green));
 }
 
 void KisImageConfig::setOnionSkinTintColorForward(const QColor &value)
 {
     m_config.writeEntry("oninSkinTintColorForward", value);
 }
 
 bool KisImageConfig::lazyFrameCreationEnabled(bool requestDefault) const
 {
     return !requestDefault ?
         m_config.readEntry("lazyFrameCreationEnabled", true) : true;
 }
 
 void KisImageConfig::setLazyFrameCreationEnabled(bool value)
 {
     m_config.writeEntry("lazyFrameCreationEnabled", value);
 }
 
 
 #if defined Q_OS_LINUX
 #include <sys/sysinfo.h>
 #elif defined Q_OS_FREEBSD || defined Q_OS_NETBSD || defined Q_OS_OPENBSD
 #include <sys/sysctl.h>
 #elif defined Q_OS_WIN
 #include <windows.h>
 #elif defined Q_OS_OSX
 #include <sys/types.h>
 #include <sys/sysctl.h>
 #endif
 
 #include <kis_debug.h>
 
 int KisImageConfig::totalRAM()
 {
     // let's think that default memory size is 1000MiB
     int totalMemory = 1000; // MiB
     int error = 1;
 
 #if defined Q_OS_LINUX
     struct sysinfo info;
 
     error = sysinfo(&info);
     if(!error) {
         totalMemory = info.totalram * info.mem_unit / (1UL << 20);
     }
 #elif defined Q_OS_FREEBSD || defined Q_OS_NETBSD || defined Q_OS_OPENBSD
     u_long physmem;
 #   if defined HW_PHYSMEM64 // NetBSD only
     int mib[] = {CTL_HW, HW_PHYSMEM64};
 #   else
     int mib[] = {CTL_HW, HW_PHYSMEM};
 #   endif
     size_t len = sizeof(physmem);
 
     error = sysctl(mib, 2, &physmem, &len, 0, 0);
     if(!error) {
         totalMemory = physmem >> 20;
     }
 #elif defined Q_OS_WIN
     MEMORYSTATUSEX status;
     status.dwLength = sizeof(status);
     error  = !GlobalMemoryStatusEx(&status);
 
     if (!error) {
         totalMemory = status.ullTotalPhys >> 20;
     }
 
     // For 32 bit windows, the total memory available is at max the 2GB per process memory limit.
 #   if defined ENV32BIT
     totalMemory = qMin(totalMemory, 2000);
 #   endif
 #elif defined Q_OS_OSX
     int mib[2] = { CTL_HW, HW_MEMSIZE };
     u_int namelen = sizeof(mib) / sizeof(mib[0]);
     uint64_t size;
     size_t len = sizeof(size);
 
     errno = 0;
     if (sysctl(mib, namelen, &size, &len, 0, 0) >= 0) {
         totalMemory = size >> 20;
         error = 0;
     }
     else {
         dbgKrita << "sysctl(\"hw.memsize\") raised error" << strerror(errno);
     }
 #endif
 
     if (error) {
         warnKrita << "Cannot get the size of your RAM. Using 1 GiB by default.";
     }
 
     return totalMemory;
 }
 
 bool KisImageConfig::showAdditionalOnionSkinsSettings(bool requestDefault) const
 {
     return !requestDefault ?
         m_config.readEntry("showAdditionalOnionSkinsSettings", true) : true;
 }
 
 void KisImageConfig::setShowAdditionalOnionSkinsSettings(bool value)
 {
     m_config.writeEntry("showAdditionalOnionSkinsSettings", value);
 }
 
 int KisImageConfig::defaultFrameColorLabel() const
 {
     return m_config.readEntry("defaultFrameColorLabel", 0);
 }
 
 void KisImageConfig::setDefaultFrameColorLabel(int label)
 {
     m_config.writeEntry("defaultFrameColorLabel", label);
 }
 
 KisProofingConfigurationSP KisImageConfig::defaultProofingconfiguration()
 {
     KisProofingConfiguration *proofingConfig= new KisProofingConfiguration();
     proofingConfig->proofingProfile = m_config.readEntry("defaultProofingProfileName", "Chemical proof");
     proofingConfig->proofingModel = m_config.readEntry("defaultProofingProfileModel", "CMYKA");
     proofingConfig->proofingDepth = m_config.readEntry("defaultProofingProfileDepth", "U8");
     proofingConfig->intent = (KoColorConversionTransformation::Intent)m_config.readEntry("defaultProofingProfileIntent", 3);
     if (m_config.readEntry("defaultProofingBlackpointCompensation", true)) {
         proofingConfig->conversionFlags  |= KoColorConversionTransformation::ConversionFlag::BlackpointCompensation;
     } else {
         proofingConfig->conversionFlags  = proofingConfig->conversionFlags & ~KoColorConversionTransformation::ConversionFlag::BlackpointCompensation;
     }
     QColor def(Qt::green);
     m_config.readEntry("defaultProofingGamutwarning", def);
     KoColor col(KoColorSpaceRegistry::instance()->rgb8());
     col.fromQColor(def);
     col.setOpacity(1.0);
     proofingConfig->warningColor = col;
     proofingConfig->adaptationState = (double)m_config.readEntry("defaultProofingAdaptationState", 1.0);
     return toQShared(proofingConfig);
 }
 
 void KisImageConfig::setDefaultProofingConfig(const KoColorSpace *proofingSpace, int proofingIntent, bool blackPointCompensation, KoColor warningColor, double adaptationState)
 {
     m_config.writeEntry("defaultProofingProfileName", proofingSpace->profile()->name());
     m_config.writeEntry("defaultProofingProfileModel", proofingSpace->colorModelId().id());
     m_config.writeEntry("defaultProofingProfileDepth", proofingSpace->colorDepthId().id());
     m_config.writeEntry("defaultProofingProfileIntent", proofingIntent);
     m_config.writeEntry("defaultProofingBlackpointCompensation", blackPointCompensation);
     QColor c;
     c = warningColor.toQColor();
     m_config.writeEntry("defaultProofingGamutwarning", c);
     m_config.writeEntry("defaultProofingAdaptationState",adaptationState);
 }
 
 bool KisImageConfig::useLodForColorizeMask(bool requestDefault) const
 {
     return !requestDefault ?
         m_config.readEntry("useLodForColorizeMask", false) : false;
 }
 
 void KisImageConfig::setUseLodForColorizeMask(bool value)
 {
     m_config.writeEntry("useLodForColorizeMask", value);
 }
 
 int KisImageConfig::maxNumberOfThreads(bool defaultValue) const
 {
     return (defaultValue ? QThread::idealThreadCount() : m_config.readEntry("maxNumberOfThreads", QThread::idealThreadCount()));
 }
 
 void KisImageConfig::setMaxNumberOfThreads(int value)
 {
     if (value == QThread::idealThreadCount()) {
         m_config.deleteEntry("maxNumberOfThreads");
     } else {
         m_config.writeEntry("maxNumberOfThreads", value);
     }
 }
 
 int KisImageConfig::frameRenderingClones(bool defaultValue) const
 {
     const int defaultClonesCount = qMax(1, maxNumberOfThreads(defaultValue) / 2);
     return defaultValue ? defaultClonesCount : m_config.readEntry("frameRenderingClones", defaultClonesCount);
 }
 
 void KisImageConfig::setFrameRenderingClones(int value)
 {
     m_config.writeEntry("frameRenderingClones", value);
 }
 
 int KisImageConfig::fpsLimit(bool defaultValue) const
 {
     return defaultValue ? 100 : m_config.readEntry("fpsLimit", 100);
 }
 
 void KisImageConfig::setFpsLimit(int value)
 {
     m_config.writeEntry("fpsLimit", value);
 }
+
+bool KisImageConfig::useOnDiskAnimationCacheSwapping(bool defaultValue) const
+{
+    return defaultValue ? true : m_config.readEntry("useOnDiskAnimationCacheSwapping", true);
+}
+
+void KisImageConfig::setUseOnDiskAnimationCacheSwapping(bool value)
+{
+    m_config.writeEntry("useOnDiskAnimationCacheSwapping", value);
+}
+
+QString KisImageConfig::animationCacheDir(bool defaultValue) const
+{
+    return safelyGetWritableTempLocation("animation_cache", "animationCacheDir", defaultValue);
+}
+
+void KisImageConfig::setAnimationCacheDir(const QString &value)
+{
+    m_config.writeEntry("animationCacheDir", value);
+}
+
+bool KisImageConfig::useAnimationCacheFrameSizeLimit(bool defaultValue) const
+{
+    return defaultValue ? true : m_config.readEntry("useAnimationCacheFrameSizeLimit", true);
+}
+
+void KisImageConfig::setUseAnimationCacheFrameSizeLimit(bool value)
+{
+    m_config.writeEntry("useAnimationCacheFrameSizeLimit", value);
+}
+
+int KisImageConfig::animationCacheFrameSizeLimit(bool defaultValue) const
+{
+    return defaultValue ? 2500 : m_config.readEntry("animationCacheFrameSizeLimit", 2500);
+}
+
+void KisImageConfig::setAnimationCacheFrameSizeLimit(int value)
+{
+    m_config.writeEntry("animationCacheFrameSizeLimit", value);
+}
+
+bool KisImageConfig::useAnimationCacheRegionOfInterest(bool defaultValue) const
+{
+    return defaultValue ? true : m_config.readEntry("useAnimationCacheRegionOfInterest", true);
+}
+
+void KisImageConfig::setUseAnimationCacheRegionOfInterest(bool value)
+{
+    m_config.writeEntry("useAnimationCacheRegionOfInterest", value);
+}
+
+qreal KisImageConfig::animationCacheRegionOfInterestMargin(bool defaultValue) const
+{
+    return defaultValue ? 0.25 : m_config.readEntry("animationCacheRegionOfInterestMargin", 0.25);
+}
+
+void KisImageConfig::setAnimationCacheRegionOfInterestMargin(qreal value)
+{
+    m_config.writeEntry("animationCacheRegionOfInterestMargin", value);
+}
diff --git a/libs/image/kis_image_config.h b/libs/image/kis_image_config.h
index b701c1d2ab..78ba9f02b5 100644
--- a/libs/image/kis_image_config.h
+++ b/libs/image/kis_image_config.h
@@ -1,133 +1,153 @@
 /*
  *  Copyright (c) 2010 Dmitry Kazakov <dimula73@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_IMAGE_CONFIG_H_
 #define KIS_IMAGE_CONFIG_H_
 
 #include <kconfiggroup.h>
 #include "kritaimage_export.h"
 #include "KisProofingConfiguration.h"
 #include "kis_types.h"
 
 class KRITAIMAGE_EXPORT KisImageConfig
 {
 public:
     KisImageConfig(bool readOnly = false);
     ~KisImageConfig();
 
     bool enableProgressReporting(bool requestDefault = false) const;
     void setEnableProgressReporting(bool value);
 
     bool enablePerfLog(bool requestDefault = false) const;
     void setEnablePerfLog(bool value);
 
     qreal transformMaskOffBoundsReadArea() const;
 
     int updatePatchHeight() const;
     void setUpdatePatchHeight(int value);
     int updatePatchWidth() const;
     void setUpdatePatchWidth(int value);
 
     qreal maxCollectAlpha() const;
     qreal maxMergeAlpha() const;
     qreal maxMergeCollectAlpha() const;
     qreal schedulerBalancingRatio() const;
     void setSchedulerBalancingRatio(qreal value);
 
     int maxSwapSize(bool requestDefault = false) const;
     void setMaxSwapSize(int value);
 
     int swapSlabSize() const;
     void setSwapSlabSize(int value);
 
     int swapWindowSize() const;
     void setSwapWindowSize(int value);
 
     int tilesHardLimit() const; // MiB
     int tilesSoftLimit() const; // MiB
     int poolLimit() const; // MiB
 
     qreal memoryHardLimitPercent(bool requestDefault = false) const; // % of total RAM
     qreal memorySoftLimitPercent(bool requestDefault = false) const; // % of memoryHardLimitPercent() * (1 - 0.01 * memoryPoolLimitPercent())
     qreal memoryPoolLimitPercent(bool requestDefault = false) const; // % of memoryHardLimitPercent()
     void setMemoryHardLimitPercent(qreal value);
     void setMemorySoftLimitPercent(qreal value);
     void setMemoryPoolLimitPercent(qreal value);
 
     static int totalRAM(); // MiB
 
     /**
      * @return a specific directory for the swapfile, if set. If not set, return an
      * empty QString and use the default KDE directory.
      */
     QString swapDir(bool requestDefault = false);
     void setSwapDir(const QString &swapDir);
 
     int numberOfOnionSkins() const;
     void setNumberOfOnionSkins(int value);
 
     int onionSkinTintFactor() const;
     void setOnionSkinTintFactor(int value);
 
     int onionSkinOpacity(int offset) const;
     void setOnionSkinOpacity(int offset, int value);
 
     bool onionSkinState(int offset) const;
     void setOnionSkinState(int offset, bool value);
 
     QColor onionSkinTintColorBackward() const;
     void setOnionSkinTintColorBackward(const QColor &value);
 
     QColor onionSkinTintColorForward() const;
     void setOnionSkinTintColorForward(const QColor &value);
 
     bool lazyFrameCreationEnabled(bool requestDefault = false) const;
     void setLazyFrameCreationEnabled(bool value);
 
     bool showAdditionalOnionSkinsSettings(bool requestDefault = false) const;
     void setShowAdditionalOnionSkinsSettings(bool value);
 
     int defaultFrameColorLabel() const;
     void setDefaultFrameColorLabel(int label);
 
     KisProofingConfigurationSP defaultProofingconfiguration();
     void setDefaultProofingConfig(const KoColorSpace *proofingSpace, int proofingIntent, bool blackPointCompensation, KoColor warningColor, double adaptationState);
 
     bool useLodForColorizeMask(bool requestDefault = false) const;
     void setUseLodForColorizeMask(bool value);
 
     int maxNumberOfThreads(bool defaultValue = false) const;
     void setMaxNumberOfThreads(int value);
 
     int frameRenderingClones(bool defaultValue = false) const;
     void setFrameRenderingClones(int value);
 
     int fpsLimit(bool defaultValue = false) const;
     void setFpsLimit(int value);
 
+    bool useOnDiskAnimationCacheSwapping(bool defaultValue = false) const;
+    void setUseOnDiskAnimationCacheSwapping(bool value);
+
+    QString animationCacheDir(bool defaultValue = false) const;
+    void setAnimationCacheDir(const QString &value);
+
+    bool useAnimationCacheFrameSizeLimit(bool defaultValue = false) const;
+    void setUseAnimationCacheFrameSizeLimit(bool value);
+
+    int animationCacheFrameSizeLimit(bool defaultValue = false) const;
+    void setAnimationCacheFrameSizeLimit(int value);
+
+    bool useAnimationCacheRegionOfInterest(bool defaultValue = false) const;
+    void setUseAnimationCacheRegionOfInterest(bool value);
+
+    qreal animationCacheRegionOfInterestMargin(bool defaultValue = false) const;
+    void setAnimationCacheRegionOfInterestMargin(qreal value);
+
 private:
     Q_DISABLE_COPY(KisImageConfig)
 
+    QString safelyGetWritableTempLocation(const QString &suffix, const QString &configKey, bool requestDefault) const;
+
 private:
     KConfigGroup m_config;
     bool m_readOnly;
 };
 
 
 #endif /* KIS_IMAGE_CONFIG_H_ */
 
diff --git a/libs/image/kis_paint_device.cc b/libs/image/kis_paint_device.cc
index 83f0f363e3..a331359180 100644
--- a/libs/image/kis_paint_device.cc
+++ b/libs/image/kis_paint_device.cc
@@ -1,2172 +1,2208 @@
 /*
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (c) 2004 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_paint_device.h"
 
 #include <QRect>
 #include <QTransform>
 #include <QImage>
 #include <QList>
 #include <QHash>
 #include <QIODevice>
 #include <qmath.h>
 
 #include <klocalizedstring.h>
 
 #include <KoChannelInfo.h>
 #include <KoColorProfile.h>
 #include <KoColor.h>
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorModelStandardIds.h>
 #include <KoIntegerMaths.h>
 #include <KoMixColorsOp.h>
 #include <KoUpdater.h>
 
 #include "kis_image.h"
 #include "kis_random_sub_accessor.h"
 #include "kis_selection.h"
 #include "kis_node.h"
 #include "kis_datamanager.h"
 #include "kis_paint_device_writer.h"
 #include "kis_selection_component.h"
 #include "kis_pixel_selection.h"
 #include "kis_repeat_iterators_pixel.h"
 #include "kis_fixed_paint_device.h"
 
 #include "tiles3/kis_hline_iterator.h"
 #include "tiles3/kis_vline_iterator.h"
 #include "tiles3/kis_random_accessor.h"
 
 #include "kis_default_bounds.h"
 
 #include "kis_lod_transform.h"
 
 #include "kis_raster_keyframe_channel.h"
 
 #include "kis_paint_device_cache.h"
 #include "kis_paint_device_data.h"
 #include "kis_paint_device_frames_interface.h"
 
 #include "kis_transform_worker.h"
 #include "kis_filter_strategy.h"
 #include "krita_utils.h"
 
 
 struct KisPaintDeviceSPStaticRegistrar {
     KisPaintDeviceSPStaticRegistrar() {
         qRegisterMetaType<KisPaintDeviceSP>("KisPaintDeviceSP");
     }
 };
 static KisPaintDeviceSPStaticRegistrar __registrar;
 
 
 
 struct KisPaintDevice::Private
 {
     /**
      * Used when the paint device is loading to ensure no lod/animation
      * interferes the process.
      */
     static const KisDefaultBoundsSP transitionalDefaultBounds;
 
 public:
 
     class KisPaintDeviceStrategy;
     class KisPaintDeviceWrappedStrategy;
 
     Private(KisPaintDevice *paintDevice);
     ~Private();
 
     KisPaintDevice *q;
     KisNodeWSP parent;
     QScopedPointer<KisRasterKeyframeChannel> contentChannel;
     KisDefaultBoundsBaseSP defaultBounds;
     QScopedPointer<KisPaintDeviceStrategy> basicStrategy;
     QScopedPointer<KisPaintDeviceWrappedStrategy> wrappedStrategy;
     QMutex m_wrappedStrategyMutex;
 
     QScopedPointer<KisPaintDeviceFramesInterface> framesInterface;
     bool isProjectionDevice;
 
     KisPaintDeviceStrategy* currentStrategy();
 
     void init(const KoColorSpace *cs, const quint8 *defaultPixel);
     KUndo2Command* convertColorSpace(const KoColorSpace * dstColorSpace, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags);
     bool assignProfile(const KoColorProfile * profile);
 
     inline const KoColorSpace* colorSpace() const
     {
         return currentData()->colorSpace();
     }
     inline KisDataManagerSP dataManager() const
     {
         return currentData()->dataManager();
     }
 
     inline qint32 x() const
     {
         return currentData()->x();
     }
     inline qint32 y() const
     {
         return currentData()->y();
     }
     inline void setX(qint32 x)
     {
         currentData()->setX(x);
     }
     inline void setY(qint32 y)
     {
         currentData()->setY(y);
     }
 
     inline KisPaintDeviceCache* cache()
     {
         return currentData()->cache();
     }
 
     inline KisIteratorCompleteListener* cacheInvalidator() {
         return currentData()->cacheInvalidator();
     }
 
 
     void cloneAllDataObjects(Private *rhs, bool copyFrames)
     {
 
         m_lodData.reset();
         m_externalFrameData.reset();
 
         if (!m_frames.isEmpty()) {
             m_frames.clear();
         }
 
         if (!copyFrames) {
             if (m_data) {
                 m_data->prepareClone(rhs->currentNonLodData(), true);
             } else {
                 m_data = toQShared(new KisPaintDeviceData(rhs->currentNonLodData(), true));
             }
         } else {
             if (m_data && !rhs->m_data) {
                 m_data.clear();
             } else if (!m_data && rhs->m_data) {
                 m_data = toQShared(new KisPaintDeviceData(rhs->m_data.data(), true));
             } else if (m_data && rhs->m_data) {
                 m_data->prepareClone(rhs->m_data.data(), true);
             }
 
             if (!rhs->m_frames.isEmpty()) {
                 FramesHash::const_iterator it = rhs->m_frames.constBegin();
                 FramesHash::const_iterator end = rhs->m_frames.constEnd();
 
                 for (; it != end; ++it) {
                     DataSP data = toQShared(new KisPaintDeviceData(it.value().data(), true));
                     m_frames.insert(it.key(), data);
                 }
             }
             m_nextFreeFrameId = rhs->m_nextFreeFrameId;
         }
 
         if (rhs->m_lodData) {
             m_lodData.reset(new KisPaintDeviceData(rhs->m_lodData.data(), true));
         }
     }
 
     void prepareClone(KisPaintDeviceSP src)
     {
         prepareCloneImpl(src, src->m_d->currentData());
         Q_ASSERT(fastBitBltPossible(src));
     }
 
     bool fastBitBltPossible(KisPaintDeviceSP src)
     {
         return fastBitBltPossibleImpl(src->m_d->currentData());
     }
 
     int currentFrameId() const
     {
         KIS_ASSERT_RECOVER(contentChannel) {
             return -1;
         }
         return !defaultBounds->currentLevelOfDetail() ?
                contentChannel->frameIdAt(defaultBounds->currentTime()) :
                -1;
     }
 
     KisDataManagerSP frameDataManager(int frameId) const
     {
         DataSP data = m_frames[frameId];
         return data->dataManager();
     }
 
     void invalidateFrameCache(int frameId)
     {
         DataSP data = m_frames[frameId];
         return data->cache()->invalidate();
     }
 
 private:
     typedef KisPaintDeviceData Data;
     typedef QSharedPointer<Data> DataSP;
     typedef QHash<int, DataSP> FramesHash;
 
     class FrameInsertionCommand : public KUndo2Command
     {
     public:
 
         FrameInsertionCommand(FramesHash *hash, DataSP data, int frameId, bool insert, KUndo2Command *parentCommand)
             : KUndo2Command(parentCommand),
               m_hash(hash),
               m_data(data),
               m_frameId(frameId),
               m_insert(insert)
         {
         }
 
         void redo() override
         {
             doSwap(m_insert);
         }
 
         void undo() override
         {
             doSwap(!m_insert);
         }
 
     private:
         void doSwap(bool insert)
         {
             if (insert) {
                 m_hash->insert(m_frameId, m_data);
             } else {
                 DataSP deletedData = m_hash->take(m_frameId);
             }
         }
 
     private:
         FramesHash *m_hash;
         DataSP m_data;
         int m_frameId;
         bool m_insert;
     };
 
 public:
 
     int getNextFrameId() {
         int frameId = 0;
         while (m_frames.contains(frameId = m_nextFreeFrameId++));
         KIS_SAFE_ASSERT_RECOVER_NOOP(!m_frames.contains(frameId));
 
         return frameId;
     }
 
     int createFrame(bool copy, int copySrc, const QPoint &offset, KUndo2Command *parentCommand)
     {
         KIS_ASSERT_RECOVER(parentCommand) {
             return -1;
         }
 
         DataSP data;
         bool initialFrame = false;
 
         if (m_frames.isEmpty()) {
             /**
              * Here we move the contents of the paint device to the
              * new frame and clear m_data to make the "background" for
              * the areas where there is no frame at all.
              */
             data = toQShared(new Data(m_data.data(), true));
             m_data->dataManager()->clear();
             m_data->cache()->invalidate();
             initialFrame = true;
 
         } else if (copy) {
             DataSP srcData = m_frames[copySrc];
             data = toQShared(new Data(srcData.data(), true));
         } else {
             DataSP srcData = m_frames.begin().value();
             data = toQShared(new Data(srcData.data(), false));
         }
 
         if (!initialFrame && !copy) {
             data->setX(offset.x());
             data->setY(offset.y());
         }
 
         int frameId = getNextFrameId();
 
         KUndo2Command *cmd =
             new FrameInsertionCommand(&m_frames,
                                       data,
                                       frameId, true,
                                       parentCommand);
 
         cmd->redo();
 
         return frameId;
     }
 
     void deleteFrame(int frame, KUndo2Command *parentCommand)
     {
         KIS_ASSERT_RECOVER_RETURN(m_frames.contains(frame));
         KIS_ASSERT_RECOVER_RETURN(parentCommand);
 
         DataSP deletedData = m_frames[frame];
 
         KUndo2Command *cmd =
             new FrameInsertionCommand(&m_frames,
                                       deletedData,
                                       frame, false,
                                       parentCommand);
         cmd->redo();
     }
 
     QRect frameBounds(int frameId)
     {
         DataSP data = m_frames[frameId];
 
         QRect extent = data->dataManager()->extent();
         extent.translate(data->x(), data->y());
 
         return extent;
     }
 
     QPoint frameOffset(int frameId) const
     {
         DataSP data = m_frames[frameId];
         return QPoint(data->x(), data->y());
     }
 
     void setFrameOffset(int frameId, const QPoint &offset)
     {
         DataSP data = m_frames[frameId];
         data->setX(offset.x());
         data->setY(offset.y());
     }
 
     const QList<int> frameIds() const
     {
         return m_frames.keys();
     }
 
     bool readFrame(QIODevice *stream, int frameId)
     {
         bool retval = false;
         DataSP data = m_frames[frameId];
         retval = data->dataManager()->read(stream);
         data->cache()->invalidate();
         return retval;
     }
 
     bool writeFrame(KisPaintDeviceWriter &store, int frameId)
     {
         DataSP data = m_frames[frameId];
         return data->dataManager()->write(store);
     }
 
     void setFrameDefaultPixel(const KoColor &defPixel, int frameId)
     {
         DataSP data = m_frames[frameId];
         KoColor color(defPixel);
         color.convertTo(data->colorSpace());
         data->dataManager()->setDefaultPixel(color.data());
     }
 
     KoColor frameDefaultPixel(int frameId) const
     {
         DataSP data = m_frames[frameId];
         return KoColor(data->dataManager()->defaultPixel(),
                        data->colorSpace());
     }
 
     void fetchFrame(int frameId, KisPaintDeviceSP targetDevice);
     void uploadFrame(int srcFrameId, int dstFrameId, KisPaintDeviceSP srcDevice);
     void uploadFrame(int dstFrameId, KisPaintDeviceSP srcDevice);
     void uploadFrameData(DataSP srcData, DataSP dstData);
 
     struct LodDataStructImpl;
     LodDataStruct* createLodDataStruct(int lod);
     void updateLodDataStruct(LodDataStruct *dst, const QRect &srcRect);
     void uploadLodDataStruct(LodDataStruct *dst);
     QRegion regionForLodSyncing() const;
 
+    void updateLodDataManager(KisDataManager *srcDataManager,
+                              KisDataManager *dstDataManager, const QPoint &srcOffset, const QPoint &dstOffset,
+                              const QRect &originalRect, int lod);
+
+    void generateLodCloneDevice(KisPaintDeviceSP dst, const QRect &originalRect, int lod);
+
     void tesingFetchLodDevice(KisPaintDeviceSP targetDevice);
 
 
 private:
     qint64 estimateDataSize(Data *data) const {
         const QRect &rc = data->dataManager()->extent();
         return rc.width() * rc.height() * data->colorSpace()->pixelSize();
     }
 
 public:
 
     void estimateMemoryStats(qint64 &imageData, qint64 &temporaryData, qint64 &lodData) const {
         imageData = 0;
         temporaryData = 0;
         lodData = 0;
 
         if (m_data) {
             imageData += estimateDataSize(m_data.data());
         }
 
         if (m_lodData) {
             lodData += estimateDataSize(m_lodData.data());
         }
 
         if (m_externalFrameData) {
             temporaryData += estimateDataSize(m_externalFrameData.data());
         }
 
         Q_FOREACH (DataSP value, m_frames.values()) {
             imageData += estimateDataSize(value.data());
         }
     }
 
 
 private:
 
     QRegion syncWholeDevice(Data *srcData);
 
     inline DataSP currentFrameData() const
     {
         DataSP data;
 
         const int numberOfFrames = contentChannel->keyframeCount();
 
         if (numberOfFrames > 1) {
             int frameId = contentChannel->frameIdAt(defaultBounds->currentTime());
 
             if (frameId == -1) {
                 data = m_data;
             } else {
                 KIS_ASSERT_RECOVER(m_frames.contains(frameId)) {
                     return m_frames.begin().value();
                 }
                 data = m_frames[frameId];
             }
         } else if (numberOfFrames == 1) {
             data = m_frames.begin().value();
         } else {
             data = m_data;
         }
 
         return data;
     }
 
     inline Data* currentNonLodData() const
     {
         Data *data = m_data.data();
 
         if (contentChannel) {
             data = currentFrameData().data();
         } else if (isProjectionDevice && defaultBounds->externalFrameActive()) {
             if (!m_externalFrameData) {
                 QMutexLocker l(&m_dataSwitchLock);
                 if (!m_externalFrameData) {
                     m_externalFrameData.reset(new Data(m_data.data(), false));
                 }
             }
             data = m_externalFrameData.data();
         }
 
         return data;
     }
 
     inline void ensureLodDataPresent() const
     {
         if (!m_lodData) {
             Data *srcData = currentNonLodData();
 
             QMutexLocker l(&m_dataSwitchLock);
             if (!m_lodData) {
                 m_lodData.reset(new Data(srcData, false));
             }
         }
     }
 
     inline Data* currentData() const
     {
         Data *data;
 
         if (defaultBounds->currentLevelOfDetail()) {
             ensureLodDataPresent();
             data = m_lodData.data();
         } else {
             data = currentNonLodData();
         }
 
         return data;
     }
 
     void prepareCloneImpl(KisPaintDeviceSP src, Data *srcData)
     {
         currentData()->prepareClone(srcData);
 
         q->setDefaultPixel(KoColor(srcData->dataManager()->defaultPixel(), colorSpace()));
         q->setDefaultBounds(src->defaultBounds());
     }
 
     bool fastBitBltPossibleImpl(Data *srcData)
     {
         return x() == srcData->x() && y() == srcData->y() &&
                *colorSpace() == *srcData->colorSpace();
     }
 
     QList<Data*> allDataObjects() const
     {
         QList<Data*> dataObjects;
 
         if (m_frames.isEmpty()) {
             dataObjects << m_data.data();
         }
         dataObjects << m_lodData.data();
         dataObjects << m_externalFrameData.data();
 
         Q_FOREACH (DataSP value, m_frames.values()) {
             dataObjects << value.data();
         }
 
         return dataObjects;
     }
 
     void transferFromData(Data *data, KisPaintDeviceSP targetDevice);
 
     struct Q_DECL_HIDDEN StrategyPolicy;
     typedef KisSequentialIteratorBase<ReadOnlyIteratorPolicy<StrategyPolicy>, StrategyPolicy> InternalSequentialConstIterator;
     typedef KisSequentialIteratorBase<WritableIteratorPolicy<StrategyPolicy>, StrategyPolicy> InternalSequentialIterator;
 
 private:
     friend class KisPaintDeviceFramesInterface;
 
 private:
     DataSP m_data;
     mutable QScopedPointer<Data> m_lodData;
     mutable QScopedPointer<Data> m_externalFrameData;
     mutable QMutex m_dataSwitchLock;
 
     FramesHash m_frames;
     int m_nextFreeFrameId;
 };
 
 const KisDefaultBoundsSP KisPaintDevice::Private::transitionalDefaultBounds = new KisDefaultBounds();
 
 #include "kis_paint_device_strategies.h"
 
 KisPaintDevice::Private::Private(KisPaintDevice *paintDevice)
     : q(paintDevice),
       basicStrategy(new KisPaintDeviceStrategy(paintDevice, this)),
       isProjectionDevice(false),
       m_data(new Data(paintDevice)),
       m_nextFreeFrameId(0)
 {
 }
 
 KisPaintDevice::Private::~Private()
 {
     m_frames.clear();
 }
 
 KisPaintDevice::Private::KisPaintDeviceStrategy* KisPaintDevice::Private::currentStrategy()
 {
     if (!defaultBounds->wrapAroundMode()) {
         return basicStrategy.data();
     }
 
     const QRect wrapRect = defaultBounds->bounds();
 
     if (!wrappedStrategy || wrappedStrategy->wrapRect() != wrapRect) {
         QMutexLocker locker(&m_wrappedStrategyMutex);
 
         if (!wrappedStrategy) {
             wrappedStrategy.reset(new KisPaintDeviceWrappedStrategy(wrapRect, q, this));
         }  else if (wrappedStrategy->wrapRect() != wrapRect) {
             wrappedStrategy->setWrapRect(wrapRect);
         }
     }
 
     return wrappedStrategy.data();
 }
 
 struct KisPaintDevice::Private::StrategyPolicy {
     StrategyPolicy(KisPaintDevice::Private::KisPaintDeviceStrategy *strategy,
                    KisDataManager *dataManager, qint32 offsetX, qint32 offsetY)
         : m_strategy(strategy),
           m_dataManager(dataManager),
           m_offsetX(offsetX),
           m_offsetY(offsetY)
     {
     }
 
     KisHLineConstIteratorSP createConstIterator(const QRect &rect)
     {
         return m_strategy->createHLineConstIteratorNG(m_dataManager, rect.x(), rect.y(), rect.width(), m_offsetX, m_offsetY);
     }
 
     KisHLineIteratorSP createIterator(const QRect &rect)
     {
         return m_strategy->createHLineIteratorNG(m_dataManager, rect.x(), rect.y(), rect.width(), m_offsetX, m_offsetY);
     }
 
     int pixelSize() const
     {
         return m_dataManager->pixelSize();
     }
 
 
     KisPaintDeviceStrategy *m_strategy;
     KisDataManager *m_dataManager;
     int m_offsetX;
     int m_offsetY;
 };
 
 struct KisPaintDevice::Private::LodDataStructImpl : public KisPaintDevice::LodDataStruct {
     LodDataStructImpl(Data *_lodData) : lodData(_lodData) {}
     QScopedPointer<Data> lodData;
 };
 
 QRegion KisPaintDevice::Private::regionForLodSyncing() const
 {
     Data *srcData = currentNonLodData();
     return srcData->dataManager()->region().translated(srcData->x(), srcData->y());
 }
 
 KisPaintDevice::LodDataStruct* KisPaintDevice::Private::createLodDataStruct(int newLod)
 {
     KIS_SAFE_ASSERT_RECOVER_NOOP(newLod > 0);
 
     Data *srcData = currentNonLodData();
 
     Data *lodData = new Data(srcData, false);
     LodDataStruct *lodStruct = new LodDataStructImpl(lodData);
 
     int expectedX = KisLodTransform::coordToLodCoord(srcData->x(), newLod);
     int expectedY = KisLodTransform::coordToLodCoord(srcData->y(), newLod);
 
     /**
      * We compare color spaces as pure pointers, because they must be
      * exactly the same, since they come from the common source.
      */
     if (lodData->levelOfDetail() != newLod ||
         lodData->colorSpace() != srcData->colorSpace() ||
         lodData->x() != expectedX ||
         lodData->y() != expectedY) {
 
 
         lodData->prepareClone(srcData);
 
         lodData->setLevelOfDetail(newLod);
         lodData->setX(expectedX);
         lodData->setY(expectedY);
 
         // FIXME: different kind of synchronization
     }
 
     //QRegion dirtyRegion = syncWholeDevice(srcData);
     lodData->cache()->invalidate();
 
     return lodStruct;
 }
 
-void KisPaintDevice::Private::updateLodDataStruct(LodDataStruct *_dst, const QRect &originalRect)
+void KisPaintDevice::Private::updateLodDataManager(KisDataManager *srcDataManager,
+                                                   KisDataManager *dstDataManager,
+                                                   const QPoint &srcOffset,
+                                                   const QPoint &dstOffset,
+                                                   const QRect &originalRect,
+                                                   int lod)
 {
-    LodDataStructImpl *dst = dynamic_cast<LodDataStructImpl*>(_dst);
-    KIS_SAFE_ASSERT_RECOVER_RETURN(dst);
-
-    Data *lodData = dst->lodData.data();
-    Data *srcData = currentNonLodData();
-
-    const int lod = lodData->levelOfDetail();
     const int srcStepSize = 1 << lod;
 
     KIS_ASSERT_RECOVER_RETURN(lod > 0);
 
     const QRect srcRect = KisLodTransform::alignedRect(originalRect, lod);
     const QRect dstRect = KisLodTransform::scaledRect(srcRect, lod);
     if (!srcRect.isValid() || !dstRect.isValid()) return;
 
     KIS_ASSERT_RECOVER_NOOP(srcRect.width() / srcStepSize == dstRect.width());
 
-    const int pixelSize = srcData->dataManager()->pixelSize();
+    const int pixelSize = srcDataManager->pixelSize();
 
     int rowsAccumulated = 0;
     int columnsAccumulated = 0;
 
     KoMixColorsOp *mixOp = colorSpace()->mixColorsOp();
 
     QScopedArrayPointer<quint8> blendData(new quint8[srcStepSize * srcRect.width() * pixelSize]);
     quint8 *blendDataPtr = blendData.data();
     int blendDataOffset = 0;
 
     const int srcCellSize = srcStepSize * srcStepSize;
     const int srcCellStride = srcCellSize * pixelSize;
     const int srcStepStride = srcStepSize * pixelSize;
     const int srcColumnStride = (srcStepSize - 1) * srcStepStride;
 
     QScopedArrayPointer<qint16> weights(new qint16[srcCellSize]);
 
     {
         const qint16 averageWeight = qCeil(255.0 / srcCellSize);
         const qint16 extraWeight = averageWeight * srcCellSize - 255;
         KIS_ASSERT_RECOVER_NOOP(extraWeight == 1);
 
         for (int i = 0; i < srcCellSize - 1; i++) {
             weights[i] = averageWeight;
         }
         weights[srcCellSize - 1] = averageWeight - extraWeight;
     }
 
-    InternalSequentialConstIterator srcIntIt(StrategyPolicy(currentStrategy(), srcData->dataManager().data(), srcData->x(), srcData->y()), srcRect);
-    InternalSequentialIterator dstIntIt(StrategyPolicy(currentStrategy(), lodData->dataManager().data(), lodData->x(), lodData->y()), dstRect);
+    InternalSequentialConstIterator srcIntIt(StrategyPolicy(currentStrategy(), srcDataManager, srcOffset.x(), srcOffset.y()), srcRect);
+    InternalSequentialIterator dstIntIt(StrategyPolicy(currentStrategy(), dstDataManager, dstOffset.x(), dstOffset.y()), dstRect);
 
     int rowsRemaining = srcRect.height();
     while (rowsRemaining > 0) {
 
         int colsRemaining = srcRect.width();
         while (colsRemaining > 0 && srcIntIt.nextPixel()) {
 
             memcpy(blendDataPtr, srcIntIt.rawDataConst(), pixelSize);
             blendDataPtr += pixelSize;
             columnsAccumulated++;
 
             if (columnsAccumulated >= srcStepSize) {
                 blendDataPtr += srcColumnStride;
                 columnsAccumulated = 0;
             }
 
             colsRemaining--;
         }
 
         rowsAccumulated++;
 
         if (rowsAccumulated >= srcStepSize) {
 
             // blend and write the final data
             blendDataPtr = blendData.data();
 
             int colsRemaining = dstRect.width();
             while (colsRemaining > 0 && dstIntIt.nextPixel()) {
                 mixOp->mixColors(blendDataPtr, weights.data(), srcCellSize, dstIntIt.rawData());
                 blendDataPtr += srcCellStride;
 
                 colsRemaining--;
             }
 
             // reset counters
             rowsAccumulated = 0;
             blendDataPtr = blendData.data();
             blendDataOffset = 0;
         } else {
             blendDataOffset += srcStepStride;
             blendDataPtr = blendData.data() + blendDataOffset;
         }
 
         rowsRemaining--;
     }
 }
 
+void KisPaintDevice::Private::updateLodDataStruct(LodDataStruct *_dst, const QRect &originalRect)
+{
+    LodDataStructImpl *dst = dynamic_cast<LodDataStructImpl*>(_dst);
+    KIS_SAFE_ASSERT_RECOVER_RETURN(dst);
+
+    Data *lodData = dst->lodData.data();
+    Data *srcData = currentNonLodData();
+
+    const int lod = lodData->levelOfDetail();
+
+    updateLodDataManager(srcData->dataManager().data(), lodData->dataManager().data(),
+                         QPoint(srcData->x(), srcData->y()),
+                         QPoint(lodData->x(), lodData->y()),
+                         originalRect, lod);
+}
+
+void KisPaintDevice::Private::generateLodCloneDevice(KisPaintDeviceSP dst, const QRect &originalRect, int lod)
+{
+    KIS_SAFE_ASSERT_RECOVER_RETURN(fastBitBltPossible(dst));
+
+    Data *srcData = currentNonLodData();
+    updateLodDataManager(srcData->dataManager().data(), dst->dataManager().data(),
+                         QPoint(srcData->x(), srcData->y()),
+                         QPoint(dst->x(), dst->y()),
+                         originalRect, lod);
+}
+
 void KisPaintDevice::Private::uploadLodDataStruct(LodDataStruct *_dst)
 {
     LodDataStructImpl *dst = dynamic_cast<LodDataStructImpl*>(_dst);
     KIS_SAFE_ASSERT_RECOVER_RETURN(dst);
 
     KIS_SAFE_ASSERT_RECOVER_RETURN(
         dst->lodData->levelOfDetail() == defaultBounds->currentLevelOfDetail());
 
     ensureLodDataPresent();
 
     m_lodData->prepareClone(dst->lodData.data());
     m_lodData->dataManager()->bitBltRough(dst->lodData->dataManager(), dst->lodData->dataManager()->extent());
 }
 
 void KisPaintDevice::Private::transferFromData(Data *data, KisPaintDeviceSP targetDevice)
 {
     QRect extent = data->dataManager()->extent();
     extent.translate(data->x(), data->y());
 
     targetDevice->m_d->prepareCloneImpl(q, data);
     targetDevice->m_d->currentStrategy()->fastBitBltRough(data->dataManager(), extent);
 }
 
 void KisPaintDevice::Private::fetchFrame(int frameId, KisPaintDeviceSP targetDevice)
 {
     DataSP data = m_frames[frameId];
     transferFromData(data.data(), targetDevice);
 }
 
 void KisPaintDevice::Private::uploadFrame(int srcFrameId, int dstFrameId, KisPaintDeviceSP srcDevice)
 {
     DataSP dstData = m_frames[dstFrameId];
     KIS_ASSERT_RECOVER_RETURN(dstData);
 
     DataSP srcData = srcDevice->m_d->m_frames[srcFrameId];
     KIS_ASSERT_RECOVER_RETURN(srcData);
 
     uploadFrameData(srcData, dstData);
 }
 
 void KisPaintDevice::Private::uploadFrame(int dstFrameId, KisPaintDeviceSP srcDevice)
 {
     DataSP dstData = m_frames[dstFrameId];
     KIS_ASSERT_RECOVER_RETURN(dstData);
 
     DataSP srcData = srcDevice->m_d->m_data;
     KIS_ASSERT_RECOVER_RETURN(srcData);
 
     uploadFrameData(srcData, dstData);
 }
 
 void KisPaintDevice::Private::uploadFrameData(DataSP srcData, DataSP dstData)
 {
     if (srcData->colorSpace() != dstData->colorSpace() &&
         *srcData->colorSpace() != *dstData->colorSpace()) {
 
         KUndo2Command tempCommand;
 
         srcData = toQShared(new Data(srcData.data(), true));
         srcData->convertDataColorSpace(dstData->colorSpace(),
                                        KoColorConversionTransformation::internalRenderingIntent(),
                                        KoColorConversionTransformation::internalConversionFlags(),
                                        &tempCommand);
     }
 
     dstData->dataManager()->clear();
     dstData->cache()->invalidate();
 
     const QRect rect = srcData->dataManager()->extent();
     dstData->dataManager()->bitBltRough(srcData->dataManager(), rect);
     dstData->setX(srcData->x());
     dstData->setY(srcData->y());
 }
 
 void KisPaintDevice::Private::tesingFetchLodDevice(KisPaintDeviceSP targetDevice)
 {
     Data *data = m_lodData.data();
     Q_ASSERT(data);
 
     transferFromData(data, targetDevice);
 }
 
 KUndo2Command* KisPaintDevice::Private::convertColorSpace(const KoColorSpace * dstColorSpace, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags)
 {
 
     class DeviceChangeColorSpaceCommand : public KUndo2Command
     {
     public:
         DeviceChangeColorSpaceCommand(KisPaintDeviceSP device)
             : m_firstRun(true),
               m_device(device)
         {
         }
 
         void emitNotifications()
         {
             m_device->emitColorSpaceChanged();
             m_device->setDirty();
         }
 
         void redo() override
         {
             KUndo2Command::redo();
 
             if (!m_firstRun) {
                 m_firstRun = false;
                 return;
             }
 
             emitNotifications();
         }
 
         void undo() override
         {
             KUndo2Command::undo();
             emitNotifications();
         }
 
     private:
         bool m_firstRun;
         KisPaintDeviceSP m_device;
     };
 
 
     KUndo2Command *parentCommand = new DeviceChangeColorSpaceCommand(q);
 
     QList<Data*> dataObjects = allDataObjects();
 
     Q_FOREACH (Data *data, dataObjects) {
         if (!data) continue;
 
         data->convertDataColorSpace(dstColorSpace, renderingIntent, conversionFlags, parentCommand);
     }
 
     if (!parentCommand->childCount()) {
         delete parentCommand;
         parentCommand = 0;
     } else {
         q->emitColorSpaceChanged();
     }
 
     return parentCommand;
 
 }
 
 bool KisPaintDevice::Private::assignProfile(const KoColorProfile * profile)
 {
     if (!profile) return false;
 
     const KoColorSpace *dstColorSpace =
         KoColorSpaceRegistry::instance()->colorSpace(colorSpace()->colorModelId().id(), colorSpace()->colorDepthId().id(), profile);
     if (!dstColorSpace) return false;
 
     QList<Data*> dataObjects = allDataObjects();
     Q_FOREACH (Data *data, dataObjects) {
         if (!data) continue;
         data->assignColorSpace(dstColorSpace);
     }
     q->emitProfileChanged();
 
     // no undo information is provided here
     return true;
 }
 
 void KisPaintDevice::Private::init(const KoColorSpace *cs, const quint8 *defaultPixel)
 {
     QList<Data*> dataObjects = allDataObjects();
     Q_FOREACH (Data *data, dataObjects) {
         if (!data) continue;
 
         KisDataManagerSP dataManager = new KisDataManager(cs->pixelSize(), defaultPixel);
         data->init(cs, dataManager);
     }
 }
 
 KisPaintDevice::KisPaintDevice(const KoColorSpace * colorSpace, const QString& name)
     : QObject(0)
     , m_d(new Private(this))
 {
     init(colorSpace, new KisDefaultBounds(), 0, name);
 }
 
 KisPaintDevice::KisPaintDevice(KisNodeWSP parent, const KoColorSpace * colorSpace, KisDefaultBoundsBaseSP defaultBounds, const QString& name)
     : QObject(0)
     , m_d(new Private(this))
 {
     init(colorSpace, defaultBounds, parent, name);
 }
 
 void KisPaintDevice::init(const KoColorSpace *colorSpace,
                           KisDefaultBoundsBaseSP defaultBounds,
                           KisNodeWSP parent, const QString& name)
 {
     Q_ASSERT(colorSpace);
     setObjectName(name);
 
     // temporary def. bounds object for the initialization phase only
     m_d->defaultBounds = m_d->transitionalDefaultBounds;
 
     if (!defaultBounds) {
         // Reuse transitionalDefaultBounds here. Change if you change
         // semantics of transitionalDefaultBounds
         defaultBounds = m_d->transitionalDefaultBounds;
     }
 
     QScopedArrayPointer<quint8> defaultPixel(new quint8[colorSpace->pixelSize()]);
     colorSpace->fromQColor(Qt::transparent, defaultPixel.data());
     m_d->init(colorSpace, defaultPixel.data());
 
     Q_ASSERT(m_d->colorSpace());
 
     setDefaultBounds(defaultBounds);
     setParentNode(parent);
 }
 
 KisPaintDevice::KisPaintDevice(const KisPaintDevice& rhs, KritaUtils::DeviceCopyMode copyMode, KisNode *newParentNode)
     : QObject()
     , KisShared()
     , m_d(new Private(this))
 {
     if (this != &rhs) {
         // temporary def. bounds object for the initialization phase only
         m_d->defaultBounds = m_d->transitionalDefaultBounds;
 
         // copy data objects with or without frames
         m_d->cloneAllDataObjects(rhs.m_d, copyMode == KritaUtils::CopyAllFrames);
 
         if (copyMode == KritaUtils::CopyAllFrames && rhs.m_d->framesInterface) {
             KIS_ASSERT_RECOVER_RETURN(rhs.m_d->framesInterface);
             KIS_ASSERT_RECOVER_RETURN(rhs.m_d->contentChannel);
             m_d->framesInterface.reset(new KisPaintDeviceFramesInterface(this));
             m_d->contentChannel.reset(new KisRasterKeyframeChannel(*rhs.m_d->contentChannel.data(), newParentNode, this));
         }
 
         setDefaultBounds(rhs.m_d->defaultBounds);
         setParentNode(newParentNode);
     }
 }
 
 KisPaintDevice::~KisPaintDevice()
 {
     delete m_d;
 }
 
 void KisPaintDevice::setProjectionDevice(bool value)
 {
     m_d->isProjectionDevice = value;
 }
 
 void KisPaintDevice::prepareClone(KisPaintDeviceSP src)
 {
     m_d->prepareClone(src);
     Q_ASSERT(fastBitBltPossible(src));
 }
 
 void KisPaintDevice::makeCloneFrom(KisPaintDeviceSP src, const QRect &rect)
 {
     prepareClone(src);
 
     // we guarantee that *this is totally empty, so copy pixels that
     // are areally present on the source image only
     const QRect optimizedRect = rect & src->extent();
 
     fastBitBlt(src, optimizedRect);
 }
 
 void KisPaintDevice::makeCloneFromRough(KisPaintDeviceSP src, const QRect &minimalRect)
 {
     prepareClone(src);
 
     // we guarantee that *this is totally empty, so copy pixels that
     // are areally present on the source image only
     const QRect optimizedRect = minimalRect & src->extent();
 
     fastBitBltRough(src, optimizedRect);
 }
 
 void KisPaintDevice::setDirty()
 {
     m_d->cache()->invalidate();
     if (m_d->parent.isValid())
         m_d->parent->setDirty();
 }
 
 void KisPaintDevice::setDirty(const QRect & rc)
 {
     m_d->cache()->invalidate();
     if (m_d->parent.isValid())
         m_d->parent->setDirty(rc);
 }
 
 void KisPaintDevice::setDirty(const QRegion & region)
 {
     m_d->cache()->invalidate();
     if (m_d->parent.isValid())
         m_d->parent->setDirty(region);
 }
 
 void KisPaintDevice::setDirty(const QVector<QRect> rects)
 {
     m_d->cache()->invalidate();
     if (m_d->parent.isValid())
         m_d->parent->setDirty(rects);
 }
 
 void KisPaintDevice::requestTimeSwitch(int time)
 {
     if (m_d->parent.isValid()) {
         m_d->parent->requestTimeSwitch(time);
     }
 }
 
 int KisPaintDevice::sequenceNumber() const
 {
     return m_d->cache()->sequenceNumber();
 }
 
 void KisPaintDevice::estimateMemoryStats(qint64 &imageData, qint64 &temporaryData, qint64 &lodData) const
 {
     m_d->estimateMemoryStats(imageData, temporaryData, lodData);
 }
 
 void KisPaintDevice::setParentNode(KisNodeWSP parent)
 {
     m_d->parent = parent;
 }
 
 // for testing purposes only
 KisNodeWSP KisPaintDevice::parentNode() const
 {
     return m_d->parent;
 }
 
 void KisPaintDevice::setDefaultBounds(KisDefaultBoundsBaseSP defaultBounds)
 {
     m_d->defaultBounds = defaultBounds;
     m_d->cache()->invalidate();
 }
 
 KisDefaultBoundsBaseSP KisPaintDevice::defaultBounds() const
 {
     return m_d->defaultBounds;
 }
 
 void KisPaintDevice::moveTo(const QPoint &pt)
 {
     m_d->currentStrategy()->move(pt);
     m_d->cache()->invalidate();
 }
 
 QPoint KisPaintDevice::offset() const
 {
     return QPoint(x(), y());
 }
 
 void KisPaintDevice::moveTo(qint32 x, qint32 y)
 {
     moveTo(QPoint(x, y));
 }
 
 void KisPaintDevice::setX(qint32 x)
 {
     moveTo(QPoint(x, m_d->y()));
 }
 
 void KisPaintDevice::setY(qint32 y)
 {
     moveTo(QPoint(m_d->x(), y));
 }
 
 qint32 KisPaintDevice::x() const
 {
     return m_d->x();
 }
 
 qint32 KisPaintDevice::y() const
 {
     return m_d->y();
 }
 
 void KisPaintDevice::extent(qint32 &x, qint32 &y, qint32 &w, qint32 &h) const
 {
     QRect rc = extent();
     x = rc.x();
     y = rc.y();
     w = rc.width();
     h = rc.height();
 }
 
 QRect KisPaintDevice::extent() const
 {
     return m_d->currentStrategy()->extent();
 }
 
 QRegion KisPaintDevice::region() const
 {
     return m_d->currentStrategy()->region();
 }
 
 QRect KisPaintDevice::nonDefaultPixelArea() const
 {
     return m_d->cache()->nonDefaultPixelArea();
 }
 
 QRect KisPaintDevice::exactBounds() const
 {
     return m_d->cache()->exactBounds();
 }
 
 QRect KisPaintDevice::exactBoundsAmortized() const
 {
     return m_d->cache()->exactBoundsAmortized();
 }
 
 namespace Impl
 {
 
 struct CheckFullyTransparent {
     CheckFullyTransparent(const KoColorSpace *colorSpace)
         : m_colorSpace(colorSpace)
     {
     }
 
     bool isPixelEmpty(const quint8 *pixelData)
     {
         return m_colorSpace->opacityU8(pixelData) == OPACITY_TRANSPARENT_U8;
     }
 
 private:
     const KoColorSpace *m_colorSpace;
 };
 
 struct CheckNonDefault {
     CheckNonDefault(int pixelSize, const quint8 *defaultPixel)
         : m_pixelSize(pixelSize),
           m_defaultPixel(defaultPixel)
     {
     }
 
     bool isPixelEmpty(const quint8 *pixelData)
     {
         return memcmp(m_defaultPixel, pixelData, m_pixelSize) == 0;
     }
 
 private:
     int m_pixelSize;
     const quint8 *m_defaultPixel;
 };
 
 template <class ComparePixelOp>
 QRect calculateExactBoundsImpl(const KisPaintDevice *device, const QRect &startRect, const QRect &endRect, ComparePixelOp compareOp)
 {
     if (startRect == endRect) return startRect;
 
     // the passed extent might have weird invalid structure that
     // can overflow integer precision when calling startRect.right()
     if (!startRect.isValid()) return QRect();
 
     // Solution n°2
     int  x, y, w, h;
     int boundLeft, boundTop, boundRight, boundBottom;
     int endDirN, endDirE, endDirS, endDirW;
 
     startRect.getRect(&x, &y, &w, &h);
 
     if (endRect.isEmpty()) {
         endDirS = startRect.bottom();
         endDirN = startRect.top();
         endDirE = startRect.right();
         endDirW = startRect.left();
         startRect.getCoords(&boundLeft, &boundTop, &boundRight, &boundBottom);
     } else {
         endDirS = endRect.top() - 1;
         endDirN = endRect.bottom() + 1;
         endDirE = endRect.left() - 1;
         endDirW = endRect.right() + 1;
         endRect.getCoords(&boundLeft, &boundTop, &boundRight, &boundBottom);
     }
 
     // XXX: a small optimization is possible by using H/V line iterators in the first
     //      and third cases, at the cost of making the code a bit more complex
 
     KisRandomConstAccessorSP accessor = device->createRandomConstAccessorNG(x, y);
 
     bool found = false;
     {
         for (qint32 y2 = y; y2 <= endDirS; ++y2) {
             for (qint32 x2 = x; x2 < x + w || found; ++ x2) {
                 accessor->moveTo(x2, y2);
                 if (!compareOp.isPixelEmpty(accessor->rawDataConst())) {
                     boundTop = y2;
                     found = true;
                     break;
                 }
             }
             if (found) break;
         }
     }
 
     /**
      * If the first pass hasn't found any opaque pixel, there is no
      * reason to check that 3 more times. They will not appear in the
      * meantime. Just return an empty bounding rect.
      */
     if (!found && endRect.isEmpty()) {
         return QRect();
     }
 
     found = false;
 
     for (qint32 y2 = y + h - 1; y2 >= endDirN ; --y2) {
         for (qint32 x2 = x + w - 1; x2 >= x || found; --x2) {
             accessor->moveTo(x2, y2);
             if (!compareOp.isPixelEmpty(accessor->rawDataConst())) {
                 boundBottom = y2;
                 found = true;
                 break;
             }
         }
         if (found) break;
     }
     found = false;
 
     {
         for (qint32 x2 = x; x2 <= endDirE ; ++x2) {
             for (qint32 y2 = y; y2 < y + h || found; ++y2) {
                 accessor->moveTo(x2, y2);
                 if (!compareOp.isPixelEmpty(accessor->rawDataConst())) {
                     boundLeft = x2;
                     found = true;
                     break;
                 }
             }
             if (found) break;
         }
     }
 
     found = false;
 
     // Look for right edge )
     {
 
         for (qint32 x2 = x + w - 1; x2 >= endDirW; --x2) {
             for (qint32 y2 = y + h - 1; y2 >= y || found; --y2) {
                 accessor->moveTo(x2, y2);
                 if (!compareOp.isPixelEmpty(accessor->rawDataConst())) {
                     boundRight = x2;
                     found = true;
                     break;
                 }
             }
             if (found) break;
         }
     }
 
     return QRect(boundLeft, boundTop,
                  boundRight - boundLeft + 1,
                  boundBottom - boundTop + 1);
 }
 
 }
 
 QRect KisPaintDevice::calculateExactBounds(bool nonDefaultOnly) const
 {
     QRect startRect = extent();
     QRect endRect;
 
     quint8 defaultOpacity = defaultPixel().opacityU8();
     if (defaultOpacity != OPACITY_TRANSPARENT_U8) {
         if (!nonDefaultOnly) {
             /**
              * We will calculate exact bounds only outside of the
              * image bounds, and that'll be nondefault area only.
              */
 
             endRect = defaultBounds()->bounds();
             nonDefaultOnly = true;
 
         } else {
             startRect = region().boundingRect();
         }
     }
 
     if (nonDefaultOnly) {
         const KoColor defaultPixel = this->defaultPixel();
         Impl::CheckNonDefault compareOp(pixelSize(), defaultPixel.data());
         endRect = Impl::calculateExactBoundsImpl(this, startRect, endRect, compareOp);
     } else {
         Impl::CheckFullyTransparent compareOp(m_d->colorSpace());
         endRect = Impl::calculateExactBoundsImpl(this, startRect, endRect, compareOp);
     }
 
     return endRect;
 }
 
 QRegion KisPaintDevice::regionExact() const
 {
     QRegion resultRegion;
     QVector<QRect> rects = region().rects();
 
     const KoColor defaultPixel = this->defaultPixel();
     Impl::CheckNonDefault compareOp(pixelSize(), defaultPixel.data());
 
     Q_FOREACH (const QRect &rc1, rects) {
         const int patchSize = 64;
         QVector<QRect> smallerRects = KritaUtils::splitRectIntoPatches(rc1, QSize(patchSize, patchSize));
         Q_FOREACH (const QRect &rc2, smallerRects) {
 
             const QRect result =
                 Impl::calculateExactBoundsImpl(this, rc2, QRect(), compareOp);
 
             if (!result.isEmpty()) {
                 resultRegion += result;
             }
         }
     }
     return resultRegion;
 }
 
 void KisPaintDevice::crop(qint32 x, qint32 y, qint32 w, qint32 h)
 {
     crop(QRect(x, y, w, h));
 }
 
 
 void KisPaintDevice::crop(const QRect &rect)
 {
     m_d->currentStrategy()->crop(rect);
 }
 
 void KisPaintDevice::purgeDefaultPixels()
 {
     KisDataManagerSP dm = m_d->dataManager();
     dm->purge(dm->extent());
 }
 
 void KisPaintDevice::setDefaultPixel(const KoColor &defPixel)
 {
     KoColor color(defPixel);
     color.convertTo(colorSpace());
 
     m_d->dataManager()->setDefaultPixel(color.data());
     m_d->cache()->invalidate();
 }
 
 KoColor KisPaintDevice::defaultPixel() const
 {
     return KoColor(m_d->dataManager()->defaultPixel(), colorSpace());
 }
 
 void KisPaintDevice::clear()
 {
     m_d->dataManager()->clear();
     m_d->cache()->invalidate();
 }
 
 void KisPaintDevice::clear(const QRect & rc)
 {
     m_d->currentStrategy()->clear(rc);
 }
 
 void KisPaintDevice::fill(const QRect & rc, const KoColor &color)
 {
     KIS_ASSERT_RECOVER_RETURN(*color.colorSpace() == *colorSpace());
     m_d->currentStrategy()->fill(rc, color.data());
 }
 
 void KisPaintDevice::fill(qint32 x, qint32 y, qint32 w, qint32 h, const quint8 *fillPixel)
 {
     m_d->currentStrategy()->fill(QRect(x, y, w, h), fillPixel);
 }
 
 
 bool KisPaintDevice::write(KisPaintDeviceWriter &store)
 {
     return m_d->dataManager()->write(store);
 }
 
 bool KisPaintDevice::read(QIODevice *stream)
 {
     bool retval;
 
     retval = m_d->dataManager()->read(stream);
     m_d->cache()->invalidate();
 
     return retval;
 }
 
 void KisPaintDevice::emitColorSpaceChanged()
 {
     emit colorSpaceChanged(m_d->colorSpace());
 }
 
 void KisPaintDevice::emitProfileChanged()
 {
     emit profileChanged(m_d->colorSpace()->profile());
 }
 
 KUndo2Command* KisPaintDevice::convertTo(const KoColorSpace * dstColorSpace, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags)
 {
     KUndo2Command *command = m_d->convertColorSpace(dstColorSpace, renderingIntent, conversionFlags);
     return command;
 }
 
 bool KisPaintDevice::setProfile(const KoColorProfile * profile)
 {
     return m_d->assignProfile(profile);
 }
 
 KisDataManagerSP KisPaintDevice::dataManager() const
 {
     return m_d->dataManager();
 }
 
 void KisPaintDevice::convertFromQImage(const QImage& _image, const KoColorProfile *profile,
                                        qint32 offsetX, qint32 offsetY)
 {
     QImage image = _image;
 
     if (image.format() != QImage::Format_ARGB32) {
         image = image.convertToFormat(QImage::Format_ARGB32);
     }
     // Don't convert if not no profile is given and both paint dev and qimage are rgba.
     if (!profile && colorSpace()->id() == "RGBA") {
         writeBytes(image.constBits(), offsetX, offsetY, image.width(), image.height());
     } else {
         try {
             quint8 * dstData = new quint8[image.width() * image.height() * pixelSize()];
             KoColorSpaceRegistry::instance()
             ->colorSpace(RGBAColorModelID.id(), Integer8BitsColorDepthID.id(), profile)
             ->convertPixelsTo(image.constBits(), dstData, colorSpace(), image.width() * image.height(),
                               KoColorConversionTransformation::internalRenderingIntent(),
                               KoColorConversionTransformation::internalConversionFlags());
 
             writeBytes(dstData, offsetX, offsetY, image.width(), image.height());
             delete[] dstData;
         } catch (std::bad_alloc) {
             warnKrita << "KisPaintDevice::convertFromQImage: Could not allocate" << image.width() * image.height() * pixelSize() << "bytes";
             return;
         }
     }
     m_d->cache()->invalidate();
 }
 
 QImage KisPaintDevice::convertToQImage(const KoColorProfile *dstProfile, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags) const
 {
     qint32 x1;
     qint32 y1;
     qint32 w;
     qint32 h;
 
     QRect rc = exactBounds();
     x1 = rc.x();
     y1 = rc.y();
     w = rc.width();
     h = rc.height();
 
     return convertToQImage(dstProfile, x1, y1, w, h, renderingIntent, conversionFlags);
 }
 
 QImage KisPaintDevice::convertToQImage(const KoColorProfile *dstProfile,
                                        const QRect &rc,
                                        KoColorConversionTransformation::Intent renderingIntent,
                                        KoColorConversionTransformation::ConversionFlags conversionFlags) const
 {
     return convertToQImage(dstProfile,
                            rc.x(), rc.y(), rc.width(), rc.height(),
                            renderingIntent, conversionFlags);
 }
 
 QImage KisPaintDevice::convertToQImage(const KoColorProfile *dstProfile, qint32 x1, qint32 y1, qint32 w, qint32 h, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags) const
 {
 
     if (w < 0)
         return QImage();
 
     if (h < 0)
         return QImage();
 
     quint8 *data = 0;
     try {
         data = new quint8 [w * h * pixelSize()];
     } catch (std::bad_alloc) {
         warnKrita << "KisPaintDevice::convertToQImage std::bad_alloc for " << w << " * " << h << " * " << pixelSize();
         //delete[] data; // data is not allocated, so don't free it
         return QImage();
     }
     Q_CHECK_PTR(data);
 
     // XXX: Is this really faster than converting line by line and building the QImage directly?
     //      This copies potentially a lot of data.
     readBytes(data, x1, y1, w, h);
     QImage image = colorSpace()->convertToQImage(data, w, h, dstProfile, renderingIntent, conversionFlags);
     delete[] data;
 
     return image;
 }
 
 inline bool moveBy(KisSequentialConstIterator& iter, int numPixels)
 {
     int pos = 0;
     while (pos < numPixels) {
         int step = std::min(iter.nConseqPixels(), numPixels - pos);
         if (!iter.nextPixels(step))
             return false;
         pos += step;
     }
     return true;
 }
 
 static KisPaintDeviceSP createThumbnailDeviceInternal(const KisPaintDevice* srcDev, qint32 srcX0, qint32 srcY0, qint32 srcWidth, qint32 srcHeight, qint32 w, qint32 h, QRect outputRect)
 {
     KisPaintDeviceSP thumbnail = new KisPaintDevice(srcDev->colorSpace());
     qint32 pixelSize = srcDev->pixelSize();
 
     KisRandomConstAccessorSP srcIter = srcDev->createRandomConstAccessorNG(0, 0);
     KisRandomAccessorSP dstIter = thumbnail->createRandomAccessorNG(0, 0);
 
     for (qint32 y = outputRect.y(); y < outputRect.y() + outputRect.height(); ++y) {
         qint32 iY = srcY0 + (y * srcHeight) / h;
         for (qint32 x = outputRect.x(); x < outputRect.x() + outputRect.width(); ++x) {
             qint32 iX = srcX0 + (x * srcWidth) / w;
             srcIter->moveTo(iX, iY);
             dstIter->moveTo(x,  y);
             memcpy(dstIter->rawData(), srcIter->rawDataConst(), pixelSize);
         }
     }
     return thumbnail;
 }
 
 QSize fixThumbnailSize(QSize size)
 {
     if (!size.width() && size.height()) {
         size.setWidth(1);
     }
 
     if (size.width() && !size.height()) {
         size.setHeight(1);
     }
 
     return size;
 }
 
 KisPaintDeviceSP KisPaintDevice::createThumbnailDevice(qint32 w, qint32 h, QRect rect, QRect outputRect) const
 {
     QSize thumbnailSize(w, h);
 
     QRect imageRect = rect.isValid() ? rect : extent();
 
     if ((thumbnailSize.width() > imageRect.width()) || (thumbnailSize.height() > imageRect.height())) {
         thumbnailSize.scale(imageRect.size(), Qt::KeepAspectRatio);
     }
 
     thumbnailSize = fixThumbnailSize(thumbnailSize);
 
     //can't create thumbnail for an empty device, e.g. layer thumbnail for empty image
     if (imageRect.isEmpty() || thumbnailSize.isEmpty()) {
         return new KisPaintDevice(colorSpace());
     }
 
     int srcWidth, srcHeight;
     int srcX0, srcY0;
     imageRect.getRect(&srcX0, &srcY0, &srcWidth, &srcHeight);
 
     if (!outputRect.isValid()) {
         outputRect = QRect(0, 0, w, h);
     }
 
     KisPaintDeviceSP thumbnail = createThumbnailDeviceInternal(this, imageRect.x(), imageRect.y(), imageRect.width(), imageRect.height(),
                                  thumbnailSize.width(), thumbnailSize.height(), outputRect);
 
     return thumbnail;
 }
 
 KisPaintDeviceSP KisPaintDevice::createThumbnailDeviceOversampled(qint32 w, qint32 h, qreal oversample, QRect rect,  QRect outputTileRect) const
 {
     QSize thumbnailSize(w, h);
     qreal oversampleAdjusted = qMax(oversample, 1.);
     QSize thumbnailOversampledSize = oversampleAdjusted * thumbnailSize;
 
     QRect outputRect;
     QRect imageRect = rect.isValid() ? rect : extent();
 
     qint32 hstart = thumbnailOversampledSize.height();
 
     if ((thumbnailOversampledSize.width() > imageRect.width()) || (thumbnailOversampledSize.height() > imageRect.height())) {
         thumbnailOversampledSize.scale(imageRect.size(), Qt::KeepAspectRatio);
     }
 
     thumbnailOversampledSize = fixThumbnailSize(thumbnailOversampledSize);
 
     //can't create thumbnail for an empty device, e.g. layer thumbnail for empty image
     if (imageRect.isEmpty() || thumbnailSize.isEmpty() || thumbnailOversampledSize.isEmpty()) {
         return new KisPaintDevice(colorSpace());
     }
 
     oversampleAdjusted *= (hstart > 0) ? ((qreal)thumbnailOversampledSize.height() / hstart) : 1.; //readjusting oversample ratio, given that we had to adjust thumbnail size
 
     outputRect = QRect(0, 0, thumbnailOversampledSize.width(), thumbnailOversampledSize.height());
 
     if (outputTileRect.isValid()) {
         //compensating output rectangle for oversampling
         outputTileRect = QRect(oversampleAdjusted * outputTileRect.topLeft(), oversampleAdjusted * outputTileRect.bottomRight());
         outputRect = outputRect.intersected(outputTileRect);
     }
 
     KisPaintDeviceSP thumbnail = createThumbnailDeviceInternal(this, imageRect.x(), imageRect.y(), imageRect.width(), imageRect.height(),
                                  thumbnailOversampledSize.width(), thumbnailOversampledSize.height(), outputRect);
 
     if (oversample != 1. && oversampleAdjusted != 1.) {
         KoDummyUpdater updater;
         KisTransformWorker worker(thumbnail, 1 / oversampleAdjusted, 1 / oversampleAdjusted, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
                                   &updater, KisFilterStrategyRegistry::instance()->value("Bilinear"));
         worker.run();
     }
     return thumbnail;
 }
 
 QImage KisPaintDevice::createThumbnail(qint32 w, qint32 h, QRect rect, qreal oversample, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags)
 {
     QSize size = fixThumbnailSize(QSize(w, h));
 
     KisPaintDeviceSP dev = createThumbnailDeviceOversampled(size.width(), size.height(), oversample, rect);
     QImage thumbnail = dev->convertToQImage(KoColorSpaceRegistry::instance()->rgb8()->profile(), 0, 0, w, h, renderingIntent, conversionFlags);
     return thumbnail;
 }
 
 QImage KisPaintDevice::createThumbnail(qint32 w, qint32 h, qreal oversample, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags)
 {
     QSize size = fixThumbnailSize(QSize(w, h));
 
     return m_d->cache()->createThumbnail(size.width(), size.height(), oversample, renderingIntent, conversionFlags);
 }
 
 KisHLineIteratorSP KisPaintDevice::createHLineIteratorNG(qint32 x, qint32 y, qint32 w)
 {
     m_d->cache()->invalidate();
     return m_d->currentStrategy()->createHLineIteratorNG(m_d->dataManager().data(), x, y, w, m_d->x(), m_d->y());
 }
 
 KisHLineConstIteratorSP KisPaintDevice::createHLineConstIteratorNG(qint32 x, qint32 y, qint32 w) const
 {
     return m_d->currentStrategy()->createHLineConstIteratorNG(m_d->dataManager().data(), x, y, w, m_d->x(), m_d->y());
 }
 
 KisVLineIteratorSP KisPaintDevice::createVLineIteratorNG(qint32 x, qint32 y, qint32 w)
 {
     m_d->cache()->invalidate();
     return m_d->currentStrategy()->createVLineIteratorNG(x, y, w);
 }
 
 KisVLineConstIteratorSP KisPaintDevice::createVLineConstIteratorNG(qint32 x, qint32 y, qint32 w) const
 {
     return m_d->currentStrategy()->createVLineConstIteratorNG(x, y, w);
 }
 
 KisRepeatHLineConstIteratorSP KisPaintDevice::createRepeatHLineConstIterator(qint32 x, qint32 y, qint32 w, const QRect& _dataWidth) const
 {
     return new KisRepeatHLineConstIteratorNG(m_d->dataManager().data(), x, y, w, m_d->x(), m_d->y(), _dataWidth, m_d->cacheInvalidator());
 }
 
 KisRepeatVLineConstIteratorSP KisPaintDevice::createRepeatVLineConstIterator(qint32 x, qint32 y, qint32 h, const QRect& _dataWidth) const
 {
     return new KisRepeatVLineConstIteratorNG(m_d->dataManager().data(), x, y, h, m_d->x(), m_d->y(), _dataWidth, m_d->cacheInvalidator());
 }
 
 KisRandomAccessorSP KisPaintDevice::createRandomAccessorNG(qint32 x, qint32 y)
 {
     m_d->cache()->invalidate();
     return m_d->currentStrategy()->createRandomAccessorNG(x, y);
 }
 
 KisRandomConstAccessorSP KisPaintDevice::createRandomConstAccessorNG(qint32 x, qint32 y) const
 {
     return m_d->currentStrategy()->createRandomConstAccessorNG(x, y);
 }
 
 KisRandomSubAccessorSP KisPaintDevice::createRandomSubAccessor() const
 {
     KisPaintDevice* pd = const_cast<KisPaintDevice*>(this);
     return new KisRandomSubAccessor(pd);
 }
 
 void KisPaintDevice::clearSelection(KisSelectionSP selection)
 {
     const KoColorSpace *colorSpace = m_d->colorSpace();
     QRect r = selection->selectedExactRect() & m_d->defaultBounds->bounds();
 
     if (r.isValid()) {
 
         KisHLineIteratorSP devIt = createHLineIteratorNG(r.x(), r.y(), r.width());
         KisHLineConstIteratorSP selectionIt = selection->projection()->createHLineConstIteratorNG(r.x(), r.y(), r.width());
 
         const KoColor defaultPixel = this->defaultPixel();
         bool transparentDefault = (defaultPixel.opacityU8() == OPACITY_TRANSPARENT_U8);
         for (qint32 y = 0; y < r.height(); y++) {
 
             do {
                 // XXX: Optimize by using stretches
                 colorSpace->applyInverseAlphaU8Mask(devIt->rawData(), selectionIt->rawDataConst(), 1);
                 if (transparentDefault && colorSpace->opacityU8(devIt->rawData()) == OPACITY_TRANSPARENT_U8) {
                     memcpy(devIt->rawData(), defaultPixel.data(), colorSpace->pixelSize());
                 }
             } while (devIt->nextPixel() && selectionIt->nextPixel());
             devIt->nextRow();
             selectionIt->nextRow();
         }
         m_d->dataManager()->purge(r.translated(-m_d->x(), -m_d->y()));
         setDirty(r);
     }
 }
 
 bool KisPaintDevice::pixel(qint32 x, qint32 y, QColor *c) const
 {
     KisHLineConstIteratorSP iter = createHLineConstIteratorNG(x, y, 1);
 
     const quint8 *pix = iter->rawDataConst();
 
     if (!pix) return false;
 
     colorSpace()->toQColor(pix, c);
 
     return true;
 }
 
 
 bool KisPaintDevice::pixel(qint32 x, qint32 y, KoColor * kc) const
 {
     KisHLineConstIteratorSP iter = createHLineConstIteratorNG(x, y, 1);
 
     const quint8 *pix = iter->rawDataConst();
 
     if (!pix) return false;
 
     kc->setColor(pix, m_d->colorSpace());
 
     return true;
 }
 
 bool KisPaintDevice::setPixel(qint32 x, qint32 y, const QColor& c)
 {
     KisHLineIteratorSP iter = createHLineIteratorNG(x, y, 1);
 
     colorSpace()->fromQColor(c, iter->rawData());
     m_d->cache()->invalidate();
     return true;
 }
 
 bool KisPaintDevice::setPixel(qint32 x, qint32 y, const KoColor& kc)
 {
     const quint8 * pix;
     KisHLineIteratorSP iter = createHLineIteratorNG(x, y, 1);
     if (kc.colorSpace() != m_d->colorSpace()) {
         KoColor kc2(kc, m_d->colorSpace());
         pix = kc2.data();
         memcpy(iter->rawData(), pix, m_d->colorSpace()->pixelSize());
     } else {
         pix = kc.data();
         memcpy(iter->rawData(), pix, m_d->colorSpace()->pixelSize());
     }
     m_d->cache()->invalidate();
     return true;
 }
 
 bool KisPaintDevice::fastBitBltPossible(KisPaintDeviceSP src)
 {
     return m_d->fastBitBltPossible(src);
 }
 
 void KisPaintDevice::fastBitBlt(KisPaintDeviceSP src, const QRect &rect)
 {
     m_d->currentStrategy()->fastBitBlt(src, rect);
 }
 
 void KisPaintDevice::fastBitBltOldData(KisPaintDeviceSP src, const QRect &rect)
 {
     m_d->currentStrategy()->fastBitBltOldData(src, rect);
 }
 
 void KisPaintDevice::fastBitBltRough(KisPaintDeviceSP src, const QRect &rect)
 {
     m_d->currentStrategy()->fastBitBltRough(src, rect);
 }
 
 void KisPaintDevice::fastBitBltRoughOldData(KisPaintDeviceSP src, const QRect &rect)
 {
     m_d->currentStrategy()->fastBitBltRoughOldData(src, rect);
 }
 
 void KisPaintDevice::readBytes(quint8 * data, qint32 x, qint32 y, qint32 w, qint32 h) const
 {
     readBytes(data, QRect(x, y, w, h));
 }
 
 void KisPaintDevice::readBytes(quint8 *data, const QRect &rect) const
 {
     m_d->currentStrategy()->readBytes(data, rect);
 }
 
 void KisPaintDevice::writeBytes(const quint8 *data, qint32 x, qint32 y, qint32 w, qint32 h)
 {
     writeBytes(data, QRect(x, y, w, h));
 }
 
 void KisPaintDevice::writeBytes(const quint8 *data, const QRect &rect)
 {
     m_d->currentStrategy()->writeBytes(data, rect);
 }
 
 QVector<quint8*> KisPaintDevice::readPlanarBytes(qint32 x, qint32 y, qint32 w, qint32 h) const
 {
     return m_d->currentStrategy()->readPlanarBytes(x, y, w, h);
 }
 
 void KisPaintDevice::writePlanarBytes(QVector<quint8*> planes, qint32 x, qint32 y, qint32 w, qint32 h)
 {
     m_d->currentStrategy()->writePlanarBytes(planes, x, y, w, h);
 }
 
 
 quint32 KisPaintDevice::pixelSize() const
 {
     quint32 _pixelSize = m_d->colorSpace()->pixelSize();
     Q_ASSERT(_pixelSize > 0);
     return _pixelSize;
 }
 
 quint32 KisPaintDevice::channelCount() const
 {
     quint32 _channelCount = m_d->colorSpace()->channelCount();
     Q_ASSERT(_channelCount > 0);
     return _channelCount;
 }
 
 KisRasterKeyframeChannel *KisPaintDevice::createKeyframeChannel(const KoID &id)
 {
     Q_ASSERT(!m_d->framesInterface);
     m_d->framesInterface.reset(new KisPaintDeviceFramesInterface(this));
 
     Q_ASSERT(!m_d->contentChannel);
     m_d->contentChannel.reset(new KisRasterKeyframeChannel(id, this, m_d->defaultBounds));
 
     // Raster channels always have at least one frame (representing a static image)
     KUndo2Command tempParentCommand;
     m_d->contentChannel->addKeyframe(0, &tempParentCommand);
 
     return m_d->contentChannel.data();
 }
 
 KisRasterKeyframeChannel* KisPaintDevice::keyframeChannel() const
 {
     Q_ASSERT(m_d->contentChannel);
     return m_d->contentChannel.data();
 }
 
 const KoColorSpace* KisPaintDevice::colorSpace() const
 {
     Q_ASSERT(m_d->colorSpace() != 0);
     return m_d->colorSpace();
 }
 
 KisPaintDeviceSP KisPaintDevice::createCompositionSourceDevice() const
 {
     KisPaintDeviceSP device = new KisPaintDevice(compositionSourceColorSpace());
     device->setDefaultBounds(defaultBounds());
     return device;
 }
 
 KisPaintDeviceSP KisPaintDevice::createCompositionSourceDevice(KisPaintDeviceSP cloneSource) const
 {
     KisPaintDeviceSP clone = new KisPaintDevice(*cloneSource);
     clone->setDefaultBounds(defaultBounds());
     clone->convertTo(compositionSourceColorSpace(),
                      KoColorConversionTransformation::internalRenderingIntent(),
                      KoColorConversionTransformation::internalConversionFlags());
     return clone;
 }
 
 KisPaintDeviceSP KisPaintDevice::createCompositionSourceDevice(KisPaintDeviceSP cloneSource, const QRect roughRect) const
 {
     KisPaintDeviceSP clone = new KisPaintDevice(colorSpace());
     clone->setDefaultBounds(defaultBounds());
     clone->makeCloneFromRough(cloneSource, roughRect);
     clone->convertTo(compositionSourceColorSpace(),
                      KoColorConversionTransformation::internalRenderingIntent(),
                      KoColorConversionTransformation::internalConversionFlags());
     return clone;
 }
 
 KisFixedPaintDeviceSP KisPaintDevice::createCompositionSourceDeviceFixed() const
 {
     return new KisFixedPaintDevice(compositionSourceColorSpace());
 }
 
 const KoColorSpace* KisPaintDevice::compositionSourceColorSpace() const
 {
     return colorSpace();
 }
 
 QVector<qint32> KisPaintDevice::channelSizes() const
 {
     QVector<qint32> sizes;
     QList<KoChannelInfo*> channels = colorSpace()->channels();
     std::sort(channels.begin(), channels.end());
 
     Q_FOREACH (KoChannelInfo * channelInfo, channels) {
         sizes.append(channelInfo->size());
     }
     return sizes;
 }
 
 KisPaintDevice::MemoryReleaseObject::~MemoryReleaseObject()
 {
     KisDataManager::releaseInternalPools();
 }
 
 KisPaintDevice::MemoryReleaseObject* KisPaintDevice::createMemoryReleaseObject()
 {
     return new MemoryReleaseObject();
 }
 
 KisPaintDevice::LodDataStruct::~LodDataStruct()
 {
 }
 
 QRegion KisPaintDevice::regionForLodSyncing() const
 {
     return m_d->regionForLodSyncing();
 }
 
 KisPaintDevice::LodDataStruct* KisPaintDevice::createLodDataStruct(int lod)
 {
     return m_d->createLodDataStruct(lod);
 }
 
 void KisPaintDevice::updateLodDataStruct(LodDataStruct *dst, const QRect &srcRect)
 {
     m_d->updateLodDataStruct(dst, srcRect);
 }
 
 void KisPaintDevice::uploadLodDataStruct(LodDataStruct *dst)
 {
     m_d->uploadLodDataStruct(dst);
 }
 
+void KisPaintDevice::generateLodCloneDevice(KisPaintDeviceSP dst, const QRect &originalRect, int lod)
+{
+    m_d->generateLodCloneDevice(dst, originalRect, lod);
+}
+
 
 KisPaintDeviceFramesInterface* KisPaintDevice::framesInterface()
 {
     return m_d->framesInterface.data();
 }
 
 /******************************************************************/
 /*               KisPaintDeviceFramesInterface                    */
 /******************************************************************/
 
 KisPaintDeviceFramesInterface::KisPaintDeviceFramesInterface(KisPaintDevice *parentDevice)
     : q(parentDevice)
 {
 }
 
 QList<int> KisPaintDeviceFramesInterface::frames()
 {
     return q->m_d->frameIds();
 }
 
 int KisPaintDeviceFramesInterface::createFrame(bool copy, int copySrc, const QPoint &offset, KUndo2Command *parentCommand)
 {
     return q->m_d->createFrame(copy, copySrc, offset, parentCommand);
 }
 
 void KisPaintDeviceFramesInterface::deleteFrame(int frame, KUndo2Command *parentCommand)
 {
     return q->m_d->deleteFrame(frame, parentCommand);
 }
 
 void KisPaintDeviceFramesInterface::fetchFrame(int frameId, KisPaintDeviceSP targetDevice)
 {
     q->m_d->fetchFrame(frameId, targetDevice);
 }
 
 void KisPaintDeviceFramesInterface::uploadFrame(int srcFrameId, int dstFrameId, KisPaintDeviceSP srcDevice)
 {
     q->m_d->uploadFrame(srcFrameId, dstFrameId, srcDevice);
 }
 
 void KisPaintDeviceFramesInterface::uploadFrame(int dstFrameId, KisPaintDeviceSP srcDevice)
 {
     q->m_d->uploadFrame(dstFrameId, srcDevice);
 }
 
 QRect KisPaintDeviceFramesInterface::frameBounds(int frameId)
 {
     return q->m_d->frameBounds(frameId);
 }
 
 QPoint KisPaintDeviceFramesInterface::frameOffset(int frameId) const
 {
     return q->m_d->frameOffset(frameId);
 }
 
 void KisPaintDeviceFramesInterface::setFrameDefaultPixel(const KoColor &defPixel, int frameId)
 {
     KIS_ASSERT_RECOVER_RETURN(frameId >= 0);
     q->m_d->setFrameDefaultPixel(defPixel, frameId);
 }
 
 KoColor KisPaintDeviceFramesInterface::frameDefaultPixel(int frameId) const
 {
     KIS_ASSERT_RECOVER(frameId >= 0) {
         return KoColor(Qt::red, q->m_d->colorSpace());
     }
     return q->m_d->frameDefaultPixel(frameId);
 }
 
 bool KisPaintDeviceFramesInterface::writeFrame(KisPaintDeviceWriter &store, int frameId)
 {
     KIS_ASSERT_RECOVER(frameId >= 0) {
         return false;
     }
     return q->m_d->writeFrame(store, frameId);
 }
 
 bool KisPaintDeviceFramesInterface::readFrame(QIODevice *stream, int frameId)
 {
     KIS_ASSERT_RECOVER(frameId >= 0) {
         return false;
     }
     return q->m_d->readFrame(stream, frameId);
 }
 
 int KisPaintDeviceFramesInterface::currentFrameId() const
 {
     return q->m_d->currentFrameId();
 }
 
 KisDataManagerSP KisPaintDeviceFramesInterface::frameDataManager(int frameId) const
 {
     KIS_ASSERT_RECOVER(frameId >= 0) {
         return q->m_d->dataManager();
     }
     return q->m_d->frameDataManager(frameId);
 }
 
 void KisPaintDeviceFramesInterface::invalidateFrameCache(int frameId)
 {
     KIS_ASSERT_RECOVER_RETURN(frameId >= 0);
 
     return q->m_d->invalidateFrameCache(frameId);
 }
 
 void KisPaintDeviceFramesInterface::setFrameOffset(int frameId, const QPoint &offset)
 {
     KIS_ASSERT_RECOVER_RETURN(frameId >= 0);
     return q->m_d->setFrameOffset(frameId, offset);
 }
 
 KisPaintDeviceFramesInterface::TestingDataObjects
 KisPaintDeviceFramesInterface::testingGetDataObjects() const
 {
     TestingDataObjects objects;
 
     objects.m_data = q->m_d->m_data.data();
     objects.m_lodData = q->m_d->m_lodData.data();
     objects.m_externalFrameData = q->m_d->m_externalFrameData.data();
 
     typedef KisPaintDevice::Private::FramesHash FramesHash;
 
     FramesHash::const_iterator it = q->m_d->m_frames.constBegin();
     FramesHash::const_iterator end = q->m_d->m_frames.constEnd();
 
     for (; it != end; ++it) {
         objects.m_frames.insert(it.key(), it.value().data());
     }
 
     objects.m_currentData = q->m_d->currentData();
 
     return objects;
 }
 
 QList<KisPaintDeviceData*> KisPaintDeviceFramesInterface::testingGetDataObjectsList() const
 {
     return q->m_d->allDataObjects();
 }
 
 void KisPaintDevice::tesingFetchLodDevice(KisPaintDeviceSP targetDevice)
 {
     m_d->tesingFetchLodDevice(targetDevice);
 }
diff --git a/libs/image/kis_paint_device.h b/libs/image/kis_paint_device.h
index 674ee3138d..9a4c833391 100644
--- a/libs/image/kis_paint_device.h
+++ b/libs/image/kis_paint_device.h
@@ -1,878 +1,880 @@
 /*
  *  Copyright (c) 2002 patrick julien <freak@codepimps.org>
  *  Copyright (c) 2006 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #ifndef KIS_PAINT_DEVICE_IMPL_H_
 #define KIS_PAINT_DEVICE_IMPL_H_
 
 #include <QObject>
 #include <QRect>
 #include <QVector>
 
 #include "kis_debug.h"
 
 #include <KoColorConversionTransformation.h>
 
 #include "kis_types.h"
 #include "kis_shared.h"
 #include "kis_default_bounds_base.h"
 
 #include <kritaimage_export.h>
 
 class KUndo2Command;
 class QRect;
 class QImage;
 class QPoint;
 class QString;
 class QColor;
 class QIODevice;
 
 class KoColor;
 class KoColorSpace;
 class KoColorProfile;
 
 class KisDataManager;
 class KisPaintDeviceWriter;
 class KisKeyframe;
 class KisRasterKeyframeChannel;
 
 class KisPaintDeviceFramesInterface;
 
 typedef KisSharedPtr<KisDataManager> KisDataManagerSP;
 
 namespace KritaUtils {
 enum DeviceCopyMode {
     CopySnapshot = 0,
     CopyAllFrames
 };
 }
 
 
 /**
  * A paint device contains the actual pixel data and offers methods
  * to read and write pixels. A paint device has an integer x, y position
  * (it is not positioned on the image with sub-pixel accuracy).
  * A KisPaintDevice doesn't have any fixed size, the size changes dynamically
  * when pixels are accessed by an iterator.
  */
 class KRITAIMAGE_EXPORT KisPaintDevice
     : public QObject
     , public KisShared
 {
 
     Q_OBJECT
 
 public:
 
     /**
      * Create a new paint device with the specified colorspace.
      *
      * @param colorSpace the colorspace of this paint device
      * @param name for debugging purposes
      */
     explicit KisPaintDevice(const KoColorSpace * colorSpace, const QString& name = QString());
 
     /**
      * Create a new paint device with the specified colorspace. The
      * parent node will be notified of changes to this paint device.
      *
      * @param parent the node that contains this paint device
      * @param colorSpace the colorspace of this paint device
      * @param defaultBounds boundaries of the device in case it is empty
      * @param name for debugging purposes
      */
     KisPaintDevice(KisNodeWSP parent, const KoColorSpace * colorSpace, KisDefaultBoundsBaseSP defaultBounds = KisDefaultBoundsBaseSP(), const QString& name = QString());
 
     /**
      * Creates a copy of this device.
      *
      * If \p copyMode is CopySnapshot, the newly created device clones the
      * current frame of \p rhs only (default and efficient
      * behavior). If \p copyFrames is CopyAllFrames, the new device is a deep
      * copy of the source with all the frames included.
      */
     KisPaintDevice(const KisPaintDevice& rhs, KritaUtils::DeviceCopyMode copyMode = KritaUtils::CopySnapshot, KisNode *newParentNode = 0);
     ~KisPaintDevice() override;
 
 protected:
     /**
      * A special constructor for usage in KisPixelSelection. It allows
      * two paint devices to share a data manager.
      *
      * @param explicitDataManager data manager to use inside paint device
      * @param src source paint device to copy parameters from
      * @param name for debugging purposes
      */
     KisPaintDevice(KisDataManagerSP explicitDataManager,
                    KisPaintDeviceSP src, const QString& name = QString());
 
 public:
 
     /**
      * Write the pixels of this paint device into the specified file store.
      */
     bool write(KisPaintDeviceWriter &store);
 
     /**
      * Fill this paint device with the pixels from the specified file store.
      */
     bool read(QIODevice *stream);
 
 public:
 
     /**
      * set the parent node of the paint device
      */
     void setParentNode(KisNodeWSP parent);
 
     /**
      * set the default bounds for the paint device when
      * the default pixel is not completely transparent
      */
     void setDefaultBounds(KisDefaultBoundsBaseSP bounds);
 
     /**
      * the default bounds rect of the paint device
      */
     KisDefaultBoundsBaseSP defaultBounds() const;
 
     /**
      * Moves the device to these new coordinates (no incremental move)
      */
     void moveTo(qint32 x, qint32 y);
 
     /**
      * Convenience method for the above.
      */
     virtual void moveTo(const QPoint& pt);
 
     /**
      * Return an X,Y offset of the device in a convenient form
      */
     QPoint offset() const;
 
     /**
      * The X offset of the paint device
      */
     qint32 x() const;
 
     /**
      * The Y offset of the paint device
      */
     qint32 y() const;
 
     /**
      * set the X offset of the paint device
      */
     void setX(qint32 x);
 
     /**
      * set the Y offset of the paint device
      */
     void setY(qint32 y);
 
     /**
      * Retrieve the bounds of the paint device. The size is not exact,
      * but may be larger if the underlying datamanager works that way.
      * For instance, the tiled datamanager keeps the extent to the nearest
      * multiple of 64.
      *
      * If default pixel is not transparent, then the actual extent
      * rect is united with the defaultBounds()->bounds() value
      * (the size of the image, usually).
      */
     QRect extent() const;
 
     /// Convenience method for the above
     void extent(qint32 &x, qint32 &y, qint32 &w, qint32 &h) const;
 
     /**
      * Get the exact bounds of this paint device. The real solution is
      * very slow because it does a linear scanline search, but it
      * uses caching, so calling to this function without changing
      * the device is quite cheap.
      *
      * Exactbounds follows these rules:
      *
      * <ul>
      * <li>if default pixel is transparent, then exact bounds
      *     of actual pixel data are returned
      * <li>if default pixel is not transparent, then the union
      *     (defaultBounds()->bounds() | nonDefaultPixelArea()) is
      *     returned
      * </ul>
      * \see calculateExactBounds()
      */
     QRect exactBounds() const;
 
     /**
      * Relaxed version of the exactBounds() that can be used in tight
      * loops.  If the exact bounds value is present in the paint
      * device cache, returns this value.  If the cache is invalidated,
      * returns extent() and tries to recalculate the exact bounds not
      * faster than once in 1000 ms.
      */
     QRect exactBoundsAmortized() const;
 
     /**
      * Returns exact rectangle of the paint device that contains
      * non-default pixels. For paint devices with fully transparent
      * default pixel is equivalent to exactBounds().
      *
      * nonDefaultPixelArea() follows these rules:
      *
      * <ul>
      * <li>if default pixel is transparent, then exact bounds
      *     of actual pixel data are returned. The same as exactBounds()
      * <li>if default pixel is not transparent, then calculates the
      *     rectangle of non-default pixels. May be smaller or greater
      *     than image bounds
      * </ul>
      * \see calculateExactBounds()
      */
     QRect nonDefaultPixelArea() const;
 
 
     /**
      * Returns a rough approximation of region covered by device.
      * For tiled data manager, it region will consist of a number
      * of rects each corresponding to a tile.
      */
     QRegion region() const;
 
     /**
      * The slow version of region() that searches for exact bounds of
      * each rectangle in the region
      */
     QRegion regionExact() const;
 
     /**
      * Cut the paint device down to the specified rect. If the crop
      * area is bigger than the paint device, nothing will happen.
      */
     void crop(qint32 x, qint32 y, qint32 w, qint32 h);
 
     /// Convenience method for the above
     void crop(const QRect & r);
 
     /**
      * Complete erase the current paint device. Its size will become 0. This
      * does not take the selection into account.
      */
     virtual void clear();
 
     /**
      * Clear the given rectangle to transparent black. The paint device will expand to
      * contain the given rect.
      */
     void clear(const QRect & rc);
 
     /**
      * Frees the memory occupied by the pixels containing default
      * values. The extents() and exactBounds() of the image will
      * probably also shrink
      */
     void purgeDefaultPixels();
 
     /**
      * Sets the default pixel. New data will be initialised with this pixel. The pixel is copied: the
      * caller still owns the pointer and needs to delete it to avoid memory leaks.
      * If frame ID is given, set default pixel for that frame. Otherwise use active frame.
      */
     void setDefaultPixel(const KoColor &defPixel);
 
     /**
      * Get a pointer to the default pixel.
      * If the frame parameter is given, get the default pixel of
      * specified frame. Otherwise use currently active frame.
      */
     KoColor defaultPixel() const;
 
     /**
      * Fill the given rectangle with the given pixel. The paint device will expand to
      * contain the given rect.
      */
     void fill(const QRect & rc, const KoColor &color);
 
     /**
      * Overloaded function. For legacy purposes only.
      * Please use fill(const QRect & rc, const KoColor &color) instead
      */
     void fill(qint32 x, qint32 y, qint32 w, qint32 h, const quint8 *fillPixel);
 
 public:
 
     /**
      * Prepares the device for fastBitBlt opreration. It clears
      * the device, switches x,y shifts and colorspace if needed.
      * After this call fastBitBltPossible will return true.
      * May be used for initialization of temporary devices.
      */
     void prepareClone(KisPaintDeviceSP src);
 
     /**
      * Make this device to become a clone of \a src. It will have the same
      * x,y shifts, colorspace and will share pixels inside \a rect.
      * After calling this function:
      * (this->extent() >= this->exactBounds() == rect).
      *
      * Rule of thumb:
      *
      * "Use makeCloneFrom() or makeCloneFromRough() if and only if you
      * are the only owner of the destination paint device and you are
      * 100% sure no other thread has access to it"
      */
     void makeCloneFrom(KisPaintDeviceSP src, const QRect &rect);
 
     /**
      * Make this device to become a clone of \a src. It will have the same
      * x,y shifts, colorspace and will share pixels inside \a rect.
      * Be careful, this function will copy *at least* \a rect
      * of pixels. Actual copy area will be a bigger - it will
      * be aligned by tiles borders. So after calling this function:
      * (this->extent() == this->exactBounds() >= rect).
      *
      * Rule of thumb:
      *
      * "Use makeCloneFrom() or makeCloneFromRough() if and only if you
      * are the only owner of the destination paint device and you are
      * 100% sure no other thread has access to it"
      */
     void makeCloneFromRough(KisPaintDeviceSP src, const QRect &minimalRect);
 
 
 protected:
     friend class KisPaintDeviceTest;
     friend class DataReaderThread;
 
     /**
      * Checks whether a src paint device can be used as source
      * of fast bitBlt operation. The result of the check may
      * depend on whether color spaces coinside, whether there is
      * any shift of tiles between the devices and etc.
      *
      * WARNING: This check must be done <i>before</i> performing any
      * fast bitBlt operation!
      *
      * \see fastBitBlt
      * \see fastBitBltRough
      */
     bool fastBitBltPossible(KisPaintDeviceSP src);
 
     /**
      * Clones rect from another paint device. The cloned area will be
      * shared between both paint devices as much as possible using
      * copy-on-write. Parts of the rect that cannot be shared
      * (cross tiles) are deep-copied,
      *
      * \see fastBitBltPossible
      * \see fastBitBltRough
      */
     void fastBitBlt(KisPaintDeviceSP src, const QRect &rect);
 
     /**
      * The same as \ref fastBitBlt() but reads old data
      */
     void fastBitBltOldData(KisPaintDeviceSP src, const QRect &rect);
 
     /**
      * Clones rect from another paint device in a rough and fast way.
      * All the tiles touched by rect will be shared, between both
      * devices, that means it will copy a bigger area than was
      * requested. This method is supposed to be used for bitBlt'ing
      * into temporary paint devices.
      *
      * \see fastBitBltPossible
      * \see fastBitBlt
      */
     void fastBitBltRough(KisPaintDeviceSP src, const QRect &rect);
 
     /**
      * The same as \ref fastBitBltRough() but reads old data
      */
     void fastBitBltRoughOldData(KisPaintDeviceSP src, const QRect &rect);
 
 public:
     /**
      * Read the bytes representing the rectangle described by x, y, w, h into
      * data. If data is not big enough, Krita will gladly overwrite the rest
      * of your precious memory.
      *
      * Since this is a copy, you need to make sure you have enough memory.
      *
      * Reading from areas not previously initialized will read the default
      * pixel value into data but not initialize that region.
      */
     void readBytes(quint8 * data, qint32 x, qint32 y, qint32 w, qint32 h) const;
 
     /**
      * Read the bytes representing the rectangle rect into
      * data. If data is not big enough, Krita will gladly overwrite the rest
      * of your precious memory.
      *
      * Since this is a copy, you need to make sure you have enough memory.
      *
      * Reading from areas not previously initialized will read the default
      * pixel value into data but not initialize that region.
      * @param data The address of the memory to receive the bytes read
      * @param rect The rectangle in the paint device to read from
      */
     void readBytes(quint8 * data, const QRect &rect) const;
 
     /**
      * Copy the bytes in data into the rect specified by x, y, w, h. If the
      * data is too small or uninitialized, Krita will happily read parts of
      * memory you never wanted to be read.
      *
      * If the data is written to areas of the paint device not previously initialized,
      * the paint device will grow.
      */
     void writeBytes(const quint8 * data, qint32 x, qint32 y, qint32 w, qint32 h);
 
     /**
      * Copy the bytes in data into the rectangle rect. If the
      * data is too small or uninitialized, Krita will happily read parts of
      * memory you never wanted to be read.
      *
      * If the data is written to areas of the paint device not previously initialized,
      * the paint device will grow.
      * @param data The address of the memory to write bytes from
      * @param rect The rectangle in the paint device to write to
      */
     void writeBytes(const quint8 * data, const QRect &rect);
 
     /**
      * Copy the bytes in the paint device into a vector of arrays of bytes,
      * where the number of arrays is the number of channels in the
      * paint device. If the specified area is larger than the paint
      * device's extent, the default pixel will be read.
      */
     QVector<quint8*> readPlanarBytes(qint32 x, qint32 y, qint32 w, qint32 h) const;
 
     /**
      * Write the data in the separate arrays to the channes. If there
      * are less vectors than channels, the remaining channels will not
      * be copied. If any of the arrays points to 0, the channel in
      * that location will not be touched. If the specified area is
      * larger than the paint device, the paint device will be
      * extended. There are no guards: if the area covers more pixels
      * than there are bytes in the arrays, krita will happily fill
      * your paint device with areas of memory you never wanted to be
      * read. Krita may also crash.
      *
      * XXX: what about undo?
      */
     void writePlanarBytes(QVector<quint8*> planes, qint32 x, qint32 y, qint32 w, qint32 h);
 
     /**
      * Converts the paint device to a different colorspace
      *
      * @return a command that can be used to undo the conversion.
      */
     KUndo2Command* convertTo(const KoColorSpace * dstColorSpace,
                              KoColorConversionTransformation::Intent renderingIntent = KoColorConversionTransformation::internalRenderingIntent(),
                              KoColorConversionTransformation::ConversionFlags conversionFlags = KoColorConversionTransformation::internalConversionFlags());
 
     /**
      * Changes the profile of the colorspace of this paint device to the given
      * profile. If the given profile is 0, nothing happens.
      */
     bool setProfile(const KoColorProfile * profile);
 
     /**
      * Fill this paint device with the data from image; starting at (offsetX, offsetY)
      * @param srcProfileName name of the RGB profile to interpret the image as. 0 is interpreted as sRGB
      */
     void convertFromQImage(const QImage& image, const KoColorProfile *profile, qint32 offsetX = 0, qint32 offsetY = 0);
 
     /**
      * Create an RGBA QImage from a rectangle in the paint device.
      *
      * @param x Left coordinate of the rectangle
      * @param y Top coordinate of the rectangle
      * @param w Width of the rectangle in pixels
      * @param h Height of the rectangle in pixels
      * @param dstProfile RGB profile to use in conversion. May be 0, in which
      * case it's up to the color strategy to choose a profile (most
      * like sRGB).
      */
     QImage convertToQImage(const KoColorProfile *dstProfile, qint32 x, qint32 y, qint32 w, qint32 h,
                            KoColorConversionTransformation::Intent renderingIntent = KoColorConversionTransformation::internalRenderingIntent(),
                            KoColorConversionTransformation::ConversionFlags conversionFlags = KoColorConversionTransformation::internalConversionFlags()) const;
 
     /**
      * Overridden method for convenience
      */
     QImage convertToQImage(const KoColorProfile *dstProfile,
                            const QRect &rc,
                            KoColorConversionTransformation::Intent renderingIntent = KoColorConversionTransformation::internalRenderingIntent(),
                            KoColorConversionTransformation::ConversionFlags conversionFlags = KoColorConversionTransformation::internalConversionFlags()) const;
 
     /**
      * Create an RGBA QImage from a rectangle in the paint device. The
      * rectangle is defined by the parent image's bounds.
      *
      * @param dstProfile RGB profile to use in conversion. May be 0, in which
      * case it's up to the color strategy to choose a profile (most
      * like sRGB).
      */
     QImage convertToQImage(const KoColorProfile *  dstProfile,
                            KoColorConversionTransformation::Intent renderingIntent = KoColorConversionTransformation::internalRenderingIntent(),
                            KoColorConversionTransformation::ConversionFlags conversionFlags = KoColorConversionTransformation::internalConversionFlags()) const;
 
     /**
      * Creates a paint device thumbnail of the paint device, retaining
      * the aspect ratio. The width and height of the returned device
      * won't exceed \p maxw and \p maxw, but they may be smaller.
      *
      * @param maxw: maximum width
      * @param maxh: maximum height
      * @param rect: only this rect will be used for the thumbnail
      *
      */
     KisPaintDeviceSP createThumbnailDevice(qint32 w, qint32 h, QRect rect = QRect(), QRect outputRect = QRect()) const;
     KisPaintDeviceSP createThumbnailDeviceOversampled(qint32 w, qint32 h, qreal oversample, QRect rect = QRect(),  QRect outputRect = QRect()) const;
 
     /**
      * Creates a thumbnail of the paint device, retaining the aspect ratio.
      * The width and height of the returned QImage won't exceed \p maxw and \p maxw, but they may be smaller.
      * The colors are not corrected for display!
      *
      * @param maxw: maximum width
      * @param maxh: maximum height
      * @param rect: only this rect will be used for the thumbnail
      * @param oversample: ratio used for antialiasing
      */
     QImage createThumbnail(qint32 maxw, qint32 maxh, QRect rect, qreal oversample = 1,
                            KoColorConversionTransformation::Intent renderingIntent = KoColorConversionTransformation::internalRenderingIntent(),
                            KoColorConversionTransformation::ConversionFlags conversionFlags = KoColorConversionTransformation::internalConversionFlags());
 
     /**
      * Cached version of createThumbnail(qint32 maxw, qint32 maxh, const KisSelection *selection, QRect rect)
      */
     QImage createThumbnail(qint32 maxw, qint32 maxh, qreal oversample = 1,
                            KoColorConversionTransformation::Intent renderingIntent = KoColorConversionTransformation::internalRenderingIntent(),
                            KoColorConversionTransformation::ConversionFlags conversionFlags = KoColorConversionTransformation::internalConversionFlags());
 
     /**
      * Fill c and opacity with the values found at x and y.
      *
      * The color values will be transformed from the profile of
      * this paint device to the display profile.
      *
      * @return true if the operation was successful.
      */
     bool pixel(qint32 x, qint32 y, QColor *c) const;
 
     /**
      * Fill kc with the values found at x and y. This method differs
      * from the above in using KoColor, which can be of any colorspace
      *
      * The color values will be transformed from the profile of
      * this paint device to the display profile.
      *
      * @return true if the operation was successful.
      */
     bool pixel(qint32 x, qint32 y, KoColor * kc) const;
 
     /**
      * Set the specified pixel to the specified color. Note that this
      * bypasses KisPainter. the PaintDevice is here used as an equivalent
      * to QImage, not QPixmap. This means that this is not undoable; also,
      * there is no compositing with an existing value at this location.
      *
      * The color values will be transformed from the display profile to
      * the paint device profile.
      *
      * Note that this will use 8-bit values and may cause a significant
      * degradation when used on 16-bit or hdr quality images.
      *
      * @return true if the operation was successful
      */
     bool setPixel(qint32 x, qint32 y, const QColor& c);
 
     /// Convenience method for the above
     bool setPixel(qint32 x, qint32 y, const KoColor& kc);
 
     /**
      * @return the colorspace of the pixels in this paint device
      */
     const KoColorSpace* colorSpace() const;
 
     /**
      * There is quite a common technique in Krita. It is used in
      * cases, when we want to paint something over a paint device
      * using the composition, opacity or selection. E.g. painting a
      * dab in a paint op, filling the selection in the Fill Tool.
      * Such work is usually done in the following way:
      *
      * 1) Create a paint device
      *
      * 2) Fill it with the desired color or data
      *
      * 3) Create a KisPainter and set all the properties of the
      *    transaction: selection, compositeOp, opacity and etc.
      *
      * 4) Paint a newly created paint device over the destination
      *    device.
      *
      * The following two methods (createCompositionSourceDevice() or
      * createCompositionSourceDeviceFixed())should be used for the
      * accomplishing the step 1). The point is that the desired color
      * space of the temporary device may not coincide with the color
      * space of the destination. That is the case, for example, for
      * the alpha8() colorspace used in the selections. So for such
      * devices the temporary target would have a different (grayscale)
      * color space.
      *
      * So there are two rules of thumb:
      *
      * 1) If you need a temporary device which you are going to fill
      *    with some data and then paint over the paint device, create
      *    it with either createCompositionSourceDevice() or
      *    createCompositionSourceDeviceFixed().
      *
      * 2) Do *not* expect that the color spaces of the destination and
      *    the temporary device would coincide. If you need to copy a
      *    single pixel from one device to another, you can use
      *    KisCrossDeviceColorPicker class, that will handle all the
      *    necessary conversions for you.
      *
      * \see createCompositionSourceDeviceFixed()
      * \see compositionSourceColorSpace()
      * \see KisCrossDeviceColorPicker
      * \see KisCrossDeviceColorPickerInt
      */
     KisPaintDeviceSP createCompositionSourceDevice() const;
 
     /**
      * The same as createCompositionSourceDevice(), but initializes the
      * newly created device with the content of \p cloneSource
      *
      * \see createCompositionSourceDevice()
      */
     KisPaintDeviceSP createCompositionSourceDevice(KisPaintDeviceSP cloneSource) const;
 
     /**
      * The same as createCompositionSourceDevice(), but initializes
      * the newly created device with the *rough* \p roughRect of
      * \p cloneSource.
      *
      * "Rough rect" means that it may copy a bit more than
      * requested. It is expected that the caller will not use the area
      * outside \p roughRect.
      *
      * \see createCompositionSourceDevice()
      */
     KisPaintDeviceSP createCompositionSourceDevice(KisPaintDeviceSP cloneSource, const QRect roughRect) const;
 
     /**
      * This is a convenience method for createCompositionSourceDevice()
      *
      * \see createCompositionSourceDevice()
      */
     KisFixedPaintDeviceSP createCompositionSourceDeviceFixed() const;
 
     /**
      * This is a lowlevel method for the principle used in
      * createCompositionSourceDevice(). In most of the cases the paint
      * device creation methods should be used instead of this function.
      *
      * \see createCompositionSourceDevice()
      * \see createCompositionSourceDeviceFixed()
      */
     virtual const KoColorSpace* compositionSourceColorSpace() const;
 
     /**
      * @return the internal datamanager that keeps the pixels.
      */
     KisDataManagerSP dataManager() const;
 
     /**
      * Replace the pixel data, color strategy, and profile.
      */
     void setDataManager(KisDataManagerSP data, const KoColorSpace * colorSpace = 0);
 
     /**
      * Return the number of bytes a pixel takes.
      */
     quint32 pixelSize() const;
 
     /**
      * Return the number of channels a pixel takes
      */
     quint32 channelCount() const;
 
     /**
      * Create a keyframe channel for the content on this device.
      * @param id identifier for the channel
      * @param node the parent node for the channel
      * @return keyframe channel
      */
     KisRasterKeyframeChannel *createKeyframeChannel(const KoID &id);
 
     KisRasterKeyframeChannel* keyframeChannel() const;
 
     /**
      * An interface to modify/load/save frames stored inside this device
      */
     KisPaintDeviceFramesInterface* framesInterface();
 
 public:
 
     /**
      * Add the specified rect to the parent layer's set of dirty rects
      * (if there is a parent layer)
      */
     void setDirty(const QRect & rc);
 
     /**
      *  Add the specified region to the parent layer's dirty region
      *  (if there is a parent layer)
      */
     void setDirty(const QRegion & region);
 
     /**
      *  Set the parent layer completely dirty, if this paint device has
      *  as parent layer.
      */
     void setDirty();
 
     void setDirty(const QVector<QRect> rects);
 
     /**
      * Called by KisTransactionData when it thinks current time should
      * be changed. And the requests is forwarded to the image if
      * needed.
      */
     void requestTimeSwitch(int time);
 
     /**
      * \return a sequence number corresponding to the current paint
      *         device state. Every time the paint device is changed,
      *         the sequence number is increased
      */
     int sequenceNumber() const;
 
 
     void estimateMemoryStats(qint64 &imageData, qint64 &temporaryData, qint64 &lodData) const;
 
 public:
 
     KisHLineIteratorSP createHLineIteratorNG(qint32 x, qint32 y, qint32 w);
     KisHLineConstIteratorSP createHLineConstIteratorNG(qint32 x, qint32 y, qint32 w) const;
 
     KisVLineIteratorSP createVLineIteratorNG(qint32 x, qint32 y, qint32 h);
     KisVLineConstIteratorSP createVLineConstIteratorNG(qint32 x, qint32 y, qint32 h) const;
 
     KisRandomAccessorSP createRandomAccessorNG(qint32 x, qint32 y);
     KisRandomConstAccessorSP createRandomConstAccessorNG(qint32 x, qint32 y) const;
 
     /**
      * Create an iterator that will "artificially" extend the paint device with the
      * value of the border when trying to access values outside the range of data.
      *
      * @param rc indicates the rectangle that truly contains data
      */
     KisRepeatHLineConstIteratorSP createRepeatHLineConstIterator(qint32 x, qint32 y, qint32 w, const QRect& _dataWidth) const;
     /**
      * Create an iterator that will "artificially" extend the paint device with the
      * value of the border when trying to access values outside the range of data.
      *
      * @param rc indicates the rectangle that trully contains data
      */
     KisRepeatVLineConstIteratorSP createRepeatVLineConstIterator(qint32 x, qint32 y, qint32 h, const QRect& _dataWidth) const;
 
     /**
      * This function create a random accessor which can easily access to sub pixel values.
      * @param selection an up-to-date selection that has the same origin as the paint device
      */
     KisRandomSubAccessorSP createRandomSubAccessor() const;
 
 
     /** Clear the selected pixels from the paint device */
     void clearSelection(KisSelectionSP selection);
 
 Q_SIGNALS:
 
     void profileChanged(const KoColorProfile *  profile);
     void colorSpaceChanged(const KoColorSpace *colorspace);
 
 public:
     friend class PaintDeviceCache;
 
     /**
      * Caclculates exact bounds of the device. Used internally
      * by a transparent caching system. The solution is very slow
      * because it does a linear scanline search. So the complexity
      * is n*n at worst.
      *
      * \see exactBounds(), nonDefaultPixelArea()
      */
     QRect calculateExactBounds(bool nonDefaultOnly) const;
 
 public:
     struct MemoryReleaseObject : public QObject {
         ~MemoryReleaseObject() override;
     };
 
     static MemoryReleaseObject* createMemoryReleaseObject();
 
 public:
     struct LodDataStruct {
         virtual ~LodDataStruct();
     };
 
     QRegion regionForLodSyncing() const;
     LodDataStruct* createLodDataStruct(int lod);
     void updateLodDataStruct(LodDataStruct *dst, const QRect &srcRect);
     void uploadLodDataStruct(LodDataStruct *dst);
 
+    void generateLodCloneDevice(KisPaintDeviceSP dst, const QRect &originalRect, int lod);
+
     void setProjectionDevice(bool value);
     void tesingFetchLodDevice(KisPaintDeviceSP targetDevice);
 
 private:
     KisPaintDevice& operator=(const KisPaintDevice&);
     void init(const KoColorSpace *colorSpace,
               KisDefaultBoundsBaseSP defaultBounds,
               KisNodeWSP parent, const QString& name);
 
     // Only KisPainter is allowed to have access to these low-level methods
     friend class KisPainter;
 
     /**
      * Return a vector with in order the size in bytes of the channels
      * in the colorspace of this paint device.
      */
     QVector<qint32> channelSizes() const;
 
     void emitColorSpaceChanged();
     void emitProfileChanged();
 
 private:
     friend class KisPaintDeviceFramesInterface;
 
 protected:
     friend class KisSelectionTest;
     KisNodeWSP parentNode() const;
 
 private:
     struct Private;
     Private * const m_d;
 };
 
 #endif // KIS_PAINT_DEVICE_IMPL_H_
diff --git a/libs/ui/CMakeLists.txt b/libs/ui/CMakeLists.txt
index c388f23b79..38b6e288e8 100644
--- a/libs/ui/CMakeLists.txt
+++ b/libs/ui/CMakeLists.txt
@@ -1,592 +1,599 @@
 include_directories(
     ${CMAKE_CURRENT_SOURCE_DIR}/qtlockedfile
     ${EXIV2_INCLUDE_DIR}
 )
 
 include_directories(SYSTEM
     ${EIGEN3_INCLUDE_DIR}
     ${OCIO_INCLUDE_DIR}
 )
 
 add_subdirectory( tests )
 
 if (APPLE)
     find_library(FOUNDATION_LIBRARY Foundation)
     find_library(APPKIT_LIBRARY AppKit)
 endif ()
 
 set(kritaui_LIB_SRCS
     canvas/kis_canvas_widget_base.cpp
     canvas/kis_canvas2.cpp
     canvas/kis_canvas_updates_compressor.cpp
     canvas/kis_canvas_controller.cpp
     canvas/kis_paintop_transformation_connector.cpp
     canvas/kis_display_color_converter.cpp
     canvas/kis_display_filter.cpp
     canvas/kis_exposure_gamma_correction_interface.cpp
     canvas/kis_tool_proxy.cpp
     canvas/kis_canvas_decoration.cc
     canvas/kis_coordinates_converter.cpp
     canvas/kis_grid_manager.cpp
     canvas/kis_grid_decoration.cpp
     canvas/kis_grid_config.cpp
     canvas/kis_prescaled_projection.cpp
     canvas/kis_qpainter_canvas.cpp
     canvas/kis_projection_backend.cpp
     canvas/kis_update_info.cpp
     canvas/kis_image_patch.cpp
     canvas/kis_image_pyramid.cpp
     canvas/kis_infinity_manager.cpp
     canvas/kis_change_guides_command.cpp
     canvas/kis_guides_decoration.cpp
     canvas/kis_guides_manager.cpp
     canvas/kis_guides_config.cpp
     canvas/kis_snap_config.cpp
     canvas/kis_snap_line_strategy.cpp
     canvas/KisSnapPointStrategy.cpp
     dialogs/kis_about_application.cpp
     dialogs/kis_dlg_adj_layer_props.cc
     dialogs/kis_dlg_adjustment_layer.cc
     dialogs/kis_dlg_filter.cpp
     dialogs/kis_dlg_generator_layer.cpp
     dialogs/kis_dlg_file_layer.cpp
     dialogs/kis_dlg_filter.cpp
     dialogs/kis_dlg_stroke_selection_properties.cpp
     dialogs/kis_dlg_image_properties.cc
     dialogs/kis_dlg_layer_properties.cc
     dialogs/kis_dlg_preferences.cc
     dialogs/slider_and_spin_box_sync.cpp
     dialogs/kis_dlg_blacklist_cleanup.cpp
     dialogs/kis_dlg_layer_style.cpp
     dialogs/kis_dlg_png_import.cpp
     dialogs/kis_dlg_import_image_sequence.cpp
     dialogs/kis_delayed_save_dialog.cpp
     dialogs/kis_dlg_internal_color_selector.cpp
     dialogs/KisSessionManagerDialog.cpp
     dialogs/KisNewWindowLayoutDialog.cpp
     flake/kis_node_dummies_graph.cpp
     flake/kis_dummies_facade_base.cpp
     flake/kis_dummies_facade.cpp
     flake/kis_node_shapes_graph.cpp
     flake/kis_node_shape.cpp
     flake/kis_shape_controller.cpp
     flake/kis_shape_layer.cc
     flake/kis_shape_layer_canvas.cpp
     flake/kis_shape_selection.cpp
     flake/kis_shape_selection_canvas.cpp
     flake/kis_shape_selection_model.cpp
     flake/kis_take_all_shapes_command.cpp
     brushhud/kis_uniform_paintop_property_widget.cpp
     brushhud/kis_brush_hud.cpp
     brushhud/kis_round_hud_button.cpp
     brushhud/kis_dlg_brush_hud_config.cpp
     brushhud/kis_brush_hud_properties_list.cpp
     brushhud/kis_brush_hud_properties_config.cpp
     kis_aspect_ratio_locker.cpp
     kis_autogradient.cc
     kis_bookmarked_configurations_editor.cc
     kis_bookmarked_configurations_model.cc
     kis_bookmarked_filter_configurations_model.cc
     KisPaintopPropertiesBase.cpp
     kis_canvas_resource_provider.cpp
     kis_derived_resources.cpp
     kis_categories_mapper.cpp
     kis_categorized_list_model.cpp
     kis_categorized_item_delegate.cpp
     kis_clipboard.cc
     kis_config.cc
     kis_config_notifier.cpp
     kis_control_frame.cpp
     kis_composite_ops_model.cc
     kis_paint_ops_model.cpp
     kis_cursor.cc
     kis_cursor_cache.cpp
     kis_custom_pattern.cc
     kis_file_layer.cpp
     kis_change_file_layer_command.h
     kis_safe_document_loader.cpp
     kis_splash_screen.cpp
     kis_filter_manager.cc
     kis_filters_model.cc
     kis_histogram_view.cc
     KisImageBarrierLockerWithFeedback.cpp
     kis_image_manager.cc
     kis_image_view_converter.cpp
     kis_import_catcher.cc
     kis_layer_manager.cc
     kis_mask_manager.cc
     kis_mimedata.cpp
     kis_node_commands_adapter.cpp
     kis_node_manager.cpp
     kis_node_juggler_compressed.cpp
     kis_node_selection_adapter.cpp
     kis_node_insertion_adapter.cpp
     kis_node_model.cpp
     kis_node_filter_proxy_model.cpp
     kis_model_index_converter_base.cpp
     kis_model_index_converter.cpp
     kis_model_index_converter_show_all.cpp
     kis_painting_assistant.cc
     kis_painting_assistants_decoration.cpp
     KisDecorationsManager.cpp
     kis_paintop_box.cc
     kis_paintop_option.cpp
     kis_paintop_options_model.cpp
     kis_paintop_settings_widget.cpp
     kis_popup_palette.cpp
     kis_png_converter.cpp
     kis_preference_set_registry.cpp
     KisResourceServerProvider.cpp
     KisResourceBundleServerProvider.cpp
     KisSelectedShapesProxy.cpp
     kis_selection_decoration.cc
     kis_selection_manager.cc
     kis_statusbar.cc
     kis_zoom_manager.cc
     kis_favorite_resource_manager.cpp
     kis_workspace_resource.cpp
     kis_action.cpp
     kis_action_manager.cpp
     KisActionPlugin.cpp
     kis_canvas_controls_manager.cpp
     kis_tooltip_manager.cpp
     kis_multinode_property.cpp
     kis_stopgradient_editor.cpp
     kisexiv2/kis_exif_io.cpp
     kisexiv2/kis_exiv2.cpp
     kisexiv2/kis_iptc_io.cpp
     kisexiv2/kis_xmp_io.cpp
     opengl/kis_opengl.cpp
     opengl/kis_opengl_canvas2.cpp
     opengl/kis_opengl_canvas_debugger.cpp
     opengl/kis_opengl_image_textures.cpp
     opengl/kis_texture_tile.cpp
     opengl/kis_opengl_shader_loader.cpp
     opengl/kis_texture_tile_info_pool.cpp
+    opengl/KisOpenGLUpdateInfoBuilder.cpp
     kis_fps_decoration.cpp
     recorder/kis_node_query_path_editor.cc
     recorder/kis_recorded_action_creator.cc
     recorder/kis_recorded_action_creator_factory.cc
     recorder/kis_recorded_action_creator_factory_registry.cc
     recorder/kis_recorded_action_editor_factory.cc
     recorder/kis_recorded_action_editor_factory_registry.cc
     recorder/kis_recorded_filter_action_editor.cc
     recorder/kis_recorded_filter_action_creator.cpp
     recorder/kis_recorded_paint_action_editor.cc
     tool/kis_selection_tool_helper.cpp
     tool/kis_selection_tool_config_widget_helper.cpp
     tool/kis_rectangle_constraint_widget.cpp
     tool/kis_shape_tool_helper.cpp
     tool/kis_tool.cc
     tool/kis_delegated_tool_policies.cpp
     tool/kis_tool_freehand.cc
     tool/kis_speed_smoother.cpp
     tool/kis_painting_information_builder.cpp
     tool/kis_stabilized_events_sampler.cpp
     tool/kis_tool_freehand_helper.cpp
     tool/kis_tool_multihand_helper.cpp
     tool/kis_figure_painting_tool_helper.cpp
     tool/kis_recording_adapter.cpp
     tool/kis_tool_paint.cc
     tool/kis_tool_shape.cc
     tool/kis_tool_ellipse_base.cpp
     tool/kis_tool_rectangle_base.cpp
     tool/kis_tool_polyline_base.cpp
     tool/kis_tool_utils.cpp
     tool/kis_resources_snapshot.cpp
     tool/kis_smoothing_options.cpp
     tool/KisStabilizerDelayedPaintHelper.cpp
     tool/KisStrokeSpeedMonitor.cpp
     tool/strokes/freehand_stroke.cpp
     tool/strokes/KisStrokeEfficiencyMeasurer.cpp
     tool/strokes/kis_painter_based_stroke_strategy.cpp
     tool/strokes/kis_filter_stroke_strategy.cpp
     tool/strokes/kis_color_picker_stroke_strategy.cpp
     tool/strokes/KisFreehandStrokeInfo.cpp
     tool/strokes/KisMaskedFreehandStrokePainter.cpp
     tool/strokes/KisMaskingBrushRenderer.cpp
     tool/strokes/KisMaskingBrushCompositeOpFactory.cpp
 
     widgets/kis_cmb_composite.cc
     widgets/kis_cmb_contour.cpp
     widgets/kis_cmb_gradient.cpp
     widgets/kis_paintop_list_widget.cpp
     widgets/kis_cmb_idlist.cc
     widgets/kis_color_space_selector.cc
     widgets/kis_advanced_color_space_selector.cc
     widgets/kis_cie_tongue_widget.cpp
     widgets/kis_tone_curve_widget.cpp
     widgets/kis_curve_widget.cpp
     widgets/kis_custom_image_widget.cc
     widgets/kis_image_from_clipboard_widget.cpp
     widgets/kis_double_widget.cc
     widgets/kis_filter_selector_widget.cc
     widgets/kis_gradient_chooser.cc
     widgets/kis_iconwidget.cc
     widgets/kis_mask_widgets.cpp
     widgets/kis_meta_data_merge_strategy_chooser_widget.cc
     widgets/kis_multi_bool_filter_widget.cc
     widgets/kis_multi_double_filter_widget.cc
     widgets/kis_multi_integer_filter_widget.cc
     widgets/kis_multipliers_double_slider_spinbox.cpp
     widgets/kis_paintop_presets_popup.cpp
     widgets/kis_tool_options_popup.cpp
     widgets/kis_paintop_presets_chooser_popup.cpp
     widgets/kis_paintop_presets_save.cpp
     widgets/kis_paintop_preset_icon_library.cpp
     widgets/kis_pattern_chooser.cc
 
     widgets/kis_popup_button.cc
     widgets/kis_preset_chooser.cpp
     widgets/kis_progress_widget.cpp
     widgets/kis_selection_options.cc
     widgets/kis_scratch_pad.cpp
     widgets/kis_scratch_pad_event_filter.cpp
     widgets/kis_preset_selector_strip.cpp
     widgets/kis_slider_spin_box.cpp
     widgets/KisSelectionPropertySlider.cpp
     widgets/kis_size_group.cpp
     widgets/kis_size_group_p.cpp
     widgets/kis_wdg_generator.cpp
     widgets/kis_workspace_chooser.cpp
     widgets/kis_categorized_list_view.cpp
     widgets/kis_widget_chooser.cpp
     widgets/kis_tool_button.cpp
     widgets/kis_floating_message.cpp
     widgets/kis_lod_availability_widget.cpp
     widgets/kis_color_label_selector_widget.cpp
     widgets/kis_color_filter_combo.cpp
     widgets/kis_elided_label.cpp
     widgets/kis_stopgradient_slider_widget.cpp
     widgets/kis_spinbox_color_selector.cpp
     widgets/kis_screen_color_picker.cpp
     widgets/kis_preset_live_preview_view.cpp
     widgets/KoDualColorButton.cpp
     widgets/kis_color_input.cpp
     widgets/kis_color_button.cpp
     widgets/KisVisualColorSelector.cpp
     widgets/KisVisualColorSelectorShape.cpp
     widgets/KisVisualEllipticalSelectorShape.cpp
     widgets/KisVisualRectangleSelectorShape.cpp
     widgets/KisVisualTriangleSelectorShape.cpp
     widgets/KoStrokeConfigWidget.cpp
     widgets/KoFillConfigWidget.cpp
 
 
     utils/kis_document_aware_spin_box_unit_manager.cpp
 
     input/kis_input_manager.cpp
     input/kis_input_manager_p.cpp
     input/kis_extended_modifiers_mapper.cpp
     input/kis_abstract_input_action.cpp
     input/kis_tool_invocation_action.cpp
     input/kis_pan_action.cpp
     input/kis_alternate_invocation_action.cpp
     input/kis_rotate_canvas_action.cpp
     input/kis_zoom_action.cpp
     input/kis_change_frame_action.cpp
     input/kis_gamma_exposure_action.cpp
     input/kis_show_palette_action.cpp
     input/kis_change_primary_setting_action.cpp
     input/kis_abstract_shortcut.cpp
     input/kis_native_gesture_shortcut.cpp
     input/kis_single_action_shortcut.cpp
     input/kis_stroke_shortcut.cpp
     input/kis_shortcut_matcher.cpp
     input/kis_select_layer_action.cpp
     input/KisQtWidgetsTweaker.cpp
     input/KisInputActionGroup.cpp
 
     operations/kis_operation.cpp
     operations/kis_operation_configuration.cpp
     operations/kis_operation_registry.cpp
     operations/kis_operation_ui_factory.cpp
     operations/kis_operation_ui_widget.cpp
     operations/kis_filter_selection_operation.cpp
     actions/kis_selection_action_factories.cpp
     actions/KisPasteActionFactory.cpp
     input/kis_touch_shortcut.cpp
     kis_document_undo_store.cpp
     kis_transaction_based_command.cpp
     kis_gui_context_command.cpp
     kis_gui_context_command_p.cpp
     input/kis_tablet_debugger.cpp
     input/kis_input_profile_manager.cpp
     input/kis_input_profile.cpp
     input/kis_shortcut_configuration.cpp
     input/config/kis_input_configuration_page.cpp
     input/config/kis_edit_profiles_dialog.cpp
     input/config/kis_input_profile_model.cpp
     input/config/kis_input_configuration_page_item.cpp
     input/config/kis_action_shortcuts_model.cpp
     input/config/kis_input_type_delegate.cpp
     input/config/kis_input_mode_delegate.cpp
     input/config/kis_input_button.cpp
     input/config/kis_input_editor_delegate.cpp
     input/config/kis_mouse_input_editor.cpp
     input/config/kis_wheel_input_editor.cpp
     input/config/kis_key_input_editor.cpp
     processing/fill_processing_visitor.cpp
     kis_asl_layer_style_serializer.cpp
     kis_psd_layer_style_resource.cpp
     canvas/kis_mirror_axis.cpp
 
     kis_abstract_perspective_grid.cpp
     
     KisApplication.cpp
     KisAutoSaveRecoveryDialog.cpp
     KisDetailsPane.cpp
     KisDocument.cpp
     KisCloneDocumentStroke.cpp
     KisNodeDelegate.cpp
     kis_node_view_visibility_delegate.cpp
     KisNodeToolTip.cpp
     KisNodeView.cpp
     kis_node_view_color_scheme.cpp
     KisImportExportFilter.cpp
     KisFilterEntry.cpp
     KisImportExportManager.cpp
     KisImportExportUtils.cpp
     kis_async_action_feedback.cpp
     KisMainWindow.cpp
     KisOpenPane.cpp
     KisPart.cpp
     KisPrintJob.cpp
     KisTemplate.cpp
     KisTemplateCreateDia.cpp
     KisTemplateGroup.cpp
     KisTemplates.cpp
     KisTemplatesPane.cpp
     KisTemplateTree.cpp
     KisUndoActionsUpdateManager.cpp
     KisView.cpp
 
     thememanager.cpp
 
     kis_mainwindow_observer.cpp
     KisViewManager.cpp
     kis_mirror_manager.cpp
 
     qtlockedfile/qtlockedfile.cpp
 
     qtsingleapplication/qtlocalpeer.cpp
     qtsingleapplication/qtsingleapplication.cpp
 
     KisResourceBundle.cpp
     KisResourceBundleManifest.cpp
 
     kis_md5_generator.cpp
     KisApplicationArguments.cpp
 
     KisNetworkAccessManager.cpp
     KisMultiFeedRSSModel.cpp
     KisRemoteFileFetcher.cpp
 
     KisPaletteModel.cpp
     kis_palette_delegate.cpp
     kis_palette_view.cpp
     KisColorsetChooser.cpp
     KisSaveGroupVisitor.cpp
     KisWindowLayoutResource.cpp
     KisWindowLayoutManager.cpp
     KisSessionResource.cpp
 
     KisReferenceImagesDecoration.cpp
     KisReferenceImage.cpp
     flake/KisReferenceImagesLayer.cpp
     flake/KisReferenceImagesLayer.h
 )
 
 if(WIN32)
     set(kritaui_LIB_SRCS
         ${kritaui_LIB_SRCS}
         input/kis_tablet_event.cpp
         input/wintab/kis_tablet_support_win.cpp
         input/wintab/kis_screen_size_choice_dialog.cpp
         qtlockedfile/qtlockedfile_win.cpp
         input/wintab/kis_tablet_support_win8.cpp
         opengl/kis_opengl_win.cpp
         )
 endif()
 
     set(kritaui_LIB_SRCS
         ${kritaui_LIB_SRCS}
         kis_animation_frame_cache.cpp
         kis_animation_cache_populator.cpp
         KisAsyncAnimationRendererBase.cpp
         KisAsyncAnimationCacheRenderer.cpp
         KisAsyncAnimationFramesSavingRenderer.cpp
         dialogs/KisAsyncAnimationRenderDialogBase.cpp
         dialogs/KisAsyncAnimationCacheRenderDialog.cpp
         dialogs/KisAsyncAnimationFramesSaveDialog.cpp
         canvas/kis_animation_player.cpp
         kis_animation_importer.cpp
         KisSyncedAudioPlayback.cpp
+        KisFrameDataSerializer.cpp
+        KisFrameCacheStore.cpp
+        KisFrameCacheSwapper.cpp
+        KisAbstractFrameCacheSwapper.cpp
+        KisInMemoryFrameCacheSwapper.cpp
+
         input/wintab/drawpile_tablettester/tablettester.cpp
         input/wintab/drawpile_tablettester/tablettest.cpp
     )
 
 if(UNIX)
     set(kritaui_LIB_SRCS
         ${kritaui_LIB_SRCS}
         input/kis_tablet_event.cpp
         input/wintab/kis_tablet_support.cpp
         qtlockedfile/qtlockedfile_unix.cpp
         )
     if(NOT APPLE)
         set(kritaui_LIB_SRCS
             ${kritaui_LIB_SRCS}
             input/wintab/qxcbconnection_xi2.cpp
             input/wintab/qxcbconnection.cpp
             input/wintab/kis_xi2_event_filter.cpp
             )
     endif()
 endif()
 
 if(APPLE)
     set(kritaui_LIB_SRCS
         ${kritaui_LIB_SRCS}
         osx.mm
     )
 endif()
 
 ki18n_wrap_ui(kritaui_LIB_SRCS
     widgets/KoFillConfigWidget.ui
     widgets/KoStrokeConfigWidget.ui
     forms/wdgdlgpngimport.ui
     forms/wdgfullscreensettings.ui
     forms/wdgautogradient.ui
     forms/wdggeneralsettings.ui
     forms/wdgperformancesettings.ui
     forms/wdggenerators.ui
     forms/wdgbookmarkedconfigurationseditor.ui
     forms/wdgapplyprofile.ui
     forms/wdgcustompattern.ui
     forms/wdglayerproperties.ui
     forms/wdgcolorsettings.ui
     forms/wdgtabletsettings.ui
     forms/wdgcolorspaceselector.ui
     forms/wdgcolorspaceselectoradvanced.ui
     forms/wdgdisplaysettings.ui
     forms/kis_previewwidgetbase.ui
     forms/kis_matrix_widget.ui
     forms/wdgselectionoptions.ui
     forms/wdggeometryoptions.ui
     forms/wdgnewimage.ui
     forms/wdgimageproperties.ui
     forms/wdgmaskfromselection.ui
     forms/wdgmasksource.ui
     forms/wdgfilterdialog.ui
     forms/wdgmetadatamergestrategychooser.ui
     forms/wdgpaintoppresets.ui
     forms/wdgpaintopsettings.ui
     forms/wdgdlggeneratorlayer.ui
     forms/wdgdlgfilelayer.ui
     forms/wdgfilterselector.ui
     forms/wdgfilternodecreation.ui
     forms/wdgpaintactioneditor.ui
     forms/wdgmultipliersdoublesliderspinbox.ui
     forms/wdgnodequerypatheditor.ui
     forms/wdgpresetselectorstrip.ui
     forms/wdgsavebrushpreset.ui
     forms/wdgpreseticonlibrary.ui
     forms/wdgdlgblacklistcleanup.ui
     forms/wdgrectangleconstraints.ui
     forms/wdgimportimagesequence.ui
     forms/wdgstrokeselectionproperties.ui
     forms/KisDetailsPaneBase.ui
     forms/KisOpenPaneBase.ui
     forms/wdgstopgradienteditor.ui
     forms/wdgsessionmanager.ui
     forms/wdgnewwindowlayout.ui
     brushhud/kis_dlg_brush_hud_config.ui
     forms/wdgdlginternalcolorselector.ui
     dialogs/kis_delayed_save_dialog.ui
     input/config/kis_input_configuration_page.ui
     input/config/kis_edit_profiles_dialog.ui
     input/config/kis_input_configuration_page_item.ui
     input/config/kis_mouse_input_editor.ui
     input/config/kis_wheel_input_editor.ui
     input/config/kis_key_input_editor.ui
 
     layerstyles/wdgBevelAndEmboss.ui
     layerstyles/wdgblendingoptions.ui
     layerstyles/WdgColorOverlay.ui
     layerstyles/wdgContour.ui
     layerstyles/wdgdropshadow.ui
     layerstyles/WdgGradientOverlay.ui
     layerstyles/wdgInnerGlow.ui
     layerstyles/wdglayerstyles.ui
     layerstyles/WdgPatternOverlay.ui
     layerstyles/WdgSatin.ui
     layerstyles/WdgStroke.ui
     layerstyles/wdgstylesselector.ui
     layerstyles/wdgTexture.ui
 
     wdgsplash.ui
     input/wintab/kis_screen_size_choice_dialog.ui
     input/wintab/drawpile_tablettester/tablettest.ui
 
 )
 
 
 QT5_WRAP_CPP(kritaui_HEADERS_MOC KisNodePropertyAction_p.h)
 
 add_library(kritaui SHARED ${kritaui_HEADERS_MOC} ${kritaui_LIB_SRCS} )
 generate_export_header(kritaui BASE_NAME kritaui)
 
 target_link_libraries(kritaui KF5::CoreAddons KF5::Completion KF5::I18n KF5::ItemViews Qt5::Network
                       kritaimpex kritacolor kritaimage kritalibbrush kritawidgets kritawidgetutils ${PNG_LIBRARIES} ${EXIV2_LIBRARIES}
 )
 
 if (HAVE_QT_MULTIMEDIA)
     target_link_libraries(kritaui Qt5::Multimedia)
 endif()
 
 if (HAVE_KIO)
     target_link_libraries(kritaui KF5::KIOCore)
 endif() 
 
 if (NOT WIN32 AND NOT APPLE)
   target_link_libraries(kritaui ${X11_X11_LIB}
                                 ${X11_Xinput_LIB}
                                 ${XCB_LIBRARIES})
 endif()
 
 if(APPLE)
     target_link_libraries(kritaui ${FOUNDATION_LIBRARY})
     target_link_libraries(kritaui ${APPKIT_LIBRARY})
 endif ()
 
 
 target_link_libraries(kritaui ${OPENEXR_LIBRARIES})
 
 # Add VSync disable workaround
 if(NOT WIN32 AND NOT APPLE)
     target_link_libraries(kritaui ${CMAKE_DL_LIBS} Qt5::X11Extras)
 endif()
 
 if(X11_FOUND)
     target_link_libraries(kritaui Qt5::X11Extras ${X11_LIBRARIES})
 endif()
 
 target_include_directories(kritaui
     PUBLIC
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/canvas>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/flake>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/ora>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/tool>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/utils>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/widgets>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/input/wintab>
 )
 
 set_target_properties(kritaui
     PROPERTIES VERSION ${GENERIC_KRITA_LIB_VERSION} SOVERSION ${GENERIC_KRITA_LIB_SOVERSION}
 )
 install(TARGETS kritaui  ${INSTALL_TARGETS_DEFAULT_ARGS})
 
 
 if (APPLE)
     install(FILES osx.stylesheet DESTINATION ${DATA_INSTALL_DIR}/krita)
 endif ()
diff --git a/libs/ui/KisAbstractFrameCacheSwapper.cpp b/libs/ui/KisAbstractFrameCacheSwapper.cpp
new file mode 100644
index 0000000000..1540d8f32b
--- /dev/null
+++ b/libs/ui/KisAbstractFrameCacheSwapper.cpp
@@ -0,0 +1,22 @@
+/*
+ *  Copyright (c) 2018 Dmitry Kazakov <dimula73@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 "KisAbstractFrameCacheSwapper.h"
+
+KisAbstractFrameCacheSwapper::~KisAbstractFrameCacheSwapper()
+{
+}
diff --git a/libs/ui/KisAbstractFrameCacheSwapper.h b/libs/ui/KisAbstractFrameCacheSwapper.h
new file mode 100644
index 0000000000..c01db7953c
--- /dev/null
+++ b/libs/ui/KisAbstractFrameCacheSwapper.h
@@ -0,0 +1,50 @@
+/*
+ *  Copyright (c) 2018 Dmitry Kazakov <dimula73@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 KISABSTRACTFRAMECACHESWAPPER_H
+#define KISABSTRACTFRAMECACHESWAPPER_H
+
+#include "kritaui_export.h"
+
+class QRect;
+
+template<class T>
+class KisSharedPtr;
+
+class KisOpenGLUpdateInfo;
+typedef KisSharedPtr<KisOpenGLUpdateInfo> KisOpenGLUpdateInfoSP;
+
+
+class KRITAUI_EXPORT KisAbstractFrameCacheSwapper
+{
+public:
+    virtual ~KisAbstractFrameCacheSwapper();
+
+    // WARNING: after transferring \p info to saveFrame() the object becomes invalid
+    virtual void saveFrame(int frameId, KisOpenGLUpdateInfoSP info, const QRect &imageBounds) = 0;
+    virtual KisOpenGLUpdateInfoSP loadFrame(int frameId) = 0;
+
+    virtual void moveFrame(int srcFrameId, int dstFrameId) = 0;
+    virtual void forgetFrame(int frameId) = 0;
+
+    virtual bool hasFrame(int frameId) const = 0;
+
+    virtual int frameLevelOfDetail(int frameId) const = 0;
+    virtual QRect frameDirtyRect(int frameId) const = 0;
+};
+
+#endif // KISABSTRACTFRAMECACHESWAPPER_H
diff --git a/libs/ui/KisAsyncAnimationCacheRenderer.cpp b/libs/ui/KisAsyncAnimationCacheRenderer.cpp
index 1e49f3720a..d41b7dcd02 100644
--- a/libs/ui/KisAsyncAnimationCacheRenderer.cpp
+++ b/libs/ui/KisAsyncAnimationCacheRenderer.cpp
@@ -1,84 +1,84 @@
 /*
  *  Copyright (c) 2017 Dmitry Kazakov <dimula73@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 "KisAsyncAnimationCacheRenderer.h"
 
 #include "kis_animation_frame_cache.h"
 #include "kis_update_info.h"
 
 struct KisAsyncAnimationCacheRenderer::Private
 {
     KisAnimationFrameCacheSP requestedCache;
     KisOpenGLUpdateInfoSP requestInfo;
 };
 
 
 KisAsyncAnimationCacheRenderer::KisAsyncAnimationCacheRenderer()
     : m_d(new Private)
 {
     connect(this, SIGNAL(sigCompleteRegenerationInternal(int)), SLOT(slotCompleteRegenerationInternal(int)));
 }
 
 KisAsyncAnimationCacheRenderer::~KisAsyncAnimationCacheRenderer()
 {
 }
 
 void KisAsyncAnimationCacheRenderer::setFrameCache(KisAnimationFrameCacheSP cache)
 {
     m_d->requestedCache = cache;
 }
 
-void KisAsyncAnimationCacheRenderer::frameCompletedCallback(int frame)
+void KisAsyncAnimationCacheRenderer::frameCompletedCallback(int frame, const QRegion &requestedRegion)
 {
     KisAnimationFrameCacheSP cache = m_d->requestedCache;
     KisImageSP image = requestedImage();
     if (!cache || !image) return;
 
-    m_d->requestInfo = cache->fetchFrameData(frame, image);
+    m_d->requestInfo = cache->fetchFrameData(frame, image, requestedRegion);
     emit sigCompleteRegenerationInternal(frame);
 }
 
 void KisAsyncAnimationCacheRenderer::slotCompleteRegenerationInternal(int frame)
 {
     if (!isActive()) return;
 
     KIS_SAFE_ASSERT_RECOVER(m_d->requestInfo) {
         frameCancelledCallback(frame);
         return;
     }
 
     m_d->requestedCache->addConvertedFrameData(m_d->requestInfo, frame);
 
     notifyFrameCompleted(frame);
 }
 
 
 void KisAsyncAnimationCacheRenderer::frameCancelledCallback(int frame)
 {
     notifyFrameCancelled(frame);
 }
 
 void KisAsyncAnimationCacheRenderer::clearFrameRegenerationState(bool isCancelled)
 {
     m_d->requestInfo.clear();
     m_d->requestedCache.clear();
 
     KisAsyncAnimationRendererBase::clearFrameRegenerationState(isCancelled);
 }
 
 
diff --git a/libs/ui/KisAsyncAnimationCacheRenderer.h b/libs/ui/KisAsyncAnimationCacheRenderer.h
index 9701203dfc..4d581c6a59 100644
--- a/libs/ui/KisAsyncAnimationCacheRenderer.h
+++ b/libs/ui/KisAsyncAnimationCacheRenderer.h
@@ -1,50 +1,50 @@
 /*
  *  Copyright (c) 2017 Dmitry Kazakov <dimula73@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 KISASYNCANIMATIONCACHERENDERER_H
 #define KISASYNCANIMATIONCACHERENDERER_H
 
 #include <KisAsyncAnimationRendererBase.h>
 
 class KisAsyncAnimationCacheRenderer : public KisAsyncAnimationRendererBase
 {
     Q_OBJECT
 public:
     KisAsyncAnimationCacheRenderer();
     ~KisAsyncAnimationCacheRenderer();
 
     void setFrameCache(KisAnimationFrameCacheSP cache);
 
 protected:
-    void frameCompletedCallback(int frame) override;
+    void frameCompletedCallback(int frame, const QRegion &requestedRegion) override;
     void frameCancelledCallback(int frame) override;
     void clearFrameRegenerationState(bool isCancelled) override;
 
 
 Q_SIGNALS:
     void sigCompleteRegenerationInternal(int frame);
 
 private Q_SLOTS:
     void slotCompleteRegenerationInternal(int frame);
 
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 };
 
 #endif // KISASYNCANIMATIONCACHERENDERER_H
diff --git a/libs/ui/KisAsyncAnimationFramesSavingRenderer.cpp b/libs/ui/KisAsyncAnimationFramesSavingRenderer.cpp
index 442a9fbc6b..76809a84fd 100644
--- a/libs/ui/KisAsyncAnimationFramesSavingRenderer.cpp
+++ b/libs/ui/KisAsyncAnimationFramesSavingRenderer.cpp
@@ -1,127 +1,132 @@
 /*
  *  Copyright (c) 2017 Dmitry Kazakov <dimula73@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 "KisAsyncAnimationFramesSavingRenderer.h"
 
 #include "kis_image.h"
 #include "kis_paint_device.h"
 #include "KisImportExportFilter.h"
 #include "KisPart.h"
 #include "KisDocument.h"
 #include "kis_time_range.h"
 #include "kis_paint_layer.h"
 
 
 struct KisAsyncAnimationFramesSavingRenderer::Private
 {
     Private(KisImageSP image, const KisTimeRange &_range, int _sequenceNumberingOffset, KisPropertiesConfigurationSP _exportConfiguration)
         : savingDoc(KisPart::instance()->createDocument()),
           range(_range),
           sequenceNumberingOffset(_sequenceNumberingOffset),
           exportConfiguration(_exportConfiguration)
     {
 
         savingDoc->setInfiniteAutoSaveInterval();
         savingDoc->setFileBatchMode(true);
 
         KisImageSP savingImage = new KisImage(savingDoc->createUndoStore(),
                                               image->bounds().width(),
                                               image->bounds().height(),
                                               image->colorSpace(),
                                               QString());
 
         savingImage->setResolution(image->xRes(), image->yRes());
         savingDoc->setCurrentImage(savingImage);
 
         KisPaintLayer* paintLayer = new KisPaintLayer(savingImage, "paint device", 255);
         savingImage->addNode(paintLayer, savingImage->root(), KisLayerSP(0));
 
         savingDevice = paintLayer->paintDevice();
     }
 
     QScopedPointer<KisDocument> savingDoc;
     KisPaintDeviceSP savingDevice;
 
     KisTimeRange range;
     int sequenceNumberingOffset = 0;
 
 
     QString filenamePrefix;
     QString filenameSuffix;
 
     QByteArray outputMimeType;
     KisPropertiesConfigurationSP exportConfiguration;
 };
 
 KisAsyncAnimationFramesSavingRenderer::KisAsyncAnimationFramesSavingRenderer(KisImageSP image,
                                                                              const QString &fileNamePrefix,
                                                                              const QString &fileNameSuffix,
                                                                              const QByteArray &outputMimeType,
                                                                              const KisTimeRange &range,
                                                                              const int sequenceNumberingOffset,
                                                                              KisPropertiesConfigurationSP exportConfiguration)
     : m_d(new Private(image, range, sequenceNumberingOffset, exportConfiguration))
 {
     m_d->filenamePrefix = fileNamePrefix;
     m_d->filenameSuffix = fileNameSuffix;
     m_d->outputMimeType = outputMimeType;
 
     connect(this, SIGNAL(sigCompleteRegenerationInternal(int)), SLOT(notifyFrameCompleted(int)));
     connect(this, SIGNAL(sigCancelRegenerationInternal(int)), SLOT(notifyFrameCancelled(int)));
 }
 
 
 
 
 KisAsyncAnimationFramesSavingRenderer::~KisAsyncAnimationFramesSavingRenderer()
 {
 }
 
-void KisAsyncAnimationFramesSavingRenderer::frameCompletedCallback(int frame)
+void KisAsyncAnimationFramesSavingRenderer::frameCompletedCallback(int frame, const QRegion &requestedRegion)
 {
     KisImageSP image = requestedImage();
     if (!image) return;
 
+    KIS_SAFE_ASSERT_RECOVER (requestedRegion == image->bounds()) {
+        emit sigCancelRegenerationInternal(frame);
+        return;
+    }
+
     m_d->savingDevice->makeCloneFromRough(image->projection(), image->bounds());
 
     KisTimeRange range(frame, 1);
 
     KisImportExportFilter::ConversionStatus status = KisImportExportFilter::OK;
 
     for (int i = range.start(); i <= range.end(); i++) {
         QString frameNumber = QString("%1").arg(i + m_d->sequenceNumberingOffset, 4, 10, QChar('0'));
         QString filename = m_d->filenamePrefix + frameNumber + m_d->filenameSuffix;
 
         if (!m_d->savingDoc->exportDocumentSync(QUrl::fromLocalFile(filename), m_d->outputMimeType, m_d->exportConfiguration)) {
             status = KisImportExportFilter::InternalError;
             break;
         }
     }
 
     if (status == KisImportExportFilter::OK) {
         emit sigCompleteRegenerationInternal(frame);
     } else {
         emit sigCancelRegenerationInternal(frame);
     }
 }
 
 void KisAsyncAnimationFramesSavingRenderer::frameCancelledCallback(int frame)
 {
     notifyFrameCancelled(frame);
 }
 
diff --git a/libs/ui/KisAsyncAnimationFramesSavingRenderer.h b/libs/ui/KisAsyncAnimationFramesSavingRenderer.h
index 6dffff69a5..efa5fcaf5e 100644
--- a/libs/ui/KisAsyncAnimationFramesSavingRenderer.h
+++ b/libs/ui/KisAsyncAnimationFramesSavingRenderer.h
@@ -1,53 +1,53 @@
 /*
  *  Copyright (c) 2017 Dmitry Kazakov <dimula73@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 KISASYNCANIMATIONFRAMESSAVINGRENDERER_H
 #define KISASYNCANIMATIONFRAMESSAVINGRENDERER_H
 
 #include <KisAsyncAnimationRendererBase.h>
 
 class KisDocument;
 class KisTimeRange;
 
 class KisAsyncAnimationFramesSavingRenderer : public KisAsyncAnimationRendererBase
 {
     Q_OBJECT
 public:
     KisAsyncAnimationFramesSavingRenderer(KisImageSP image,
                                           const QString &fileNamePrefix,
                                           const QString &fileNameSuffix,
                                           const QByteArray &outputMimeType,
                                           const KisTimeRange &range,
                                           int sequenceNumberingOffset,
                                           KisPropertiesConfigurationSP exportConfiguration);
     ~KisAsyncAnimationFramesSavingRenderer();
 
 protected:
-    void frameCompletedCallback(int frame) override;
+    void frameCompletedCallback(int frame, const QRegion &requestedRegion) override;
     void frameCancelledCallback(int frame) override;
 
 Q_SIGNALS:
     void sigCompleteRegenerationInternal(int frame);
     void sigCancelRegenerationInternal(int frame);
 
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 };
 
 #endif // KISASYNCANIMATIONFRAMESSAVINGRENDERER_H
diff --git a/libs/ui/KisAsyncAnimationRendererBase.cpp b/libs/ui/KisAsyncAnimationRendererBase.cpp
index 4216a923b7..1ba2f92c5f 100644
--- a/libs/ui/KisAsyncAnimationRendererBase.cpp
+++ b/libs/ui/KisAsyncAnimationRendererBase.cpp
@@ -1,160 +1,168 @@
 /*
  *  Copyright (c) 2017 Dmitry Kazakov <dimula73@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 "KisAsyncAnimationRendererBase.h"
 
 #include <QTimer>
 #include <QThread>
 
 #include "kis_image.h"
 #include "kis_image_animation_interface.h"
 #include "kis_signal_auto_connection.h"
 
-struct KisAsyncAnimationRendererBase::Private
+struct KRITAUI_NO_EXPORT KisAsyncAnimationRendererBase::Private
 {
 
     KisSignalAutoConnectionsStore imageRequestConnections;
     QTimer regenerationTimeout;
 
     KisImageSP requestedImage;
     int requestedFrame = -1;
     bool isCancelled = false;
+    QRegion requestedRegion;
 
     static const int WAITING_FOR_FRAME_TIMEOUT = 10000;
 };
 
 KisAsyncAnimationRendererBase::KisAsyncAnimationRendererBase(QObject *parent)
     : QObject(parent),
       m_d(new Private())
 {
     connect(&m_d->regenerationTimeout, SIGNAL(timeout()), SLOT(slotFrameRegenerationCancelled()));
     m_d->regenerationTimeout.setSingleShot(true);
     m_d->regenerationTimeout.setInterval(Private::WAITING_FOR_FRAME_TIMEOUT);
 }
 
 KisAsyncAnimationRendererBase::~KisAsyncAnimationRendererBase()
 {
 
 }
 
-void KisAsyncAnimationRendererBase::startFrameRegeneration(KisImageSP image, int frame)
+void KisAsyncAnimationRendererBase::startFrameRegeneration(KisImageSP image, int frame, const QRegion &regionOfInterest)
 {
     KIS_SAFE_ASSERT_RECOVER_NOOP(QThread::currentThread() == this->thread());
 
     m_d->requestedImage = image;
     m_d->requestedFrame = frame;
     m_d->isCancelled = false;
+    m_d->requestedRegion = !regionOfInterest.isEmpty() ? regionOfInterest : image->bounds();
 
     KisImageAnimationInterface *animation = m_d->requestedImage->animationInterface();
 
     m_d->imageRequestConnections.clear();
     m_d->imageRequestConnections.addConnection(
                 animation, SIGNAL(sigFrameReady(int)),
                 this, SLOT(slotFrameRegenerationFinished(int)),
                 Qt::DirectConnection);
 
     m_d->imageRequestConnections.addConnection(
                 animation, SIGNAL(sigFrameCancelled()),
                 this, SLOT(slotFrameRegenerationCancelled()),
                 Qt::AutoConnection);
 
     m_d->regenerationTimeout.start();
-    animation->requestFrameRegeneration(m_d->requestedFrame, image->bounds());
+    animation->requestFrameRegeneration(m_d->requestedFrame, m_d->requestedRegion);
+}
+
+void KisAsyncAnimationRendererBase::startFrameRegeneration(KisImageSP image, int frame)
+{
+    startFrameRegeneration(image, frame, QRegion());
 }
 
 bool KisAsyncAnimationRendererBase::isActive() const
 {
     return m_d->requestedImage;
 }
 
 void KisAsyncAnimationRendererBase::cancelCurrentFrameRendering()
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->requestedImage);
     frameCancelledCallback(m_d->requestedFrame);
 }
 
 void KisAsyncAnimationRendererBase::slotFrameRegenerationCancelled()
 {
     // the timeout can arrive in async way
     if (!m_d->requestedImage) return;
     frameCancelledCallback(m_d->requestedFrame);
 }
 
 void KisAsyncAnimationRendererBase::slotFrameRegenerationFinished(int frame)
 {
     // We might have already cancelled the regeneration. We don't check
     // isCancelled flag here because this code runs asynchronously.
     if (!m_d->requestedImage) return;
 
     // WARNING: executed in the context of image worker thread!
 
     // probably a bit too strict...
     KIS_SAFE_ASSERT_RECOVER_NOOP(QThread::currentThread() != this->thread());
 
-    frameCompletedCallback(frame);
+    frameCompletedCallback(frame, m_d->requestedRegion);
 }
 
 void KisAsyncAnimationRendererBase::notifyFrameCompleted(int frame)
 {
     KIS_SAFE_ASSERT_RECOVER_NOOP(QThread::currentThread() == this->thread());
 
     // the image events can come with a delay, even after
     // the processing was cancelled
     if (m_d->isCancelled) return;
 
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->requestedImage);
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->requestedFrame == frame);
 
     clearFrameRegenerationState(false);
     emit sigFrameCompleted(frame);
 }
 
 void KisAsyncAnimationRendererBase::notifyFrameCancelled(int frame)
 {
     KIS_SAFE_ASSERT_RECOVER_NOOP(QThread::currentThread() == this->thread());
 
     // the image events can come with a delay, even after
     // the processing was cancelled
     if (m_d->isCancelled) return;
 
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->requestedImage);
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->requestedFrame == frame);
 
     clearFrameRegenerationState(true);
     emit sigFrameCancelled(frame);
 }
 
 void KisAsyncAnimationRendererBase::clearFrameRegenerationState(bool isCancelled)
 {
     // TODO: for some reason we mark the process as cancelled in any case, and it
     //       seem to be a correct behavior
     Q_UNUSED(isCancelled);
 
     m_d->imageRequestConnections.clear();
     m_d->requestedImage = 0;
     m_d->requestedFrame = -1;
     m_d->regenerationTimeout.stop();
     m_d->isCancelled = true;
+    m_d->requestedRegion = QRegion();
 }
 
 KisImageSP KisAsyncAnimationRendererBase::requestedImage() const
 {
     return m_d->requestedImage;
 }
 
 
diff --git a/libs/ui/KisAsyncAnimationRendererBase.h b/libs/ui/KisAsyncAnimationRendererBase.h
index 388d586b61..48074838a5 100644
--- a/libs/ui/KisAsyncAnimationRendererBase.h
+++ b/libs/ui/KisAsyncAnimationRendererBase.h
@@ -1,136 +1,145 @@
 /*
  *  Copyright (c) 2017 Dmitry Kazakov <dimula73@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 KISASYNCANIMATIONRENDERERBASE_H
 #define KISASYNCANIMATIONRENDERERBASE_H
 
 #include <QObject>
 #include "kis_types.h"
 
+#include "kritaui_export.h"
+
 /**
  * KisAsyncAnimationRendererBase is a special class represinting a
  * single worker thread inside KisAsyncAnimationRenderDialogBase. It connects
  * the specified image using correct Qt::DirectConnection connections and
  * reacts on them. On sigFrameReady() signal it calls frameCompletedCallback(),
  * so the derived class can fetch a frame from the image and process it. On
  * sigFrameCancelled() it calls frameCancelledCallback(). The derived class
  * should override these two methods to do the actual work.
  */
 
-class KisAsyncAnimationRendererBase : public QObject
+class KRITAUI_EXPORT KisAsyncAnimationRendererBase : public QObject
 {
     Q_OBJECT
 public:
     explicit KisAsyncAnimationRendererBase(QObject *parent = 0);
     virtual ~KisAsyncAnimationRendererBase();
 
     /**
-     * Initiates the rendering of the frame \p frame on an image \p image
+     * Initiates the rendering of the frame \p frame on an image \p image.
+     * Only \p regionOfInterest is regenerated. If \p regionOfInterest is
+     * empty, then entire bounds of the image is regenerated.
+     */
+    void startFrameRegeneration(KisImageSP image, int frame, const QRegion &regionOfInterest);
+
+    /**
+     * Convenience overload that regenerates the full image
      */
-    virtual void startFrameRegeneration(KisImageSP image, int frame);
+    void startFrameRegeneration(KisImageSP image, int frame);
 
     /**
      * @return true if the regeneration process is in progress
      */
     bool isActive() const;
 
 public Q_SLOTS:
     /**
      * @brief cancels current rendering operation
      *
      * After calling this slot requestedImage() becomes invalid.
      * @see requestedImage()
      */
     void cancelCurrentFrameRendering();
 
 Q_SIGNALS:
     void sigFrameCompleted(int frame);
     void sigFrameCancelled(int frame);
 
 private Q_SLOTS:
     void slotFrameRegenerationCancelled();
     void slotFrameRegenerationFinished(int frame);
 
 protected Q_SLOTS:
     /**
      * Called by a derived class to continue processing of the frames
      */
     void notifyFrameCompleted(int frame);
 
     /**
      * Called by a derived class to cancel processing of the frames. After calling
      * this method, the dialog will stop processing the frames and close.
      */
     void notifyFrameCancelled(int frame);
 
 protected:
     /**
      * @brief frameCompletedCallback is called by the renderer when
      *        a new frame becomes ready
      *
      * NOTE1: the callback is called from the context of a image
      *        worker thread! So it is asynchronous from the GUI thread.
      * NOTE2: in case of successful processing of the frame, the callback
      *        must issue some signal, connected to notifyFrameCompleted()
      *        via auto connection, to continue processing. Please do not
      *        call the method directly, because notifyFame*() slots should
      *        be called from the context of the GUI thread.
      * NOTE3: In case of failure, notifyFrameCancelled(). The same threading
      *        rules apply.
      */
-    virtual void frameCompletedCallback(int frame) = 0;
+    virtual void frameCompletedCallback(int frame, const QRegion &requestedRegion) = 0;
 
     /**
      * @brief frameCancelledCallback is called when the rendering of
      *        the frame was cancelled.
      *
      * The rendering of the frame can be either cancelled by the image itself or
      * by receiving a timeout signal (10 seconds).
      *
      * NOTE: the slot is called in the GUI thread. Don't forget to call
      *       notifyFrameCancelled() in he end of your call.
      */
     virtual void frameCancelledCallback(int frame) = 0;
 
 
     /**
      * Called by KisAsyncAnimationRendererBase when the processing has been completed
      * and the internal state of the populator should be cleared
      *
      * @param isCancelled tells if frame regeneration has failed to be regenerated
      */
     virtual void clearFrameRegenerationState(bool isCancelled);
 
 protected:
     /**
      * @return the image that for which the rendering was requested using
      * startFrameRegeneration(). Should be used by the derived classes only.
      *
      * Please note that requestedImage() will become null as soon as the user
      * cancels the processing. That happends in the GUI thread so
      * frameCompletedCallback() should be extremely careful when requesting the
      * value (check the shared pointer after fetching).
      */
     KisImageSP requestedImage() const;
 
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 };
 
 #endif // KISASYNCANIMATIONRENDERERBASE_H
diff --git a/libs/ui/KisCloneDocumentStroke.cpp b/libs/ui/KisCloneDocumentStroke.cpp
index a6290c91c9..17071af1dc 100644
--- a/libs/ui/KisCloneDocumentStroke.cpp
+++ b/libs/ui/KisCloneDocumentStroke.cpp
@@ -1,59 +1,60 @@
 /*
  *  Copyright (c) 2018 Dmitry Kazakov <dimula73@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 "KisCloneDocumentStroke.h"
 
 #include "KisDocument.h"
 #include "kis_layer_utils.h"
 
+#include <QApplication>
+
+
 struct KRITAIMAGE_NO_EXPORT KisCloneDocumentStroke::Private
 {
     Private(KisDocument *_document)
         : document(_document)
     {
     }
 
     KisDocument *document = 0;
 };
 
 KisCloneDocumentStroke::KisCloneDocumentStroke(KisDocument *document)
     : KisSimpleStrokeStrategy("clone-document-stroke", kundo2_i18n("Clone Document")),
       m_d(new Private(document))
 {
     setClearsRedoOnStart(false);
-    setRequestsOtherStrokesToEnd(false); // TODO: ???
+    setRequestsOtherStrokesToEnd(false);
     enableJob(JOB_INIT, true, KisStrokeJobData::BARRIER, KisStrokeJobData::EXCLUSIVE);
     enableJob(JOB_FINISH, true, KisStrokeJobData::BARRIER, KisStrokeJobData::EXCLUSIVE);
 }
 
 KisCloneDocumentStroke::~KisCloneDocumentStroke()
 {
 }
 
 void KisCloneDocumentStroke::initStrokeCallback()
 {
     KisLayerUtils::forceAllDelayedNodesUpdate(m_d->document->image()->root());
 }
 
-#include <QApplication>
-
 void KisCloneDocumentStroke::finishStrokeCallback()
 {
     KisDocument *doc = m_d->document->clone();
     doc->moveToThread(qApp->thread());
     emit sigDocumentCloned(doc);
 }
diff --git a/libs/ui/KisDocument.cpp b/libs/ui/KisDocument.cpp
index e3946c0317..b2b8b6cba5 100644
--- a/libs/ui/KisDocument.cpp
+++ b/libs/ui/KisDocument.cpp
@@ -1,1791 +1,1797 @@
 /* This file is part of the Krita project
  *
  * Copyright (C) 2014 Boudewijn Rempt <boud@valdyas.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "KisMainWindow.h" // XXX: remove
 #include <QMessageBox> // XXX: remove
 
 #include <KisMimeDatabase.h>
 
 #include <KoCanvasBase.h>
 #include <KoColor.h>
 #include <KoColorProfile.h>
 #include <KoColorSpaceEngine.h>
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoDocumentInfoDlg.h>
 #include <KoDocumentInfo.h>
 #include <KoDpi.h>
 #include <KoUnit.h>
 #include <KoID.h>
 #include <KoOdfReadStore.h>
 #include <KoProgressProxy.h>
 #include <KoProgressUpdater.h>
 #include <KoSelection.h>
 #include <KoShape.h>
 #include <KoShapeController.h>
 #include <KoStore.h>
 #include <KoUpdater.h>
 #include <KoXmlWriter.h>
 #include <KoXmlReader.h>
 #include <KoStoreDevice.h>
 #include <KoDialog.h>
 
 #include <klocalizedstring.h>
 #include <kis_debug.h>
 #include <kdesktopfile.h>
 #include <kconfiggroup.h>
 #include <QTemporaryFile>
 #include <kbackup.h>
 
 #include <QTextBrowser>
 #include <QApplication>
 #include <QBuffer>
 #include <QStandardPaths>
 #include <QDir>
 #include <QDomDocument>
 #include <QDomElement>
 #include <QFileInfo>
 #include <QImage>
 #include <QList>
 #include <QPainter>
 #include <QRect>
 #include <QScopedPointer>
 #include <QSize>
 #include <QStringList>
 #include <QtGlobal>
 #include <QTimer>
 #include <QWidget>
 #include <QFuture>
 #include <QFutureWatcher>
 
 // Krita Image
 #include <kis_config.h>
 #include <flake/kis_shape_layer.h>
 #include <kis_debug.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_debug.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 "KisPart.h"
 #include "KisView.h"
 #include "kis_grid_config.h"
 #include "kis_guides_config.h"
 #include "kis_image_barrier_lock_adapter.h"
 #include "KisReferenceImagesLayer.h"
 
 #include <mutex>
 #include "kis_config_notifier.h"
 #include "kis_async_action_feedback.h"
 #include "KisCloneDocumentStroke.h"
 
 
 // Define the protocol used here for embedded documents' URL
 // This used to "store" but QUrl didn't like it,
 // so let's simply make it "tar" !
 #define STORE_PROTOCOL "tar"
 // The internal path is a hack to make QUrl happy and for document children
 #define INTERNAL_PROTOCOL "intern"
 #define INTERNAL_PREFIX "intern:/"
 // Warning, keep it sync in koStore.cc
 
 #include <unistd.h>
 
 using namespace std;
 
 namespace {
 constexpr int errorMessageTimeout = 5000;
 constexpr int successMessageTimeout = 1000;
 }
 
 
 /**********************************************************
  *
  * KisDocument
  *
  **********************************************************/
 
 //static
 QString KisDocument::newObjectName()
 {
     static int s_docIFNumber = 0;
     QString name; name.setNum(s_docIFNumber++); name.prepend("document_");
     return name;
 }
 
 
 class UndoStack : public KUndo2Stack
 {
 public:
     UndoStack(KisDocument *doc)
         : KUndo2Stack(doc),
           m_doc(doc)
     {
     }
 
     void setIndex(int idx) override {
         KisImageWSP image = this->image();
         image->requestStrokeCancellation();
         if(image->tryBarrierLock()) {
             KUndo2Stack::setIndex(idx);
             image->unlock();
         }
     }
 
     void notifySetIndexChangedOneCommand() override {
         KisImageWSP image = this->image();
         image->unlock();
 
         /**
          * Some very weird commands may emit blocking signals to
          * the GUI (e.g. KisGuiContextCommand). Here is the best thing
          * we can do to avoid the deadlock
          */
         while(!image->tryBarrierLock()) {
             QApplication::processEvents();
         }
     }
 
     void undo() override {
         KisImageWSP image = this->image();
         image->requestUndoDuringStroke();
 
         if (image->tryUndoUnfinishedLod0Stroke() == UNDO_OK) {
             return;
         }
 
         if(image->tryBarrierLock()) {
             KUndo2Stack::undo();
             image->unlock();
         }
     }
 
     void redo() override {
         KisImageWSP image = this->image();
         if(image->tryBarrierLock()) {
             KUndo2Stack::redo();
             image->unlock();
         }
     }
 
 private:
     KisImageWSP image() {
         KisImageWSP currentImage = m_doc->image();
         Q_ASSERT(currentImage);
         return currentImage;
     }
 
 private:
     KisDocument *m_doc;
 };
 
 class Q_DECL_HIDDEN KisDocument::Private
 {
 public:
     Private(KisDocument *q)
         : docInfo(new KoDocumentInfo(q)) // deleted by QObject
         , importExportManager(new KisImportExportManager(q)) // deleted manually
         , autoSaveTimer(new QTimer(q))
         , undoStack(new UndoStack(q)) // deleted by QObject
         , m_bAutoDetectedMime(false)
         , modified(false)
         , readwrite(true)
         , firstMod(QDateTime::currentDateTime())
         , lastMod(firstMod)
         , nserver(new KisNameServer(1))
         , imageIdleWatcher(2000 /*ms*/)
         , savingLock(&savingMutex)
         , batchMode(false)
     {
         if (QLocale().measurementSystem() == QLocale::ImperialSystem) {
             unit = KoUnit::Inch;
         } else {
             unit = KoUnit::Centimeter;
         }
     }
 
     Private(const Private &rhs, KisDocument *q)
         : docInfo(new KoDocumentInfo(*rhs.docInfo, q))
         , unit(rhs.unit)
         , importExportManager(new KisImportExportManager(q))
         , mimeType(rhs.mimeType)
         , outputMimeType(rhs.outputMimeType)
         , autoSaveTimer(new QTimer(q))
         , undoStack(new UndoStack(q))
         , guidesConfig(rhs.guidesConfig)
         , m_bAutoDetectedMime(rhs.m_bAutoDetectedMime)
         , m_url(rhs.m_url)
         , m_file(rhs.m_file)
         , modified(rhs.modified)
         , readwrite(rhs.readwrite)
         , firstMod(rhs.firstMod)
         , lastMod(rhs.lastMod)
         , nserver(new KisNameServer(*rhs.nserver))
         , preActivatedNode(0) // the node is from another hierarchy!
         , imageIdleWatcher(2000 /*ms*/)
         , assistants(rhs.assistants) // WARNING: assistants should not store pointers to the document!
         , gridConfig(rhs.gridConfig)
         , savingLock(&savingMutex)
         , batchMode(rhs.batchMode)
     {
     }
 
     ~Private() {
         // Don't delete m_d->shapeController because it's in a QObject hierarchy.
         delete nserver;
     }
 
     KoDocumentInfo *docInfo = 0;
 
     KoUnit unit;
 
     KisImportExportManager *importExportManager = 0; // The filter-manager to use when loading/saving [for the options]
 
     QByteArray mimeType; // The actual mimetype of the document
     QByteArray outputMimeType; // The mimetype to use when saving
 
     QTimer *autoSaveTimer;
     QString lastErrorMessage; // see openFile()
     QString lastWarningMessage;
     int autoSaveDelay = 300; // in seconds, 0 to disable.
     bool modifiedAfterAutosave = false;
     bool isAutosaving = false;
     bool disregardAutosaveFailure = false;
     int autoSaveFailureCount = 0;
 
     KUndo2Stack *undoStack = 0;
 
     KisGuidesConfig guidesConfig;
 
     bool m_bAutoDetectedMime = false; // whether the mimetype in the arguments was detected by the part itself
     QUrl m_url; // local url - the one displayed to the user.
     QString m_file; // Local file - the only one the part implementation should deal with.
 
     QMutex savingMutex;
 
     bool modified = false;
     bool readwrite = false;
 
     QDateTime firstMod;
     QDateTime lastMod;
 
     KisNameServer *nserver;
 
     KisImageSP image;
     KisImageSP savingImage;
 
     KisNodeWSP preActivatedNode;
     KisShapeController* shapeController = 0;
     KoShapeController* koShapeController = 0;
     KisIdleWatcher imageIdleWatcher;
     QScopedPointer<KisSignalAutoConnection> imageIdleConnection;
 
     QList<KisPaintingAssistantSP> assistants;
 
     KisSharedPtr<KisReferenceImagesLayer> referenceImagesLayer;
 
     KisGridConfig gridConfig;
 
     StdLockableWrapper<QMutex> savingLock;
 
     bool modifiedWhileSaving = false;
     QScopedPointer<KisDocument> backgroundSaveDocument;
     QPointer<KoUpdater> savingUpdater;
     QFuture<KisImportExportFilter::ConversionStatus> childSavingFuture;
     KritaUtils::ExportFileJob backgroundSaveJob;
 
     bool isRecovered = false;
 
     bool batchMode { false };
 
     void setImageAndInitIdleWatcher(KisImageSP _image) {
         image = _image;
 
         imageIdleWatcher.setTrackedImage(image);
 
         if (image) {
             imageIdleConnection.reset(
                         new KisSignalAutoConnection(
                             &imageIdleWatcher, SIGNAL(startedIdleMode()),
                             image.data(), SLOT(explicitRegenerateLevelOfDetail())));
         }
     }
 
     class StrippedSafeSavingLocker;
 };
 
 class KisDocument::Private::StrippedSafeSavingLocker {
 public:
     StrippedSafeSavingLocker(QMutex *savingMutex, KisImageSP image)
         : m_locked(false)
         , m_image(image)
         , m_savingLock(savingMutex)
         , m_imageLock(image, true)
 
     {
         /**
          * Initial try to lock both objects. Locking the image guards
          * us from any image composition threads running in the
          * background, while savingMutex guards us from entering the
          * saving code twice by autosave and main threads.
          *
          * Since we are trying to lock multiple objects, so we should
          * do it in a safe manner.
          */
         m_locked = std::try_lock(m_imageLock, m_savingLock) < 0;
 
         if (!m_locked) {
             m_image->requestStrokeEnd();
             QApplication::processEvents();
 
             // one more try...
             m_locked = std::try_lock(m_imageLock, m_savingLock) < 0;
         }
     }
 
     ~StrippedSafeSavingLocker() {
          if (m_locked) {
              m_imageLock.unlock();
              m_savingLock.unlock();
          }
      }
 
     bool successfullyLocked() const {
         return m_locked;
     }
 
 private:
     bool m_locked;
     KisImageSP m_image;
     StdLockableWrapper<QMutex> m_savingLock;
     KisImageBarrierLockAdapter m_imageLock;
 };
 
 KisDocument::KisDocument()
     : d(new Private(this))
 {
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotConfigChanged()));
     connect(d->undoStack, SIGNAL(cleanChanged(bool)), this, SLOT(slotUndoStackCleanChanged(bool)));
     connect(d->autoSaveTimer, SIGNAL(timeout()), this, SLOT(slotAutoSave()));
     setObjectName(newObjectName());
 
     // preload the krita resources
     KisResourceServerProvider::instance();
 
     d->shapeController = new KisShapeController(this, d->nserver),
     d->koShapeController = new KoShapeController(0, d->shapeController),
 
     slotConfigChanged();
 }
 
 KisDocument::KisDocument(const KisDocument &rhs)
     : QObject(),
       d(new Private(*rhs.d, this))
 {
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotConfigChanged()));
     connect(d->undoStack, SIGNAL(cleanChanged(bool)), this, SLOT(slotUndoStackCleanChanged(bool)));
     connect(d->autoSaveTimer, SIGNAL(timeout()), this, SLOT(slotAutoSave()));
     setObjectName(rhs.objectName());
 
     d->shapeController = new KisShapeController(this, d->nserver),
     d->koShapeController = new KoShapeController(0, d->shapeController),
 
     slotConfigChanged();
 
     // clone the image with keeping the GUIDs of the layers intact
     // NOTE: we expect the image to be locked!
     setCurrentImage(rhs.image()->clone(true), false);
 
     if (rhs.d->preActivatedNode) {
         // since we clone uuid's, we can use them for lacating new
         // nodes. Otherwise we would need to use findSymmetricClone()
         d->preActivatedNode =
                 KisLayerUtils::findNodeByUuid(d->image->root(), rhs.d->preActivatedNode->uuid());
     }
 }
 
 KisDocument::~KisDocument()
 {
     // wait until all the pending operations are in progress
     waitForSavingToComplete();
 
     /**
      * Push a timebomb, which will try to release the memory after
      * the document has been deleted
      */
     KisPaintDevice::createMemoryReleaseObject()->deleteLater();
 
     d->autoSaveTimer->disconnect(this);
     d->autoSaveTimer->stop();
 
     delete d->importExportManager;
 
     // Despite being QObject they needs to be deleted before the image
     delete d->shapeController;
 
     delete d->koShapeController;
 
     if (d->image) {
         d->image->notifyAboutToBeDeleted();
 
         /**
          * WARNING: We should wait for all the internal image jobs to
          * finish before entering KisImage's destructor. The problem is,
          * while execution of KisImage::~KisImage, all the weak shared
          * pointers pointing to the image enter an inconsistent
          * state(!). The shared counter is already zero and destruction
          * has started, but the weak reference doesn't know about it,
          * because KisShared::~KisShared hasn't been executed yet. So all
          * the threads running in background and having weak pointers will
          * enter the KisImage's destructor as well.
          */
 
         d->image->requestStrokeCancellation();
         d->image->waitForDone();
 
         // clear undo commands that can still point to the image
         d->undoStack->clear();
         d->image->waitForDone();
 
         KisImageWSP sanityCheckPointer = d->image;
         Q_UNUSED(sanityCheckPointer);
 
         // The following line trigger the deletion of the image
         d->image.clear();
 
         // check if the image has actually been deleted
         KIS_SAFE_ASSERT_RECOVER_NOOP(!sanityCheckPointer.isValid());
     }
 
     delete d;
 }
 
 bool KisDocument::reload()
 {
     // XXX: reimplement!
     return false;
 }
 
 KisDocument *KisDocument::clone()
 {
     return new KisDocument(*this);
 }
 
 bool KisDocument::exportDocumentImpl(const KritaUtils::ExportFileJob &job, KisPropertiesConfigurationSP exportConfiguration)
 {
     QFileInfo filePathInfo(job.filePath);
 
     if (filePathInfo.exists() && !filePathInfo.isWritable()) {
         slotCompleteSavingDocument(job,
                                    KisImportExportFilter::CreationError,
                                    i18n("%1 cannot be written to. Please save under a different name.", job.filePath));
         return false;
     }
 
     KisConfig cfg;
     if (cfg.backupFile() && filePathInfo.exists()) {
         KBackup::backupFile(job.filePath);
     }
 
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!job.mimeType.isEmpty(), false);
 
     const QString actionName =
         job.flags & KritaUtils::SaveIsExporting ?
         i18n("Exporting Document...") :
         i18n("Saving Document...");
 
     bool started =
         initiateSavingInBackground(actionName,
                                    this, SLOT(slotCompleteSavingDocument(KritaUtils::ExportFileJob, KisImportExportFilter::ConversionStatus,QString)),
                                    job, exportConfiguration);
 
     if (!started) {
         emit canceled(QString());
     }
 
     return started;
 }
 
 bool KisDocument::exportDocument(const QUrl &url, const QByteArray &mimeType, bool showWarnings, KisPropertiesConfigurationSP exportConfiguration)
 {
     using namespace KritaUtils;
 
     SaveFlags flags = SaveIsExporting;
     if (showWarnings) {
         flags |= SaveShowWarnings;
     }
 
     return exportDocumentImpl(KritaUtils::ExportFileJob(url.toLocalFile(),
                                                         mimeType,
                                                         flags),
                               exportConfiguration);
 
 }
 
 bool KisDocument::saveAs(const QUrl &url, const QByteArray &mimeType, bool showWarnings, KisPropertiesConfigurationSP exportConfiguration)
 {
     using namespace KritaUtils;
 
     return exportDocumentImpl(ExportFileJob(url.toLocalFile(),
                                             mimeType,
                                             showWarnings ? SaveShowWarnings : SaveNone),
                               exportConfiguration);
 }
 
 bool KisDocument::save(bool showWarnings, KisPropertiesConfigurationSP exportConfiguration)
 {
     return saveAs(url(), mimeType(), showWarnings, exportConfiguration);
 }
 
 QByteArray KisDocument::serializeToNativeByteArray()
 {
     QByteArray byteArray;
     QBuffer buffer(&byteArray);
 
     QScopedPointer<KisImportExportFilter> filter(KisImportExportManager::filterForMimeType(nativeFormatMimeType(), KisImportExportManager::Export));
     filter->setBatchMode(true);
     filter->setMimeType(nativeFormatMimeType());
 
     Private::StrippedSafeSavingLocker locker(&d->savingMutex, d->image);
     if (!locker.successfullyLocked()) {
         return byteArray;
     }
 
     d->savingImage = d->image;
 
     if (filter->convert(this, &buffer) != KisImportExportFilter::OK) {
         qWarning() << "serializeToByteArray():: Could not export to our native format";
     }
 
     return byteArray;
 }
 
 void KisDocument::slotCompleteSavingDocument(const KritaUtils::ExportFileJob &job, KisImportExportFilter::ConversionStatus status, const QString &errorMessage)
 {
     if (status == KisImportExportFilter::UserCancelled)
         return;
 
     const QString fileName = QFileInfo(job.filePath).fileName();
 
     if (status != KisImportExportFilter::OK) {
         emit statusBarMessage(i18nc("%1 --- failing file name, %2 --- error message",
                                     "Error during saving %1: %2",
                                     fileName,
                                     exportErrorToUserMessage(status, errorMessage)), errorMessageTimeout);
 
         if (!fileBatchMode()) {
             const QString filePath = job.filePath;
             QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Could not save %1\nReason: %2", filePath, errorMessage));
         }
     } else {
         if (!(job.flags & KritaUtils::SaveIsExporting)) {
             setUrl(QUrl::fromLocalFile(job.filePath));
             setLocalFilePath(job.filePath);
             setMimeType(job.mimeType);
             updateEditingTime(true);
 
             if (!d->modifiedWhileSaving) {
                 d->undoStack->setClean();
             }
             setRecovered(false);
             removeAutoSaveFiles();
         }
 
         emit completed();
         emit sigSavingFinished();
 
         emit statusBarMessage(i18n("Finished saving %1", fileName), successMessageTimeout);
     }
 }
 
 QByteArray KisDocument::mimeType() const
 {
     return d->mimeType;
 }
 
 void KisDocument::setMimeType(const QByteArray & mimeType)
 {
     d->mimeType = mimeType;
 }
 
 bool KisDocument::fileBatchMode() const
 {
     return d->batchMode;
 }
 
 void KisDocument::setFileBatchMode(const bool batchMode)
 {
     d->batchMode = batchMode;
 }
 
 KisDocument* KisDocument::lockAndCloneForSaving()
 {
     // force update of all the asynchronous nodes before cloning
     QApplication::processEvents();
     KisLayerUtils::forceAllDelayedNodesUpdate(d->image->root());
 
     KisMainWindow *window = KisPart::instance()->currentMainwindow();
     if (window) {
         if (window->viewManager()) {
             if (!window->viewManager()->blockUntilOperationsFinished(d->image)) {
                 return 0;
             }
         }
     }
 
     Private::StrippedSafeSavingLocker locker(&d->savingMutex, d->image);
     if (!locker.successfullyLocked()) {
         return 0;
     }
 
     return new KisDocument(*this);
 }
 
 bool KisDocument::exportDocumentSync(const QUrl &url, const QByteArray &mimeType, KisPropertiesConfigurationSP exportConfiguration)
 {
     Private::StrippedSafeSavingLocker locker(&d->savingMutex, d->image);
     if (!locker.successfullyLocked()) {
         return false;
     }
 
     d->savingImage = d->image;
 
     const QString fileName = url.toLocalFile();
 
     KisImportExportFilter::ConversionStatus status =
         d->importExportManager->
             exportDocument(fileName, fileName, mimeType, false, exportConfiguration);
 
     d->savingImage = 0;
 
     return status == KisImportExportFilter::OK;
 }
 
 bool KisDocument::initiateSavingInBackground(const QString actionName,
                                              const QObject *receiverObject, const char *receiverMethod,
                                              const KritaUtils::ExportFileJob &job,
                                              KisPropertiesConfigurationSP exportConfiguration)
 {
     return initiateSavingInBackground(actionName, receiverObject, receiverMethod,
                                       job, exportConfiguration, std::unique_ptr<KisDocument>());
 }
 
 bool KisDocument::initiateSavingInBackground(const QString actionName,
                                              const QObject *receiverObject, const char *receiverMethod,
                                              const KritaUtils::ExportFileJob &job,
                                              KisPropertiesConfigurationSP exportConfiguration,
                                              std::unique_ptr<KisDocument> &&optionalClonedDocument)
 {
     KIS_ASSERT_RECOVER_RETURN_VALUE(job.isValid(), false);
 
     QScopedPointer<KisDocument> clonedDocument;
 
     if (!optionalClonedDocument) {
         clonedDocument.reset(lockAndCloneForSaving());
     } else {
         clonedDocument.reset(optionalClonedDocument.release());
     }
 
     // we block saving until the current saving is finished!
     if (!clonedDocument || !d->savingMutex.tryLock()) {
         return false;
     }
 
     KIS_ASSERT_RECOVER_RETURN_VALUE(!d->backgroundSaveDocument, false);
     KIS_ASSERT_RECOVER_RETURN_VALUE(!d->backgroundSaveJob.isValid(), false);
     d->backgroundSaveDocument.reset(clonedDocument.take());
     d->backgroundSaveJob = job;
     d->modifiedWhileSaving = false;
 
     if (d->backgroundSaveJob.flags & KritaUtils::SaveInAutosaveMode) {
         d->backgroundSaveDocument->d->isAutosaving = true;
     }
 
     connect(d->backgroundSaveDocument.data(),
             SIGNAL(sigBackgroundSavingFinished(KisImportExportFilter::ConversionStatus, const QString&)),
             this,
             SLOT(slotChildCompletedSavingInBackground(KisImportExportFilter::ConversionStatus, const QString&)));
 
 
     connect(this, SIGNAL(sigCompleteBackgroundSaving(KritaUtils::ExportFileJob,KisImportExportFilter::ConversionStatus,QString)),
             receiverObject, receiverMethod, Qt::UniqueConnection);
 
     bool started =
         d->backgroundSaveDocument->startExportInBackground(actionName,
                                                            job.filePath,
                                                            job.filePath,
                                                            job.mimeType,
                                                            job.flags & KritaUtils::SaveShowWarnings,
                                                            exportConfiguration);
 
     if (!started) {
         // the state should have been deinitialized in slotChildCompletedSavingInBackground()
 
         KIS_SAFE_ASSERT_RECOVER (!d->backgroundSaveDocument && !d->backgroundSaveJob.isValid()) {
             d->backgroundSaveDocument.take()->deleteLater();
             d->savingMutex.unlock();
             d->backgroundSaveJob = KritaUtils::ExportFileJob();
         }
     }
 
     return started;
 }
 
 
 void KisDocument::slotChildCompletedSavingInBackground(KisImportExportFilter::ConversionStatus status, const QString &errorMessage)
 {
     KIS_SAFE_ASSERT_RECOVER(!d->savingMutex.tryLock()) {
         d->savingMutex.unlock();
         return;
     }
 
     KIS_SAFE_ASSERT_RECOVER_RETURN(d->backgroundSaveDocument);
 
     if (d->backgroundSaveJob.flags & KritaUtils::SaveInAutosaveMode) {
         d->backgroundSaveDocument->d->isAutosaving = false;
     }
 
     d->backgroundSaveDocument.take()->deleteLater();
     d->savingMutex.unlock();
 
     KIS_SAFE_ASSERT_RECOVER_RETURN(d->backgroundSaveJob.isValid());
     const KritaUtils::ExportFileJob job = d->backgroundSaveJob;
     d->backgroundSaveJob = KritaUtils::ExportFileJob();
 
     emit sigCompleteBackgroundSaving(job, status, errorMessage);
 }
 
 void KisDocument::slotAutoSaveImpl(std::unique_ptr<KisDocument> &&optionalClonedDocument)
 {
     if (!d->modified || !d->modifiedAfterAutosave) return;
     const QString autoSaveFileName = generateAutoSaveFileName(localFilePath());
 
     emit statusBarMessage(i18n("Autosaving... %1", autoSaveFileName), successMessageTimeout);
 
     const bool hadClonedDocument = bool(optionalClonedDocument);
     bool started = false;
 
     if (d->image->isIdle() || hadClonedDocument) {
         started = initiateSavingInBackground(i18n("Autosaving..."),
                                              this, SLOT(slotCompleteAutoSaving(KritaUtils::ExportFileJob, KisImportExportFilter::ConversionStatus, const QString&)),
                                              KritaUtils::ExportFileJob(autoSaveFileName, nativeFormatMimeType(), KritaUtils::SaveIsExporting | KritaUtils::SaveInAutosaveMode),
                                              0,
                                              std::move(optionalClonedDocument));
     } else {
         emit statusBarMessage(i18n("Autosaving postponed: document is busy..."), errorMessageTimeout);
     }
 
     if (!started && !hadClonedDocument && d->autoSaveFailureCount >= 3) {
         KisCloneDocumentStroke *stroke = new KisCloneDocumentStroke(this);
         connect(stroke, SIGNAL(sigDocumentCloned(KisDocument*)),
                 this, SLOT(slotInitiateAsyncAutosaving(KisDocument*)),
                 Qt::BlockingQueuedConnection);
 
         KisStrokeId strokeId = d->image->startStroke(stroke);
         d->image->endStroke(strokeId);
 
         setInfiniteAutoSaveInterval();
 
     } else if (!started) {
         setEmergencyAutoSaveInterval();
     } else {
         d->modifiedAfterAutosave = false;
     }
 }
 
 void KisDocument::slotAutoSave()
 {
     slotAutoSaveImpl(std::unique_ptr<KisDocument>());
 }
 
 void KisDocument::slotInitiateAsyncAutosaving(KisDocument *clonedDocument)
 {
     slotAutoSaveImpl(std::unique_ptr<KisDocument>(clonedDocument));
 }
 
 void KisDocument::slotCompleteAutoSaving(const KritaUtils::ExportFileJob &job, KisImportExportFilter::ConversionStatus status, const QString &errorMessage)
 {
     Q_UNUSED(job);
 
     const QString fileName = QFileInfo(job.filePath).fileName();
 
     if (status != KisImportExportFilter::OK) {
         setEmergencyAutoSaveInterval();
         emit statusBarMessage(i18nc("%1 --- failing file name, %2 --- error message",
                                     "Error during autosaving %1: %2",
                                     fileName,
                                     exportErrorToUserMessage(status, errorMessage)), errorMessageTimeout);
     } else {
         KisConfig cfg;
         d->autoSaveDelay = cfg.autoSaveInterval();
 
         if (!d->modifiedWhileSaving) {
             d->autoSaveTimer->stop(); // until the next change
             d->autoSaveFailureCount = 0;
         } else {
             setNormalAutoSaveInterval();
         }
 
         emit statusBarMessage(i18n("Finished autosaving %1", fileName), successMessageTimeout);
     }
 }
 
 bool KisDocument::startExportInBackground(const QString &actionName,
                                           const QString &location,
                                           const QString &realLocation,
                                           const QByteArray &mimeType,
                                           bool showWarnings,
                                           KisPropertiesConfigurationSP exportConfiguration)
 {
     d->savingImage = d->image;
 
     KisMainWindow *window = KisPart::instance()->currentMainwindow();
     if (window) {
         if (window->viewManager()) {
             d->savingUpdater = window->viewManager()->createThreadedUpdater(actionName);
             d->importExportManager->setUpdater(d->savingUpdater);
         }
     }
 
     KisImportExportFilter::ConversionStatus initializationStatus;
     d->childSavingFuture =
         d->importExportManager->exportDocumentAsyc(location,
                                                    realLocation,
                                                    mimeType,
                                                    initializationStatus,
                                                    showWarnings,
                                                    exportConfiguration);
 
     if (initializationStatus != KisImportExportFilter::ConversionStatus::OK) {
         if (d->savingUpdater) {
             d->savingUpdater->cancel();
         }
         d->savingImage.clear();
         emit sigBackgroundSavingFinished(initializationStatus, this->errorMessage());
         return false;
     }
 
     typedef QFutureWatcher<KisImportExportFilter::ConversionStatus> StatusWatcher;
     StatusWatcher *watcher = new StatusWatcher();
     watcher->setFuture(d->childSavingFuture);
 
     connect(watcher, SIGNAL(finished()), SLOT(finishExportInBackground()));
     connect(watcher, SIGNAL(finished()), watcher, SLOT(deleteLater()));
 
     return true;
 }
 
 void KisDocument::finishExportInBackground()
 {
     KIS_SAFE_ASSERT_RECOVER(d->childSavingFuture.isFinished()) {
         emit sigBackgroundSavingFinished(KisImportExportFilter::InternalError, "");
         return;
     }
 
     KisImportExportFilter::ConversionStatus status =
         d->childSavingFuture.result();
     const QString errorMessage = this->errorMessage();
 
     d->savingImage.clear();
     d->childSavingFuture = QFuture<KisImportExportFilter::ConversionStatus>();
     d->lastErrorMessage.clear();
 
     if (d->savingUpdater) {
         d->savingUpdater->setProgress(100);
     }
 
     emit sigBackgroundSavingFinished(status, errorMessage);
 }
 
 void KisDocument::setReadWrite(bool readwrite)
 {
     d->readwrite = readwrite;
     setNormalAutoSaveInterval();
 
     Q_FOREACH (KisMainWindow *mainWindow, KisPart::instance()->mainWindows()) {
         mainWindow->setReadWrite(readwrite);
     }
 }
 
 void KisDocument::setAutoSaveDelay(int delay)
 {
     if (isReadWrite() && delay > 0) {
         d->autoSaveTimer->start(delay * 1000);
     } else {
         d->autoSaveTimer->stop();
     }
 }
 
 void KisDocument::setNormalAutoSaveInterval()
 {
     setAutoSaveDelay(d->autoSaveDelay);
     d->autoSaveFailureCount = 0;
 }
 
 void KisDocument::setEmergencyAutoSaveInterval()
 {
     const int emergencyAutoSaveInterval = 10; /* sec */
     setAutoSaveDelay(emergencyAutoSaveInterval);
     d->autoSaveFailureCount++;
 }
 
 void KisDocument::setInfiniteAutoSaveInterval()
 {
     setAutoSaveDelay(-1);
 }
 
 KoDocumentInfo *KisDocument::documentInfo() const
 {
     return d->docInfo;
 }
 
 bool KisDocument::isModified() const
 {
     return d->modified;
 }
 
 QPixmap KisDocument::generatePreview(const QSize& size)
 {
     KisImageSP image = d->image;
     if (d->savingImage) image = d->savingImage;
 
     if (image) {
         QRect bounds = image->bounds();
         QSize newSize = bounds.size();
         newSize.scale(size, Qt::KeepAspectRatio);
         QPixmap px = QPixmap::fromImage(image->convertToQImage(newSize, 0));
         if (px.size() == QSize(0,0)) {
             px = QPixmap(newSize);
             QPainter gc(&px);
             QBrush checkBrush = QBrush(KisCanvasWidgetBase::createCheckersImage(newSize.width() / 5));
             gc.fillRect(px.rect(), checkBrush);
             gc.end();
         }
         return px;
     }
     return QPixmap(size);
 }
 
 QString KisDocument::generateAutoSaveFileName(const QString & path) const
 {
     QString retval;
 
     // Using the extension allows to avoid relying on the mime magic when opening
     const QString extension (".kra");
     QRegularExpression autosavePattern("^\\..+-autosave.kra$");
 
     QFileInfo fi(path);
     QString dir = fi.absolutePath();
     QString filename = fi.fileName();
 
     if (path.isEmpty() || autosavePattern.match(filename).hasMatch()) {
         // Never saved?
 #ifdef Q_OS_WIN
         // On Windows, use the temp location (https://bugs.kde.org/show_bug.cgi?id=314921)
         retval = QString("%1%2.%3-%4-%5-autosave%6").arg(QDir::tempPath()).arg(QDir::separator()).arg("krita").arg(qApp->applicationPid()).arg(objectName()).arg(extension);
 #else
         // On Linux, use a temp file in $HOME then. Mark it with the pid so two instances don't overwrite each other's autosave file
         retval = QString("%1%2.%3-%4-%5-autosave%6").arg(QDir::homePath()).arg(QDir::separator()).arg("krita").arg(qApp->applicationPid()).arg(objectName()).arg(extension);
 #endif
     } else {
         retval = QString("%1%2.%3-autosave%4").arg(dir).arg(QDir::separator()).arg(filename).arg(extension);
     }
 
     //qDebug() << "generateAutoSaveFileName() for path" << path << ":" << retval;
     return retval;
 }
 
 bool KisDocument::importDocument(const QUrl &_url)
 {
     bool ret;
 
     dbgUI << "url=" << _url.url();
 
     // open...
     ret = openUrl(_url);
 
     // reset url & m_file (kindly? set by KisParts::openUrl()) to simulate a
     // File --> Import
     if (ret) {
         dbgUI << "success, resetting url";
         resetURL();
         setTitleModified();
     }
 
     return ret;
 }
 
 
 bool KisDocument::openUrl(const QUrl &_url, OpenFlags flags)
 {
     if (!_url.isLocalFile()) {
         return false;
     }
     dbgUI << "url=" << _url.url();
     d->lastErrorMessage.clear();
 
     // Reimplemented, to add a check for autosave files and to improve error reporting
     if (!_url.isValid()) {
         d->lastErrorMessage = i18n("Malformed URL\n%1", _url.url());  // ## used anywhere ?
         return false;
     }
 
     QUrl url(_url);
     bool autosaveOpened = false;
     if (url.isLocalFile() && !fileBatchMode()) {
         QString file = url.toLocalFile();
         QString asf = generateAutoSaveFileName(file);
         if (QFile::exists(asf)) {
             KisApplication *kisApp = static_cast<KisApplication*>(qApp);
             kisApp->hideSplashScreen();
             //dbgUI <<"asf=" << asf;
             // ## TODO compare timestamps ?
             int res = QMessageBox::warning(0,
                                            i18nc("@title:window", "Krita"),
                                            i18n("An autosaved file exists for this document.\nDo you want to open the autosaved file instead?"),
                                            QMessageBox::Yes | QMessageBox::No | QMessageBox::Cancel, QMessageBox::Yes);
             switch (res) {
             case QMessageBox::Yes :
                 url.setPath(asf);
                 autosaveOpened = true;
                 break;
             case QMessageBox::No :
                 QFile::remove(asf);
                 break;
             default: // Cancel
                 return false;
             }
         }
     }
 
     bool ret = openUrlInternal(url);
 
     if (autosaveOpened || flags & RecoveryFile) {
         setReadWrite(true); // enable save button
         setModified(true);
         setRecovered(true);
     }
     else {
         if (!(flags & DontAddToRecent)) {
             KisPart::instance()->addRecentURLToAllMainWindows(_url);
         }
 
         if (ret) {
             // Detect readonly local-files; remote files are assumed to be writable
             QFileInfo fi(url.toLocalFile());
             setReadWrite(fi.isWritable());
         }
 
         setRecovered(false);
     }
 
     return ret;
 }
 
 class DlgLoadMessages : public KoDialog {
 public:
     DlgLoadMessages(const QString &title, const QString &message, const QStringList &warnings) {
         setWindowTitle(title);
         setWindowIcon(KisIconUtils::loadIcon("warning"));
         QWidget *page = new QWidget(this);
         QVBoxLayout *layout = new QVBoxLayout(page);
         QHBoxLayout *hlayout = new QHBoxLayout();
         QLabel *labelWarning= new QLabel();
         labelWarning->setPixmap(KisIconUtils::loadIcon("warning").pixmap(32, 32));
         hlayout->addWidget(labelWarning);
         hlayout->addWidget(new QLabel(message));
         layout->addLayout(hlayout);
         QTextBrowser *browser = new QTextBrowser();
         QString warning = "<html><body><p><b>";
         if (warnings.size() == 1) {
             warning += "</b> Reason:</p>";
         }
         else {
             warning += "</b> Reasons:</p>";
         }
         warning += "<p/><ul>";
 
         Q_FOREACH(const QString &w, warnings) {
             warning += "\n<li>" + w + "</li>";
         }
         warning += "</ul>";
         browser->setHtml(warning);
         browser->setMinimumHeight(200);
         browser->setMinimumWidth(400);
         layout->addWidget(browser);
         setMainWidget(page);
         setButtons(KoDialog::Ok);
         resize(minimumSize());
     }
 };
 
 bool KisDocument::openFile()
 {
     //dbgUI <<"for" << localFilePath();
     if (!QFile::exists(localFilePath())) {
         QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("File %1 does not exist.", localFilePath()));
         return false;
     }
 
     QString filename = localFilePath();
     QString typeName = mimeType();
 
     if (typeName.isEmpty()) {
         typeName = KisMimeDatabase::mimeTypeForFile(filename);
     }
 
     //qDebug() << "mimetypes 4:" << typeName;
 
     // Allow to open backup files, don't keep the mimetype application/x-trash.
     if (typeName == "application/x-trash") {
         QString path = filename;
         while (path.length() > 0) {
             path.chop(1);
             typeName = KisMimeDatabase::mimeTypeForFile(path);
             //qDebug() << "\t" << path << typeName;
             if (!typeName.isEmpty()) {
                 break;
             }
         }
         //qDebug() << "chopped" << filename  << "to" << path << "Was trash, is" << typeName;
     }
     dbgUI << localFilePath() << "type:" << typeName;
 
     KisMainWindow *window = KisPart::instance()->currentMainwindow();
     if (window && window->viewManager()) {
         KoUpdaterPtr updater = window->viewManager()->createUnthreadedUpdater(i18n("Opening document"));
         d->importExportManager->setUpdater(updater);
     }
 
     KisImportExportFilter::ConversionStatus status;
 
     status = d->importExportManager->importDocument(localFilePath(), typeName);
 
     if (status != KisImportExportFilter::OK) {
         QString msg = KisImportExportFilter::conversionStatusString(status);
         if (!msg.isEmpty()) {
             DlgLoadMessages dlg(i18nc("@title:window", "Krita"),
                                 i18n("Could not open %2.\nReason: %1.", msg, prettyPathOrUrl()),
                                 errorMessage().split("\n") + warningMessage().split("\n"));
             dlg.exec();
         }
         return false;
     }
     else if (!warningMessage().isEmpty()) {
         DlgLoadMessages dlg(i18nc("@title:window", "Krita"),
                             i18n("There were problems opening %1.", prettyPathOrUrl()),
                             warningMessage().split("\n"));
         dlg.exec();
         setUrl(QUrl());
     }
 
     setMimeTypeAfterLoading(typeName);
     emit sigLoadingFinished();
 
     undoStack()->clear();
 
     return true;
 }
 
 // shared between openFile and koMainWindow's "create new empty document" code
 void KisDocument::setMimeTypeAfterLoading(const QString& mimeType)
 {
     d->mimeType = mimeType.toLatin1();
     d->outputMimeType = d->mimeType;
 }
 
 
 bool KisDocument::loadNativeFormat(const QString & file_)
 {
     return openUrl(QUrl::fromLocalFile(file_));
 }
 
 void KisDocument::setModified()
 {
     d->modified = true;
 
 }
 
 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->modifiedAfterAutosave) {
         // 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()
 {
     //qDebug() << "removeAutoSaveFiles";
     // Eliminate any auto-save file
     QString asf = generateAutoSaveFileName(localFilePath());   // 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);
     }
 }
 
 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;
     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;
 }
 
 const KisGuidesConfig& KisDocument::guidesConfig() const
 {
     return d->guidesConfig;
 }
 
 void KisDocument::setGuidesConfig(const KisGuidesConfig &data)
 {
     if (d->guidesConfig == data) return;
 
     d->guidesConfig = data;
     emit sigGuidesConfigChanged(d->guidesConfig);
 }
 
 void KisDocument::resetURL() {
     setUrl(QUrl());
     setLocalFilePath(QString());
 }
 
 KoDocumentInfoDlg *KisDocument::createDocumentInfoDialog(QWidget *parent, KoDocumentInfo *docInfo) const
 {
     return new KoDocumentInfoDlg(parent, docInfo);
 }
 
 bool KisDocument::isReadWrite() const
 {
     return d->readwrite;
 }
 
 QUrl KisDocument::url() const
 {
     return d->m_url;
 }
 
 bool KisDocument::closeUrl(bool promptToSave)
 {
     if (promptToSave) {
         if ( isReadWrite() && isModified()) {
             Q_FOREACH (KisView *view, KisPart::instance()->views()) {
                 if (view && view->document() == this) {
                     if (!view->queryClose()) {
                         return false;
                     }
                 }
             }
         }
     }
     // Not modified => ok and delete temp file.
     d->mimeType = QByteArray();
 
     // It always succeeds for a read-only part,
     // but the return value exists for reimplementations
     // (e.g. pressing cancel for a modified read-write part)
     return true;
 }
 
 
 
 void KisDocument::setUrl(const QUrl &url)
 {
     d->m_url = url;
 }
 
 QString KisDocument::localFilePath() const
 {
     return d->m_file;
 }
 
 
 void KisDocument::setLocalFilePath( const QString &localFilePath )
 {
     d->m_file = localFilePath;
 }
 
 bool KisDocument::openUrlInternal(const QUrl &url)
 {
     if ( !url.isValid() )
         return false;
 
     if (d->m_bAutoDetectedMime) {
         d->mimeType = QByteArray();
         d->m_bAutoDetectedMime = false;
     }
 
     QByteArray mimetype = d->mimeType;
 
     if ( !closeUrl() )
         return false;
 
     d->mimeType = mimetype;
     setUrl(url);
 
     d->m_file.clear();
 
     if (d->m_url.isLocalFile()) {
         d->m_file = d->m_url.toLocalFile();
         bool ret;
         // set the mimetype only if it was not already set (for example, by the host application)
         if (d->mimeType.isEmpty()) {
             // get the mimetype of the file
             // using findByUrl() to avoid another string -> url conversion
             QString mime = KisMimeDatabase::mimeTypeForFile(d->m_url.toLocalFile());
             d->mimeType = mime.toLocal8Bit();
             d->m_bAutoDetectedMime = true;
         }
 
         setUrl(d->m_url);
         ret = openFile();
 
         if (ret) {
             emit completed();
         } else {
             emit canceled(QString());
         }
         return ret;
     }
     return false;
 }
 
 bool KisDocument::newImage(const QString& name,
                            qint32 width, qint32 height,
                            const KoColorSpace* cs,
                            const KoColor &bgColor, bool backgroundAsLayer,
                            int numberOfLayers,
                            const QString &description, const double imageResolution)
 {
     Q_ASSERT(cs);
 
     KisConfig cfg;
 
     KisImageSP image;
     KisPaintLayerSP layer;
 
     if (!cs) return false;
 
     QApplication::setOverrideCursor(Qt::BusyCursor);
 
     image = new KisImage(createUndoStore(), width, height, cs, name);
 
     Q_CHECK_PTR(image);
 
     connect(image, SIGNAL(sigImageModified()), this, SLOT(setImageModified()), Qt::UniqueConnection);
     image->setResolution(imageResolution, imageResolution);
 
     image->assignImageProfile(cs->profile());
     documentInfo()->setAboutInfo("title", name);
     documentInfo()->setAboutInfo("abstract", description);
 
     layer = new KisPaintLayer(image.data(), image->nextLayerName(), OPACITY_OPAQUE_U8, cs);
     Q_CHECK_PTR(layer);
 
     if (backgroundAsLayer) {
         image->setDefaultProjectionColor(KoColor(cs));
 
         if (bgColor.opacityU8() == OPACITY_OPAQUE_U8) {
             layer->paintDevice()->setDefaultPixel(bgColor);
         } else {
             // Hack: with a semi-transparent background color, the projection isn't composited right if we just set the default pixel
             KisFillPainter painter;
             painter.begin(layer->paintDevice());
             painter.fillRect(0, 0, width, height, bgColor, bgColor.opacityU8());
         }
     } else {
         image->setDefaultProjectionColor(bgColor);
     }
     layer->setDirty(QRect(0, 0, width, height));
 
     image->addNode(layer.data(), image->rootLayer().data());
     setCurrentImage(image);
 
     for(int i = 1; i < numberOfLayers; ++i) {
         KisPaintLayerSP layer = new KisPaintLayer(image, image->nextLayerName(), OPACITY_OPAQUE_U8, cs);
         image->addNode(layer, image->root(), i);
         layer->setDirty(QRect(0, 0, width, height));
     }
 
     cfg.defImageWidth(width);
     cfg.defImageHeight(height);
     cfg.defImageResolution(imageResolution);
     cfg.defColorModel(image->colorSpace()->colorModelId().id());
     cfg.setDefaultColorDepth(image->colorSpace()->colorDepthId().id());
     cfg.defColorProfile(image->colorSpace()->profile()->name());
 
     QApplication::restoreOverrideCursor();
 
     return true;
 }
 
 bool KisDocument::isSaving() const
 {
     const bool result = d->savingMutex.tryLock();
     if (result) {
         d->savingMutex.unlock();
     }
     return !result;
 }
 
 void KisDocument::waitForSavingToComplete()
 {
     if (isSaving()) {
         KisAsyncActionFeedback f(i18nc("progress dialog message when the user closes the document that is being saved", "Waiting for saving to complete..."), 0);
         f.waitForMutex(&d->savingMutex);
     }
 }
 
 KoShapeBasedDocumentBase *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::createReferenceImagesLayer(KisImageSP targetImage)
+KisSharedPtr<KisReferenceImagesLayer> KisDocument::getOrCreateReferenceImagesLayer(KisImageSP targetImage)
 {
     if (!d->referenceImagesLayer) {
         if (targetImage.isNull()) targetImage = d->image;
 
         d->referenceImagesLayer = new KisReferenceImagesLayer(shapeController(), targetImage);
         targetImage->addNode(d->referenceImagesLayer, targetImage->root());
     }
 
     return d->referenceImagesLayer;
 }
 
+// TODO: change signature to return a shared pointer
 KisReferenceImagesLayer *KisDocument::referenceImagesLayer() const
 {
     return d->referenceImagesLayer.data();
 }
 
+void KisDocument::setReferenceImagesLayer(KisSharedPtr<KisReferenceImagesLayer> layer)
+{
+    d->referenceImagesLayer = layer;
+}
+
 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->disconnect(this);
         d->shapeController->setImage(0);
         d->image = 0;
     }
 
     if (!image) return;
 
     d->setImageAndInitIdleWatcher(image);
     d->shapeController->setImage(image);
     setModified(false);
     connect(d->image, SIGNAL(sigImageModified()), this, SLOT(setImageModified()), Qt::UniqueConnection);
 
     if (forceInitialUpdate) {
         d->image->initialRefreshGraph();
     }
 }
 
 void KisDocument::hackPreliminarySetImage(KisImageSP image)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(!d->image);
 
     d->setImageAndInitIdleWatcher(image);
     d->shapeController->setImage(image);
 }
 
 void KisDocument::setImageModified()
 {
     setModified(true);
 }
 
 
 KisUndoStore* KisDocument::createUndoStore()
 {
     return new KisDocumentUndoStore(this);
 }
 
 bool KisDocument::isAutosaving() const
 {
     return d->isAutosaving;
 }
 
 QString KisDocument::exportErrorToUserMessage(KisImportExportFilter::ConversionStatus status, const QString &errorMessage)
 {
     return errorMessage.isEmpty() ? KisImportExportFilter::conversionStatusString(status) : errorMessage;
 }
diff --git a/libs/ui/KisDocument.h b/libs/ui/KisDocument.h
index 22130bfb27..71232d2df7 100644
--- a/libs/ui/KisDocument.h
+++ b/libs/ui/KisDocument.h
@@ -1,644 +1,648 @@
 /* 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 <kis_image.h>
 #include <KisImportExportFilter.h>
 #include <kis_properties_configuration.h>
 #include <kis_types.h>
 #include <kis_painting_assistant.h>
 #include <KisReferenceImage.h>
 #include <kis_debug.h>
 #include <KisImportExportUtils.h>
 
 #include "kritaui_export.h"
 
 #include <memory>
 
 class QString;
 
 class KUndo2Command;
 class KoUnit;
 
 class KoColor;
 class KoColorSpace;
 class KoShapeBasedDocumentBase;
 class KoShapeLayer;
 class KoStore;
 class KoOdfReadStore;
 class KoDocumentInfo;
 class KoDocumentInfoDlg;
 class KisImportExportManager;
 class KisUndoStore;
 class KisPart;
 class KisGridConfig;
 class KisGuidesConfig;
 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);
 
     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();
 
     /**
      * 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);
 
     void clearUndoHistory();
 
 
     /**
      *  Sets the modified flag on the document. This means that it has
      *  to be saved or not before deleting it.
      */
     void setModified(bool _mod);
 
     void setRecovered(bool value);
     bool isRecovered() const;
 
     void updateEditingTime(bool forceStoreElapsed);
 
     /**
      * Returns the global undo stack
      */
     KUndo2Stack *undoStack();
 
 
     /**
      * @brief importExportManager gives access to the internal import/export manager
      * @return the document's import/export manager
      */
     KisImportExportManager *importExportManager() const;
 
     /**
      * @brief serializeToNativeByteArray daves the document into a .kra file wtitten
      * to a memory-based byte-array
      * @return a byte array containing the .kra file
      */
     QByteArray serializeToNativeByteArray();
 
 
     /**
      * @brief isInSaving shown if the document has any (background) saving process or not
      * @return true if there is some saving in action
      */
     bool isInSaving() const;
 
 public Q_SLOTS:
 
     /**
      * Adds a command to the undo stack and executes it by calling the redo() function.
      * @param command command to add to the undo stack
      */
     void addCommand(KUndo2Command *command);
 
     /**
      * Begins recording of a macro command. At the end endMacro needs to be called.
      * @param text command description
      */
     void beginMacro(const KUndo2MagicString &text);
 
     /**
      * Ends the recording of a macro command.
      */
     void endMacro();
 
 Q_SIGNALS:
 
     /**
      * This signal is emitted when the unit is changed by setUnit().
      * It is common to connect views to it, in order to change the displayed units
      * (e.g. in the rulers)
      */
     void unitChanged(const KoUnit &unit);
 
     /**
      * Emitted e.g. at the beginning of a save operation
      * This is emitted by KisDocument and used by KisView to display a statusbar message
      */
     void statusBarMessage(const QString& text, int timeout = 0);
 
     /**
      * Emitted e.g. at the end of a save operation
      * This is emitted by KisDocument and used by KisView to clear the statusbar message
      */
     void clearStatusBarMessage();
 
     /**
     * Emitted when the document is modified
     */
     void modified(bool);
 
     void titleModified(const QString &caption, bool isModified);
 
     void sigLoadingFinished();
 
     void sigSavingFinished();
 
     void sigGuidesConfigChanged(const KisGuidesConfig &config);
 
     void sigBackgroundSavingFinished(KisImportExportFilter::ConversionStatus status, const QString &errorMessage);
 
     void sigCompleteBackgroundSaving(const KritaUtils::ExportFileJob &job, KisImportExportFilter::ConversionStatus status, const QString &errorMessage);
 
 private Q_SLOTS:
     void finishExportInBackground();
     void slotChildCompletedSavingInBackground(KisImportExportFilter::ConversionStatus status, const QString &errorMessage);
     void slotCompleteAutoSaving(const KritaUtils::ExportFileJob &job, KisImportExportFilter::ConversionStatus status, const QString &errorMessage);
 
     void slotCompleteSavingDocument(const KritaUtils::ExportFileJob &job, KisImportExportFilter::ConversionStatus status, const QString &errorMessage);
 
     void slotInitiateAsyncAutosaving(KisDocument *clonedDocument);
 
 private:
 
     friend class KisPart;
     friend class SafeSavingLocker;
 
     bool initiateSavingInBackground(const QString actionName,
                                     const QObject *receiverObject, const char *receiverMethod,
                                     const KritaUtils::ExportFileJob &job,
                                     KisPropertiesConfigurationSP exportConfiguration,
                                     std::unique_ptr<KisDocument> &&optionalClonedDocument);
 
     bool initiateSavingInBackground(const QString actionName,
                                     const QObject *receiverObject, const char *receiverMethod,
                                     const KritaUtils::ExportFileJob &job,
                                     KisPropertiesConfigurationSP exportConfiguration);
 
     bool startExportInBackground(const QString &actionName, const QString &location,
                                  const QString &realLocation,
                                  const QByteArray &mimeType,
                                  bool showWarnings,
                                  KisPropertiesConfigurationSP exportConfiguration);
 
     /**
      * Activate/deactivate/configure the autosave feature.
      * @param delay in seconds, 0 to disable
      */
     void setAutoSaveDelay(int delay);
 
     /**
      * Generate a name for the document.
      */
     QString newObjectName();
 
     QString generateAutoSaveFileName(const QString & path) const;
 
     /**
      *  Loads a document
      *
      *  Applies a filter if necessary, and calls loadNativeFormat in any case
      *  You should not have to reimplement, except for very special cases.
      *
      * NOTE: this method also creates a new KisView instance!
      *
      * This method is called from the KReadOnlyPart::openUrl method.
      */
     bool openFile();
 
     /** @internal */
     void setModified();
 
 public:
 
     bool isAutosaving() const override;
 
 public:
 
     QString localFilePath() const override;
     void setLocalFilePath( const QString &localFilePath );
 
     KoDocumentInfoDlg* createDocumentInfoDialog(QWidget *parent, KoDocumentInfo *docInfo) const;
 
     bool isReadWrite() const;
 
     QUrl url() const override;
     void setUrl(const QUrl &url) override;
 
     bool closeUrl(bool promptToSave = true);
 
     bool saveAs(const QUrl &url, const QByteArray &mimeType, bool showWarnings, KisPropertiesConfigurationSP exportConfigration = 0);
 
     /**
      * Create a new image that has this document as a parent and
      * replace the current image with this image.
      */
     bool newImage(const QString& name, qint32 width, qint32 height, const KoColorSpace * cs, const KoColor &bgColor, bool backgroundAsLayer,
                   int numberOfLayers, const QString &imageDescription, const double imageResolution);
 
     bool isSaving() const;
     void waitForSavingToComplete();
 
 
     KisImageWSP image() const;
 
     /**
      * @brief savingImage provides a detached, shallow copy of the original image that must be used when saving.
      * Any strokes in progress will not be applied to this image, so the result might be missing some data. On
      * the other hand, it won't block.
      *
      * @return a shallow copy of the original image, or 0 is saving is not in progress
      */
     KisImageSP savingImage() const;
 
     /**
      * Set the current image to the specified image and turn undo on.
      */
     void setCurrentImage(KisImageSP image, bool forceInitialUpdate = true);
 
     /**
      * Set the image of the document preliminary, before the document
      * has completed loading. Some of the document items (shapes) may want
      * to access image properties (bounds and resolution), so we should provide
      * it to them even before the entire image is loaded.
      *
      * Right now, the only use by KoShapeRegistry::createShapeFromOdf(), remove
      * after it is deprecated.
      */
     void hackPreliminarySetImage(KisImageSP image);
 
     KisUndoStore* createUndoStore();
 
     /**
      * The shape controller matches internal krita image layers with
      * the flake shape hierarchy.
      */
     KoShapeBasedDocumentBase * 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);
 
     /**
      * Get existing reference images layer or create new if none exists.
+     *
+     * TODO: use setReferenceImagesLayer() combined with undo commands instead
      */
-    KisSharedPtr<KisReferenceImagesLayer> createReferenceImagesLayer(KisImageSP targetImage = KisImageSP());
+    KRITAUI_DEPRECATED KisSharedPtr<KisReferenceImagesLayer> getOrCreateReferenceImagesLayer(KisImageSP targetImage = KisImageSP());
 
     /**
      * Get existing reference images layer or null if none exists.
      */
     KisReferenceImagesLayer *referenceImagesLayer() const;
 
+    void setReferenceImagesLayer(KisSharedPtr<KisReferenceImagesLayer> layer);
+
     bool save(bool showWarnings, KisPropertiesConfigurationSP exportConfiguration);
 
 Q_SIGNALS:
 
     void completed();
     void canceled(const QString &);
 
 private Q_SLOTS:
 
     void setImageModified();
 
     void slotAutoSave();
 
     void slotUndoStackCleanChanged(bool value);
 
     void slotConfigChanged();
 
 
 private:
     /**
      * @brief try to clone the image. This method handles all the locking for you. If locking
      *        has failed, no cloning happens
      * @return cloned document on success, null otherwise
      */
     KisDocument *lockAndCloneForSaving();
 
     QString exportErrorToUserMessage(KisImportExportFilter::ConversionStatus status, const QString &errorMessage);
 
     QString prettyPathOrUrl() const;
 
     bool openUrlInternal(const QUrl &url);
 
     void slotAutoSaveImpl(std::unique_ptr<KisDocument> &&optionalClonedDocument);
 
     class Private;
     Private *const d;
 };
 
 Q_DECLARE_OPERATORS_FOR_FLAGS(KisDocument::OpenFlags)
 Q_DECLARE_METATYPE(KisDocument*)
 
 #endif
diff --git a/libs/ui/KisFrameCacheStore.cpp b/libs/ui/KisFrameCacheStore.cpp
new file mode 100644
index 0000000000..e00d3e9b80
--- /dev/null
+++ b/libs/ui/KisFrameCacheStore.cpp
@@ -0,0 +1,369 @@
+/*
+ *  Copyright (c) 2018 Dmitry Kazakov <dimula73@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 "KisFrameCacheStore.h"
+
+#include <KoColorSpace.h>
+#include "kis_update_info.h"
+#include "KisFrameDataSerializer.h"
+#include "opengl/KisOpenGLUpdateInfoBuilder.h"
+
+#define SANITY_CHECK
+
+namespace {
+enum FrameType {
+    FrameFull,
+    FrameCopy,
+    FrameDiff
+};
+
+struct FrameInfo;
+typedef QSharedPointer<FrameInfo> FrameInfoSP;
+
+struct FrameInfo {
+    // full frame
+    FrameInfo(const QRect &dirtyImageRect, const QRect &imageBounds, int levelOfDetail, KisFrameDataSerializer &serializer, const KisFrameDataSerializer::Frame &frame);
+    // diff frame
+    FrameInfo(const QRect &dirtyImageRect, const QRect &imageBounds, int levelOfDetail, KisFrameDataSerializer &serializer, FrameInfoSP baseFrame, const KisFrameDataSerializer::Frame &frame);
+    // copy frame
+    FrameInfo(const QRect &dirtyImageRect, const QRect &imageBounds, int levelOfDetail, KisFrameDataSerializer &serializer, FrameInfoSP baseFrame);
+
+    ~FrameInfo();
+
+    FrameType type() const {
+        return m_type;
+    }
+
+    int levelOfDetail() const {
+        return m_levelOfDetail;
+    }
+
+    QRect dirtyImageRect() const {
+        return m_dirtyImageRect;
+    }
+
+    QRect imageBounds() const {
+        return m_imageBounds;
+    }
+
+    int frameDataId() const {
+        return m_savedFrameDataId;
+    }
+
+    FrameInfoSP baseFrame() const {
+        return m_baseFrame;
+    }
+
+    int m_levelOfDetail = 0;
+    QRect m_dirtyImageRect;
+    QRect m_imageBounds;
+    FrameInfoSP m_baseFrame;
+    FrameType m_type = FrameFull;
+    int m_savedFrameDataId = -1;
+    KisFrameDataSerializer &m_serializer;
+};
+
+// full frame
+FrameInfo::FrameInfo(const QRect &dirtyImageRect, const QRect &imageBounds, int levelOfDetail, KisFrameDataSerializer &serializer, const KisFrameDataSerializer::Frame &frame)
+    : m_levelOfDetail(levelOfDetail),
+      m_dirtyImageRect(dirtyImageRect),
+      m_imageBounds(imageBounds),
+      m_baseFrame(0),
+      m_type(FrameFull),
+      m_serializer(serializer)
+{
+    m_savedFrameDataId = m_serializer.saveFrame(frame);
+}
+
+// diff frame
+FrameInfo::FrameInfo(const QRect &dirtyImageRect, const QRect &imageBounds, int levelOfDetail, KisFrameDataSerializer &serializer, FrameInfoSP baseFrame, const KisFrameDataSerializer::Frame &frame)
+    : m_levelOfDetail(levelOfDetail),
+      m_dirtyImageRect(dirtyImageRect),
+      m_imageBounds(imageBounds),
+      m_baseFrame(baseFrame),
+      m_type(FrameDiff),
+      m_serializer(serializer)
+{
+    m_savedFrameDataId = m_serializer.saveFrame(frame);
+}
+
+// copy frame
+FrameInfo::FrameInfo(const QRect &dirtyImageRect, const QRect &imageBounds, int levelOfDetail, KisFrameDataSerializer &serializer, FrameInfoSP baseFrame)
+    : m_levelOfDetail(levelOfDetail),
+      m_dirtyImageRect(dirtyImageRect),
+      m_imageBounds(imageBounds),
+      m_baseFrame(baseFrame),
+      m_type(FrameCopy),
+      m_savedFrameDataId(-1),
+      m_serializer(serializer)
+{
+}
+
+FrameInfo::~FrameInfo()
+{
+    KIS_SAFE_ASSERT_RECOVER_RETURN(m_savedFrameDataId >= 0 || m_type == FrameCopy);
+
+    if (m_savedFrameDataId >= 0) {
+        m_serializer.forgetFrame(m_savedFrameDataId);
+    }
+}
+
+}
+
+
+struct KRITAUI_NO_EXPORT KisFrameCacheStore::Private
+{
+    Private(const QString &frameCachePath)
+        : serializer(frameCachePath)
+    {
+    }
+
+    // the serializer should be killed after *all* the frame info objects
+    // got destroyed, because they use it in their own destruction
+    KisFrameDataSerializer serializer;
+
+    KisFrameDataSerializer::Frame lastSavedFullFrame;
+    int lastSavedFullFrameId = -1;
+
+    KisFrameDataSerializer::Frame lastLoadedBaseFrame;
+    FrameInfoSP lastLoadedBaseFrameInfo;
+
+    QMap<int, FrameInfoSP> savedFrames;
+};
+
+KisFrameCacheStore::KisFrameCacheStore()
+    : KisFrameCacheStore(QString())
+{
+}
+
+KisFrameCacheStore::KisFrameCacheStore(const QString &frameCachePath)
+    : m_d(new Private(frameCachePath))
+{
+}
+
+
+KisFrameCacheStore::~KisFrameCacheStore()
+{
+}
+
+void KisFrameCacheStore::saveFrame(int frameId, KisOpenGLUpdateInfoSP info, const QRect &imageBounds)
+{
+    int pixelSize = 0;
+
+    Q_FOREACH (auto tile, info->tileList) {
+#ifdef SANITY_CHECK
+        if (!pixelSize) {
+            pixelSize = tile->pixelSize();
+        } else {
+            KIS_SAFE_ASSERT_RECOVER_RETURN(pixelSize == tile->pixelSize());
+        }
+#else
+        pixelSize = tile->pixelSize();
+        break;
+#endif
+    }
+
+    KIS_SAFE_ASSERT_RECOVER_RETURN(pixelSize);
+
+    // TODO: assert that dirty image rect is equal to the full image rect
+    // TODO: assert tile color space coicides with the destination color space
+
+    KisFrameDataSerializer::Frame frame;
+    frame.pixelSize = pixelSize;
+
+    for (auto it = info->tileList.begin(); it != info->tileList.end(); ++it) {
+        KisFrameDataSerializer::FrameTile tile(0); // TODO: fix null!
+        tile.col = (*it)->tileCol();
+        tile.row = (*it)->tileRow();
+        tile.rect = (*it)->realPatchRect();
+        tile.data = std::move((*it)->takePixelData());
+
+        frame.frameTiles.push_back(std::move(tile));
+    }
+
+    FrameInfoSP frameInfo;
+
+    if (m_d->lastSavedFullFrame.isValid()) {
+        boost::optional<qreal> uniqueness = KisFrameDataSerializer::estimateFrameUniqueness(m_d->lastSavedFullFrame, frame, 0.01);
+
+        if (uniqueness) {
+            if (*uniqueness == 0.0) {
+                FrameInfoSP baseFrameInfo = m_d->savedFrames[m_d->lastSavedFullFrameId];
+                frameInfo = toQShared(new FrameInfo(info->dirtyImageRect(),
+                                                    imageBounds,
+                                                    info->levelOfDetail(),
+                                                    m_d->serializer,
+                                                    baseFrameInfo));
+
+            } else if (*uniqueness < 0.5) {
+                FrameInfoSP baseFrameInfo = m_d->savedFrames[m_d->lastSavedFullFrameId];
+
+                KisFrameDataSerializer::subtractFrames(frame, m_d->lastSavedFullFrame);
+                frameInfo = toQShared(new FrameInfo(info->dirtyImageRect(),
+                                                    imageBounds,
+                                                    info->levelOfDetail(),
+                                                    m_d->serializer,
+                                                    baseFrameInfo,
+                                                    frame));
+            }
+        }
+    }
+
+    if (!frameInfo) {
+        frameInfo = toQShared(new FrameInfo(info->dirtyImageRect(),
+                                            imageBounds,
+                                            info->levelOfDetail(),
+                                            m_d->serializer,
+                                            frame));
+    }
+
+    m_d->savedFrames.insert(frameId, frameInfo);
+
+    if (frameInfo->type() == FrameFull) {
+        m_d->lastSavedFullFrame = std::move(frame);
+        m_d->lastSavedFullFrameId = frameId;
+    }
+}
+
+KisOpenGLUpdateInfoSP KisFrameCacheStore::loadFrame(int frameId, const KisOpenGLUpdateInfoBuilder &builder)
+{
+    KisOpenGLUpdateInfoSP info = new KisOpenGLUpdateInfo();
+    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(m_d->savedFrames.contains(frameId), info);
+
+    FrameInfoSP frameInfo = m_d->savedFrames[frameId];
+
+    info->assignDirtyImageRect(frameInfo->dirtyImageRect());
+    info->assignLevelOfDetail(frameInfo->levelOfDetail());
+
+    KisFrameDataSerializer::Frame frame;
+
+    switch (frameInfo->type()) {
+    case FrameFull:
+        frame = m_d->serializer.loadFrame(frameInfo->frameDataId(), builder.textureInfoPool());
+        m_d->lastLoadedBaseFrame = frame.clone();
+        m_d->lastLoadedBaseFrameInfo = frameInfo;
+        break;
+    case FrameCopy: {
+        FrameInfoSP baseFrameInfo = frameInfo->baseFrame();
+        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(baseFrameInfo, KisOpenGLUpdateInfoSP());
+
+        if (baseFrameInfo == m_d->lastLoadedBaseFrameInfo) {
+            frame = m_d->lastLoadedBaseFrame.clone();
+        } else {
+            frame = m_d->serializer.loadFrame(baseFrameInfo->frameDataId(), builder.textureInfoPool());
+            m_d->lastLoadedBaseFrame = frame.clone();
+            m_d->lastLoadedBaseFrameInfo = baseFrameInfo;
+        }
+        break;
+    }
+    case FrameDiff: {
+        FrameInfoSP baseFrameInfo = frameInfo->baseFrame();
+        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(baseFrameInfo, KisOpenGLUpdateInfoSP());
+
+        if (baseFrameInfo == m_d->lastLoadedBaseFrameInfo) {
+            // noop
+        } else {
+            m_d->lastLoadedBaseFrame = m_d->serializer.loadFrame(baseFrameInfo->frameDataId(), builder.textureInfoPool());
+            m_d->lastLoadedBaseFrameInfo = baseFrameInfo;
+
+            KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(m_d->lastLoadedBaseFrame.isValid(), KisOpenGLUpdateInfoSP());
+        }
+
+        const KisFrameDataSerializer::Frame &baseFrame = m_d->lastLoadedBaseFrame;
+        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(baseFrame.isValid(), KisOpenGLUpdateInfoSP());
+
+        frame = m_d->serializer.loadFrame(frameInfo->frameDataId(), builder.textureInfoPool());
+        KisFrameDataSerializer::addFrames(frame, baseFrame);
+        break;
+    }
+    }
+
+    for (auto it = frame.frameTiles.begin(); it != frame.frameTiles.end(); ++it) {
+        KisFrameDataSerializer::FrameTile &tile = *it;
+
+        QRect patchRect = tile.rect;
+
+        if (frameInfo->levelOfDetail()) {
+            patchRect = KisLodTransform::upscaledRect(patchRect, frameInfo->levelOfDetail());
+        }
+
+        const QRect fullSizeTileRect =
+            builder.calculatePhysicalTileRect(tile.col, tile.row,
+                                              frameInfo->imageBounds(),
+                                              frameInfo->levelOfDetail());
+
+        KisTextureTileUpdateInfoSP tileInfo(
+            new KisTextureTileUpdateInfo(tile.col, tile.row,
+                                         fullSizeTileRect, patchRect,
+                                         frameInfo->imageBounds(),
+                                         frameInfo->levelOfDetail(),
+                                         builder.textureInfoPool()));
+
+        tileInfo->putPixelData(std::move(tile.data), builder.destinationColorSpace());
+
+        info->tileList << tileInfo;
+    }
+
+    return info;
+}
+
+void KisFrameCacheStore::moveFrame(int srcFrameId, int dstFrameId)
+{
+    KIS_SAFE_ASSERT_RECOVER_RETURN(srcFrameId != dstFrameId);
+
+    KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->savedFrames.contains(srcFrameId));
+
+    KIS_SAFE_ASSERT_RECOVER(!m_d->savedFrames.contains(dstFrameId)) {
+        m_d->savedFrames.remove(dstFrameId);
+    }
+
+    m_d->savedFrames.insert(dstFrameId, m_d->savedFrames[srcFrameId]);
+    m_d->savedFrames.remove(srcFrameId);
+
+    if (m_d->lastSavedFullFrameId == srcFrameId) {
+        m_d->lastSavedFullFrameId = dstFrameId;
+    }
+}
+
+void KisFrameCacheStore::forgetFrame(int frameId)
+{
+    KIS_SAFE_ASSERT_RECOVER_NOOP(m_d->savedFrames.contains(frameId));
+
+    if (m_d->lastSavedFullFrameId == frameId) {
+        m_d->lastSavedFullFrame = KisFrameDataSerializer::Frame();
+        m_d->lastSavedFullFrameId = -1;
+    }
+
+    m_d->savedFrames.remove(frameId);
+}
+
+bool KisFrameCacheStore::hasFrame(int frameId) const
+{
+    return m_d->savedFrames.contains(frameId);
+}
+
+int KisFrameCacheStore::frameLevelOfDetail(int frameId) const
+{
+    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(m_d->savedFrames.contains(frameId), 0);
+    return m_d->savedFrames[frameId]->levelOfDetail();
+}
+
+QRect KisFrameCacheStore::frameDirtyRect(int frameId) const
+{
+    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(m_d->savedFrames.contains(frameId), QRect());
+    return m_d->savedFrames[frameId]->dirtyImageRect();
+}
diff --git a/libs/ui/KisFrameCacheStore.h b/libs/ui/KisFrameCacheStore.h
new file mode 100644
index 0000000000..58db2681ee
--- /dev/null
+++ b/libs/ui/KisFrameCacheStore.h
@@ -0,0 +1,75 @@
+/*
+ *  Copyright (c) 2018 Dmitry Kazakov <dimula73@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 KISFRAMECACHESTORE_H
+#define KISFRAMECACHESTORE_H
+
+#include "kritaui_export.h"
+#include <QScopedPointer>
+#include "kis_types.h"
+
+#include "opengl/kis_texture_tile_info_pool.h"
+
+class KisOpenGLUpdateInfoBuilder;
+
+class KisOpenGLUpdateInfo;
+typedef KisSharedPtr<KisOpenGLUpdateInfo> KisOpenGLUpdateInfoSP;
+
+/**
+ * KisFrameCacheStore is a middle-level class for reading/writing
+ * animation frames on disk. Its main responsibilities:
+ *
+ * 1) Convert frames from KisOpenGLUpdateInfo format into a serializable
+ *    KisFrameDataSerializer::Frame format.
+ *
+ * 2) Calculate differences between the frames and decide which
+ *    frame will be a keyframe for other frames.
+ *
+ * 3) The keyframes will be used as a base for difference
+ *    calculation and stored in a short in-memory cache to avoid
+ *    fetching them from disk too often.
+ *
+ * 4) The in-memory cache of the keyframes is stored in serializable
+ *    KisFrameDataSerializer::Frame format.
+ */
+
+class KRITAUI_EXPORT KisFrameCacheStore
+{
+public:
+    KisFrameCacheStore();
+    KisFrameCacheStore(const QString &frameCachePath);
+
+    ~KisFrameCacheStore();
+
+    // WARNING: after transferring \p info to saveFrame() the object becomes invalid
+    void saveFrame(int frameId, KisOpenGLUpdateInfoSP info, const QRect &imageBounds);
+    KisOpenGLUpdateInfoSP loadFrame(int frameId, const KisOpenGLUpdateInfoBuilder &builder);
+
+    void moveFrame(int srcFrameId, int dstFrameId);
+
+    void forgetFrame(int frameId);
+    bool hasFrame(int frameId) const;
+
+    int frameLevelOfDetail(int frameId) const;
+    QRect frameDirtyRect(int frameId) const;
+
+private:
+    struct Private;
+    const QScopedPointer<Private> m_d;
+};
+
+#endif // KISFRAMECACHESTORE_H
diff --git a/libs/ui/KisFrameCacheSwapper.cpp b/libs/ui/KisFrameCacheSwapper.cpp
new file mode 100644
index 0000000000..15c138fcd1
--- /dev/null
+++ b/libs/ui/KisFrameCacheSwapper.cpp
@@ -0,0 +1,84 @@
+/*
+ *  Copyright (c) 2018 Dmitry Kazakov <dimula73@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 "KisFrameCacheSwapper.h"
+
+#include "KisFrameCacheStore.h"
+
+#include "kis_update_info.h"
+#include "opengl/KisOpenGLUpdateInfoBuilder.h"
+
+struct KisFrameCacheSwapper::Private
+{
+    Private(const KisOpenGLUpdateInfoBuilder &_builder, const QString &frameCachePath)
+        : frameStore(frameCachePath),
+          builder(_builder)
+    {
+    }
+
+    KisFrameCacheStore frameStore;
+    const KisOpenGLUpdateInfoBuilder &builder;
+};
+
+KisFrameCacheSwapper::KisFrameCacheSwapper(const KisOpenGLUpdateInfoBuilder &builder)
+    : KisFrameCacheSwapper(builder, "")
+{
+}
+
+KisFrameCacheSwapper::KisFrameCacheSwapper(const KisOpenGLUpdateInfoBuilder &builder, const QString &frameCachePath)
+    : m_d(new Private(builder, frameCachePath))
+{
+}
+
+KisFrameCacheSwapper::~KisFrameCacheSwapper()
+{
+}
+
+void KisFrameCacheSwapper::saveFrame(int frameId, KisOpenGLUpdateInfoSP info, const QRect &imageBounds)
+{
+    m_d->frameStore.saveFrame(frameId, info, imageBounds);
+}
+
+KisOpenGLUpdateInfoSP KisFrameCacheSwapper::loadFrame(int frameId)
+{
+    return m_d->frameStore.loadFrame(frameId, m_d->builder);
+}
+
+void KisFrameCacheSwapper::moveFrame(int srcFrameId, int dstFrameId)
+{
+    m_d->frameStore.moveFrame(srcFrameId, dstFrameId);
+}
+
+void KisFrameCacheSwapper::forgetFrame(int frameId)
+{
+    m_d->frameStore.forgetFrame(frameId);
+}
+
+bool KisFrameCacheSwapper::hasFrame(int frameId) const
+{
+    return m_d->frameStore.hasFrame(frameId);
+}
+
+int KisFrameCacheSwapper::frameLevelOfDetail(int frameId) const
+{
+    return m_d->frameStore.frameLevelOfDetail(frameId);
+}
+
+QRect KisFrameCacheSwapper::frameDirtyRect(int frameId) const
+{
+    return m_d->frameStore.frameDirtyRect(frameId);
+}
diff --git a/libs/ui/KisFrameCacheSwapper.h b/libs/ui/KisFrameCacheSwapper.h
new file mode 100644
index 0000000000..17cd32390c
--- /dev/null
+++ b/libs/ui/KisFrameCacheSwapper.h
@@ -0,0 +1,65 @@
+/*
+ *  Copyright (c) 2018 Dmitry Kazakov <dimula73@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 KISFRAMECACHESWAPPER_H
+#define KISFRAMECACHESWAPPER_H
+
+#include <QScopedPointer>
+
+#include "KisAbstractFrameCacheSwapper.h"
+
+class KisOpenGLUpdateInfoBuilder;
+
+
+/**
+ * KisFrameCacheSwapper is the most highlevel facade of the frame
+ * swapping infrastructure. The main responsibilities of the class:
+ *
+ * 1) Asynchronously predict and prefetch the pending frames from disk
+ *    and maintain a short in-memory cache of these frames (already
+ *    converted into KisOpenGLUpdateInfo)
+ *
+ * 2) Pass all the other requests to the lower-level API,
+ *    like KisFrameCacheStore
+ */
+
+class KRITAUI_EXPORT KisFrameCacheSwapper : public KisAbstractFrameCacheSwapper
+{
+public:
+    KisFrameCacheSwapper(const KisOpenGLUpdateInfoBuilder &builder);
+    KisFrameCacheSwapper(const KisOpenGLUpdateInfoBuilder &builder, const QString &frameCachePath);
+    ~KisFrameCacheSwapper();
+
+    // WARNING: after transferring \p info to saveFrame() the object becomes invalid
+    void saveFrame(int frameId, KisOpenGLUpdateInfoSP info, const QRect &imageBounds) override;
+    KisOpenGLUpdateInfoSP loadFrame(int frameId) override;
+
+    void moveFrame(int srcFrameId, int dstFrameId) override;
+
+    void forgetFrame(int frameId) override;
+    bool hasFrame(int frameId) const override;
+
+    int frameLevelOfDetail(int frameId) const override;
+
+    QRect frameDirtyRect(int frameId) const override;
+
+private:
+    struct Private;
+    const QScopedPointer<Private> m_d;
+};
+
+#endif // KISFRAMECACHESWAPPER_H
diff --git a/libs/ui/KisFrameDataSerializer.cpp b/libs/ui/KisFrameDataSerializer.cpp
new file mode 100644
index 0000000000..67f637e901
--- /dev/null
+++ b/libs/ui/KisFrameDataSerializer.cpp
@@ -0,0 +1,360 @@
+/*
+ *  Copyright (c) 2018 Dmitry Kazakov <dimula73@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 "KisFrameDataSerializer.h"
+
+#include <cstring>
+#include <QTemporaryDir>
+#include "tiles3/swap/kis_lzf_compression.h"
+
+
+struct KRITAUI_NO_EXPORT KisFrameDataSerializer::Private
+{
+    Private(const QString &frameCachePath)
+        : framesDir(
+              (!frameCachePath.isEmpty() ? frameCachePath : QDir::tempPath()) +
+              QDir::separator() + "KritaFrameCacheXXXXXX")
+    {
+        KIS_SAFE_ASSERT_RECOVER_NOOP(framesDir.isValid());
+        framesDirObject = QDir(framesDir.path());
+        framesDirObject.makeAbsolute();
+    }
+
+    QString subfolderNameForFrame(int frameId)
+    {
+        const int subfolderIndex = frameId & 0xff00;
+        return QString::number(subfolderIndex);
+    }
+
+    QString fileNameForFrame(int frameId) {
+        return QString("frame_%1").arg(frameId);
+    }
+
+    QString filePathForFrame(int frameId)
+    {
+        return framesDirObject.filePath(
+                    subfolderNameForFrame(frameId) + QDir::separator() +
+                    fileNameForFrame(frameId));
+    }
+
+    int generateFrameId() {
+        // TODO: handle wrapping and range compression
+        return nextFrameId++;
+    }
+
+    quint8* getCompressionBuffer(int size) {
+        if (compressionBuffer.size() < size) {
+            compressionBuffer.resize(size);
+        }
+        return reinterpret_cast<quint8*>(compressionBuffer.data());
+    }
+
+    QTemporaryDir framesDir;
+    QDir framesDirObject;
+    int nextFrameId = 0;
+
+    QByteArray compressionBuffer;
+};
+
+KisFrameDataSerializer::KisFrameDataSerializer()
+    : KisFrameDataSerializer(QString())
+{
+}
+
+KisFrameDataSerializer::KisFrameDataSerializer(const QString &frameCachePath)
+    : m_d(new Private(frameCachePath))
+{
+}
+
+KisFrameDataSerializer::~KisFrameDataSerializer()
+{
+}
+
+int KisFrameDataSerializer::saveFrame(const KisFrameDataSerializer::Frame &frame)
+{
+    KisLzfCompression compression;
+
+    const int frameId = m_d->generateFrameId();
+
+    const QString frameSubfolder = m_d->subfolderNameForFrame(frameId);
+
+    if (!m_d->framesDirObject.exists(frameSubfolder)) {
+        m_d->framesDirObject.mkpath(frameSubfolder);
+    }
+
+    const QString frameRelativePath = frameSubfolder + QDir::separator() + m_d->fileNameForFrame(frameId);
+
+    if (m_d->framesDirObject.exists(frameRelativePath)) {
+        qWarning() << "WARNING: overwriting existing frame file!" << frameRelativePath;
+        forgetFrame(frameId);
+    }
+
+    const QString frameFilePath = m_d->framesDirObject.filePath(frameRelativePath);
+
+    QFile file(frameFilePath);
+    file.open(QFile::WriteOnly);
+
+    QDataStream stream(&file);
+    stream << frameId;
+    stream << frame.pixelSize;
+
+    stream << int(frame.frameTiles.size());
+
+    for (int i = 0; i < int(frame.frameTiles.size()); i++) {
+        const FrameTile &tile = frame.frameTiles[i];
+
+        stream << tile.col;
+        stream << tile.row;
+        stream << tile.rect;
+
+        const int frameByteSize = frame.pixelSize * tile.rect.width() * tile.rect.height();
+        const int maxBufferSize = compression.outputBufferSize(frameByteSize);
+        quint8 *buffer = m_d->getCompressionBuffer(maxBufferSize);
+
+        const int compressedSize =
+            compression.compress(tile.data.data(), frameByteSize, buffer, maxBufferSize);
+
+        ENTER_FUNCTION() << ppVar(compressedSize) << ppVar(frameByteSize);
+
+        const bool isCompressed = compressedSize < frameByteSize;
+        stream << isCompressed;
+
+        if (isCompressed) {
+            stream << compressedSize;
+            stream.writeRawData((char*)buffer, compressedSize);
+        } else {
+            stream << frameByteSize;
+            stream.writeRawData((char*)tile.data.data(), frameByteSize);
+        }
+    }
+
+    file.close();
+
+    return frameId;
+}
+
+#include "../sdk/tests/testutil.h"
+#include <QElapsedTimer>
+
+TestUtil::MeasureAvgPortion CC(10);
+
+KisFrameDataSerializer::Frame KisFrameDataSerializer::loadFrame(int frameId, KisTextureTileInfoPoolSP pool)
+{
+    KisLzfCompression compression;
+
+    QElapsedTimer loadingTime;
+    loadingTime.start();
+
+    int loadedFrameId = -1;
+    KisFrameDataSerializer::Frame frame;
+
+    qint64 compressionTime = 0;
+
+    const QString framePath = m_d->filePathForFrame(frameId);
+
+    QFile file(framePath);
+    KIS_SAFE_ASSERT_RECOVER_NOOP(file.exists());
+    if (!file.open(QFile::ReadOnly)) return frame;
+
+    QDataStream stream(&file);
+
+    int numTiles = 0;
+
+    stream >> loadedFrameId;
+    stream >> frame.pixelSize;
+    stream >> numTiles;
+    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(loadedFrameId == frameId, KisFrameDataSerializer::Frame());
+
+
+
+    for (int i = 0; i < numTiles; i++) {
+        FrameTile tile(pool);
+        stream >> tile.col;
+        stream >> tile.row;
+        stream >> tile.rect;
+
+        const int frameByteSize = frame.pixelSize * tile.rect.width() * tile.rect.height();
+        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(frameByteSize <= pool->chunkSize(frame.pixelSize),
+                                             KisFrameDataSerializer::Frame());
+
+        bool isCompressed = false;
+        int inputSize = -1;
+
+        stream >> isCompressed;
+        stream >> inputSize;
+
+        if (isCompressed) {
+            const int maxBufferSize = compression.outputBufferSize(inputSize);
+            quint8 *buffer = m_d->getCompressionBuffer(maxBufferSize);
+            stream.readRawData((char*)buffer, inputSize);
+
+            tile.data.allocate(frame.pixelSize);
+
+            QElapsedTimer compTime;
+            compTime.start();
+
+            const int decompressedSize =
+                compression.decompress(buffer, inputSize, tile.data.data(), frameByteSize);
+
+            compressionTime += compTime.nsecsElapsed();
+
+            KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(frameByteSize == decompressedSize,
+                                                 KisFrameDataSerializer::Frame());
+
+        } else {
+            KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(frameByteSize == inputSize,
+                                                 KisFrameDataSerializer::Frame());
+
+            tile.data.allocate(frame.pixelSize);
+            stream.readRawData((char*)tile.data.data(), inputSize);
+        }
+
+        frame.frameTiles.push_back(std::move(tile));
+    }
+
+    file.close();
+
+    CC.addVal(compressionTime / 1000);
+    CC.addTotal(loadingTime.nsecsElapsed() / 1000);
+
+    return frame;
+}
+
+void KisFrameDataSerializer::moveFrame(int srcFrameId, int dstFrameId)
+{
+    const QString srcFramePath = m_d->filePathForFrame(srcFrameId);
+    const QString dstFramePath = m_d->filePathForFrame(dstFrameId);
+    KIS_SAFE_ASSERT_RECOVER_RETURN(QFileInfo(srcFramePath).exists());
+
+    KIS_SAFE_ASSERT_RECOVER(!QFileInfo(dstFramePath).exists()) {
+        QFile::remove(dstFramePath);
+    }
+
+    QFile::rename(srcFramePath, dstFramePath);
+}
+
+bool KisFrameDataSerializer::hasFrame(int frameId) const
+{
+    const QString framePath = m_d->filePathForFrame(frameId);
+    return QFileInfo(framePath).exists();
+}
+
+void KisFrameDataSerializer::forgetFrame(int frameId)
+{
+    const QString framePath = m_d->filePathForFrame(frameId);
+    QFile::remove(framePath);
+}
+
+boost::optional<qreal> KisFrameDataSerializer::estimateFrameUniqueness(const KisFrameDataSerializer::Frame &lhs, const KisFrameDataSerializer::Frame &rhs, qreal portion)
+{
+    if (lhs.pixelSize != rhs.pixelSize) return boost::none;
+    if (lhs.frameTiles.size() != rhs.frameTiles.size()) return boost::none;
+
+    const int pixelSize = lhs.pixelSize;
+    int numSampledPixels = 0;
+    int numUniquePixels = 0;
+    const int sampleStep = portion > 0.0 ? qMax(1, qRound(1.0 / portion)) : 0;
+
+    for (int i = 0; i < int(lhs.frameTiles.size()); i++) {
+        const FrameTile &lhsTile = lhs.frameTiles[i];
+        const FrameTile &rhsTile = rhs.frameTiles[i];
+
+        if (lhsTile.col != rhsTile.col ||
+            lhsTile.row != rhsTile.row ||
+            lhsTile.rect != rhsTile.rect) {
+
+            return boost::none;
+        }
+
+        if (sampleStep > 0) {
+            const int numPixels = lhsTile.rect.width() * lhsTile.rect.height();
+            for (int j = 0; j < numPixels; j += sampleStep) {
+                quint8 *lhsDataPtr = lhsTile.data.data() + j * pixelSize;
+                quint8 *rhsDataPtr = rhsTile.data.data() + j * pixelSize;
+
+                if (std::memcmp(lhsDataPtr, rhsDataPtr, pixelSize) != 0) {
+                    numUniquePixels++;
+                }
+                numSampledPixels++;
+            }
+        }
+    }
+
+    return numSampledPixels > 0 ? qreal(numUniquePixels) / numSampledPixels : 1.0;
+}
+
+template <template <typename U> class OpPolicy, typename T>
+bool processData(T *dst, const T *src, int numUnits)
+{
+    OpPolicy<T> op;
+
+    bool unitsAreSame = true;
+
+    for (int j = 0; j < numUnits; j++) {
+        *dst = op(*dst, *src);
+
+        if (*dst != 0) {
+            unitsAreSame = false;
+        }
+
+        src++;
+        dst++;
+    }
+    return unitsAreSame;
+}
+
+
+template<template <typename U> class OpPolicy>
+bool KisFrameDataSerializer::processFrames(KisFrameDataSerializer::Frame &dst, const KisFrameDataSerializer::Frame &src)
+{
+    bool framesAreSame = true;
+
+    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(estimateFrameUniqueness(src, dst, 0.0), false);
+
+    for (int i = 0; i < int(src.frameTiles.size()); i++) {
+        const FrameTile &srcTile = src.frameTiles[i];
+        FrameTile &dstTile = dst.frameTiles[i];
+
+        const int numBytes = srcTile.rect.width() * srcTile.rect.height() * src.pixelSize;
+        const int numQWords = numBytes / 8;
+
+        const quint64 *srcDataPtr = reinterpret_cast<const quint64*>(srcTile.data.data());
+        quint64 *dstDataPtr = reinterpret_cast<quint64*>(dstTile.data.data());
+
+        framesAreSame &= processData<OpPolicy>(dstDataPtr, srcDataPtr, numQWords);
+
+
+        const int tailBytes = numBytes % 8;
+        const quint8 *srcTailDataPtr = srcTile.data.data() + numBytes - tailBytes;
+        quint8 *dstTailDataPtr = dstTile.data.data() + numBytes - tailBytes;
+
+        framesAreSame &= processData<OpPolicy>(dstTailDataPtr, srcTailDataPtr, tailBytes);
+    }
+
+    return framesAreSame;
+}
+
+bool KisFrameDataSerializer::subtractFrames(KisFrameDataSerializer::Frame &dst, const KisFrameDataSerializer::Frame &src)
+{
+    return processFrames<std::minus>(dst, src);
+}
+
+void KisFrameDataSerializer::addFrames(KisFrameDataSerializer::Frame &dst, const KisFrameDataSerializer::Frame &src)
+{
+    // TODO: don't spend time on calculation of "framesAreSame" in this case
+    (void) processFrames<std::plus>(dst, src);
+}
diff --git a/libs/ui/KisFrameDataSerializer.h b/libs/ui/KisFrameDataSerializer.h
new file mode 100644
index 0000000000..b2f83c9098
--- /dev/null
+++ b/libs/ui/KisFrameDataSerializer.h
@@ -0,0 +1,137 @@
+/*
+ *  Copyright (c) 2018 Dmitry Kazakov <dimula73@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 KISFRAMEDATASERIALIZER_H
+#define KISFRAMEDATASERIALIZER_H
+
+#include "kritaui_export.h"
+#include <QScopedPointer>
+#include "opengl/kis_texture_tile_info_pool.h"
+
+// TODO: extract DataBuffer into a separate file
+#include "opengl/kis_texture_tile_update_info.h"
+
+#include <vector>
+#include <boost/optional.hpp>
+
+class QString;
+
+
+/**
+ * KisFrameDataSerializer is the lowest level class for storing frame
+ * data on disk. Its responsibilities are simple:
+ *
+ * 1) Accept low-level frame data object (KisFrameDataSerializer::Frame),
+ *    which contains raw data in it (the data may be not a pixel data,
+ *    but a preprocessed pixel differences)
+ *
+ * 2) Compress this data and save it on disk
+ */
+
+class KRITAUI_EXPORT KisFrameDataSerializer
+{
+public:
+    struct FrameTile
+    {
+        FrameTile(KisTextureTileInfoPoolSP pool) : data(pool) {}
+
+        FrameTile(FrameTile &&rhs) = default;
+        FrameTile& operator=(FrameTile &&rhs) = default;
+
+        FrameTile(const FrameTile &rhs) = delete;
+        FrameTile& operator=(FrameTile &rhs) = delete;
+
+        bool isValid() const {
+            return data.data();
+        }
+
+        FrameTile clone() const{
+            FrameTile tile(data.pool());
+            tile.col = col;
+            tile.row = row;
+            tile.rect = rect;
+            tile.data.allocate(data.pixelSize());
+
+            const int bufferSize = data.pixelSize() * rect.width() * rect.height();
+            memcpy(tile.data.data(), data.data(), bufferSize);
+
+            return tile;
+        }
+
+        int col = -1;
+        int row = -1;
+        bool isCompressed = false;
+        QRect rect;
+        DataBuffer data;
+    };
+
+    struct Frame
+    {
+        Frame() = default;
+
+        Frame(Frame&&rhs) = default;
+        Frame& operator=(Frame &&rhs) = default;
+
+        Frame(const Frame &rhs) = delete;
+        Frame& operator=(Frame &rhs) = delete;
+
+        Frame clone() const {
+            Frame frame;
+            frame.pixelSize = pixelSize;
+            for (auto it = frameTiles.begin(); it != frameTiles.end(); ++it) {
+                frame.frameTiles.push_back(it->clone());
+            }
+            return frame;
+        }
+
+        int pixelSize = 0;
+        std::vector<FrameTile> frameTiles;
+
+        bool isValid() const {
+            return pixelSize > 0;
+        }
+    };
+
+public:
+    KisFrameDataSerializer();
+    KisFrameDataSerializer(const QString &frameCachePath);
+    ~KisFrameDataSerializer();
+
+    int saveFrame(const Frame &frame);
+    Frame loadFrame(int frameId, KisTextureTileInfoPoolSP pool);
+
+    void moveFrame(int srcFrameId, int dstFrameId);
+
+    bool hasFrame(int frameId) const;
+    void forgetFrame(int frameId);
+
+    static boost::optional<qreal> estimateFrameUniqueness(const Frame &lhs, const Frame &rhs, qreal portion);
+    static bool subtractFrames(Frame &dst, const Frame &src);
+    static void addFrames(Frame &dst, const Frame &src);
+
+private:
+    template<template <typename U> class OpPolicy>
+    static bool processFrames(KisFrameDataSerializer::Frame &dst, const KisFrameDataSerializer::Frame &src);
+
+private:
+    Q_DISABLE_COPY(KisFrameDataSerializer)
+
+    struct Private;
+    const QScopedPointer<Private> m_d;
+};
+
+#endif // KISFRAMEDATASERIALIZER_H
diff --git a/libs/ui/KisInMemoryFrameCacheSwapper.cpp b/libs/ui/KisInMemoryFrameCacheSwapper.cpp
new file mode 100644
index 0000000000..299ebdfa49
--- /dev/null
+++ b/libs/ui/KisInMemoryFrameCacheSwapper.cpp
@@ -0,0 +1,82 @@
+/*
+ *  Copyright (c) 2018 Dmitry Kazakov <dimula73@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 "KisInMemoryFrameCacheSwapper.h"
+
+#include <QMap>
+#include <kis_update_info.h>
+
+
+struct KRITAUI_NO_EXPORT KisInMemoryFrameCacheSwapper::Private
+{
+    QMap<int, KisOpenGLUpdateInfoSP> framesMap;
+};
+
+KisInMemoryFrameCacheSwapper::KisInMemoryFrameCacheSwapper()
+    : m_d(new Private)
+{
+}
+
+KisInMemoryFrameCacheSwapper::~KisInMemoryFrameCacheSwapper()
+{
+}
+
+void KisInMemoryFrameCacheSwapper::saveFrame(int frameId, KisOpenGLUpdateInfoSP info, const QRect &imageBounds)
+{
+    Q_UNUSED(imageBounds);
+    KIS_SAFE_ASSERT_RECOVER_NOOP(!m_d->framesMap.contains(frameId));
+
+    m_d->framesMap.insert(frameId, info);
+}
+
+KisOpenGLUpdateInfoSP KisInMemoryFrameCacheSwapper::loadFrame(int frameId)
+{
+    KIS_SAFE_ASSERT_RECOVER_NOOP(m_d->framesMap.contains(frameId));
+    return m_d->framesMap.value(frameId, KisOpenGLUpdateInfoSP());
+}
+
+void KisInMemoryFrameCacheSwapper::moveFrame(int srcFrameId, int dstFrameId)
+{
+    KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->framesMap.contains(srcFrameId));
+    KIS_SAFE_ASSERT_RECOVER_NOOP(!m_d->framesMap.contains(dstFrameId));
+
+    m_d->framesMap[dstFrameId] = m_d->framesMap[srcFrameId];
+    m_d->framesMap.remove(srcFrameId);
+}
+
+void KisInMemoryFrameCacheSwapper::forgetFrame(int frameId)
+{
+    KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->framesMap.contains(frameId));
+    m_d->framesMap.remove(frameId);
+}
+
+bool KisInMemoryFrameCacheSwapper::hasFrame(int frameId) const
+{
+    return m_d->framesMap.contains(frameId);
+}
+
+int KisInMemoryFrameCacheSwapper::frameLevelOfDetail(int frameId) const
+{
+    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(m_d->framesMap.contains(frameId), 0);
+    return m_d->framesMap[frameId]->levelOfDetail();
+}
+
+QRect KisInMemoryFrameCacheSwapper::frameDirtyRect(int frameId) const
+{
+    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(m_d->framesMap.contains(frameId), QRect());
+    return m_d->framesMap[frameId]->dirtyImageRect();
+}
diff --git a/libs/ui/KisInMemoryFrameCacheSwapper.h b/libs/ui/KisInMemoryFrameCacheSwapper.h
new file mode 100644
index 0000000000..9a5ae1263f
--- /dev/null
+++ b/libs/ui/KisInMemoryFrameCacheSwapper.h
@@ -0,0 +1,53 @@
+/*
+ *  Copyright (c) 2018 Dmitry Kazakov <dimula73@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 KISINMEMORYFRAMECACHESWAPPER_H
+#define KISINMEMORYFRAMECACHESWAPPER_H
+
+#include <QScopedPointer>
+
+#include "KisAbstractFrameCacheSwapper.h"
+#include "opengl/kis_texture_tile_info_pool.h"
+
+class KisOpenGLUpdateInfoBuilder;
+
+
+class KRITAUI_EXPORT KisInMemoryFrameCacheSwapper : public KisAbstractFrameCacheSwapper
+{
+public:
+    KisInMemoryFrameCacheSwapper();
+    ~KisInMemoryFrameCacheSwapper();
+
+    // WARNING: after transferring \p info to saveFrame() the object becomes invalid
+    void saveFrame(int frameId, KisOpenGLUpdateInfoSP info, const QRect &imageBounds) override;
+    KisOpenGLUpdateInfoSP loadFrame(int frameId) override;
+
+    void moveFrame(int srcFrameId, int dstFrameId) override;
+
+    void forgetFrame(int frameId) override;
+    bool hasFrame(int frameId) const override;
+
+    int frameLevelOfDetail(int frameId) const override;
+
+    QRect frameDirtyRect(int frameId) const override;
+
+private:
+    struct Private;
+    const QScopedPointer<Private> m_d;
+};
+
+#endif // KISINMEMORYFRAMECACHESWAPPER_H
diff --git a/libs/ui/KisReferenceImagesDecoration.cpp b/libs/ui/KisReferenceImagesDecoration.cpp
index 989b76c30d..d14366c1b2 100644
--- a/libs/ui/KisReferenceImagesDecoration.cpp
+++ b/libs/ui/KisReferenceImagesDecoration.cpp
@@ -1,138 +1,138 @@
 /*
  * Copyright (C) 2016 Boudewijn Rempt <boud@valdyas.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "KisReferenceImagesDecoration.h"
 
 #include "KoShapeManager.h"
 
 #include "kis_algebra_2d.h"
 #include "KisDocument.h"
 #include "KisReferenceImagesLayer.h"
 
 struct KisReferenceImagesDecoration::Private {
     struct Buffer
     {
         /// Top left corner of the buffer relative to the viewport
         QPointF position;
         QImage image;
 
         QRectF bounds() const
         {
             return QRectF(position, image.size());
         }
     };
 
     KisReferenceImagesDecoration *q;
 
     KisWeakSharedPtr<KisReferenceImagesLayer> layer;
     Buffer buffer;
     QTransform previousTransform;
 
     explicit Private(KisReferenceImagesDecoration *q)
         : q(q)
     {}
 
     void updateBufferByImageCoordinates(const QRectF &dirtyImageRect)
     {
         QRectF dirtyWidgetRect = q->view()->viewConverter()->imageToWidget(dirtyImageRect);
         updateBuffer(dirtyWidgetRect, dirtyImageRect);
     }
 
     void updateBufferByWidgetCoordinates(const QRectF &dirtyWidgetRect)
     {
         QRectF dirtyImageRect = q->view()->viewConverter()->widgetToImage(dirtyWidgetRect);
         updateBuffer(dirtyWidgetRect, dirtyImageRect);
     }
 
 private:
     void updateBuffer(const QRectF &widgetRect, const QRectF &imageRect)
     {
         KisCoordinatesConverter *viewConverter = q->view()->viewConverter();
         QTransform transform = viewConverter->imageToWidgetTransform();
 
         if (buffer.image.isNull() || !buffer.bounds().contains(widgetRect)) {
             // TODO: only use enough buffer to cover the BB of the shapes
             buffer.position = QPointF();
             buffer.image = QImage(q->view()->width(), q->view()->height(), QImage::Format_ARGB32);
             buffer.image.fill(Qt::transparent);
         }
 
         QPainter gc(&buffer.image);
         gc.setTransform(transform);
 
         gc.save();
         gc.setCompositionMode(QPainter::CompositionMode_Source);
         gc.fillRect(imageRect, Qt::transparent);
         gc.restore();
 
         gc.setClipRect(imageRect);
         layer->paintReferences(gc);
     }
 };
 
 KisReferenceImagesDecoration::KisReferenceImagesDecoration(QPointer<KisView> parent)
     : KisCanvasDecoration("referenceImagesDecoration", parent)
     , d(new Private(this))
 {}
 
 KisReferenceImagesDecoration::~KisReferenceImagesDecoration()
 {}
 
 void KisReferenceImagesDecoration::addReferenceImage(KisReferenceImage *referenceImage)
 {
-    KisSharedPtr<KisReferenceImagesLayer> layer = view()->document()->createReferenceImagesLayer();
+    KisSharedPtr<KisReferenceImagesLayer> layer = view()->document()->getOrCreateReferenceImagesLayer();
     KIS_SAFE_ASSERT_RECOVER_RETURN(layer);
 
     KUndo2Command *cmd = layer->addReferenceImage(referenceImage);
     view()->document()->addCommand(cmd);
 }
 
 bool KisReferenceImagesDecoration::documentHasReferenceImages() const
 {
     return view()->document()->referenceImagesLayer() != nullptr;
 }
 
 void KisReferenceImagesDecoration::drawDecoration(QPainter &gc, const QRectF &updateRect, const KisCoordinatesConverter */*converter*/, KisCanvas2 */*canvas*/)
 {
     KisSharedPtr<KisReferenceImagesLayer> layer = d->layer.toStrongRef();
     if (layer.isNull()) {
         layer = d->layer = view()->document()->referenceImagesLayer();
         if (layer.isNull()) return;
 
         connect(layer.data(), SIGNAL(sigUpdateCanvas(const QRectF&)), this, SLOT(slotReferenceImagesChanged(const QRectF&)));
 
         d->updateBufferByWidgetCoordinates(updateRect);
     } else {
         QTransform transform = view()->viewConverter()->imageToWidgetTransform();
         if (!KisAlgebra2D::fuzzyMatrixCompare(transform, d->previousTransform, 1e-4)) {
             d->previousTransform = transform;
             d->updateBufferByWidgetCoordinates(QRectF(0, 0, view()->width(), view()->height()));
         }
     }
 
     gc.drawImage(d->buffer.position, d->buffer.image);
 }
 
 void KisReferenceImagesDecoration::slotReferenceImagesChanged(const QRectF &dirtyRect)
 {
     d->updateBufferByImageCoordinates(dirtyRect);
 
     QRectF documentRect = view()->viewConverter()->imageToDocument(dirtyRect);
     view()->canvasBase()->updateCanvas(documentRect);
 }
diff --git a/libs/ui/KisViewManager.cpp b/libs/ui/KisViewManager.cpp
index 7db6d793ee..7d4e95d96d 100644
--- a/libs/ui/KisViewManager.cpp
+++ b/libs/ui/KisViewManager.cpp
@@ -1,1402 +1,1402 @@
 /*
  *  This file is part of KimageShop^WKrayon^WKrita
  *
  *  Copyright (c) 1999 Matthias Elter  <me@kde.org>
  *                1999 Michael Koch    <koch@kde.org>
  *                1999 Carsten Pfeiffer <pfeiffer@kde.org>
  *                2002 Patrick Julien <freak@codepimps.org>
  *                2003-2011 Boudewijn Rempt <boud@valdyas.org>
  *                2004 Clarence Dang <dang@kde.org>
  *                2011 José Luis Vergara <pentalis@gmail.com>
  *                2017 L. E. Segovia <leo.segovia@siggraph.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include <stdio.h>
 
 #include "KisViewManager.h"
 #include <QPrinter>
 
 #include <QAction>
 #include <QApplication>
 #include <QBuffer>
 #include <QByteArray>
 #include <QStandardPaths>
 #include <QDesktopWidget>
 #include <QDesktopServices>
 #include <QGridLayout>
 #include <QMainWindow>
 #include <QMenu>
 #include <QMenuBar>
 #include <QMessageBox>
 #include <QObject>
 #include <QPoint>
 #include <QPrintDialog>
 #include <QRect>
 #include <QScrollBar>
 #include <QStatusBar>
 #include <QToolBar>
 #include <QUrl>
 #include <QWidget>
 
 #include <kactioncollection.h>
 #include <klocalizedstring.h>
 #include <KoResourcePaths.h>
 #include <kselectaction.h>
 
 #include <KoCanvasController.h>
 #include <KoCompositeOp.h>
 #include <KoDockRegistry.h>
 #include <KoProperties.h>
 #include <KoResourceItemChooserSync.h>
 #include <KoSelection.h>
 #include <KoStore.h>
 #include <KoToolManager.h>
 #include <KoToolRegistry.h>
 #include <KoViewConverter.h>
 #include <KoZoomHandler.h>
 #include <KoPluginLoader.h>
 #include <KoDocumentInfo.h>
 #include <KoGlobal.h>
 #include <KoColorSpaceRegistry.h>
 
 #include "input/kis_input_manager.h"
 #include "canvas/kis_canvas2.h"
 #include "canvas/kis_canvas_controller.h"
 #include "canvas/kis_grid_manager.h"
 #include "dialogs/kis_dlg_blacklist_cleanup.h"
 #include "input/kis_input_profile_manager.h"
 #include "kis_action_manager.h"
 #include "kis_action.h"
 #include "kis_canvas_controls_manager.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_composite_progress_proxy.h"
 #include <KoProgressUpdater.h>
 #include "kis_config.h"
 #include "kis_config_notifier.h"
 #include "kis_control_frame.h"
 #include "kis_coordinates_converter.h"
 #include "KisDocument.h"
 #include "kis_favorite_resource_manager.h"
 #include "kis_filter_manager.h"
 #include "kis_group_layer.h"
 #include <kis_image.h>
 #include <kis_image_barrier_locker.h>
 #include "kis_image_manager.h"
 #include <kis_layer.h>
 #include "kis_mainwindow_observer.h"
 #include "kis_mask_manager.h"
 #include "kis_mimedata.h"
 #include "kis_mirror_manager.h"
 #include "kis_node_commands_adapter.h"
 #include "kis_node.h"
 #include "kis_node_manager.h"
 #include "KisDecorationsManager.h"
 #include <kis_paint_layer.h>
 #include "kis_paintop_box.h"
 #include <brushengine/kis_paintop_preset.h>
 #include "KisPart.h"
 #include "KisPrintJob.h"
 #include <KoUpdater.h>
 #include "KisResourceServerProvider.h"
 #include "kis_selection.h"
 #include "kis_selection_manager.h"
 #include "kis_shape_controller.h"
 #include "kis_shape_layer.h"
 #include <kis_signal_compressor.h>
 #include "kis_statusbar.h"
 #include <KisTemplateCreateDia.h>
 #include <kis_tool_freehand.h>
 #include "kis_tooltip_manager.h"
 #include <kis_undo_adapter.h>
 #include "KisView.h"
 #include "kis_zoom_manager.h"
 #include "widgets/kis_floating_message.h"
 #include "kis_signal_auto_connection.h"
 #include "kis_icon_utils.h"
 #include "kis_guides_manager.h"
 #include "kis_derived_resources.h"
 #include "dialogs/kis_delayed_save_dialog.h"
 #include <kis_image.h>
 #include <KisMainWindow.h>
 #include "kis_signals_blocker.h"
 
 
 class BlockingUserInputEventFilter : public QObject
 {
     bool eventFilter(QObject *watched, QEvent *event) override
     {
         Q_UNUSED(watched);
         if(dynamic_cast<QWheelEvent*>(event)
                 || dynamic_cast<QKeyEvent*>(event)
                 || dynamic_cast<QMouseEvent*>(event)) {
             return true;
         }
         else {
             return false;
         }
     }
 };
 
 class KisViewManager::KisViewManagerPrivate
 {
 
 public:
 
     KisViewManagerPrivate(KisViewManager *_q, KActionCollection *_actionCollection, QWidget *_q_parent)
         : filterManager(_q)
         , createTemplate(0)
         , saveIncremental(0)
         , saveIncrementalBackup(0)
         , openResourcesDirectory(0)
         , rotateCanvasRight(0)
         , rotateCanvasLeft(0)
         , resetCanvasRotation(0)
         , wrapAroundAction(0)
         , levelOfDetailAction(0)
         , showRulersAction(0)
         , rulersTrackMouseAction(0)
         , zoomTo100pct(0)
         , zoomIn(0)
         , zoomOut(0)
         , selectionManager(_q)
         , statusBar(_q)
         , controlFrame(_q, _q_parent)
         , nodeManager(_q)
         , imageManager(_q)
         , gridManager(_q)
         , canvasControlsManager(_q)
         , paintingAssistantsManager(_q)
         , actionManager(_q, _actionCollection)
         , mainWindow(0)
         , showFloatingMessage(true)
         , currentImageView(0)
         , canvasResourceProvider(_q)
         , canvasResourceManager()
         , guiUpdateCompressor(30, KisSignalCompressor::POSTPONE, _q)
         , actionCollection(_actionCollection)
         , mirrorManager(_q)
         , inputManager(_q)
         , actionAuthor(0)
         , showPixelGrid(0)
     {
         KisViewManager::initializeResourceManager(&canvasResourceManager);
     }
 
 public:
     KisFilterManager filterManager;
     KisAction *createTemplate;
     KisAction *createCopy;
     KisAction *saveIncremental;
     KisAction *saveIncrementalBackup;
     KisAction *openResourcesDirectory;
     KisAction *rotateCanvasRight;
     KisAction *rotateCanvasLeft;
     KisAction *resetCanvasRotation;
     KisAction *wrapAroundAction;
     KisAction *levelOfDetailAction;
     KisAction *showRulersAction;
     KisAction *rulersTrackMouseAction;
     KisAction *zoomTo100pct;
     KisAction *zoomIn;
     KisAction *zoomOut;
     KisAction *softProof;
     KisAction *gamutCheck;
 
     KisSelectionManager selectionManager;
     KisGuidesManager guidesManager;
     KisStatusBar statusBar;
     QPointer<KoUpdater> persistentImageProgressUpdater;
 
     QScopedPointer<KoProgressUpdater> persistentUnthreadedProgressUpdaterRouter;
     QPointer<KoUpdater> persistentUnthreadedProgressUpdater;
 
     KisControlFrame controlFrame;
     KisNodeManager nodeManager;
     KisImageManager imageManager;
     KisGridManager gridManager;
     KisCanvasControlsManager canvasControlsManager;
     KisDecorationsManager paintingAssistantsManager;
     BlockingUserInputEventFilter blockingEventFilter;
     KisActionManager actionManager;
     QMainWindow* mainWindow;
     QPointer<KisFloatingMessage> savedFloatingMessage;
     bool showFloatingMessage;
     QPointer<KisView> currentImageView;
     KisCanvasResourceProvider canvasResourceProvider;
     KoCanvasResourceManager canvasResourceManager;
     KisSignalCompressor guiUpdateCompressor;
     KActionCollection *actionCollection;
     KisMirrorManager mirrorManager;
     KisInputManager inputManager;
 
     KisSignalAutoConnectionsStore viewConnections;
     KSelectAction *actionAuthor; // Select action for author profile.
     KisAction *showPixelGrid;
 
     QByteArray canvasState;
 #if QT_VERSION < QT_VERSION_CHECK(5, 10, 0)
     QFlags<Qt::WindowState> windowFlags;
 #endif
 
     bool blockUntilOperationsFinishedImpl(KisImageSP image, bool force);
 };
 
 KisViewManager::KisViewManager(QWidget *parent, KActionCollection *_actionCollection)
     : d(new KisViewManagerPrivate(this, _actionCollection, parent))
 {
     d->actionCollection = _actionCollection;
     d->mainWindow = dynamic_cast<QMainWindow*>(parent);
     d->canvasResourceProvider.setResourceManager(&d->canvasResourceManager);
     connect(&d->guiUpdateCompressor, SIGNAL(timeout()), this, SLOT(guiUpdateTimeout()));
 
     createActions();
     setupManagers();
 
     // These initialization functions must wait until KisViewManager ctor is complete.
     d->statusBar.setup();
     d->persistentImageProgressUpdater =
         d->statusBar.progressUpdater()->startSubtask(1, "", true);
     // reset state to "completed"
     d->persistentImageProgressUpdater->setRange(0,100);
     d->persistentImageProgressUpdater->setValue(100);
 
     d->persistentUnthreadedProgressUpdater =
         d->statusBar.progressUpdater()->startSubtask(1, "", true);
         // reset state to "completed"
     d->persistentUnthreadedProgressUpdater->setRange(0,100);
     d->persistentUnthreadedProgressUpdater->setValue(100);
 
     d->persistentUnthreadedProgressUpdaterRouter.reset(
         new KoProgressUpdater(d->persistentUnthreadedProgressUpdater,
                               KoProgressUpdater::Unthreaded));
     d->persistentUnthreadedProgressUpdaterRouter->setAutoNestNames(true);
 
     d->controlFrame.setup(parent);
 
     //Check to draw scrollbars after "Canvas only mode" toggle is created.
     this->showHideScrollbars();
 
     QScopedPointer<KoDummyCanvasController> dummy(new KoDummyCanvasController(actionCollection()));
     KoToolManager::instance()->registerToolActions(actionCollection(), dummy.data());
 
     QTimer::singleShot(0, this, SLOT(initializeStatusBarVisibility()));
 
     connect(KoToolManager::instance(), SIGNAL(inputDeviceChanged(KoInputDevice)),
             d->controlFrame.paintopBox(), SLOT(slotInputDeviceChanged(KoInputDevice)));
 
     connect(KoToolManager::instance(), SIGNAL(changedTool(KoCanvasController*,int)),
             d->controlFrame.paintopBox(), SLOT(slotToolChanged(KoCanvasController*,int)));
 
     connect(&d->nodeManager, SIGNAL(sigNodeActivated(KisNodeSP)),
             resourceProvider(), SLOT(slotNodeActivated(KisNodeSP)));
 
     connect(resourceProvider()->resourceManager(), SIGNAL(canvasResourceChanged(int,QVariant)),
             d->controlFrame.paintopBox(), SLOT(slotCanvasResourceChanged(int,QVariant)));
 
     connect(KisPart::instance(), SIGNAL(sigViewAdded(KisView*)), SLOT(slotViewAdded(KisView*)));
     connect(KisPart::instance(), SIGNAL(sigViewRemoved(KisView*)), SLOT(slotViewRemoved(KisView*)));
 
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotUpdateAuthorProfileActions()));
     connect(KisConfigNotifier::instance(), SIGNAL(pixelGridModeChanged()), SLOT(slotUpdatePixelGridAction()));
 
     KisInputProfileManager::instance()->loadProfiles();
 
     KisConfig cfg;
     d->showFloatingMessage = cfg.showCanvasMessages();
 
 }
 
 
 KisViewManager::~KisViewManager()
 {
     KisConfig cfg;
     if (resourceProvider() && resourceProvider()->currentPreset()) {
         cfg.writeEntry("LastPreset", resourceProvider()->currentPreset()->name());
         cfg.writeKoColor("LastForeGroundColor",resourceProvider()->fgColor());
         cfg.writeKoColor("LastBackGroundColor",resourceProvider()->bgColor());
 
     }
 
     cfg.writeEntry("baseLength", KoResourceItemChooserSync::instance()->baseLength());
 
     delete d;
 }
 
 void KisViewManager::initializeResourceManager(KoCanvasResourceManager *resourceManager)
 {
     resourceManager->addDerivedResourceConverter(toQShared(new KisCompositeOpResourceConverter));
     resourceManager->addDerivedResourceConverter(toQShared(new KisEffectiveCompositeOpResourceConverter));
     resourceManager->addDerivedResourceConverter(toQShared(new KisOpacityResourceConverter));
     resourceManager->addDerivedResourceConverter(toQShared(new KisFlowResourceConverter));
     resourceManager->addDerivedResourceConverter(toQShared(new KisSizeResourceConverter));
     resourceManager->addDerivedResourceConverter(toQShared(new KisLodAvailabilityResourceConverter));
     resourceManager->addDerivedResourceConverter(toQShared(new KisLodSizeThresholdResourceConverter));
     resourceManager->addDerivedResourceConverter(toQShared(new KisLodSizeThresholdSupportedResourceConverter));
     resourceManager->addDerivedResourceConverter(toQShared(new KisEraserModeResourceConverter));
     resourceManager->addResourceUpdateMediator(toQShared(new KisPresetUpdateMediator));
 }
 
 KActionCollection *KisViewManager::actionCollection() const
 {
     return d->actionCollection;
 }
 
 void KisViewManager::slotViewAdded(KisView *view)
 {
     // WARNING: this slot is called even when a view from another main windows is added!
     //          Don't expect \p view be a child of this view manager!
     Q_UNUSED(view);
 
     if (viewCount() == 0) {
         d->statusBar.showAllStatusBarItems();
     }
 }
 
 void KisViewManager::slotViewRemoved(KisView *view)
 {
     // WARNING: this slot is called even when a view from another main windows is removed!
     //          Don't expect \p view be a child of this view manager!
     Q_UNUSED(view);
 
     if (viewCount() == 0) {
         d->statusBar.hideAllStatusBarItems();
     }
 }
 
 void KisViewManager::setCurrentView(KisView *view)
 {
     bool first = true;
     if (d->currentImageView) {
         d->currentImageView->notifyCurrentStateChanged(false);
 
         d->currentImageView->canvasBase()->setCursor(QCursor(Qt::ArrowCursor));
         first = false;
         KisDocument* doc = d->currentImageView->document();
         if (doc) {
             doc->image()->compositeProgressProxy()->removeProxy(d->persistentImageProgressUpdater);
             doc->disconnect(this);
         }
         d->currentImageView->canvasController()->proxyObject->disconnect(&d->statusBar);
         d->viewConnections.clear();
     }
 
 
     QPointer<KisView> imageView = qobject_cast<KisView*>(view);
     d->currentImageView = imageView;
 
     if (imageView) {
         d->softProof->setChecked(imageView->softProofing());
         d->gamutCheck->setChecked(imageView->gamutCheck());
 
         // Wait for the async image to have loaded
         KisDocument* doc = view->document();
         //        connect(canvasController()->proxyObject, SIGNAL(documentMousePositionChanged(QPointF)), d->statusBar, SLOT(documentMousePositionChanged(QPointF)));
 
         // Restore the last used brush preset, color and background color.
         if (first) {
             KisConfig cfg;
             KisPaintOpPresetResourceServer * rserver = KisResourceServerProvider::instance()->paintOpPresetServer();
             QString defaultPresetName = "basic_tip_default";
             bool foundTip = false;
             for (int i=0; i<rserver->resourceCount(); i++) {
                 KisPaintOpPresetSP resource = rserver->resources().at(i);
                 if (resource->name().toLower().contains("basic_tip_default")) {
                     defaultPresetName = resource->name();
                     foundTip = true;
                 } else if (foundTip == false && (resource->name().toLower().contains("default") ||
                                                  resource->filename().toLower().contains("default"))) {
                     defaultPresetName = resource->name();
                     foundTip = true;
                 }
             }
             QString lastPreset = cfg.readEntry("LastPreset", defaultPresetName);
             KisPaintOpPresetSP preset = rserver->resourceByName(lastPreset);
             if (!preset) {
                 preset = rserver->resourceByName(defaultPresetName);
             }
 
-            if (!preset) {
+            if (!preset && !rserver->resources().isEmpty()) {
                 preset = rserver->resources().first();
             }
             if (preset) {
                 paintOpBox()->restoreResource(preset.data());
             }
 
             const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
             KoColor foreground(Qt::black, cs);
             d->canvasResourceProvider.setFGColor(cfg.readKoColor("LastForeGroundColor",foreground));
             KoColor background(Qt::white, cs);
             d->canvasResourceProvider.setBGColor(cfg.readKoColor("LastBackGroundColor",background));
 
         }
 
         KisCanvasController *canvasController = dynamic_cast<KisCanvasController*>(d->currentImageView->canvasController());
 
         d->viewConnections.addUniqueConnection(&d->nodeManager, SIGNAL(sigNodeActivated(KisNodeSP)), doc->image(), SLOT(requestStrokeEndActiveNode()));
         d->viewConnections.addUniqueConnection(d->rotateCanvasRight, SIGNAL(triggered()), canvasController, SLOT(rotateCanvasRight15()));
         d->viewConnections.addUniqueConnection(d->rotateCanvasLeft, SIGNAL(triggered()),canvasController, SLOT(rotateCanvasLeft15()));
         d->viewConnections.addUniqueConnection(d->resetCanvasRotation, SIGNAL(triggered()),canvasController, SLOT(resetCanvasRotation()));
 
         d->viewConnections.addUniqueConnection(d->wrapAroundAction, SIGNAL(toggled(bool)), canvasController, SLOT(slotToggleWrapAroundMode(bool)));
         d->wrapAroundAction->setChecked(canvasController->wrapAroundMode());
 
         d->viewConnections.addUniqueConnection(d->levelOfDetailAction, SIGNAL(toggled(bool)), canvasController, SLOT(slotToggleLevelOfDetailMode(bool)));
         d->levelOfDetailAction->setChecked(canvasController->levelOfDetailMode());
 
         d->viewConnections.addUniqueConnection(d->currentImageView->image(), SIGNAL(sigColorSpaceChanged(const KoColorSpace*)), d->controlFrame.paintopBox(), SLOT(slotColorSpaceChanged(const KoColorSpace*)));
         d->viewConnections.addUniqueConnection(d->showRulersAction, SIGNAL(toggled(bool)), imageView->zoomManager(), SLOT(setShowRulers(bool)));
         d->viewConnections.addUniqueConnection(d->rulersTrackMouseAction, SIGNAL(toggled(bool)), imageView->zoomManager(), SLOT(setRulersTrackMouse(bool)));
         d->viewConnections.addUniqueConnection(d->zoomTo100pct, SIGNAL(triggered()), imageView->zoomManager(), SLOT(zoomTo100()));
         d->viewConnections.addUniqueConnection(d->zoomIn, SIGNAL(triggered()), imageView->zoomController()->zoomAction(), SLOT(zoomIn()));
         d->viewConnections.addUniqueConnection(d->zoomOut, SIGNAL(triggered()), imageView->zoomController()->zoomAction(), SLOT(zoomOut()));
 
         d->viewConnections.addUniqueConnection(d->softProof, SIGNAL(toggled(bool)), view, SLOT(slotSoftProofing(bool)) );
         d->viewConnections.addUniqueConnection(d->gamutCheck, SIGNAL(toggled(bool)), view, SLOT(slotGamutCheck(bool)) );
 
         // set up progrress reporting
         doc->image()->compositeProgressProxy()->addProxy(d->persistentImageProgressUpdater);
         d->viewConnections.addUniqueConnection(&d->statusBar, SIGNAL(sigCancellationRequested()), doc->image(), SLOT(requestStrokeCancellation()));
 
         d->viewConnections.addUniqueConnection(d->showPixelGrid, SIGNAL(toggled(bool)), canvasController, SLOT(slotTogglePixelGrid(bool)));
 
         imageView->zoomManager()->setShowRulers(d->showRulersAction->isChecked());
         imageView->zoomManager()->setRulersTrackMouse(d->rulersTrackMouseAction->isChecked());
 
         showHideScrollbars();
     }
 
     d->filterManager.setView(imageView);
     d->selectionManager.setView(imageView);
     d->guidesManager.setView(imageView);
     d->nodeManager.setView(imageView);
     d->imageManager.setView(imageView);
     d->canvasControlsManager.setView(imageView);
     d->actionManager.setView(imageView);
     d->gridManager.setView(imageView);
     d->statusBar.setView(imageView);
     d->paintingAssistantsManager.setView(imageView);
     d->mirrorManager.setView(imageView);
 
     if (d->currentImageView) {
         d->currentImageView->notifyCurrentStateChanged(true);
         d->currentImageView->canvasController()->activate();
         d->currentImageView->canvasController()->setFocus();
 
         d->viewConnections.addUniqueConnection(
             image(), SIGNAL(sigSizeChanged(const QPointF&, const QPointF&)),
             resourceProvider(), SLOT(slotImageSizeChanged()));
 
         d->viewConnections.addUniqueConnection(
             image(), SIGNAL(sigResolutionChanged(double,double)),
             resourceProvider(), SLOT(slotOnScreenResolutionChanged()));
 
         d->viewConnections.addUniqueConnection(
             image(), SIGNAL(sigNodeChanged(KisNodeSP)),
             this, SLOT(updateGUI()));
 
         d->viewConnections.addUniqueConnection(
             d->currentImageView->zoomManager()->zoomController(),
             SIGNAL(zoomChanged(KoZoomMode::Mode,qreal)),
             resourceProvider(), SLOT(slotOnScreenResolutionChanged()));
 
     }
 
     d->actionManager.updateGUI();
 
     resourceProvider()->slotImageSizeChanged();
     resourceProvider()->slotOnScreenResolutionChanged();
 
     Q_EMIT viewChanged();
 }
 
 
 KoZoomController *KisViewManager::zoomController() const
 {
     if (d->currentImageView) {
         return d->currentImageView->zoomController();
     }
     return 0;
 }
 
 KisImageWSP KisViewManager::image() const
 {
     if (document()) {
         return document()->image();
     }
     return 0;
 }
 
 KisCanvasResourceProvider * KisViewManager::resourceProvider()
 {
     return &d->canvasResourceProvider;
 }
 
 KisCanvas2 * KisViewManager::canvasBase() const
 {
     if (d && d->currentImageView) {
         return d->currentImageView->canvasBase();
     }
     return 0;
 }
 
 QWidget* KisViewManager::canvas() const
 {
     if (d && d->currentImageView && d->currentImageView->canvasBase()->canvasWidget()) {
         return d->currentImageView->canvasBase()->canvasWidget();
     }
     return 0;
 }
 
 KisStatusBar * KisViewManager::statusBar() const
 {
     return &d->statusBar;
 }
 
 void KisViewManager::addStatusBarItem(QWidget *widget, int stretch, bool permanent)
 {
     d->statusBar.addStatusBarItem(widget, stretch, permanent);
 }
 
 void KisViewManager::removeStatusBarItem(QWidget *widget)
 {
     d->statusBar.removeStatusBarItem(widget);
 }
 
 KisPaintopBox* KisViewManager::paintOpBox() const
 {
     return d->controlFrame.paintopBox();
 }
 
 QPointer<KoUpdater> KisViewManager::createUnthreadedUpdater(const QString &name)
 {
     return d->persistentUnthreadedProgressUpdaterRouter->startSubtask(1, name, false);
 }
 
 QPointer<KoUpdater> KisViewManager::createThreadedUpdater(const QString &name)
 {
     return d->statusBar.progressUpdater()->startSubtask(1, name, false);
 }
 
 KisSelectionManager * KisViewManager::selectionManager()
 {
     return &d->selectionManager;
 }
 
 KisNodeSP KisViewManager::activeNode()
 {
     return d->nodeManager.activeNode();
 }
 
 KisLayerSP KisViewManager::activeLayer()
 {
     return d->nodeManager.activeLayer();
 }
 
 KisPaintDeviceSP KisViewManager::activeDevice()
 {
     return d->nodeManager.activePaintDevice();
 }
 
 KisZoomManager * KisViewManager::zoomManager()
 {
     if (d->currentImageView) {
         return d->currentImageView->zoomManager();
     }
     return 0;
 }
 
 KisFilterManager * KisViewManager::filterManager()
 {
     return &d->filterManager;
 }
 
 KisImageManager * KisViewManager::imageManager()
 {
     return &d->imageManager;
 }
 
 KisInputManager* KisViewManager::inputManager() const
 {
     return &d->inputManager;
 }
 
 KisSelectionSP KisViewManager::selection()
 {
     if (d->currentImageView) {
         return d->currentImageView->selection();
     }
     return 0;
 
 }
 
 bool KisViewManager::selectionEditable()
 {
     KisLayerSP layer = activeLayer();
     if (layer) {
         KoProperties properties;
         QList<KisNodeSP> masks = layer->childNodes(QStringList("KisSelectionMask"), properties);
         if (masks.size() == 1) {
             return masks[0]->isEditable();
         }
     }
     // global selection is always editable
     return true;
 }
 
 KisUndoAdapter * KisViewManager::undoAdapter()
 {
     if (!document()) return 0;
 
     KisImageWSP image = document()->image();
     Q_ASSERT(image);
 
     return image->undoAdapter();
 }
 
 void KisViewManager::createActions()
 {
     KisConfig cfg;
 
     d->saveIncremental = actionManager()->createAction("save_incremental_version");
     connect(d->saveIncremental, SIGNAL(triggered()), this, SLOT(slotSaveIncremental()));
 
     d->saveIncrementalBackup = actionManager()->createAction("save_incremental_backup");
     connect(d->saveIncrementalBackup, SIGNAL(triggered()), this, SLOT(slotSaveIncrementalBackup()));
 
     connect(mainWindow(), SIGNAL(documentSaved()), this, SLOT(slotDocumentSaved()));
 
     d->saveIncremental->setEnabled(false);
     d->saveIncrementalBackup->setEnabled(false);
 
     KisAction *tabletDebugger = actionManager()->createAction("tablet_debugger");
     connect(tabletDebugger, SIGNAL(triggered()), this, SLOT(toggleTabletLogger()));
 
     d->createTemplate = actionManager()->createAction("create_template");
     connect(d->createTemplate, SIGNAL(triggered()), this, SLOT(slotCreateTemplate()));
 
     d->createCopy = actionManager()->createAction("create_copy");
     connect(d->createCopy, SIGNAL(triggered()), this, SLOT(slotCreateCopy()));
 
     d->openResourcesDirectory = actionManager()->createAction("open_resources_directory");
     connect(d->openResourcesDirectory, SIGNAL(triggered()), SLOT(openResourcesDirectory()));
 
     d->rotateCanvasRight   = actionManager()->createAction("rotate_canvas_right");
     d->rotateCanvasLeft    = actionManager()->createAction("rotate_canvas_left");
     d->resetCanvasRotation = actionManager()->createAction("reset_canvas_rotation");
     d->wrapAroundAction    = actionManager()->createAction("wrap_around_mode");
     d->levelOfDetailAction = actionManager()->createAction("level_of_detail_mode");
     d->softProof           = actionManager()->createAction("softProof");
     d->gamutCheck          = actionManager()->createAction("gamutCheck");
 
     KisAction *tAction = actionManager()->createAction("showStatusBar");
     tAction->setChecked(cfg.showStatusBar());
     connect(tAction, SIGNAL(toggled(bool)), this, SLOT(showStatusBar(bool)));
 
     tAction = actionManager()->createAction("view_show_canvas_only");
     tAction->setChecked(false);
     connect(tAction, SIGNAL(toggled(bool)), this, SLOT(switchCanvasOnly(bool)));
 
     //Workaround, by default has the same shortcut as mirrorCanvas
     KisAction *a = dynamic_cast<KisAction*>(actionCollection()->action("format_italic"));
     if (a) {
         a->setDefaultShortcut(QKeySequence());
     }
 
     a = actionManager()->createAction("edit_blacklist_cleanup");
     connect(a, SIGNAL(triggered()), this, SLOT(slotBlacklistCleanup()));
 
     actionManager()->createAction("ruler_pixel_multiple2");
     d->showRulersAction = actionManager()->createAction("view_ruler");
     d->showRulersAction->setChecked(cfg.showRulers());
     connect(d->showRulersAction, SIGNAL(toggled(bool)), SLOT(slotSaveShowRulersState(bool)));
 
     d->rulersTrackMouseAction = actionManager()->createAction("rulers_track_mouse");
     d->rulersTrackMouseAction->setChecked(cfg.rulersTrackMouse());
     connect(d->rulersTrackMouseAction, SIGNAL(toggled(bool)), SLOT(slotSaveRulersTrackMouseState(bool)));
 
     d->zoomTo100pct = actionManager()->createAction("zoom_to_100pct");
 
     d->zoomIn = actionManager()->createStandardAction(KStandardAction::ZoomIn, 0, "");
     d->zoomOut = actionManager()->createStandardAction(KStandardAction::ZoomOut, 0, "");
 
     d->actionAuthor  = new KSelectAction(KisIconUtils::loadIcon("im-user"), i18n("Active Author Profile"), this);
     connect(d->actionAuthor, SIGNAL(triggered(const QString &)), this, SLOT(changeAuthorProfile(const QString &)));
     actionCollection()->addAction("settings_active_author", d->actionAuthor);
     slotUpdateAuthorProfileActions();
 
     d->showPixelGrid = actionManager()->createAction("view_pixel_grid");
     slotUpdatePixelGridAction();
 }
 
 void KisViewManager::setupManagers()
 {
     // Create the managers for filters, selections, layers etc.
     // XXX: When the currentlayer changes, call updateGUI on all
     // managers
 
     d->filterManager.setup(actionCollection(), actionManager());
 
     d->selectionManager.setup(actionManager());
 
     d->guidesManager.setup(actionManager());
 
     d->nodeManager.setup(actionCollection(), actionManager());
 
     d->imageManager.setup(actionManager());
 
     d->gridManager.setup(actionManager());
 
     d->paintingAssistantsManager.setup(actionManager());
 
     d->canvasControlsManager.setup(actionManager());
 
     d->mirrorManager.setup(actionCollection());
 }
 
 void KisViewManager::updateGUI()
 {
     d->guiUpdateCompressor.start();
 }
 
 void KisViewManager::slotBlacklistCleanup()
 {
     KisDlgBlacklistCleanup dialog;
     dialog.exec();
 }
 
 KisNodeManager * KisViewManager::nodeManager() const
 {
     return &d->nodeManager;
 }
 
 KisActionManager* KisViewManager::actionManager() const
 {
     return &d->actionManager;
 }
 
 KisGridManager * KisViewManager::gridManager() const
 {
     return &d->gridManager;
 }
 
 KisGuidesManager * KisViewManager::guidesManager() const
 {
     return &d->guidesManager;
 }
 
 KisDocument *KisViewManager::document() const
 {
     if (d->currentImageView && d->currentImageView->document()) {
         return d->currentImageView->document();
     }
     return 0;
 }
 
 int KisViewManager::viewCount() const
 {
     KisMainWindow *mw  = qobject_cast<KisMainWindow*>(d->mainWindow);
     if (mw) {
         return mw->viewCount();
     }
     return 0;
 }
 
 bool KisViewManager::KisViewManagerPrivate::blockUntilOperationsFinishedImpl(KisImageSP image, bool force)
 {
     const int busyWaitDelay = 1000;
     KisDelayedSaveDialog dialog(image, !force ? KisDelayedSaveDialog::GeneralDialog : KisDelayedSaveDialog::ForcedDialog, busyWaitDelay, mainWindow);
     dialog.blockIfImageIsBusy();
 
     return dialog.result() == QDialog::Accepted;
 }
 
 
 bool KisViewManager::blockUntilOperationsFinished(KisImageSP image)
 {
     return d->blockUntilOperationsFinishedImpl(image, false);
 }
 
 void KisViewManager::blockUntilOperationsFinishedForced(KisImageSP image)
 {
     d->blockUntilOperationsFinishedImpl(image, true);
 }
 
 void KisViewManager::slotCreateTemplate()
 {
     if (!document()) return;
     KisTemplateCreateDia::createTemplate( QStringLiteral("templates/"), ".kra", document(), mainWindow());
 }
 
 void KisViewManager::slotCreateCopy()
 {
     KisDocument *srcDoc = document();
     if (!srcDoc) return;
 
     if (!this->blockUntilOperationsFinished(srcDoc->image())) return;
 
     KisDocument *doc = 0;
     {
         KisImageBarrierLocker l(srcDoc->image());
         doc = srcDoc->clone();
     }
     KIS_SAFE_ASSERT_RECOVER_RETURN(doc);
 
     QString name = srcDoc->documentInfo()->aboutInfo("name");
     if (name.isEmpty()) {
         name = document()->url().toLocalFile();
     }
     name = i18n("%1 (Copy)", name);
     doc->documentInfo()->setAboutInfo("title", name);
 
     KisPart::instance()->addDocument(doc);
     KisMainWindow *mw  = qobject_cast<KisMainWindow*>(d->mainWindow);
     mw->addViewAndNotifyLoadingCompleted(doc);
 }
 
 
 QMainWindow* KisViewManager::qtMainWindow() const
 {
     if (d->mainWindow)
         return d->mainWindow;
 
     //Fallback for when we have not yet set the main window.
     QMainWindow* w = qobject_cast<QMainWindow*>(qApp->activeWindow());
     if(w)
         return w;
 
     return mainWindow();
 }
 
 void KisViewManager::setQtMainWindow(QMainWindow* newMainWindow)
 {
     d->mainWindow = newMainWindow;
 }
 
 void KisViewManager::slotDocumentSaved()
 {
     d->saveIncremental->setEnabled(true);
     d->saveIncrementalBackup->setEnabled(true);
 }
 
 void KisViewManager::slotSaveIncremental()
 {
     if (!document()) return;
 
     if (document()->url().isEmpty()) {
         KisMainWindow *mw = qobject_cast<KisMainWindow*>(d->mainWindow);
         mw->saveDocument(document(), true, false);
         return;
     }
 
     bool foundVersion;
     bool fileAlreadyExists;
     bool isBackup;
     QString version = "000";
     QString newVersion;
     QString letter;
     QString fileName = document()->localFilePath();
 
     // Find current version filenames
     // v v Regexp to find incremental versions in the filename, taking our backup scheme into account as well
     // Considering our incremental version and backup scheme, format is filename_001~001.ext
     QRegExp regex("_\\d{1,4}[.]|_\\d{1,4}[a-z][.]|_\\d{1,4}[~]|_\\d{1,4}[a-z][~]");
     regex.indexIn(fileName);     //  Perform the search
     QStringList matches = regex.capturedTexts();
     foundVersion = matches.at(0).isEmpty() ? false : true;
 
     // Ensure compatibility with Save Incremental Backup
     // If this regex is not kept separate, the entire algorithm needs modification;
     // It's simpler to just add this.
     QRegExp regexAux("_\\d{1,4}[~]|_\\d{1,4}[a-z][~]");
     regexAux.indexIn(fileName);     //  Perform the search
     QStringList matchesAux = regexAux.capturedTexts();
     isBackup = matchesAux.at(0).isEmpty() ? false : true;
 
     // If the filename has a version, prepare it for incrementation
     if (foundVersion) {
         version = matches.at(matches.count() - 1);     //  Look at the last index, we don't care about other matches
         if (version.contains(QRegExp("[a-z]"))) {
             version.chop(1);             //  Trim "."
             letter = version.right(1);   //  Save letter
             version.chop(1);             //  Trim letter
         } else {
             version.chop(1);             //  Trim "."
         }
         version.remove(0, 1);            //  Trim "_"
     } else {
         // TODO: this will not work with files extensions like jp2
         // ...else, simply add a version to it so the next loop works
         QRegExp regex2("[.][a-z]{2,4}$");  //  Heuristic to find file extension
         regex2.indexIn(fileName);
         QStringList matches2 = regex2.capturedTexts();
         QString extensionPlusVersion = matches2.at(0);
         extensionPlusVersion.prepend(version);
         extensionPlusVersion.prepend("_");
         fileName.replace(regex2, extensionPlusVersion);
     }
 
     // Prepare the base for new version filename
     int intVersion = version.toInt(0);
     ++intVersion;
     QString baseNewVersion = QString::number(intVersion);
     while (baseNewVersion.length() < version.length()) {
         baseNewVersion.prepend("0");
     }
 
     // Check if the file exists under the new name and search until options are exhausted (test appending a to z)
     do {
         newVersion = baseNewVersion;
         newVersion.prepend("_");
         if (!letter.isNull()) newVersion.append(letter);
         if (isBackup) {
             newVersion.append("~");
         } else {
             newVersion.append(".");
         }
         fileName.replace(regex, newVersion);
         fileAlreadyExists = QFile(fileName).exists();
         if (fileAlreadyExists) {
             if (!letter.isNull()) {
                 char letterCh = letter.at(0).toLatin1();
                 ++letterCh;
                 letter = QString(QChar(letterCh));
             } else {
                 letter = 'a';
             }
         }
     } while (fileAlreadyExists && letter != "{");  // x, y, z, {...
 
     if (letter == "{") {
         QMessageBox::critical(mainWindow(), i18nc("@title:window", "Couldn't save incremental version"), i18n("Alternative names exhausted, try manually saving with a higher number"));
         return;
     }
     document()->setFileBatchMode(true);
     document()->saveAs(QUrl::fromUserInput(fileName), document()->mimeType(), true);
     document()->setFileBatchMode(false);
 
     if (mainWindow()) {
         mainWindow()->updateCaption();
     }
 
 }
 
 void KisViewManager::slotSaveIncrementalBackup()
 {
     if (!document()) return;
 
     if (document()->url().isEmpty()) {
         KisMainWindow *mw = qobject_cast<KisMainWindow*>(d->mainWindow);
         mw->saveDocument(document(), true, false);
         return;
     }
 
     bool workingOnBackup;
     bool fileAlreadyExists;
     QString version = "000";
     QString newVersion;
     QString letter;
     QString fileName = document()->localFilePath();
 
     // First, discover if working on a backup file, or a normal file
     QRegExp regex("~\\d{1,4}[.]|~\\d{1,4}[a-z][.]");
     regex.indexIn(fileName);     //  Perform the search
     QStringList matches = regex.capturedTexts();
     workingOnBackup = matches.at(0).isEmpty() ? false : true;
 
     if (workingOnBackup) {
         // Try to save incremental version (of backup), use letter for alt versions
         version = matches.at(matches.count() - 1);     //  Look at the last index, we don't care about other matches
         if (version.contains(QRegExp("[a-z]"))) {
             version.chop(1);             //  Trim "."
             letter = version.right(1);   //  Save letter
             version.chop(1);             //  Trim letter
         } else {
             version.chop(1);             //  Trim "."
         }
         version.remove(0, 1);            //  Trim "~"
 
         // Prepare the base for new version filename
         int intVersion = version.toInt(0);
         ++intVersion;
         QString baseNewVersion = QString::number(intVersion);
         QString backupFileName = document()->localFilePath();
         while (baseNewVersion.length() < version.length()) {
             baseNewVersion.prepend("0");
         }
 
         // Check if the file exists under the new name and search until options are exhausted (test appending a to z)
         do {
             newVersion = baseNewVersion;
             newVersion.prepend("~");
             if (!letter.isNull()) newVersion.append(letter);
             newVersion.append(".");
             backupFileName.replace(regex, newVersion);
             fileAlreadyExists = QFile(backupFileName).exists();
             if (fileAlreadyExists) {
                 if (!letter.isNull()) {
                     char letterCh = letter.at(0).toLatin1();
                     ++letterCh;
                     letter = QString(QChar(letterCh));
                 } else {
                     letter = 'a';
                 }
             }
         } while (fileAlreadyExists && letter != "{");  // x, y, z, {...
 
         if (letter == "{") {
             QMessageBox::critical(mainWindow(), i18nc("@title:window", "Couldn't save incremental backup"), i18n("Alternative names exhausted, try manually saving with a higher number"));
             return;
         }
         QFile::copy(fileName, backupFileName);
         document()->saveAs(QUrl::fromUserInput(fileName), document()->mimeType(), true);
 
         if (mainWindow()) mainWindow()->updateCaption();
     }
     else { // if NOT working on a backup...
         // Navigate directory searching for latest backup version, ignore letters
         const quint8 HARDCODED_DIGIT_COUNT = 3;
         QString baseNewVersion = "000";
         QString backupFileName = document()->localFilePath();
         QRegExp regex2("[.][a-z]{2,4}$");  //  Heuristic to find file extension
         regex2.indexIn(backupFileName);
         QStringList matches2 = regex2.capturedTexts();
         QString extensionPlusVersion = matches2.at(0);
         extensionPlusVersion.prepend(baseNewVersion);
         extensionPlusVersion.prepend("~");
         backupFileName.replace(regex2, extensionPlusVersion);
 
         // Save version with 1 number higher than the highest version found ignoring letters
         do {
             newVersion = baseNewVersion;
             newVersion.prepend("~");
             newVersion.append(".");
             backupFileName.replace(regex, newVersion);
             fileAlreadyExists = QFile(backupFileName).exists();
             if (fileAlreadyExists) {
                 // Prepare the base for new version filename, increment by 1
                 int intVersion = baseNewVersion.toInt(0);
                 ++intVersion;
                 baseNewVersion = QString::number(intVersion);
                 while (baseNewVersion.length() < HARDCODED_DIGIT_COUNT) {
                     baseNewVersion.prepend("0");
                 }
             }
         } while (fileAlreadyExists);
 
         // Save both as backup and on current file for interapplication workflow
         document()->setFileBatchMode(true);
         QFile::copy(fileName, backupFileName);
         document()->saveAs(QUrl::fromUserInput(fileName), document()->mimeType(), true);
         document()->setFileBatchMode(false);
 
         if (mainWindow()) mainWindow()->updateCaption();
     }
 }
 
 void KisViewManager::disableControls()
 {
     // prevents possible crashes, if somebody changes the paintop during dragging by using the mousewheel
     // this is for Bug 250944
     // the solution blocks all wheel, mouse and key event, while dragging with the freehand tool
     // see KisToolFreehand::initPaint() and endPaint()
     d->controlFrame.paintopBox()->installEventFilter(&d->blockingEventFilter);
     Q_FOREACH (QObject* child, d->controlFrame.paintopBox()->children()) {
         child->installEventFilter(&d->blockingEventFilter);
     }
 }
 
 void KisViewManager::enableControls()
 {
     d->controlFrame.paintopBox()->removeEventFilter(&d->blockingEventFilter);
     Q_FOREACH (QObject* child, d->controlFrame.paintopBox()->children()) {
         child->removeEventFilter(&d->blockingEventFilter);
     }
 }
 
 void KisViewManager::showStatusBar(bool toggled)
 {
     KisMainWindow *mw = mainWindow();
     if(mw && mw->statusBar()) {
         mw->statusBar()->setVisible(toggled);
         KisConfig cfg;
         cfg.setShowStatusBar(toggled);
     }
 }
 
 void KisViewManager::switchCanvasOnly(bool toggled)
 {
     KisConfig cfg;
     KisMainWindow* main = mainWindow();
 
     if(!main) {
         dbgUI << "Unable to switch to canvas-only mode, main window not found";
         return;
     }
 
     if (toggled) {
         d->canvasState = qtMainWindow()->saveState();
 #if QT_VERSION < QT_VERSION_CHECK(5, 10, 0)
         d->windowFlags = main->windowState();
 #endif
     }
 
     if (cfg.hideStatusbarFullscreen()) {
         if (main->statusBar()) {
             if (!toggled) {
                 if (main->statusBar()->dynamicPropertyNames().contains("wasvisible")) {
                     if (main->statusBar()->property("wasvisible").toBool()) {
                         main->statusBar()->setVisible(true);
                     }
                 }
             }
             else {
                 main->statusBar()->setProperty("wasvisible", main->statusBar()->isVisible());
                 main->statusBar()->setVisible(false);
             }
         }
     }
 
     if (cfg.hideDockersFullscreen()) {
         KisAction* action = qobject_cast<KisAction*>(main->actionCollection()->action("view_toggledockers"));
         if (action) {
             action->setCheckable(true);
             if (toggled) {
                 if (action->isChecked()) {
                     cfg.setShowDockers(action->isChecked());
                     action->setChecked(false);
                 } else {
                     cfg.setShowDockers(false);
                 }
             } else {
                 action->setChecked(cfg.showDockers());
             }
         }
     }
 
     // QT in windows does not return to maximized upon 4th tab in a row
     // https://bugreports.qt.io/browse/QTBUG-57882, https://bugreports.qt.io/browse/QTBUG-52555, https://codereview.qt-project.org/#/c/185016/
     if (cfg.hideTitlebarFullscreen() && !cfg.fullscreenMode()) {
         if(toggled) {
             main->setWindowState( main->windowState() | Qt::WindowFullScreen);
         } else {
             main->setWindowState( main->windowState() & ~Qt::WindowFullScreen);
 #if QT_VERSION < QT_VERSION_CHECK(5, 10, 0)
             // If window was maximized prior to fullscreen, restore that
             if (d->windowFlags & Qt::WindowMaximized) {
                 main->setWindowState( main->windowState() | Qt::WindowMaximized);
             }
 #endif
         }
     }
 
     if (cfg.hideMenuFullscreen()) {
         if (!toggled) {
             if (main->menuBar()->dynamicPropertyNames().contains("wasvisible")) {
                 if (main->menuBar()->property("wasvisible").toBool()) {
                     main->menuBar()->setVisible(true);
                 }
             }
         }
         else {
             main->menuBar()->setProperty("wasvisible", main->menuBar()->isVisible());
             main->menuBar()->setVisible(false);
         }
     }
 
     if (cfg.hideToolbarFullscreen()) {
         QList<QToolBar*> toolBars = main->findChildren<QToolBar*>();
         Q_FOREACH (QToolBar* toolbar, toolBars) {
             if (!toggled) {
                 if (toolbar->dynamicPropertyNames().contains("wasvisible")) {
                     if (toolbar->property("wasvisible").toBool()) {
                         toolbar->setVisible(true);
                     }
                 }
             }
             else {
                 toolbar->setProperty("wasvisible", toolbar->isVisible());
                 toolbar->setVisible(false);
             }
         }
     }
 
     showHideScrollbars();
 
     if (toggled) {
         // show a fading heads-up display about the shortcut to go back
 
         showFloatingMessage(i18n("Going into Canvas-Only mode.\nPress %1 to go back.",
                                  actionCollection()->action("view_show_canvas_only")->shortcut().toString()), QIcon());
     }
     else {
         main->restoreState(d->canvasState);
     }
 
 }
 
 void KisViewManager::toggleTabletLogger()
 {
     d->inputManager.toggleTabletLogger();
 }
 
 void KisViewManager::openResourcesDirectory()
 {
     QString dir = KoResourcePaths::locateLocal("data", "");
     QDesktopServices::openUrl(QUrl::fromLocalFile(dir));
 }
 
 void KisViewManager::updateIcons()
 {
     if (mainWindow()) {
         QList<QDockWidget*> dockers = mainWindow()->dockWidgets();
         Q_FOREACH (QDockWidget* dock, dockers) {
             dbgKrita << "name " << dock->objectName();
 
             QObjectList objects;
             objects.append(dock);
             while (!objects.isEmpty()) {
                 QObject* object = objects.takeFirst();
                 objects.append(object->children());
                 KisIconUtils::updateIconCommon(object);
             }
         }
     }
 }
 void KisViewManager::initializeStatusBarVisibility()
 {
     KisConfig cfg;
     d->mainWindow->statusBar()->setVisible(cfg.showStatusBar());
 }
 
 void KisViewManager::guiUpdateTimeout()
 {
     d->nodeManager.updateGUI();
     d->selectionManager.updateGUI();
     d->filterManager.updateGUI();
     if (zoomManager()) {
         zoomManager()->updateGUI();
     }
     d->gridManager.updateGUI();
     d->actionManager.updateGUI();
 }
 
 void KisViewManager::showFloatingMessage(const QString &message, const QIcon& icon, int timeout, KisFloatingMessage::Priority priority, int alignment)
 {
     if (!d->currentImageView) return;
     d->currentImageView->showFloatingMessageImpl(message, icon, timeout, priority, alignment);
 
     emit floatingMessageRequested(message, icon.name());
 }
 
 KisMainWindow *KisViewManager::mainWindow() const
 {
     return qobject_cast<KisMainWindow*>(d->mainWindow);
 }
 
 
 void KisViewManager::showHideScrollbars()
 {
     if (!d->currentImageView) return;
     if (!d->currentImageView->canvasController()) return;
 
     KisConfig cfg;
     bool toggled = actionCollection()->action("view_show_canvas_only")->isChecked();
 
     if ( (toggled && cfg.hideScrollbarsFullscreen()) || (!toggled && cfg.hideScrollbars()) ) {
         d->currentImageView->canvasController()->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
         d->currentImageView->canvasController()->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
     } else {
         d->currentImageView->canvasController()->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
         d->currentImageView->canvasController()->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
     }
 }
 
 void KisViewManager::slotSaveShowRulersState(bool value)
 {
     KisConfig cfg;
     cfg.setShowRulers(value);
 }
 
 void KisViewManager::slotSaveRulersTrackMouseState(bool value)
 {
     KisConfig cfg;
     cfg.setRulersTrackMouse(value);
 }
 
 void KisViewManager::setShowFloatingMessage(bool show)
 {
     d->showFloatingMessage = show;
 }
 
 void KisViewManager::changeAuthorProfile(const QString &profileName)
 {
     KConfigGroup appAuthorGroup(KoGlobal::calligraConfig(), "Author");
     if (profileName.isEmpty() || profileName == i18nc("choice for author profile", "Anonymous")) {
         appAuthorGroup.writeEntry("active-profile", "");
     } else {
         appAuthorGroup.writeEntry("active-profile", profileName);
     }
     appAuthorGroup.sync();
     Q_FOREACH (KisDocument *doc, KisPart::instance()->documents()) {
         doc->documentInfo()->updateParameters();
     }
 }
 
 void KisViewManager::slotUpdateAuthorProfileActions()
 {
     Q_ASSERT(d->actionAuthor);
     if (!d->actionAuthor) {
         return;
     }
     d->actionAuthor->clear();
     d->actionAuthor->addAction(i18nc("choice for author profile", "Anonymous"));
 
     KConfigGroup authorGroup(KoGlobal::calligraConfig(), "Author");
     QStringList profiles = authorGroup.readEntry("profile-names", QStringList());
     QString authorInfo = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/authorinfo/";
     QStringList filters = QStringList() << "*.authorinfo";
     QDir dir(authorInfo);
     Q_FOREACH(QString entry, dir.entryList(filters)) {
         int ln = QString(".authorinfo").size();
         entry.chop(ln);
         if (!profiles.contains(entry)) {
             profiles.append(entry);
         }
     }
     Q_FOREACH (const QString &profile , profiles) {
         d->actionAuthor->addAction(profile);
     }
 
     KConfigGroup appAuthorGroup(KoGlobal::calligraConfig(), "Author");
     QString profileName = appAuthorGroup.readEntry("active-profile", "");
 
     if (profileName == "anonymous" || profileName.isEmpty()) {
         d->actionAuthor->setCurrentItem(0);
     } else if (profiles.contains(profileName)) {
         d->actionAuthor->setCurrentAction(profileName);
     }
 }
 
 void KisViewManager::slotUpdatePixelGridAction()
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(d->showPixelGrid);
 
     KisSignalsBlocker b(d->showPixelGrid);
 
     KisConfig cfg;
     d->showPixelGrid->setChecked(cfg.pixelGridEnabled());
 }
diff --git a/libs/ui/actions/KisPasteActionFactory.cpp b/libs/ui/actions/KisPasteActionFactory.cpp
index 8d9128b802..646feb5631 100644
--- a/libs/ui/actions/KisPasteActionFactory.cpp
+++ b/libs/ui/actions/KisPasteActionFactory.cpp
@@ -1,241 +1,242 @@
 /*
  *  Copyright (c) 2017 Dmitry Kazakov <dimula73@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 "KisPasteActionFactory.h"
 
 #include "kis_image.h"
 #include "KisViewManager.h"
 #include "kis_tool_proxy.h"
 #include "kis_canvas2.h"
 #include "kis_canvas_controller.h"
 #include "kis_paint_device.h"
 #include "kis_paint_layer.h"
 #include "kis_shape_layer.h"
 #include "kis_import_catcher.h"
 #include "kis_clipboard.h"
 #include "commands/kis_image_layer_add_command.h"
 #include "kis_processing_applicator.h"
 
 #include <KoSvgPaste.h>
 #include <KoShapeController.h>
 #include <KoShapeManager.h>
 #include <KoSelection.h>
 #include <KoSelectedShapesProxy.h>
 #include "kis_algebra_2d.h"
 #include <KoShapeMoveCommand.h>
 #include <KoShapeReorderCommand.h>
 #include "kis_time_range.h"
 #include "kis_keyframe_channel.h"
 #include "kis_raster_keyframe_channel.h"
+#include "kis_painter.h"
 
 namespace {
 QPointF getFittingOffset(QList<KoShape*> shapes,
                          const QPointF &shapesOffset,
                          const QRectF &documentRect,
                          const qreal fitRatio)
 {
     QPointF accumulatedFitOffset;
 
     Q_FOREACH (KoShape *shape, shapes) {
         const QRectF bounds = shape->boundingRect();
 
         const QPointF center = bounds.center() + shapesOffset;
 
         const qreal wMargin = (0.5 - fitRatio) * bounds.width();
         const qreal hMargin = (0.5 - fitRatio) * bounds.height();
         const QRectF allowedRect = documentRect.adjusted(-wMargin, -hMargin, wMargin, hMargin);
 
         const QPointF fittedCenter = KisAlgebra2D::clampPoint(center, allowedRect);
 
         accumulatedFitOffset += fittedCenter - center;
     }
 
     return accumulatedFitOffset;
 }
 
 bool tryPasteShapes(bool pasteAtCursorPosition, KisViewManager *view)
 {
     bool result = false;
 
     KoSvgPaste paste;
 
     if (paste.hasShapes()) {
         KoCanvasBase *canvas = view->canvasBase();
 
         QSizeF fragmentSize;
         QList<KoShape*> shapes =
             paste.fetchShapes(canvas->shapeController()->documentRectInPixels(),
                               canvas->shapeController()->pixelsPerInch(), &fragmentSize);
 
         if (!shapes.isEmpty()) {
             KoShapeManager *shapeManager = canvas->shapeManager();
             shapeManager->selection()->deselectAll();
 
             // adjust z-index of the shapes so that they would be
             // pasted on the top of the stack
             QList<KoShape*> topLevelShapes = shapeManager->topLevelShapes();
             auto it = std::max_element(topLevelShapes.constBegin(), topLevelShapes.constEnd(), KoShape::compareShapeZIndex);
             if (it != topLevelShapes.constEnd()) {
                 const int zIndexOffset = (*it)->zIndex();
 
                 std::stable_sort(shapes.begin(), shapes.end(), KoShape::compareShapeZIndex);
 
                 QList<KoShapeReorderCommand::IndexedShape> indexedShapes;
                 std::transform(shapes.constBegin(), shapes.constEnd(),
                                std::back_inserter(indexedShapes),
                     [zIndexOffset] (KoShape *shape) {
                         KoShapeReorderCommand::IndexedShape indexedShape(shape);
                         indexedShape.zIndex += zIndexOffset;
                         return indexedShape;
                     });
 
                 indexedShapes = KoShapeReorderCommand::homogenizeZIndexesLazy(indexedShapes);
 
                 KoShapeReorderCommand cmd(indexedShapes);
                 cmd.redo();
             }
 
             KUndo2Command *parentCommand = new KUndo2Command(kundo2_i18n("Paste shapes"));
             canvas->shapeController()->addShapesDirect(shapes, 0, parentCommand);
 
             QPointF finalShapesOffset;
 
 
             if (pasteAtCursorPosition) {
                 QRectF boundingRect = KoShape::boundingRect(shapes);
                 const QPointF cursorPos = canvas->canvasController()->currentCursorPosition();
                 finalShapesOffset = cursorPos - boundingRect.center();
 
             } else {
                 bool foundOverlapping = false;
 
                 QRectF boundingRect = KoShape::boundingRect(shapes);
                 const QPointF offsetStep = 0.1 * QPointF(boundingRect.width(), boundingRect.height());
 
                 QPointF offset;
 
                 Q_FOREACH (KoShape *shape, shapes) {
                     QRectF br1 = shape->boundingRect();
 
                     bool hasOverlappingShape = false;
 
                     do {
                         hasOverlappingShape = false;
 
                         // we cannot use shapesAt() here, because the groups are not
                         // handled in the shape manager's tree
                         QList<KoShape*> conflicts = shapeManager->shapes();
 
                         Q_FOREACH (KoShape *intersectedShape, conflicts) {
                             if (intersectedShape == shape) continue;
 
                             QRectF br2 = intersectedShape->boundingRect();
 
                             const qreal tolerance = 2.0; /* pt */
                             if (KisAlgebra2D::fuzzyCompareRects(br1, br2, tolerance)) {
                                 br1.translate(offsetStep.x(), offsetStep.y());
                                 offset += offsetStep;
 
                                 hasOverlappingShape = true;
                                 foundOverlapping = true;
                                 break;
                             }
                         }
                     } while (hasOverlappingShape);
 
                     if (foundOverlapping) break;
                 }
 
                 if (foundOverlapping) {
                     finalShapesOffset = offset;
                 }
             }
 
             const QRectF documentRect = canvas->shapeController()->documentRect();
             finalShapesOffset += getFittingOffset(shapes, finalShapesOffset, documentRect, 0.1);
 
             if (!finalShapesOffset.isNull()) {
                 new KoShapeMoveCommand(shapes, finalShapesOffset, parentCommand);
             }
 
             canvas->addCommand(parentCommand);
 
             Q_FOREACH (KoShape *shape, shapes) {
                 canvas->selectedShapesProxy()->selection()->select(shape);
             }
 
             result = true;
         }
     }
 
     return result;
 }
 
 }
 #include "kis_painter.h"
 void KisPasteActionFactory::run(bool pasteAtCursorPosition, KisViewManager *view)
 {
     KisImageSP image = view->image();
     if (!image) return;
 
     if (tryPasteShapes(pasteAtCursorPosition, view)) {
         return;
     }
 
     KisTimeRange range;
     const QRect fittingBounds = pasteAtCursorPosition ? QRect() : image->bounds();
     KisPaintDeviceSP clip = KisClipboard::instance()->clip(fittingBounds, true, &range);
 
     if (clip) {
         if (pasteAtCursorPosition) {
             const QPointF docPos = view->canvasBase()->canvasController()->currentCursorPosition();
             const QPointF imagePos = view->canvasBase()->coordinatesConverter()->documentToImage(docPos);
 
             const QPointF offset = (imagePos - QRectF(clip->exactBounds()).center()).toPoint();
 
             clip->setX(clip->x() + offset.x());
             clip->setY(clip->y() + offset.y());
         }
 
         KisImportCatcher::adaptClipToImageColorSpace(clip, image);
         KisPaintLayerSP newLayer = new KisPaintLayer(image.data(),
                                                      image->nextLayerName() + i18n("(pasted)"),
                                                      OPACITY_OPAQUE_U8);
         KisNodeSP aboveNode = view->activeLayer();
         KisNodeSP parentNode = aboveNode ? aboveNode->parent() : image->root();
 
         if (range.isValid()) {
             newLayer->enableAnimation();
             KisKeyframeChannel *channel = newLayer->getKeyframeChannel(KisKeyframeChannel::Content.id(), true);
             KisRasterKeyframeChannel *rasterChannel = dynamic_cast<KisRasterKeyframeChannel*>(channel);
             rasterChannel->importFrame(range.start(), clip, 0);
             rasterChannel->addKeyframe(range.end() + 1, 0);
         } else {
             const QRect rc = clip->extent();
             KisPainter::copyAreaOptimized(rc.topLeft(), clip, newLayer->paintDevice(), rc);
         }
 
         KUndo2Command *cmd = new KisImageLayerAddCommand(image, newLayer, parentNode, aboveNode);
         KisProcessingApplicator *ap = beginAction(view, cmd->text());
         ap->applyCommand(cmd, KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::NORMAL);
         endAction(ap, KisOperationConfiguration(id()).toXML());
     } else {
         // XXX: "Add saving of XML data for Paste of shapes"
         view->canvasBase()->toolProxy()->paste();
     }
 }
diff --git a/libs/ui/canvas/kis_animation_player.cpp b/libs/ui/canvas/kis_animation_player.cpp
index 9e72f292f8..6570900809 100644
--- a/libs/ui/canvas/kis_animation_player.cpp
+++ b/libs/ui/canvas/kis_animation_player.cpp
@@ -1,546 +1,588 @@
 /*
  *  Copyright (c) 2015 Jouni Pentikäinen <joupent@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_animation_player.h"
 
 #include <QElapsedTimer>
 #include <QTimer>
 #include <QtMath>
 
 //#define PLAYER_DEBUG_FRAMERATE
 
 #include "kis_global.h"
+#include "kis_algebra_2d.h"
 
 #include "kis_config.h"
 #include "kis_config_notifier.h"
 #include "kis_image.h"
 #include "kis_canvas2.h"
 #include "kis_animation_frame_cache.h"
 #include "kis_signal_auto_connection.h"
 #include "kis_image_animation_interface.h"
 #include "kis_time_range.h"
 #include "kis_signal_compressor.h"
 #include <KisDocument.h>
 #include <QFileInfo>
 #include "KisSyncedAudioPlayback.h"
 #include "kis_signal_compressor_with_param.h"
 
+#include "kis_image_config.h"
+#include <limits>
+
 #include "KisViewManager.h"
 #include "kis_icon_utils.h"
 
 #include "KisPart.h"
 #include "dialogs/KisAsyncAnimationCacheRenderDialog.h"
 #include "KisRollingMeanAccumulatorWrapper.h"
 
 
 struct KisAnimationPlayer::Private
 {
 public:
     Private(KisAnimationPlayer *_q)
         : q(_q),
           realFpsAccumulator(24),
           droppedFpsAccumulator(24),
           droppedFramesPortion(24),
           dropFramesMode(true),
           nextFrameExpectedTime(0),
           expectedInterval(0),
           expectedFrame(0),
           lastTimerInterval(0),
           lastPaintedFrame(0),
           playbackStatisticsCompressor(1000, KisSignalCompressor::FIRST_INACTIVE),
           stopAudioOnScrubbingCompressor(100, KisSignalCompressor::POSTPONE),
           audioOffsetTolerance(-1)
           {}
 
     KisAnimationPlayer *q;
 
     bool useFastFrameUpload;
     bool playing;
 
     QTimer *timer;
 
     int initialFrame;
     int firstFrame;
     int lastFrame;
     qreal playbackSpeed;
 
     KisCanvas2 *canvas;
 
     KisSignalAutoConnectionsStore cancelStrokeConnections;
 
     QElapsedTimer realFpsTimer;
     KisRollingMeanAccumulatorWrapper realFpsAccumulator;
     KisRollingMeanAccumulatorWrapper droppedFpsAccumulator;
     KisRollingMeanAccumulatorWrapper droppedFramesPortion;
 
 
     bool dropFramesMode;
 
     QElapsedTimer playbackTime;
     int nextFrameExpectedTime;
     int expectedInterval;
     int expectedFrame;
     int lastTimerInterval;
     int lastPaintedFrame;
 
     KisSignalCompressor playbackStatisticsCompressor;
 
     QScopedPointer<KisSyncedAudioPlayback> syncedAudio;
     QScopedPointer<KisSignalCompressorWithParam<int> > audioSyncScrubbingCompressor;
     KisSignalCompressor stopAudioOnScrubbingCompressor;
 
     int audioOffsetTolerance;
 
     void stopImpl(bool doUpdates);
 
     int incFrame(int frame, int inc) {
         frame += inc;
         if (frame > lastFrame) {
             frame = firstFrame + frame - lastFrame - 1;
         }
         return frame;
     }
 
     qint64 frameToMSec(int value, int fps) {
         return qreal(value) / fps * 1000.0;
     }
     int msecToFrame(qint64 value, int fps) {
         return qreal(value) * fps / 1000.0;
     }
 };
 
 KisAnimationPlayer::KisAnimationPlayer(KisCanvas2 *canvas)
     : QObject(canvas)
     , m_d(new Private(this))
 {
     m_d->useFastFrameUpload = false;
     m_d->playing = false;
     m_d->canvas = canvas;
     m_d->playbackSpeed = 1.0;
 
     m_d->timer = new QTimer(this);
     connect(m_d->timer, SIGNAL(timeout()), this, SLOT(slotUpdate()));
     m_d->timer->setSingleShot(true);
 
     connect(KisConfigNotifier::instance(),
             SIGNAL(dropFramesModeChanged()),
             SLOT(slotUpdateDropFramesMode()));
     slotUpdateDropFramesMode();
 
     connect(&m_d->playbackStatisticsCompressor, SIGNAL(timeout()),
             this, SIGNAL(sigPlaybackStatisticsUpdated()));
 
     using namespace std::placeholders;
     std::function<void (int)> callback(
         std::bind(&KisAnimationPlayer::slotSyncScrubbingAudio, this, _1));
 
     const int defaultScrubbingUdpatesDelay = 40; /* 40 ms == 25 fps */
 
     m_d->audioSyncScrubbingCompressor.reset(
         new KisSignalCompressorWithParam<int>(defaultScrubbingUdpatesDelay, callback, KisSignalCompressor::FIRST_ACTIVE));
 
     m_d->stopAudioOnScrubbingCompressor.setDelay(defaultScrubbingUdpatesDelay);
     connect(&m_d->stopAudioOnScrubbingCompressor, SIGNAL(timeout()), SLOT(slotTryStopScrubbingAudio()));
 
     connect(m_d->canvas->image()->animationInterface(), SIGNAL(sigFramerateChanged()), SLOT(slotUpdateAudioChunkLength()));
     slotUpdateAudioChunkLength();
 
     connect(m_d->canvas->image()->animationInterface(), SIGNAL(sigAudioChannelChanged()), SLOT(slotAudioChannelChanged()));
     connect(m_d->canvas->image()->animationInterface(), SIGNAL(sigAudioVolumeChanged()), SLOT(slotAudioVolumeChanged()));
 
     slotAudioChannelChanged();
 }
 
 KisAnimationPlayer::~KisAnimationPlayer()
 {}
 
 void KisAnimationPlayer::slotUpdateDropFramesMode()
 {
     KisConfig cfg;
     m_d->dropFramesMode = cfg.animationDropFrames();
 }
 
 void KisAnimationPlayer::slotSyncScrubbingAudio(int msecTime)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->syncedAudio);
 
     if (!m_d->syncedAudio->isPlaying()) {
         m_d->syncedAudio->play(msecTime);
     } else {
         m_d->syncedAudio->syncWithVideo(msecTime);
     }
 
     if (!isPlaying()) {
         m_d->stopAudioOnScrubbingCompressor.start();
     }
 }
 
 void KisAnimationPlayer::slotTryStopScrubbingAudio()
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->syncedAudio);
     if (m_d->syncedAudio && !isPlaying()) {
         m_d->syncedAudio->stop();
     }
 }
 
 void KisAnimationPlayer::slotAudioChannelChanged()
 {
 
     KisImageAnimationInterface *interface = m_d->canvas->image()->animationInterface();
     QString fileName = interface->audioChannelFileName();
     QFileInfo info(fileName);
     if (info.exists() && !interface->isAudioMuted()) {
         m_d->syncedAudio.reset(new KisSyncedAudioPlayback(info.absoluteFilePath()));
         m_d->syncedAudio->setVolume(interface->audioVolume());
         m_d->syncedAudio->setSoundOffsetTolerance(m_d->audioOffsetTolerance);
 
         connect(m_d->syncedAudio.data(), SIGNAL(error(const QString &, const QString &)), SLOT(slotOnAudioError(const QString &, const QString &)));
     } else {
         m_d->syncedAudio.reset();
     }
 }
 
 void KisAnimationPlayer::slotAudioVolumeChanged()
 {
     KisImageAnimationInterface *interface = m_d->canvas->image()->animationInterface();
     if (m_d->syncedAudio) {
         m_d->syncedAudio->setVolume(interface->audioVolume());
     }
 }
 
 void KisAnimationPlayer::slotOnAudioError(const QString &fileName, const QString &message)
 {
     QString errorMessage(i18nc("floating on-canvas message", "Cannot open audio: \"%1\"\nError: %2", fileName, message));
     m_d->canvas->viewManager()->showFloatingMessage(errorMessage, KisIconUtils::loadIcon("warning"));
 }
 
 void KisAnimationPlayer::connectCancelSignals()
 {
     m_d->cancelStrokeConnections.addConnection(
         m_d->canvas->image().data(), SIGNAL(sigUndoDuringStrokeRequested()),
         this, SLOT(slotCancelPlayback()));
 
     m_d->cancelStrokeConnections.addConnection(
         m_d->canvas->image().data(), SIGNAL(sigStrokeCancellationRequested()),
         this, SLOT(slotCancelPlayback()));
 
     m_d->cancelStrokeConnections.addConnection(
         m_d->canvas->image().data(), SIGNAL(sigStrokeEndRequested()),
         this, SLOT(slotCancelPlaybackSafe()));
 
     m_d->cancelStrokeConnections.addConnection(
         m_d->canvas->image()->animationInterface(), SIGNAL(sigFramerateChanged()),
         this, SLOT(slotUpdatePlaybackTimer()));
 
     m_d->cancelStrokeConnections.addConnection(
         m_d->canvas->image()->animationInterface(), SIGNAL(sigFullClipRangeChanged()),
         this, SLOT(slotUpdatePlaybackTimer()));
 
     m_d->cancelStrokeConnections.addConnection(
         m_d->canvas->image()->animationInterface(), SIGNAL(sigPlaybackRangeChanged()),
         this, SLOT(slotUpdatePlaybackTimer()));
 }
 
 void KisAnimationPlayer::disconnectCancelSignals()
 {
     m_d->cancelStrokeConnections.clear();
 }
 
 void KisAnimationPlayer::slotUpdateAudioChunkLength()
 {
     const KisImageAnimationInterface *animation = m_d->canvas->image()->animationInterface();
     const int animationFramePeriod = qMax(1, 1000 / animation->framerate());
 
     KisConfig cfg;
     int scrubbingAudioUdpatesDelay = cfg.scrubbingAudioUpdatesDelay();
 
     if (scrubbingAudioUdpatesDelay < 0) {
 
         scrubbingAudioUdpatesDelay = qMax(1, animationFramePeriod);
     }
 
     m_d->audioSyncScrubbingCompressor->setDelay(scrubbingAudioUdpatesDelay);
     m_d->stopAudioOnScrubbingCompressor.setDelay(scrubbingAudioUdpatesDelay);
 
     m_d->audioOffsetTolerance = cfg.audioOffsetTolerance();
     if (m_d->audioOffsetTolerance < 0) {
         m_d->audioOffsetTolerance = animationFramePeriod;
     }
 
     if (m_d->syncedAudio) {
         m_d->syncedAudio->setSoundOffsetTolerance(m_d->audioOffsetTolerance);
     }
 }
 
 void KisAnimationPlayer::slotUpdatePlaybackTimer()
 {
     m_d->timer->stop();
 
     const KisImageAnimationInterface *animation = m_d->canvas->image()->animationInterface();
     const KisTimeRange &playBackRange = animation->playbackRange();
     if (!playBackRange.isValid()) return;
 
     const int fps = animation->framerate();
 
     m_d->initialFrame = animation->currentUITime();
     m_d->firstFrame = playBackRange.start();
     m_d->lastFrame = playBackRange.end();
     m_d->expectedFrame = qBound(m_d->firstFrame, m_d->expectedFrame, m_d->lastFrame);
 
 
     m_d->expectedInterval = qreal(1000) / fps / m_d->playbackSpeed;
     m_d->lastTimerInterval = m_d->expectedInterval;
 
     if (m_d->syncedAudio) {
         m_d->syncedAudio->setSpeed(m_d->playbackSpeed);
     }
 
     m_d->timer->start(m_d->expectedInterval);
 
     if (m_d->playbackTime.isValid()) {
         m_d->playbackTime.restart();
     } else {
         m_d->playbackTime.start();
     }
 
     m_d->nextFrameExpectedTime = m_d->playbackTime.elapsed() + m_d->expectedInterval;
 }
 
 void KisAnimationPlayer::play()
 {
     {
         const KisImageAnimationInterface *animation = m_d->canvas->image()->animationInterface();
         const KisTimeRange &range = animation->playbackRange();
         if (!range.isValid()) return;
 
         // when openGL is disabled, there is no animation cache
         if (m_d->canvas->frameCache()) {
+            KisImageConfig cfg;
+
+            const int dimensionLimit =
+                cfg.useAnimationCacheFrameSizeLimit() ?
+                cfg.animationCacheFrameSizeLimit() :
+                std::numeric_limits<int>::max();
+
+            const int maxImageDimension = KisAlgebra2D::maxDimension(m_d->canvas->image()->bounds());
+
+            const QRect regionOfInterest =
+                cfg.useAnimationCacheRegionOfInterest() && maxImageDimension > dimensionLimit ?
+                m_d->canvas->regionOfInterest() :
+                m_d->canvas->coordinatesConverter()->imageRectInImagePixels();
+
+            const QRect minimalNeedRect =
+                m_d->canvas->coordinatesConverter()->widgetRectInImagePixels().toAlignedRect() &
+                m_d->canvas->coordinatesConverter()->imageRectInImagePixels();
+
+            m_d->canvas->frameCache()->dropLowQualityFrames(range, regionOfInterest, minimalNeedRect);
+
             KisAsyncAnimationCacheRenderDialog dlg(m_d->canvas->frameCache(),
                                                    range,
                                                    200);
 
+            dlg.setRegionOfInterest(regionOfInterest);
+
             KisAsyncAnimationCacheRenderDialog::Result result =
                 dlg.regenerateRange(m_d->canvas->viewManager());
 
             if (result != KisAsyncAnimationCacheRenderDialog::RenderComplete) {
                 return;
             }
+
+            m_d->canvas->setRenderingLimit(regionOfInterest);
         }
     }
 
     m_d->playing = true;
 
     slotUpdatePlaybackTimer();
     m_d->expectedFrame = m_d->firstFrame;
-    m_d->lastPaintedFrame = m_d->firstFrame;
+    m_d->lastPaintedFrame = -1;
 
     connectCancelSignals();
 
     if (m_d->syncedAudio) {
         KisImageAnimationInterface *animationInterface = m_d->canvas->image()->animationInterface();
         m_d->syncedAudio->play(m_d->frameToMSec(m_d->firstFrame, animationInterface->framerate()));
     }
+
+    emit sigPlaybackStarted();
 }
 
 void KisAnimationPlayer::Private::stopImpl(bool doUpdates)
 {
     if (syncedAudio) {
         syncedAudio->stop();
     }
 
     q->disconnectCancelSignals();
 
     timer->stop();
     playing = false;
+    canvas->setRenderingLimit(QRect());
 
     if (doUpdates) {
         KisImageAnimationInterface *animation = canvas->image()->animationInterface();
         if (animation->currentUITime() == initialFrame) {
             canvas->refetchDataFromImage();
         } else {
             animation->switchCurrentTimeAsync(initialFrame);
         }
     }
 
     emit q->sigPlaybackStopped();
 }
 
 void KisAnimationPlayer::stop()
 {
     m_d->stopImpl(true);
 }
 
 void KisAnimationPlayer::forcedStopOnExit()
 {
     m_d->stopImpl(false);
 }
 
 bool KisAnimationPlayer::isPlaying()
 {
     return m_d->playing;
 }
 
 int KisAnimationPlayer::currentTime()
 {
     return m_d->lastPaintedFrame;
 }
 
 void KisAnimationPlayer::displayFrame(int time)
 {
     uploadFrame(time);
 }
 
 void KisAnimationPlayer::slotUpdate()
 {
     uploadFrame(-1);
 }
 
 void KisAnimationPlayer::uploadFrame(int frame)
 {
     KisImageAnimationInterface *animationInterface = m_d->canvas->image()->animationInterface();
 
     if (frame < 0) {
         const int currentTime = m_d->playbackTime.elapsed();
         const int framesDiff = currentTime - m_d->nextFrameExpectedTime;
         const qreal framesDiffNorm = qreal(framesDiff) / m_d->expectedInterval;
 
         // qDebug() << ppVar(framesDiff)
         //          << ppVar(m_d->expectedFrame)
         //          << ppVar(framesDiffNorm)
         //          << ppVar(m_d->lastTimerInterval);
 
         if (m_d->dropFramesMode) {
             const int numDroppedFrames = qMax(0, qRound(framesDiffNorm));
             frame = m_d->incFrame(m_d->expectedFrame, numDroppedFrames);
         } else {
             frame = m_d->expectedFrame;
         }
 
         m_d->nextFrameExpectedTime = currentTime + m_d->expectedInterval;
 
         m_d->lastTimerInterval = qMax(0.0, m_d->lastTimerInterval - 0.5 * framesDiff);
         m_d->expectedFrame = m_d->incFrame(frame,  1);
 
         m_d->timer->start(m_d->lastTimerInterval);
 
         m_d->playbackStatisticsCompressor.start();
     }
 
     if (m_d->syncedAudio) {
         const int msecTime = m_d->frameToMSec(frame, animationInterface->framerate());
         if (isPlaying()) {
             slotSyncScrubbingAudio(msecTime);
         } else {
             m_d->audioSyncScrubbingCompressor->start(msecTime);
         }
     }
 
-    if (m_d->canvas->frameCache() && m_d->canvas->frameCache()->uploadFrame(frame)) {
-        m_d->canvas->updateCanvas();
 
-        m_d->useFastFrameUpload = true;
-        emit sigFrameChanged();
-    } else {
+    bool useFallbackUploadMethod = !m_d->canvas->frameCache();
+
+    if (m_d->canvas->frameCache() &&
+        m_d->canvas->frameCache()->shouldUploadNewFrame(frame, m_d->lastPaintedFrame)) {
+
+
+        if (m_d->canvas->frameCache()->uploadFrame(frame)) {
+            m_d->canvas->updateCanvas();
+
+            m_d->useFastFrameUpload = true;
+        } else {
+            useFallbackUploadMethod = true;
+        }
+    }
+
+    if (useFallbackUploadMethod) {
         m_d->useFastFrameUpload = false;
 
         m_d->canvas->image()->barrierLock(true);
         m_d->canvas->image()->unlock();
 
         // no OpenGL cache or the frame just not cached yet
         animationInterface->switchCurrentTimeAsync(frame);
-
-        emit sigFrameChanged();
     }
 
     if (!m_d->realFpsTimer.isValid()) {
         m_d->realFpsTimer.start();
     } else {
         const int elapsed = m_d->realFpsTimer.restart();
         m_d->realFpsAccumulator(elapsed);
 
-        int numFrames = frame - m_d->lastPaintedFrame;
-        if (numFrames < 0) {
-            numFrames += m_d->lastFrame - m_d->firstFrame + 1;
-        }
+        if (m_d->lastPaintedFrame >= 0) {
+            int numFrames = frame - m_d->lastPaintedFrame;
+            if (numFrames < 0) {
+                numFrames += m_d->lastFrame - m_d->firstFrame + 1;
+            }
 
-        m_d->droppedFramesPortion(qreal(int(numFrames != 1)));
+            m_d->droppedFramesPortion(qreal(int(numFrames != 1)));
 
-        if (numFrames > 0) {
-            m_d->droppedFpsAccumulator(qreal(elapsed) / numFrames);
-        }
+            if (numFrames > 0) {
+                m_d->droppedFpsAccumulator(qreal(elapsed) / numFrames);
+            }
 
 #ifdef PLAYER_DEBUG_FRAMERATE
-        qDebug() << "    RFPS:" << 1000.0 / m_d->realFpsAccumulator.rollingMean()
-                 << "DFPS:" << 1000.0 / m_d->droppedFpsAccumulator.rollingMean() << ppVar(numFrames);
+            qDebug() << "    RFPS:" << 1000.0 / m_d->realFpsAccumulator.rollingMean()
+                     << "DFPS:" << 1000.0 / m_d->droppedFpsAccumulator.rollingMean() << ppVar(numFrames);
 #endif /* PLAYER_DEBUG_FRAMERATE */
+        }
     }
 
     m_d->lastPaintedFrame = frame;
-
+    emit sigFrameChanged();
 }
 
 qreal KisAnimationPlayer::effectiveFps() const
 {
     return 1000.0 / m_d->droppedFpsAccumulator.rollingMean();
 }
 
 qreal KisAnimationPlayer::realFps() const
 {
     return 1000.0 / m_d->realFpsAccumulator.rollingMean();
 }
 
 qreal KisAnimationPlayer::framesDroppedPortion() const
 {
     return m_d->droppedFramesPortion.rollingMean();
 }
 
 void KisAnimationPlayer::slotCancelPlayback()
 {
     stop();
 }
 
 void KisAnimationPlayer::slotCancelPlaybackSafe()
 {
     /**
      * If there is no openGL support, then we have no (!) cache at
      * all. Therefore we should regenerate frame on every time switch,
      * which, yeah, can be very slow.  What is more important, when
      * regenerating a frame animation interface will emit a
      * sigStrokeEndRequested() signal and we should ignore it. That is
      * not an ideal solution, because the user will be able to paint
      * on random frames while playing, but it lets users with faulty
      * GPUs see at least some preview of their animation.
      */
 
     if (m_d->useFastFrameUpload) {
         stop();
     }
 }
 
 qreal KisAnimationPlayer::playbackSpeed()
 {
     return m_d->playbackSpeed;
 }
 
 void KisAnimationPlayer::slotUpdatePlaybackSpeed(double value)
 {
     m_d->playbackSpeed = value;
     if (m_d->playing) {
         slotUpdatePlaybackTimer();
     }
 }
diff --git a/libs/ui/canvas/kis_animation_player.h b/libs/ui/canvas/kis_animation_player.h
index be25cdc00a..8af2d8977e 100644
--- a/libs/ui/canvas/kis_animation_player.h
+++ b/libs/ui/canvas/kis_animation_player.h
@@ -1,87 +1,88 @@
 /*
  *  Copyright (c) 2015 Jouni Pentikäinen <joupent@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef KIS_ANIMATION_PLAYER_H
 #define KIS_ANIMATION_PLAYER_H
 
 #include <QScopedPointer>
 #include <QObject>
 
 #include "kritaui_export.h"
 
 
 class KisCanvas2;
 
 class KRITAUI_EXPORT KisAnimationPlayer : public QObject
 {
     Q_OBJECT
 
 public:
     KisAnimationPlayer(KisCanvas2 *canvas);
     ~KisAnimationPlayer() override;
 
     void play();
     void stop();
     void displayFrame(int time);
 
     bool isPlaying();
     int currentTime();
 
     qreal playbackSpeed();
 
     void forcedStopOnExit();
 
     qreal effectiveFps() const;
     qreal realFps() const;
     qreal framesDroppedPortion() const;
 
 public Q_SLOTS:
     void slotUpdate();
     void slotCancelPlayback();
     void slotCancelPlaybackSafe();
     void slotUpdatePlaybackSpeed(double value);
     void slotUpdatePlaybackTimer();
     void slotUpdateDropFramesMode();
 
 private Q_SLOTS:
     void slotSyncScrubbingAudio(int msecTime);
     void slotTryStopScrubbingAudio();
     void slotUpdateAudioChunkLength();
     void slotAudioChannelChanged();
     void slotAudioVolumeChanged();
     void slotOnAudioError(const QString &fileName, const QString &message);
 
 
 Q_SIGNALS:
     void sigFrameChanged();
+    void sigPlaybackStarted();
     void sigPlaybackStopped();
     void sigPlaybackStatisticsUpdated();
     void sigFullClipRangeChanged();
 
 private:
     void connectCancelSignals();
     void disconnectCancelSignals();
     void uploadFrame(int time);
 
 private:
     struct Private;
     QScopedPointer<Private> m_d;
 };
 
 
 #endif
diff --git a/libs/ui/canvas/kis_canvas2.cpp b/libs/ui/canvas/kis_canvas2.cpp
index 477e2347d7..64c8db5d9f 100644
--- a/libs/ui/canvas/kis_canvas2.cpp
+++ b/libs/ui/canvas/kis_canvas2.cpp
@@ -1,1098 +1,1145 @@
 /* This file is part of the KDE project
  *
  * Copyright (C) 2006, 2010 Boudewijn Rempt <boud@valdyas.org>
  * Copyright (C) Lukáš Tvrdý <lukast.dev@gmail.com>, (C) 2010
  * Copyright (C) 2011 Silvio Heinrich <plassy@web.de>
  *
  *  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_canvas2.h"
 
 #include <functional>
 #include <numeric>
 
 #include <QApplication>
 #include <QWidget>
 #include <QVBoxLayout>
 #include <QTime>
 #include <QLabel>
 #include <QMouseEvent>
 #include <QDesktopWidget>
 
 #include <kis_debug.h>
 
 #include <KoUnit.h>
 #include <KoShapeManager.h>
 #include <KisSelectedShapesProxy.h>
 #include <KoColorProfile.h>
 #include <KoCanvasControllerWidget.h>
 #include <KisDocument.h>
 #include <KoSelection.h>
 #include <KoShapeController.h>
 
 #include <kis_lod_transform.h>
 #include "kis_tool_proxy.h"
 #include "kis_coordinates_converter.h"
 #include "kis_prescaled_projection.h"
 #include "kis_image.h"
 #include "kis_image_barrier_locker.h"
 #include "kis_undo_adapter.h"
 #include "KisDocument.h"
 #include "flake/kis_shape_layer.h"
 #include "kis_canvas_resource_provider.h"
 #include "KisViewManager.h"
 #include "kis_config.h"
 #include "kis_config_notifier.h"
 #include "kis_abstract_canvas_widget.h"
 #include "kis_qpainter_canvas.h"
 #include "kis_group_layer.h"
 #include "flake/kis_shape_controller.h"
 #include "kis_node_manager.h"
 #include "kis_selection.h"
 #include "kis_selection_component.h"
 #include "flake/kis_shape_selection.h"
 #include "kis_image_config.h"
 #include "kis_infinity_manager.h"
 #include "kis_signal_compressor.h"
 #include "kis_display_color_converter.h"
 #include "kis_exposure_gamma_correction_interface.h"
 #include "KisView.h"
 #include "kis_canvas_controller.h"
 #include "kis_grid_config.h"
 
 #include "kis_animation_player.h"
 #include "kis_animation_frame_cache.h"
 #include "opengl/kis_opengl_canvas2.h"
 #include "opengl/kis_opengl.h"
 #include "kis_fps_decoration.h"
 
 #include "KoColorConversionTransformation.h"
 #include "KisProofingConfiguration.h"
 
 #include <kis_favorite_resource_manager.h>
 #include <kis_popup_palette.h>
 
 #include "input/kis_input_manager.h"
 #include "kis_painting_assistants_decoration.h"
 
 #include "kis_canvas_updates_compressor.h"
 #include "KoZoomController.h"
 
 #include <KisStrokeSpeedMonitor.h>
 #include "opengl/kis_opengl_canvas_debugger.h"
 
+#include "kis_algebra_2d.h"
+
 class Q_DECL_HIDDEN KisCanvas2::KisCanvas2Private
 {
 
 public:
 
     KisCanvas2Private(KoCanvasBase *parent, KisCoordinatesConverter* coordConverter, QPointer<KisView> view, KoCanvasResourceManager* resourceManager)
         : coordinatesConverter(coordConverter)
         , view(view)
         , shapeManager(parent)
         , selectedShapesProxy(&shapeManager)
         , toolProxy(parent)
         , displayColorConverter(resourceManager, view)
+        , regionOfInterestUpdateCompressor(100, KisSignalCompressor::FIRST_INACTIVE)
     {
     }
 
     KisCoordinatesConverter *coordinatesConverter;
     QPointer<KisView>view;
     KisAbstractCanvasWidget *canvasWidget = 0;
     KoShapeManager shapeManager;
     KisSelectedShapesProxy selectedShapesProxy;
     bool currentCanvasIsOpenGL;
     int openGLFilterMode;
     KisToolProxy toolProxy;
     KisPrescaledProjectionSP prescaledProjection;
     bool vastScrolling;
 
     KisSignalCompressor canvasUpdateCompressor;
     QRect savedUpdateRect;
 
     QBitArray channelFlags;
     KisProofingConfigurationSP proofingConfig;
     bool softProofing = false;
     bool gamutCheck = false;
     bool proofingConfigUpdated = false;
 
     KisPopupPalette *popupPalette = 0;
     KisDisplayColorConverter displayColorConverter;
 
     KisCanvasUpdatesCompressor projectionUpdatesCompressor;
     KisAnimationPlayer *animationPlayer;
     KisAnimationFrameCacheSP frameCache;
-    bool lodAllowedInCanvas;
+    bool lodAllowedInImage = false;
     bool bootstrapLodBlocked;
     QPointer<KoShapeManager> currentlyActiveShapeManager;
     KisInputActionGroupsMask inputActionGroupsMask = AllActionGroup;
 
     KisSignalCompressor frameRenderStartCompressor;
 
-    bool effectiveLodAllowedInCanvas() {
-        return lodAllowedInCanvas && !bootstrapLodBlocked;
+    KisSignalCompressor regionOfInterestUpdateCompressor;
+    QRect regionOfInterest;
+
+    QRect renderingLimit;
+
+    bool effectiveLodAllowedInImage() {
+        return lodAllowedInImage && !bootstrapLodBlocked;
     }
 
     void setActiveShapeManager(KoShapeManager *shapeManager);
 };
 
 namespace {
 KoShapeManager* fetchShapeManagerFromNode(KisNodeSP node)
 {
     KoShapeManager *shapeManager = 0;
 
     KisLayer *layer = dynamic_cast<KisLayer*>(node.data());
 
     if (layer) {
         KisShapeLayer *shapeLayer = dynamic_cast<KisShapeLayer*>(layer);
         if (shapeLayer) {
             shapeManager = shapeLayer->shapeManager();
 
         } else {
             KisSelectionSP selection = layer->selection();
             if (selection && selection->hasShapeSelection()) {
                 KisShapeSelection *shapeSelection = dynamic_cast<KisShapeSelection*>(selection->shapeSelection());
                 KIS_ASSERT_RECOVER_RETURN_VALUE(shapeSelection, 0);
 
                 shapeManager = shapeSelection->shapeManager();
             }
         }
     }
 
     return shapeManager;
 }
 }
 
 KisCanvas2::KisCanvas2(KisCoordinatesConverter *coordConverter, KoCanvasResourceManager *resourceManager, KisView *view, KoShapeBasedDocumentBase *sc)
     : KoCanvasBase(sc, resourceManager)
     , m_d(new KisCanvas2Private(this, coordConverter, view, resourceManager))
 {
     /**
      * While loading LoD should be blocked. Only when GUI has finished
      * loading and zoom level settled down, LoD is given a green
      * light.
      */
     m_d->bootstrapLodBlocked = true;
     connect(view->mainWindow(), SIGNAL(guiLoadingFinished()), SLOT(bootstrapFinished()));
 
     KisImageConfig config;
 
     m_d->canvasUpdateCompressor.setDelay(1000 / config.fpsLimit());
     m_d->canvasUpdateCompressor.setMode(KisSignalCompressor::FIRST_ACTIVE);
 
     m_d->frameRenderStartCompressor.setDelay(1000 / config.fpsLimit());
     m_d->frameRenderStartCompressor.setMode(KisSignalCompressor::FIRST_ACTIVE);
 }
 
 void KisCanvas2::setup()
 {
     // a bit of duplication from slotConfigChanged()
     KisConfig cfg;
     m_d->vastScrolling = cfg.vastScrolling();
-    m_d->lodAllowedInCanvas = cfg.levelOfDetailEnabled();
+    m_d->lodAllowedInImage = cfg.levelOfDetailEnabled();
 
     createCanvas(cfg.useOpenGL());
 
-    setLodAllowedInCanvas(m_d->lodAllowedInCanvas);
+    setLodAllowedInCanvas(m_d->lodAllowedInImage);
     m_d->animationPlayer = new KisAnimationPlayer(this);
     connect(m_d->view->canvasController()->proxyObject, SIGNAL(moveDocumentOffset(QPoint)), SLOT(documentOffsetMoved(QPoint)));
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotConfigChanged()));
 
     /**
      * We switch the shape manager every time vector layer or
      * shape selection is activated. Flake does not expect this
      * and connects all the signals of the global shape manager
      * to the clients in the constructor. To workaround this we
      * forward the signals of local shape managers stored in the
      * vector layers to the signals of global shape manager. So the
      * sequence of signal deliveries is the following:
      *
      * shapeLayer.m_d.canvas.m_shapeManager.selection() ->
      * shapeLayer ->
      * shapeController ->
      * globalShapeManager.selection()
      */
 
     KisShapeController *kritaShapeController = static_cast<KisShapeController*>(shapeController()->documentBase());
     connect(kritaShapeController, SIGNAL(selectionChanged()),
             this, SLOT(slotSelectionChanged()));
     connect(kritaShapeController, SIGNAL(selectionContentChanged()),
             globalShapeManager(), SIGNAL(selectionContentChanged()));
     connect(kritaShapeController, SIGNAL(currentLayerChanged(const KoShapeLayer*)),
             globalShapeManager()->selection(), SIGNAL(currentLayerChanged(const KoShapeLayer*)));
 
     connect(&m_d->canvasUpdateCompressor, SIGNAL(timeout()), SLOT(slotDoCanvasUpdate()));
 
     connect(this, SIGNAL(sigCanvasCacheUpdated()), &m_d->frameRenderStartCompressor, SLOT(start()));
     connect(&m_d->frameRenderStartCompressor, SIGNAL(timeout()), SLOT(updateCanvasProjection()));
 
     connect(this, SIGNAL(sigContinueResizeImage(qint32,qint32)), SLOT(finishResizingImage(qint32,qint32)));
 
+    connect(&m_d->regionOfInterestUpdateCompressor, SIGNAL(timeout()), SLOT(slotUpdateRegionOfInterest()));
+
     initializeFpsDecoration();
 }
 
 void KisCanvas2::initializeFpsDecoration()
 {
     KisConfig cfg;
 
     const bool shouldShowDebugOverlay =
         (canvasIsOpenGL() && cfg.enableOpenGLFramerateLogging()) ||
         cfg.enableBrushSpeedLogging();
 
     if (shouldShowDebugOverlay && !decoration(KisFpsDecoration::idTag)) {
         addDecoration(new KisFpsDecoration(imageView()));
 
         if (cfg.enableBrushSpeedLogging()) {
             connect(KisStrokeSpeedMonitor::instance(), SIGNAL(sigStatsUpdated()), this, SLOT(updateCanvas()));
         }
     } else if (!shouldShowDebugOverlay && decoration(KisFpsDecoration::idTag)) {
         m_d->canvasWidget->removeDecoration(KisFpsDecoration::idTag);
         disconnect(KisStrokeSpeedMonitor::instance(), SIGNAL(sigStatsUpdated()), this, SLOT(updateCanvas()));
     }
 }
 
 KisCanvas2::~KisCanvas2()
 {
     if (m_d->animationPlayer->isPlaying()) {
         m_d->animationPlayer->forcedStopOnExit();
     }
     delete m_d;
 }
 
 void KisCanvas2::setCanvasWidget(QWidget * widget)
 {
     KisAbstractCanvasWidget *tmp = dynamic_cast<KisAbstractCanvasWidget*>(widget);
     Q_ASSERT_X(tmp, "setCanvasWidget", "Cannot cast the widget to a KisAbstractCanvasWidget");
     if (m_d->popupPalette) {
         m_d->popupPalette->setParent(widget);
     }
 
     if(m_d->canvasWidget != 0)
     {
         tmp->setDecorations(m_d->canvasWidget->decorations());
 
         // Redundant check for the constructor case, see below
         if(viewManager() != 0)
             viewManager()->inputManager()->removeTrackedCanvas(this);
     }
 
     m_d->canvasWidget = tmp;
 
     // Either tmp was null or we are being called by KisCanvas2 constructor that is called by KisView
     // constructor, so the view manager still doesn't exists.
     if(m_d->canvasWidget != 0 && viewManager() != 0)
         viewManager()->inputManager()->addTrackedCanvas(this);
 
     if (!m_d->canvasWidget->decoration(INFINITY_DECORATION_ID)) {
         KisInfinityManager *manager = new KisInfinityManager(m_d->view, this);
         manager->setVisible(true);
         m_d->canvasWidget->addDecoration(manager);
     }
 
     widget->setAutoFillBackground(false);
     widget->setAttribute(Qt::WA_OpaquePaintEvent);
     widget->setMouseTracking(true);
     widget->setAcceptDrops(true);
 
     KoCanvasControllerWidget *controller = dynamic_cast<KoCanvasControllerWidget*>(canvasController());
     if (controller) {
         Q_ASSERT(controller->canvas() == this);
         controller->changeCanvasWidget(widget);
     }
 }
 
 bool KisCanvas2::canvasIsOpenGL() const
 {
     return m_d->currentCanvasIsOpenGL;
 }
 
 KisOpenGL::FilterMode KisCanvas2::openGLFilterMode() const
 {
     return KisOpenGL::FilterMode(m_d->openGLFilterMode);
 }
 
 void KisCanvas2::gridSize(QPointF *offset, QSizeF *spacing) const
 {
     QTransform transform = coordinatesConverter()->imageToDocumentTransform();
 
     const QPoint intSpacing = m_d->view->document()->gridConfig().spacing();
     const QPoint intOffset = m_d->view->document()->gridConfig().offset();
 
     QPointF size = transform.map(QPointF(intSpacing));
     spacing->rwidth() = size.x();
     spacing->rheight() = size.y();
 
     *offset = transform.map(QPointF(intOffset));
 }
 
 bool KisCanvas2::snapToGrid() const
 {
     return m_d->view->document()->gridConfig().snapToGrid();
 }
 
 qreal KisCanvas2::rotationAngle() const
 {
     return m_d->coordinatesConverter->rotationAngle();
 }
 
 bool KisCanvas2::xAxisMirrored() const
 {
     return m_d->coordinatesConverter->xAxisMirrored();
 }
 
 bool KisCanvas2::yAxisMirrored() const
 {
     return m_d->coordinatesConverter->yAxisMirrored();
 }
 
 void KisCanvas2::channelSelectionChanged()
 {
     KisImageSP image = this->image();
     m_d->channelFlags = image->rootLayer()->channelFlags();
 
     m_d->view->viewManager()->blockUntilOperationsFinishedForced(image);
 
     image->barrierLock();
     m_d->canvasWidget->channelSelectionChanged(m_d->channelFlags);
     startUpdateInPatches(image->bounds());
     image->unlock();
 }
 
 void KisCanvas2::addCommand(KUndo2Command *command)
 {
     // This method exists to support flake-related operations
     m_d->view->document()->addCommand(command);
 }
 
 void KisCanvas2::KisCanvas2Private::setActiveShapeManager(KoShapeManager *shapeManager)
 {
     if (shapeManager != currentlyActiveShapeManager) {
         currentlyActiveShapeManager = shapeManager;
         selectedShapesProxy.setShapeManager(shapeManager);
     }
 }
 
 KoShapeManager* KisCanvas2::shapeManager() const
 {
     KisNodeSP node = m_d->view->currentNode();
     KoShapeManager *localShapeManager = fetchShapeManagerFromNode(node);
 
     if (localShapeManager != m_d->currentlyActiveShapeManager) {
         m_d->setActiveShapeManager(localShapeManager);
     }
 
     // sanity check for consistency of the local shape manager
     KIS_SAFE_ASSERT_RECOVER (localShapeManager == m_d->currentlyActiveShapeManager) {
         localShapeManager = globalShapeManager();
     }
 
     return localShapeManager ? localShapeManager : globalShapeManager();
 }
 
 KoSelectedShapesProxy* KisCanvas2::selectedShapesProxy() const
 {
     return &m_d->selectedShapesProxy;
 }
 
 KoShapeManager* KisCanvas2::globalShapeManager() const
 {
     return &m_d->shapeManager;
 }
 
 void KisCanvas2::updateInputMethodInfo()
 {
     // TODO call (the protected) QWidget::updateMicroFocus() on the proper canvas widget...
 }
 
 const KisCoordinatesConverter* KisCanvas2::coordinatesConverter() const
 {
     return m_d->coordinatesConverter;
 }
 
 KoViewConverter* KisCanvas2::viewConverter() const
 {
     return m_d->coordinatesConverter;
 }
 
 KisInputManager* KisCanvas2::globalInputManager() const
 {
     return m_d->view->globalInputManager();
 }
 
 KisInputActionGroupsMask KisCanvas2::inputActionGroupsMask() const
 {
     return m_d->inputActionGroupsMask;
 }
 
 void KisCanvas2::setInputActionGroupsMask(KisInputActionGroupsMask mask)
 {
     m_d->inputActionGroupsMask = mask;
 }
 
 QWidget* KisCanvas2::canvasWidget()
 {
     return m_d->canvasWidget->widget();
 }
 
 const QWidget* KisCanvas2::canvasWidget() const
 {
     return m_d->canvasWidget->widget();
 }
 
 
 KoUnit KisCanvas2::unit() const
 {
     KoUnit unit(KoUnit::Pixel);
 
     KisImageWSP image = m_d->view->image();
     if (image) {
         if (!qFuzzyCompare(image->xRes(), image->yRes())) {
             warnKrita << "WARNING: resolution of the image is anisotropic"
                        << ppVar(image->xRes())
                        << ppVar(image->yRes());
         }
 
         const qreal resolution = image->xRes();
         unit.setFactor(resolution);
     }
 
     return unit;
 }
 
 KoToolProxy * KisCanvas2::toolProxy() const
 {
     return &m_d->toolProxy;
 }
 
 void KisCanvas2::createQPainterCanvas()
 {
     m_d->currentCanvasIsOpenGL = false;
 
     KisQPainterCanvas * canvasWidget = new KisQPainterCanvas(this, m_d->coordinatesConverter, m_d->view);
     m_d->prescaledProjection = new KisPrescaledProjection();
     m_d->prescaledProjection->setCoordinatesConverter(m_d->coordinatesConverter);
     m_d->prescaledProjection->setMonitorProfile(m_d->displayColorConverter.monitorProfile(),
                                                 m_d->displayColorConverter.renderingIntent(),
                                                 m_d->displayColorConverter.conversionFlags());
     m_d->prescaledProjection->setDisplayFilter(m_d->displayColorConverter.displayFilter());
     canvasWidget->setPrescaledProjection(m_d->prescaledProjection);
     setCanvasWidget(canvasWidget);
 }
 
 void KisCanvas2::createOpenGLCanvas()
 {
     KisConfig cfg;
     m_d->openGLFilterMode = cfg.openGLFilteringMode();
     m_d->currentCanvasIsOpenGL = true;
 
     KisOpenGLCanvas2 *canvasWidget = new KisOpenGLCanvas2(this, m_d->coordinatesConverter, 0, m_d->view->image(), &m_d->displayColorConverter);
     m_d->frameCache = KisAnimationFrameCache::getFrameCache(canvasWidget->openGLImageTextures());
 
     setCanvasWidget(canvasWidget);
 }
 
 void KisCanvas2::createCanvas(bool useOpenGL)
 {
     // deinitialize previous canvas structures
     m_d->prescaledProjection = 0;
     m_d->frameCache = 0;
 
     KisConfig cfg;
     QDesktopWidget dw;
     const KoColorProfile *profile = cfg.displayProfile(dw.screenNumber(imageView()));
     m_d->displayColorConverter.setMonitorProfile(profile);
 
     if (useOpenGL) {
         if (KisOpenGL::hasOpenGL()) {
             createOpenGLCanvas();
             if (cfg.canvasState() == "OPENGL_FAILED") {
                 // Creating the opengl canvas failed, fall back
                 warnKrita << "OpenGL Canvas initialization returned OPENGL_FAILED. Falling back to QPainter.";
                 createQPainterCanvas();
             }
         } else {
             warnKrita << "Tried to create OpenGL widget when system doesn't have OpenGL\n";
             createQPainterCanvas();
         }
     }
     else {
         createQPainterCanvas();
     }
 
     if (m_d->popupPalette) {
         m_d->popupPalette->setParent(m_d->canvasWidget->widget());
     }
 
 }
 
 void KisCanvas2::initializeImage()
 {
     KisImageSP image = m_d->view->image();
 
     m_d->coordinatesConverter->setImage(image);
     m_d->toolProxy.initializeImage(image);
 
     connect(image, SIGNAL(sigImageUpdated(QRect)), SLOT(startUpdateCanvasProjection(QRect)), Qt::DirectConnection);
     connect(image, SIGNAL(sigProofingConfigChanged()), SLOT(slotChangeProofingConfig()));
     connect(image, SIGNAL(sigSizeChanged(const QPointF&, const QPointF&)), SLOT(startResizingImage()), Qt::DirectConnection);
     connect(image->undoAdapter(), SIGNAL(selectionChanged()), SLOT(slotTrySwitchShapeManager()));
 
     connectCurrentCanvas();
 }
 
 void KisCanvas2::connectCurrentCanvas()
 {
     KisImageWSP image = m_d->view->image();
 
     if (!m_d->currentCanvasIsOpenGL) {
         Q_ASSERT(m_d->prescaledProjection);
         m_d->prescaledProjection->setImage(image);
     }
 
     startResizingImage();
+    setLodAllowedInCanvas(m_d->lodAllowedInImage);
 
-    emit imageChanged(image);
-    setLodAllowedInCanvas(m_d->lodAllowedInCanvas);
+    emit sigCanvasEngineChanged();
 }
 
 void KisCanvas2::resetCanvas(bool useOpenGL)
 {
     // we cannot reset the canvas before it's created, but this method might be called,
     // for instance when setting the monitor profile.
     if (!m_d->canvasWidget) {
         return;
     }
     KisConfig cfg;
     bool needReset = (m_d->currentCanvasIsOpenGL != useOpenGL) ||
         (m_d->currentCanvasIsOpenGL &&
          m_d->openGLFilterMode != cfg.openGLFilteringMode());
 
     if (needReset) {
         createCanvas(useOpenGL);
         connectCurrentCanvas();
         notifyZoomChanged();
     }
     updateCanvasWidgetImpl();
 }
 
 void KisCanvas2::startUpdateInPatches(const QRect &imageRect)
 {
     if (m_d->currentCanvasIsOpenGL) {
         startUpdateCanvasProjection(imageRect);
     } else {
         KisImageConfig imageConfig;
         int patchWidth = imageConfig.updatePatchWidth();
         int patchHeight = imageConfig.updatePatchHeight();
 
         for (int y = 0; y < imageRect.height(); y += patchHeight) {
             for (int x = 0; x < imageRect.width(); x += patchWidth) {
                 QRect patchRect(x, y, patchWidth, patchHeight);
                 startUpdateCanvasProjection(patchRect);
             }
         }
     }
 }
 
 void KisCanvas2::setDisplayFilter(QSharedPointer<KisDisplayFilter> displayFilter)
 {
     m_d->displayColorConverter.setDisplayFilter(displayFilter);
     KisImageSP image = this->image();
 
     m_d->view->viewManager()->blockUntilOperationsFinishedForced(image);
 
     image->barrierLock();
     m_d->canvasWidget->setDisplayFilter(displayFilter);
     image->unlock();
 }
 
 QSharedPointer<KisDisplayFilter> KisCanvas2::displayFilter() const
 {
     return m_d->displayColorConverter.displayFilter();
 }
 
 KisDisplayColorConverter* KisCanvas2::displayColorConverter() const
 {
     return &m_d->displayColorConverter;
 }
 
 KisExposureGammaCorrectionInterface* KisCanvas2::exposureGammaCorrectionInterface() const
 {
     QSharedPointer<KisDisplayFilter> displayFilter = m_d->displayColorConverter.displayFilter();
 
     return displayFilter ?
         displayFilter->correctionInterface() :
         KisDumbExposureGammaCorrectionInterface::instance();
 }
 
 void KisCanvas2::setProofingOptions(bool softProof, bool gamutCheck)
 {
     m_d->proofingConfig = this->image()->proofingConfiguration();
     if (!m_d->proofingConfig) {
         qDebug()<<"Canvas: No proofing config found, generating one.";
         KisImageConfig cfg;
         m_d->proofingConfig = cfg.defaultProofingconfiguration();
     }
     KoColorConversionTransformation::ConversionFlags conversionFlags = m_d->proofingConfig->conversionFlags;
 #if QT_VERSION >= 0x050700
 
     if (this->image()->colorSpace()->colorDepthId().id().contains("U")) {
         conversionFlags.setFlag(KoColorConversionTransformation::SoftProofing, softProof);
         if (softProof) {
             conversionFlags.setFlag(KoColorConversionTransformation::GamutCheck, gamutCheck);
         }
     }
 #else
     if (this->image()->colorSpace()->colorDepthId().id().contains("U")) {
         conversionFlags |= KoColorConversionTransformation::SoftProofing;
     } else {
         conversionFlags = conversionFlags & ~KoColorConversionTransformation::SoftProofing;
     }
     if (gamutCheck && softProof && this->image()->colorSpace()->colorDepthId().id().contains("U")) {
         conversionFlags |= KoColorConversionTransformation::GamutCheck;
     } else {
         conversionFlags = conversionFlags & ~KoColorConversionTransformation::GamutCheck;
     }
 #endif
     m_d->proofingConfig->conversionFlags = conversionFlags;
 
     m_d->proofingConfigUpdated = true;
     startUpdateInPatches(this->image()->bounds());
 
 }
 
 void KisCanvas2::slotSoftProofing(bool softProofing)
 {
     m_d->softProofing = softProofing;
     setProofingOptions(m_d->softProofing, m_d->gamutCheck);
 }
 
 void KisCanvas2::slotGamutCheck(bool gamutCheck)
 {
     m_d->gamutCheck = gamutCheck;
     setProofingOptions(m_d->softProofing, m_d->gamutCheck);
 }
 
 void KisCanvas2::slotChangeProofingConfig()
 {
     setProofingOptions(m_d->softProofing, m_d->gamutCheck);
 }
 
 void KisCanvas2::setProofingConfigUpdated(bool updated)
 {
     m_d->proofingConfigUpdated = updated;
 }
 
 bool KisCanvas2::proofingConfigUpdated()
 {
     return m_d->proofingConfigUpdated;
 }
 
 KisProofingConfigurationSP KisCanvas2::proofingConfiguration() const
 {
     if (!m_d->proofingConfig) {
         m_d->proofingConfig = this->image()->proofingConfiguration();
         if (!m_d->proofingConfig) {
             m_d->proofingConfig = KisImageConfig().defaultProofingconfiguration();
         }
     }
     return m_d->proofingConfig;
 }
 
 void KisCanvas2::startResizingImage()
 {
     KisImageWSP image = this->image();
     qint32 w = image->width();
     qint32 h = image->height();
 
     emit sigContinueResizeImage(w, h);
 
     QRect imageBounds(0, 0, w, h);
     startUpdateInPatches(imageBounds);
 }
 
 void KisCanvas2::finishResizingImage(qint32 w, qint32 h)
 {
     m_d->canvasWidget->finishResizingImage(w, h);
 }
 
 void KisCanvas2::startUpdateCanvasProjection(const QRect & rc)
 {
     KisUpdateInfoSP info = m_d->canvasWidget->startUpdateCanvasProjection(rc, m_d->channelFlags);
     if (m_d->projectionUpdatesCompressor.putUpdateInfo(info)) {
         emit sigCanvasCacheUpdated();
     }
 }
 
 void KisCanvas2::updateCanvasProjection()
 {
     QVector<KisUpdateInfoSP> infoObjects;
     while (KisUpdateInfoSP info = m_d->projectionUpdatesCompressor.takeUpdateInfo()) {
         infoObjects << info;
     }
 
     QVector<QRect> viewportRects = m_d->canvasWidget->updateCanvasProjection(infoObjects);
 
     const QRect vRect = std::accumulate(viewportRects.constBegin(), viewportRects.constEnd(),
                                         QRect(), std::bit_or<QRect>());
 
     // TODO: Implement info->dirtyViewportRect() for KisOpenGLCanvas2 to avoid updating whole canvas
     if (m_d->currentCanvasIsOpenGL) {
         m_d->savedUpdateRect = QRect();
 
         // we already had a compression in frameRenderStartCompressor, so force the update directly
         slotDoCanvasUpdate();
     } else if (/* !m_d->currentCanvasIsOpenGL && */ !vRect.isEmpty()) {
         m_d->savedUpdateRect = m_d->coordinatesConverter->viewportToWidget(vRect).toAlignedRect();
 
         // we already had a compression in frameRenderStartCompressor, so force the update directly
         slotDoCanvasUpdate();
     }
 }
 
 void KisCanvas2::slotDoCanvasUpdate()
 {
     /**
      * WARNING: in isBusy() we access openGL functions without making the painting
      * context current. We hope that currently active context will be Qt's one,
      * which is shared with our own.
      */
     if (m_d->canvasWidget->isBusy()) {
         // just restarting the timer
         updateCanvasWidgetImpl(m_d->savedUpdateRect);
         return;
     }
 
     if (m_d->savedUpdateRect.isEmpty()) {
         m_d->canvasWidget->widget()->update();
         emit updateCanvasRequested(m_d->canvasWidget->widget()->rect());
     } else {
         emit updateCanvasRequested(m_d->savedUpdateRect);
         m_d->canvasWidget->widget()->update(m_d->savedUpdateRect);
     }
 
     m_d->savedUpdateRect = QRect();
 }
 
 void KisCanvas2::updateCanvasWidgetImpl(const QRect &rc)
 {
     if (!m_d->canvasUpdateCompressor.isActive() ||
         !m_d->savedUpdateRect.isEmpty()) {
         m_d->savedUpdateRect |= rc;
     }
     m_d->canvasUpdateCompressor.start();
 }
 
 void KisCanvas2::updateCanvas()
 {
     updateCanvasWidgetImpl();
 }
 
 void KisCanvas2::updateCanvas(const QRectF& documentRect)
 {
     if (m_d->currentCanvasIsOpenGL && m_d->canvasWidget->decorations().size() > 0) {
         updateCanvasWidgetImpl();
     }
     else {
         // updateCanvas is called from tools, never from the projection
         // updates, so no need to prescale!
         QRect widgetRect = m_d->coordinatesConverter->documentToWidget(documentRect).toAlignedRect();
         widgetRect.adjust(-2, -2, 2, 2);
         if (!widgetRect.isEmpty()) {
             updateCanvasWidgetImpl(widgetRect);
         }
     }
 }
 
 void KisCanvas2::disconnectCanvasObserver(QObject *object)
 {
     KoCanvasBase::disconnectCanvasObserver(object);
     m_d->view->disconnect(object);
 }
 
 void KisCanvas2::notifyZoomChanged()
 {
     if (!m_d->currentCanvasIsOpenGL) {
         Q_ASSERT(m_d->prescaledProjection);
         m_d->prescaledProjection->notifyZoomChanged();
     }
 
     notifyLevelOfDetailChange();
     updateCanvas(); // update the canvas, because that isn't done when zooming using KoZoomAction
+
+    m_d->regionOfInterestUpdateCompressor.start();
+}
+
+QRect KisCanvas2::regionOfInterest() const
+{
+    return m_d->regionOfInterest;
+}
+
+void KisCanvas2::slotUpdateRegionOfInterest()
+{
+    const QRect oldRegionOfInterest = m_d->regionOfInterest;
+
+    const qreal ratio = 0.25;
+    const QRect proposedRoi = KisAlgebra2D::blowRect(m_d->coordinatesConverter->widgetRectInImagePixels(), ratio).toAlignedRect();
+
+    const QRect imageRect = m_d->coordinatesConverter->imageRectInImagePixels();
+
+    m_d->regionOfInterest = imageRect.contains(proposedRoi) ? proposedRoi : imageRect;
+
+    if (m_d->regionOfInterest != oldRegionOfInterest) {
+        emit sigRegionOfInterestChanged(m_d->regionOfInterest);
+    }
+}
+
+void KisCanvas2::setRenderingLimit(const QRect &rc)
+{
+    m_d->renderingLimit = rc;
+}
+
+QRect KisCanvas2::renderingLimit() const
+{
+    return m_d->renderingLimit;
 }
 
 void KisCanvas2::slotTrySwitchShapeManager()
 {
     KisNodeSP node = m_d->view->currentNode();
 
     QPointer<KoShapeManager> newManager;
     newManager = fetchShapeManagerFromNode(node);
 
     m_d->setActiveShapeManager(newManager);
 }
 
 void KisCanvas2::notifyLevelOfDetailChange()
 {
-    if (!m_d->effectiveLodAllowedInCanvas()) return;
-
-    KisImageSP image = this->image();
+    if (!m_d->effectiveLodAllowedInImage()) return;
 
     const qreal effectiveZoom = m_d->coordinatesConverter->effectiveZoom();
 
     KisConfig cfg;
     const int maxLod = cfg.numMipmapLevels();
 
-    int lod = KisLodTransform::scaleToLod(effectiveZoom, maxLod);
-    image->setDesiredLevelOfDetail(lod);
+    const int lod = KisLodTransform::scaleToLod(effectiveZoom, maxLod);
+
+    if (m_d->effectiveLodAllowedInImage()) {
+        KisImageSP image = this->image();
+        image->setDesiredLevelOfDetail(lod);
+    }
 }
 
 const KoColorProfile *  KisCanvas2::monitorProfile()
 {
     return m_d->displayColorConverter.monitorProfile();
 }
 
 KisViewManager* KisCanvas2::viewManager() const
 {
     if (m_d->view) {
         return m_d->view->viewManager();
     }
     return 0;
 }
 
 QPointer<KisView>KisCanvas2::imageView() const
 {
     return m_d->view;
 }
 
 KisImageWSP KisCanvas2::image() const
 {
     return m_d->view->image();
 
 }
 
 KisImageWSP KisCanvas2::currentImage() const
 {
     return m_d->view->image();
 }
 
 void KisCanvas2::documentOffsetMoved(const QPoint &documentOffset)
 {
     QPointF offsetBefore = m_d->coordinatesConverter->imageRectInViewportPixels().topLeft();
     m_d->coordinatesConverter->setDocumentOffset(documentOffset);
     QPointF offsetAfter = m_d->coordinatesConverter->imageRectInViewportPixels().topLeft();
 
     QPointF moveOffset = offsetAfter - offsetBefore;
 
     if (!m_d->currentCanvasIsOpenGL)
         m_d->prescaledProjection->viewportMoved(moveOffset);
 
     emit documentOffsetUpdateFinished();
 
     updateCanvas();
+
+    m_d->regionOfInterestUpdateCompressor.start();
 }
 
 void KisCanvas2::slotConfigChanged()
 {
     KisConfig cfg;
     m_d->vastScrolling = cfg.vastScrolling();
 
     resetCanvas(cfg.useOpenGL());
     slotSetDisplayProfile(cfg.displayProfile(QApplication::desktop()->screenNumber(this->canvasWidget())));
 
     initializeFpsDecoration();
 }
 
 void KisCanvas2::refetchDataFromImage()
 {
     KisImageSP image = this->image();
     KisImageBarrierLocker l(image);
     startUpdateInPatches(image->bounds());
 }
 
 void KisCanvas2::slotSetDisplayProfile(const KoColorProfile *monitorProfile)
 {
     if (m_d->displayColorConverter.monitorProfile() == monitorProfile) return;
 
     m_d->displayColorConverter.setMonitorProfile(monitorProfile);
 
     {
         KisImageSP image = this->image();
         KisImageBarrierLocker l(image);
         m_d->canvasWidget->setDisplayProfile(&m_d->displayColorConverter);
     }
 
     refetchDataFromImage();
 }
 
 void KisCanvas2::addDecoration(KisCanvasDecorationSP deco)
 {
     m_d->canvasWidget->addDecoration(deco);
 }
 
 KisCanvasDecorationSP KisCanvas2::decoration(const QString& id) const
 {
     return m_d->canvasWidget->decoration(id);
 }
 
 
 QPoint KisCanvas2::documentOrigin() const
 {
     /**
      * In Krita we don't use document origin anymore.
      * All the centering when needed (vastScrolling < 0.5) is done
      * automatically by the KisCoordinatesConverter.
      */
 
     return QPoint();
 }
 
 QPoint KisCanvas2::documentOffset() const
 {
     return m_d->coordinatesConverter->documentOffset();
 }
 
 void KisCanvas2::setFavoriteResourceManager(KisFavoriteResourceManager* favoriteResourceManager)
 {
     m_d->popupPalette = new KisPopupPalette(viewManager(), m_d->coordinatesConverter, favoriteResourceManager, displayColorConverter()->displayRendererInterface(),
                                             m_d->view->resourceProvider(), m_d->canvasWidget->widget());
-    connect(m_d->popupPalette, SIGNAL(zoomLevelChanged(int)), this, SLOT(slotZoomChanged(int)));
+    connect(m_d->popupPalette, SIGNAL(zoomLevelChanged(int)), this, SLOT(slotPopupPaletteRequestedZoomChange(int)));
     connect(m_d->popupPalette, SIGNAL(sigUpdateCanvas()), this, SLOT(updateCanvas()));
     connect(m_d->view->mainWindow(), SIGNAL(themeChanged()), m_d->popupPalette, SLOT(slotUpdateIcons()));
 
     m_d->popupPalette->showPopupPalette(false);
 }
 
-void KisCanvas2::slotZoomChanged(int zoom ) {
+void KisCanvas2::slotPopupPaletteRequestedZoomChange(int zoom ) {
     m_d->view->viewManager()->zoomController()->setZoom(KoZoomMode::ZOOM_CONSTANT, (qreal)(zoom/100.0)); // 1.0 is 100% zoom
     notifyZoomChanged();
 }
 
 void KisCanvas2::setCursor(const QCursor &cursor)
 {
     canvasWidget()->setCursor(cursor);
 }
 
 KisAnimationFrameCacheSP KisCanvas2::frameCache() const
 {
     return m_d->frameCache;
 }
 
 KisAnimationPlayer *KisCanvas2::animationPlayer() const
 {
     return m_d->animationPlayer;
 }
 
 void KisCanvas2::slotSelectionChanged()
 {
     KisShapeLayer* shapeLayer = dynamic_cast<KisShapeLayer*>(viewManager()->activeLayer().data());
     if (!shapeLayer) {
         return;
     }
     m_d->shapeManager.selection()->deselectAll();
     Q_FOREACH (KoShape* shape, shapeLayer->shapeManager()->selection()->selectedShapes()) {
         m_d->shapeManager.selection()->select(shape);
     }
 }
 
 bool KisCanvas2::isPopupPaletteVisible() const
 {
     if (!m_d->popupPalette) {
         return false;
     }
     return m_d->popupPalette->isVisible();
 }
 
 
 void KisCanvas2::setWrapAroundViewingMode(bool value)
 {
     KisCanvasDecorationSP infinityDecoration =
         m_d->canvasWidget->decoration(INFINITY_DECORATION_ID);
 
     if (infinityDecoration) {
         infinityDecoration->setVisible(!value);
     }
 
     m_d->canvasWidget->setWrapAroundViewingMode(value);
 }
 
 bool KisCanvas2::wrapAroundViewingMode() const
 {
     KisCanvasDecorationSP infinityDecoration =
         m_d->canvasWidget->decoration(INFINITY_DECORATION_ID);
 
     if (infinityDecoration) {
         return !(infinityDecoration->visible());
     }
     return false;
 }
 
 void KisCanvas2::bootstrapFinished()
 {
     if (!m_d->bootstrapLodBlocked) return;
 
     m_d->bootstrapLodBlocked = false;
-    setLodAllowedInCanvas(m_d->lodAllowedInCanvas);
+    setLodAllowedInCanvas(m_d->lodAllowedInImage);
 }
 
 void KisCanvas2::setLodAllowedInCanvas(bool value)
 {
     if (!KisOpenGL::supportsLoD()) {
         qWarning() << "WARNING: Level of Detail functionality is available only with openGL + GLSL 1.3 support";
     }
 
-    m_d->lodAllowedInCanvas =
-            value &&
-            m_d->currentCanvasIsOpenGL &&
-            KisOpenGL::supportsLoD() &&
-            (m_d->openGLFilterMode == KisOpenGL::TrilinearFilterMode ||
-             m_d->openGLFilterMode == KisOpenGL::HighQualityFiltering);
+    m_d->lodAllowedInImage =
+        value &&
+        m_d->currentCanvasIsOpenGL &&
+        KisOpenGL::supportsLoD() &&
+        (m_d->openGLFilterMode == KisOpenGL::TrilinearFilterMode ||
+         m_d->openGLFilterMode == KisOpenGL::HighQualityFiltering);
 
     KisImageSP image = this->image();
 
-    if (m_d->effectiveLodAllowedInCanvas() != !image->levelOfDetailBlocked()) {
-
-        image->setLevelOfDetailBlocked(!m_d->effectiveLodAllowedInCanvas());
-        notifyLevelOfDetailChange();
+    if (m_d->effectiveLodAllowedInImage() != !image->levelOfDetailBlocked()) {
+        image->setLevelOfDetailBlocked(!m_d->effectiveLodAllowedInImage());
     }
 
+    notifyLevelOfDetailChange();
+
     KisConfig cfg;
-    cfg.setLevelOfDetailEnabled(m_d->lodAllowedInCanvas);
+    cfg.setLevelOfDetailEnabled(m_d->lodAllowedInImage);
 }
 
 bool KisCanvas2::lodAllowedInCanvas() const
 {
-    return m_d->lodAllowedInCanvas;
+    return m_d->lodAllowedInImage;
 }
 
 void KisCanvas2::slotShowPopupPalette(const QPoint &p)
 {
     if (!m_d->popupPalette) {
         return;
     }
 
     m_d->popupPalette->showPopupPalette(p);
 }
 
 KisPaintingAssistantsDecorationSP KisCanvas2::paintingAssistantsDecoration() const
 {
     KisCanvasDecorationSP deco = decoration("paintingAssistantsDecoration");
     return qobject_cast<KisPaintingAssistantsDecoration*>(deco.data());
 }
 
 KisReferenceImagesDecorationSP KisCanvas2::referenceImagesDecoration() const
 {
     KisCanvasDecorationSP deco = decoration("referenceImagesDecoration");
     return qobject_cast<KisReferenceImagesDecoration*>(deco.data());
 }
diff --git a/libs/ui/canvas/kis_canvas2.h b/libs/ui/canvas/kis_canvas2.h
index be9854b337..5ca115794a 100644
--- a/libs/ui/canvas/kis_canvas2.h
+++ b/libs/ui/canvas/kis_canvas2.h
@@ -1,320 +1,341 @@
 /* This file is part of the KDE project
  * Copyright (C) 2006, 2010 Boudewijn Rempt <boud@valdyas.org>
  * Copyright (C) 2011       Silvio Heinrich <plassy@web.de>
  *
  *  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_CANVAS_H
 #define KIS_CANVAS_H
 
 #include <QObject>
 #include <QWidget>
 #include <QSize>
 #include <QString>
 
 #include <KoConfig.h>
 #include <KoColorConversionTransformation.h>
 #include <KoCanvasBase.h>
 #include <kritaui_export.h>
 #include <kis_types.h>
 #include <KoPointerEvent.h>
 
 #include "opengl/kis_opengl.h"
 
 #include "kis_ui_types.h"
 #include "kis_coordinates_converter.h"
 #include "kis_canvas_decoration.h"
 #include "kis_painting_assistants_decoration.h"
 #include "input/KisInputActionGroup.h"
 #include "KisReferenceImagesDecoration.h"
 
 class KoToolProxy;
 class KoColorProfile;
 
 
 class KisViewManager;
 class KisFavoriteResourceManager;
 class KisDisplayFilter;
 class KisDisplayColorConverter;
 struct KisExposureGammaCorrectionInterface;
 class KisView;
 class KisInputManager;
 class KisAnimationPlayer;
 class KisShapeController;
 class KisCoordinatesConverter;
 class KoViewConverter;
 
 /**
  * KisCanvas2 is not an actual widget class, but rather an adapter for
  * the widget it contains, which may be either a QPainter based
  * canvas, or an OpenGL based canvas: that are the real widgets.
  */
 class KRITAUI_EXPORT KisCanvas2 : public KoCanvasBase, public KisInputActionGroupsMaskInterface
 {
 
     Q_OBJECT
 
 public:
 
     /**
      * Create a new canvas. The canvas manages a widget that will do
      * the actual painting: the canvas itself is not a widget.
      *
      * @param viewConverter the viewconverter for converting between
      *                       window and document coordinates.
      */
     KisCanvas2(KisCoordinatesConverter *coordConverter, KoCanvasResourceManager *resourceManager, KisView *view, KoShapeBasedDocumentBase *sc);
 
     ~KisCanvas2() override;
 
     void notifyZoomChanged();
 
     void disconnectCanvasObserver(QObject *object) override;
 
 public: // KoCanvasBase implementation
 
     bool canvasIsOpenGL() const override;
 
     KisOpenGL::FilterMode openGLFilterMode() const;
 
     void gridSize(QPointF *offset, QSizeF *spacing) const override;
 
     bool snapToGrid() const override;
 
     // This method only exists to support flake-related operations
     void addCommand(KUndo2Command *command) override;
 
     QPoint documentOrigin() const override;
     QPoint documentOffset() const;
 
     /**
      * Return the right shape manager for the current layer. That is
      * to say, if the current layer is a vector layer, return the shape
      * layer's canvas' shapemanager, else the shapemanager associated
      * with the global krita canvas.
      */
     KoShapeManager * shapeManager() const override;
 
     /**
      * Since shapeManager() may change, we need a persistent object where we can
      * connect to and thack the selection. See more comments in KoCanvasBase.
      */
     KoSelectedShapesProxy *selectedShapesProxy() const override;
 
     /**
      * Return the shape manager associated with this canvas
      */
     KoShapeManager *globalShapeManager() const;
 
     void updateCanvas(const QRectF& rc) override;
 
     void updateInputMethodInfo() override;
 
     const KisCoordinatesConverter* coordinatesConverter() const;
     KoViewConverter *viewConverter() const override;
 
     QWidget* canvasWidget() override;
 
     const QWidget* canvasWidget() const override;
 
     KoUnit unit() const override;
 
     KoToolProxy* toolProxy() const override;
 
     const KoColorProfile* monitorProfile();
 
     // FIXME:
     // Temporary! Either get the current layer and image from the
     // resource provider, or use this, which gets them from the
     // current shape selection.
     KisImageWSP currentImage() const;
 
     /**
      * Filters events and sends them to canvas actions. Shared
      * among all the views/canvases
      *
      * NOTE: May be null while initialization!
      */
     KisInputManager* globalInputManager() const;
 
     /**
      * Return the mask of currently available input action groups
      * Note: Override from KisInputActionGroupsMaskInterface
      */
     KisInputActionGroupsMask inputActionGroupsMask() const override;
 
     /**
      * Set the mask of currently available action groups
      * Note: Override from KisInputActionGroupsMaskInterface
      */
     void setInputActionGroupsMask(KisInputActionGroupsMask mask) override;
 
     KisPaintingAssistantsDecorationSP paintingAssistantsDecoration() const;
     KisReferenceImagesDecorationSP referenceImagesDecoration() const;
 
 public: // KisCanvas2 methods
 
     KisImageWSP image() const;
     KisViewManager* viewManager() const;
     QPointer<KisView> imageView() const;
 
     /// @return true if the canvas image should be displayed in vertically mirrored mode
     void addDecoration(KisCanvasDecorationSP deco);
     KisCanvasDecorationSP decoration(const QString& id) const;
 
     void setDisplayFilter(QSharedPointer<KisDisplayFilter> displayFilter);
     QSharedPointer<KisDisplayFilter> displayFilter() const;
 
     KisDisplayColorConverter *displayColorConverter() const;
     KisExposureGammaCorrectionInterface* exposureGammaCorrectionInterface() const;
 
     /**
      * @brief setProofingOptions
      * set the options for softproofing, without affecting the proofing options as stored inside the image.
      */
     void setProofingOptions(bool softProof, bool gamutCheck);
     KisProofingConfigurationSP proofingConfiguration() const;
 
     /**
      * @brief setProofingConfigUpdated This function is to set whether the proofing config is updated,
      * this is needed for determining whether or not to generate a new proofing transform.
      * @param updated whether it's updated. Just set it to false in normal usage.
      */
     void setProofingConfigUpdated(bool updated);
 
     /**
      * @brief proofingConfigUpdated ask the canvas whether or not it updated the proofing config.
      * @return whether or not the proofing config is updated, if so, a new proofing transform needs to be made
      * in KisOpenGL canvas.
      */
     bool proofingConfigUpdated();
 
     void setCursor(const QCursor &cursor) override;
     KisAnimationFrameCacheSP frameCache() const;
     KisAnimationPlayer *animationPlayer() const;
     void refetchDataFromImage();
 
+    /**
+     * @return area of the image (in image coordinates) that is visible on the canvas
+     * with a small margin selected by the user
+     */
+    QRect regionOfInterest() const;
+
+    /**
+     * Set aftificial limit outside which the image will not be rendered
+     * \p rc is measured in image pixels
+     */
+    void setRenderingLimit(const QRect &rc);
+
+    /**
+     * @return aftificial limit outside which the image will not be rendered
+     */
+    QRect renderingLimit() const;
+
 Q_SIGNALS:
-    void imageChanged(KisImageWSP image);
+    void sigCanvasEngineChanged();
 
     void sigCanvasCacheUpdated();
     void sigContinueResizeImage(qint32 w, qint32 h);
 
     void documentOffsetUpdateFinished();
 
     // emitted whenever the canvas widget thinks sketch should update
     void updateCanvasRequested(const QRect &rc);
 
+    void sigRegionOfInterestChanged(const QRect &roi);
+
 public Q_SLOTS:
 
     /// Update the entire canvas area
     void updateCanvas();
 
     void startResizingImage();
     void finishResizingImage(qint32 w, qint32 h);
 
     /// canvas rotation in degrees
     qreal rotationAngle() const;
     /// Bools indicating canvasmirroring.
     bool xAxisMirrored() const;
     bool yAxisMirrored() const;
     void slotSoftProofing(bool softProofing);
     void slotGamutCheck(bool gamutCheck);
     void slotChangeProofingConfig();
-    void slotZoomChanged(int zoom);
+    void slotPopupPaletteRequestedZoomChange(int zoom);
 
     void channelSelectionChanged();
 
     /**
      * Called whenever the display monitor profile resource changes
      */
     void slotSetDisplayProfile(const KoColorProfile *profile);
     void startUpdateInPatches(const QRect &imageRect);
 
     void slotTrySwitchShapeManager();
 
     /**
      * Called whenever the configuration settings change.
      */
     void slotConfigChanged();
 
 
 private Q_SLOTS:
 
     /// The image projection has changed, now start an update
     /// of the canvas representation.
     void startUpdateCanvasProjection(const QRect & rc);
     void updateCanvasProjection();
 
 
     /**
      * Called whenever the view widget needs to show a different part of
      * the document
      *
      * @param documentOffset the offset in widget pixels
      */
     void documentOffsetMoved(const QPoint &documentOffset);
 
     void slotSelectionChanged();
 
     void slotDoCanvasUpdate();
 
     void bootstrapFinished();
 
+    void slotUpdateRegionOfInterest();
+
 public:
 
     bool isPopupPaletteVisible() const;
     void slotShowPopupPalette(const QPoint& = QPoint(0,0));
 
     // interface for KisCanvasController only
     void setWrapAroundViewingMode(bool value);
     bool wrapAroundViewingMode() const;
 
     void setLodAllowedInCanvas(bool value);
     bool lodAllowedInCanvas() const;
 
     void initializeImage();
 
     void setFavoriteResourceManager(KisFavoriteResourceManager* favoriteResourceManager);
 
 private:
     Q_DISABLE_COPY(KisCanvas2)
 
     void connectCurrentCanvas();
     void createCanvas(bool useOpenGL);
     void createQPainterCanvas();
     void createOpenGLCanvas();
     void updateCanvasWidgetImpl(const QRect &rc = QRect());
     void setCanvasWidget(QWidget *widget);
     void resetCanvas(bool useOpenGL);
 
     void notifyLevelOfDetailChange();
 
     // Completes construction of canvas.
     // To be called by KisView in its constructor, once it has been setup enough
     // (to be defined what that means) for things KisCanvas2 expects from KisView
     // TODO: see to avoid that
     void setup();
 
     void initializeFpsDecoration();
 
 private:
     friend class KisView; // calls setup()
     class KisCanvas2Private;
     KisCanvas2Private * const m_d;
 };
 
 #endif
diff --git a/libs/ui/canvas/kis_coordinates_converter.cpp b/libs/ui/canvas/kis_coordinates_converter.cpp
index 36f6aa4805..80b2a889a6 100644
--- a/libs/ui/canvas/kis_coordinates_converter.cpp
+++ b/libs/ui/canvas/kis_coordinates_converter.cpp
@@ -1,441 +1,446 @@
 /*
  *  Copyright (c) 2010 Dmitry Kazakov <dimula73@gmail.com>
  *  Copyright (c) 2011 Silvio Heinrich <plassy@web.de>
  *
  *  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 <cmath>
 
 #include "kis_coordinates_converter.h"
 
 #include <QTransform>
 #include <KoViewConverter.h>
 
 #include <kis_config.h>
 #include <kis_image.h>
 
 
 struct KisCoordinatesConverter::Private {
     Private():
         isXAxisMirrored(false), isYAxisMirrored(false), rotationAngle(0.0) { }
 
     KisImageWSP image;
 
     bool isXAxisMirrored;
     bool isYAxisMirrored;
     qreal rotationAngle;
     QSizeF canvasWidgetSize;
     QPointF documentOffset;
 
     QTransform flakeToWidget;
     QTransform imageToDocument;
     QTransform documentToFlake;
     QTransform widgetToViewport;
 };
 
 /**
  * When vastScrolling value is less than 0.5 it is possible
  * that the whole scrolling area (viewport) will be smaller than
  * the size of the widget. In such cases the image should be
  * centered in the widget. Previously we used a special parameter
  * documentOrigin for this purpose, now the value for this
  * centering is calculated dynamically, helping the offset to
  * center the image inside the widget
  *
  * Note that the correction is null when the size of the document
  * plus vast scrolling reserve is larger than the widget. This
  * is always true for vastScrolling parameter > 0.5.
  */
 
 QPointF KisCoordinatesConverter::centeringCorrection() const
 {
     KisConfig cfg;
 
     QSize documentSize = imageRectInWidgetPixels().toAlignedRect().size();
     QPointF dPoint(documentSize.width(), documentSize.height());
     QPointF wPoint(m_d->canvasWidgetSize.width(), m_d->canvasWidgetSize.height());
 
     QPointF minOffset = -cfg.vastScrolling() * wPoint;
     QPointF maxOffset = dPoint - wPoint + cfg.vastScrolling() * wPoint;
 
     QPointF range = maxOffset - minOffset;
 
     range.rx() = qMin(range.x(), (qreal)0.0);
     range.ry() = qMin(range.y(), (qreal)0.0);
 
     range /= 2;
 
     return -range;
 }
 
 /**
  * The document offset and the position of the top left corner of the
  * image must always coincide, that is why we need to correct them to
  * and fro.
  *
  * When we change zoom level, the calculation of the new offset is
  * done by KoCanvasControllerWidget, that is why we just passively fix
  * the flakeToWidget transform to conform the offset and wait until
  * the canvas controller will recenter us.
  *
  * But when we do our own transformations of the canvas, like rotation
  * and mirroring, we cannot rely on the centering of the canvas
  * controller and we do it ourselves. Then we just set new offset and
  * return its value to be set in the canvas controller explicitly.
  */
 
 void KisCoordinatesConverter::correctOffsetToTransformation()
 {
     m_d->documentOffset = -(imageRectInWidgetPixels().topLeft() -
           centeringCorrection()).toPoint();
 }
 
 void KisCoordinatesConverter::correctTransformationToOffset()
 {
     QPointF topLeft = imageRectInWidgetPixels().topLeft();
     QPointF diff = (-topLeft) - m_d->documentOffset;
     diff += centeringCorrection();
     m_d->flakeToWidget *= QTransform::fromTranslate(diff.x(), diff.y());
 }
 
 void KisCoordinatesConverter::recalculateTransformations()
 {
     if(!m_d->image) return;
 
     m_d->imageToDocument = QTransform::fromScale(1 / m_d->image->xRes(),
                                                  1 / m_d->image->yRes());
 
     qreal zoomX, zoomY;
     KoZoomHandler::zoom(&zoomX, &zoomY);
     m_d->documentToFlake = QTransform::fromScale(zoomX, zoomY);
 
     correctTransformationToOffset();
 
     QRectF irect = imageRectInWidgetPixels();
     QRectF wrect = QRectF(QPoint(0,0), m_d->canvasWidgetSize);
     QRectF rrect = irect & wrect;
 
     QTransform reversedTransform = flakeToWidgetTransform().inverted();
     QRectF     canvasBounds      = reversedTransform.mapRect(rrect);
     QPointF    offset            = canvasBounds.topLeft();
 
     m_d->widgetToViewport = reversedTransform * QTransform::fromTranslate(-offset.x(), -offset.y());
 }
 
 
 KisCoordinatesConverter::KisCoordinatesConverter()
     : m_d(new Private) { }
 
 KisCoordinatesConverter::~KisCoordinatesConverter()
 {
     delete m_d;
 }
 
 void KisCoordinatesConverter::setCanvasWidgetSize(QSize size)
 {
     m_d->canvasWidgetSize = size;
     recalculateTransformations();
 }
 
 void KisCoordinatesConverter::setImage(KisImageWSP image)
 {
     m_d->image = image;
     recalculateTransformations();
 }
 
 void KisCoordinatesConverter::setDocumentOffset(const QPoint& offset)
 {
     QPointF diff = m_d->documentOffset - offset;
 
     m_d->documentOffset = offset;
     m_d->flakeToWidget *= QTransform::fromTranslate(diff.x(), diff.y());
     recalculateTransformations();
 }
 
 QPoint KisCoordinatesConverter::documentOffset() const
 {
     return QPoint(int(m_d->documentOffset.x()), int(m_d->documentOffset.y()));
 }
 
 qreal KisCoordinatesConverter::rotationAngle() const
 {
     return m_d->rotationAngle;
 }
 
 void KisCoordinatesConverter::setZoom(qreal zoom)
 {
     KoZoomHandler::setZoom(zoom);
     recalculateTransformations();
 }
 
 qreal KisCoordinatesConverter::effectiveZoom() const
 {
     qreal scaleX, scaleY;
     this->imageScale(&scaleX, &scaleY);
 
     if (scaleX != scaleY) {
         qWarning() << "WARNING: Zoom is not isotropic!"  << ppVar(scaleX) << ppVar(scaleY) << ppVar(qFuzzyCompare(scaleX, scaleY));
     }
 
     // zoom by average of x and y
     return 0.5 * (scaleX + scaleY);
 }
 
 QPoint KisCoordinatesConverter::rotate(QPointF center, qreal angle)
 {
     QTransform rot;
     rot.rotate(angle);
 
     m_d->flakeToWidget *= QTransform::fromTranslate(-center.x(),-center.y());
     m_d->flakeToWidget *= rot;
     m_d->flakeToWidget *= QTransform::fromTranslate(center.x(), center.y());
     m_d->rotationAngle = std::fmod(m_d->rotationAngle + angle, 360.0);
 
     correctOffsetToTransformation();
     recalculateTransformations();
 
     return m_d->documentOffset.toPoint();
 }
 
 QPoint KisCoordinatesConverter::mirror(QPointF center, bool mirrorXAxis, bool mirrorYAxis)
 {
     bool keepOrientation = false; // XXX: Keep here for now, maybe some day we can restore the parameter again.
 
     bool       doXMirroring = m_d->isXAxisMirrored ^ mirrorXAxis;
     bool       doYMirroring = m_d->isYAxisMirrored ^ mirrorYAxis;
     qreal      scaleX       = doXMirroring ? -1.0 : 1.0;
     qreal      scaleY       = doYMirroring ? -1.0 : 1.0;
     QTransform mirror       = QTransform::fromScale(scaleX, scaleY);
 
     QTransform rot;
     rot.rotate(m_d->rotationAngle);
 
     m_d->flakeToWidget *= QTransform::fromTranslate(-center.x(),-center.y());
 
     if (keepOrientation) {
         m_d->flakeToWidget *= rot.inverted();
     }
 
     m_d->flakeToWidget *= mirror;
 
     if (keepOrientation) {
         m_d->flakeToWidget *= rot;
     }
 
     m_d->flakeToWidget *= QTransform::fromTranslate(center.x(),center.y());
 
 
     if (!keepOrientation && (doXMirroring ^ doYMirroring)) {
         m_d->rotationAngle = -m_d->rotationAngle;
     }
 
     m_d->isXAxisMirrored = mirrorXAxis;
     m_d->isYAxisMirrored = mirrorYAxis;
 
     correctOffsetToTransformation();
     recalculateTransformations();
 
     return m_d->documentOffset.toPoint();
 }
 
 bool KisCoordinatesConverter::xAxisMirrored() const
 {
     return m_d->isXAxisMirrored;
 }
 
 bool KisCoordinatesConverter::yAxisMirrored() const
 {
     return m_d->isYAxisMirrored;
 }
 
 QPoint KisCoordinatesConverter::resetRotation(QPointF center)
 {
     QTransform rot;
     rot.rotate(-m_d->rotationAngle);
 
     m_d->flakeToWidget *= QTransform::fromTranslate(-center.x(), -center.y());
     m_d->flakeToWidget *= rot;
     m_d->flakeToWidget *= QTransform::fromTranslate(center.x(), center.y());
     m_d->rotationAngle = 0.0;
 
     correctOffsetToTransformation();
     recalculateTransformations();
 
     return m_d->documentOffset.toPoint();
 }
 
 QTransform KisCoordinatesConverter::imageToWidgetTransform() const{
     return m_d->imageToDocument * m_d->documentToFlake * m_d->flakeToWidget;
 }
 
 QTransform KisCoordinatesConverter::imageToDocumentTransform() const {
     return m_d->imageToDocument;
 }
 
 QTransform KisCoordinatesConverter::documentToFlakeTransform() const {
     return m_d->documentToFlake;
 }
 
 QTransform KisCoordinatesConverter::flakeToWidgetTransform() const {
     return m_d->flakeToWidget;
 }
 
 QTransform KisCoordinatesConverter::documentToWidgetTransform() const
 {
     return m_d->documentToFlake * m_d->flakeToWidget;
 }
 
 QTransform KisCoordinatesConverter::viewportToWidgetTransform() const {
     return m_d->widgetToViewport.inverted();
 }
 
 QTransform KisCoordinatesConverter::imageToViewportTransform() const {
     return m_d->imageToDocument * m_d->documentToFlake * m_d->flakeToWidget * m_d->widgetToViewport;
 }
 
 void KisCoordinatesConverter::getQPainterCheckersInfo(QTransform *transform,
                                                       QPointF *brushOrigin,
                                                       QPolygonF *polygon,
                                                       const bool scrollCheckers) const
 {
     /**
      * Qt has different rounding for QPainter::drawRect/drawImage.
      * The image is rounded mathematically, while rect in aligned
      * to the next integer. That causes transparent line appear on
      * the canvas.
      *
      * See: https://bugreports.qt.nokia.com/browse/QTBUG-22827
      */
 
     QRectF imageRect = imageRectInViewportPixels();
     imageRect.adjust(0,0,-0.5,-0.5);
 
     if (scrollCheckers) {
         *transform = viewportToWidgetTransform();
         *polygon = imageRect;
         *brushOrigin = imageToViewport(QPointF(0,0));
     }
     else {
         *transform = QTransform();
         *polygon = viewportToWidgetTransform().map(imageRect);
         *brushOrigin = QPoint(0,0);
     }
 }
 
 void KisCoordinatesConverter::getOpenGLCheckersInfo(const QRectF &viewportRect,
                                                     QTransform *textureTransform,
                                                     QTransform *modelTransform,
                                                     QRectF *textureRect,
                                                     QRectF *modelRect,
                                                     const bool scrollCheckers) const
 {
     if(scrollCheckers) {
         *textureTransform = QTransform();
         *textureRect = QRectF(0, 0, viewportRect.width(),viewportRect.height());
     }
     else {
         *textureTransform = viewportToWidgetTransform();
         *textureRect = viewportRect;
     }
 
     *modelTransform = viewportToWidgetTransform();
     *modelRect = viewportRect;
 }
 
 QPointF KisCoordinatesConverter::imageCenterInWidgetPixel() const
 {
     if(!m_d->image)
         return QPointF();
 
     QPolygonF poly = imageToWidget(QPolygon(m_d->image->bounds()));
     return (poly[0] + poly[1] + poly[2] + poly[3]) / 4.0;
 }
 
 
 // these functions return a bounding rect if the canvas is rotated
 
 QRectF KisCoordinatesConverter::imageRectInWidgetPixels() const
 {
     if(!m_d->image) return QRectF();
     return imageToWidget(m_d->image->bounds());
 }
 
 QRectF KisCoordinatesConverter::imageRectInViewportPixels() const
 {
     if(!m_d->image) return QRectF();
     return imageToViewport(m_d->image->bounds());
 }
 
 QRect KisCoordinatesConverter::imageRectInImagePixels() const
 {
     if(!m_d->image) return QRect();
     return m_d->image->bounds();
 }
 
 QRectF KisCoordinatesConverter::imageRectInDocumentPixels() const
 {
     if(!m_d->image) return QRectF();
     return imageToDocument(m_d->image->bounds());
 }
 
 QSizeF KisCoordinatesConverter::imageSizeInFlakePixels() const
 {
     if(!m_d->image) return QSizeF();
 
     qreal scaleX, scaleY;
     imageScale(&scaleX, &scaleY);
     QSize imageSize = m_d->image->size();
 
     return QSizeF(imageSize.width() * scaleX, imageSize.height() * scaleY);
 }
 
 QRectF KisCoordinatesConverter::widgetRectInFlakePixels() const
 {
     return widgetToFlake(QRectF(QPoint(0,0), m_d->canvasWidgetSize));
 }
 
+QRectF KisCoordinatesConverter::widgetRectInImagePixels() const
+{
+    return widgetToImage(QRectF(QPoint(0,0), m_d->canvasWidgetSize));
+}
+
 QPointF KisCoordinatesConverter::flakeCenterPoint() const
 {
     QRectF widgetRect = widgetRectInFlakePixels();
     return QPointF(widgetRect.left() + widgetRect.width() / 2,
                    widgetRect.top() + widgetRect.height() / 2);
 }
 
 QPointF KisCoordinatesConverter::widgetCenterPoint() const
 {
     return QPointF(m_d->canvasWidgetSize.width() / 2.0, m_d->canvasWidgetSize.height() / 2.0);
 }
 
 void KisCoordinatesConverter::imageScale(qreal *scaleX, qreal *scaleY) const
 {
     if(!m_d->image) {
         *scaleX = 1.0;
         *scaleY = 1.0;
         return;
     }
 
     // get the x and y zoom level of the canvas
     qreal zoomX, zoomY;
     KoZoomHandler::zoom(&zoomX, &zoomY);
 
     // Get the KisImage resolution
     qreal resX = m_d->image->xRes();
     qreal resY = m_d->image->yRes();
 
     // Compute the scale factors
     *scaleX = zoomX / resX;
     *scaleY = zoomY / resY;
 }
diff --git a/libs/ui/canvas/kis_coordinates_converter.h b/libs/ui/canvas/kis_coordinates_converter.h
index e7ce76b2c9..8ac87183c8 100644
--- a/libs/ui/canvas/kis_coordinates_converter.h
+++ b/libs/ui/canvas/kis_coordinates_converter.h
@@ -1,163 +1,164 @@
 /*
  *  Copyright (c) 2010 Dmitry Kazakov <dimula73@gmail.com>
  *  Copyright (c) 2011 Silvio Heinrich <plassy@web.de>
  *
  *  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_COORDINATES_CONVERTER_H
 #define KIS_COORDINATES_CONVERTER_H
 
 #include <QTransform>
 #include <KoZoomHandler.h>
 
 #include "kritaui_export.h"
 #include "kis_types.h"
 
 #define EPSILON 1e-6
 
 #define SCALE_LESS_THAN(scX, scY, value)                        \
     (scX < (value) - EPSILON && scY < (value) - EPSILON)
 #define SCALE_MORE_OR_EQUAL_TO(scX, scY, value)                 \
     (scX > (value) - EPSILON && scY > (value) - EPSILON)
 
 namespace _Private
 {
     template<class T> struct Traits
     {
         typedef T Result;
         static T map(const QTransform& transform, const T& obj)  { return transform.map(obj); }
     };
 
     template<> struct Traits<QRectF>
     {
         typedef QRectF Result;
         static QRectF map(const QTransform& transform, const QRectF& rc)  { return transform.mapRect(rc); }
     };
 
     template<> struct Traits<QRect>:    public Traits<QRectF>    { };
     template<> struct Traits<QPoint>:   public Traits<QPointF>   { };
     template<> struct Traits<QPolygon>: public Traits<QPolygonF> { };
     template<> struct Traits<QLine>:    public Traits<QLineF>    { };
 }
 
 class KRITAUI_EXPORT KisCoordinatesConverter: public KoZoomHandler
 {
 public:
     KisCoordinatesConverter();
     ~KisCoordinatesConverter() override;
 
     void setCanvasWidgetSize(QSize size);
     void setImage(KisImageWSP image);
     void setDocumentOffset(const QPoint &offset);
 
     QPoint documentOffset() const;
     qreal rotationAngle() const;
 
     QPoint rotate(QPointF center, qreal angle);
     QPoint mirror(QPointF center, bool mirrorXAxis, bool mirrorYAxis);
     bool xAxisMirrored() const;
     bool yAxisMirrored() const;
     QPoint resetRotation(QPointF center);
 
     void setZoom(qreal zoom) override;
 
     /**
      * A composition of to scale methods: zoom level + image resolution
      */
     qreal effectiveZoom() const;
 
     template<class T> typename _Private::Traits<T>::Result
     imageToViewport(const T& obj) const { return _Private::Traits<T>::map(imageToViewportTransform(), obj); }
     template<class T> typename _Private::Traits<T>::Result
     viewportToImage(const T& obj) const { return _Private::Traits<T>::map(imageToViewportTransform().inverted(), obj); }
 
     template<class T> typename _Private::Traits<T>::Result
     flakeToWidget(const T& obj) const { return _Private::Traits<T>::map(flakeToWidgetTransform(), obj); }
     template<class T> typename _Private::Traits<T>::Result
     widgetToFlake(const T& obj) const { return _Private::Traits<T>::map(flakeToWidgetTransform().inverted(), obj); }
 
     template<class T> typename _Private::Traits<T>::Result
     widgetToViewport(const T& obj) const { return _Private::Traits<T>::map(viewportToWidgetTransform().inverted(), obj); }
     template<class T> typename _Private::Traits<T>::Result
     viewportToWidget(const T& obj) const { return _Private::Traits<T>::map(viewportToWidgetTransform(), obj); }
 
     template<class T> typename _Private::Traits<T>::Result
     documentToWidget(const T& obj) const { return _Private::Traits<T>::map(documentToWidgetTransform(), obj); }
     template<class T> typename _Private::Traits<T>::Result
     widgetToDocument(const T& obj) const { return _Private::Traits<T>::map(documentToWidgetTransform().inverted(), obj); }
 
     template<class T> typename _Private::Traits<T>::Result
     imageToDocument(const T& obj) const { return _Private::Traits<T>::map(imageToDocumentTransform(), obj); }
     template<class T> typename _Private::Traits<T>::Result
     documentToImage(const T& obj) const { return _Private::Traits<T>::map(imageToDocumentTransform().inverted(), obj); }
 
     template<class T> typename _Private::Traits<T>::Result
     documentToFlake(const T& obj) const { return _Private::Traits<T>::map(documentToFlakeTransform(), obj); }
     template<class T> typename _Private::Traits<T>::Result
     flakeToDocument(const T& obj) const { return _Private::Traits<T>::map(documentToFlakeTransform().inverted(), obj); }
 
     template<class T> typename _Private::Traits<T>::Result
     imageToWidget(const T& obj) const { return _Private::Traits<T>::map(imageToWidgetTransform(), obj); }
     template<class T> typename _Private::Traits<T>::Result
     widgetToImage(const T& obj) const { return _Private::Traits<T>::map(imageToWidgetTransform().inverted(), obj); }
 
     QTransform imageToWidgetTransform() const;
     QTransform imageToDocumentTransform() const;
     QTransform documentToFlakeTransform() const;
     QTransform imageToViewportTransform() const;
     QTransform viewportToWidgetTransform() const;
     QTransform flakeToWidgetTransform() const;
     QTransform documentToWidgetTransform() const;
 
     void getQPainterCheckersInfo(QTransform *transform,
                                  QPointF *brushOrigin,
                                  QPolygonF *poligon,
                                  const bool scrollCheckers) const;
 
     void getOpenGLCheckersInfo(const QRectF &viewportRect,
                                QTransform *textureTransform,
                                QTransform *modelTransform,
                                QRectF *textureRect,
                                QRectF *modelRect,
                                const bool scrollCheckers) const;
 
     QPointF imageCenterInWidgetPixel() const;
     QRectF imageRectInWidgetPixels() const;
     QRectF imageRectInViewportPixels() const;
     QSizeF imageSizeInFlakePixels() const;
     QRectF widgetRectInFlakePixels() const;
+    QRectF widgetRectInImagePixels() const;
     QRect imageRectInImagePixels() const;
     QRectF imageRectInDocumentPixels() const;
 
     QPointF flakeCenterPoint() const;
     QPointF widgetCenterPoint() const;
 
     void imageScale(qreal *scaleX, qreal *scaleY) const;
 
 private:
     friend class KisZoomAndPanTest;
 
     QPointF centeringCorrection() const;
     void correctOffsetToTransformation();
     void correctTransformationToOffset();
     void recalculateTransformations();
 
 private:
     struct Private;
     Private * const m_d;
 };
 
 #endif /* KIS_COORDINATES_CONVERTER_H */
diff --git a/libs/ui/canvas/kis_update_info.cpp b/libs/ui/canvas/kis_update_info.cpp
index 58e2b5b6e4..9640d43735 100644
--- a/libs/ui/canvas/kis_update_info.cpp
+++ b/libs/ui/canvas/kis_update_info.cpp
@@ -1,102 +1,98 @@
 /*
  *  Copyright (c) 2010, Dmitry Kazakov <dimula73@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_update_info.h"
 
 /**
  * The connection in KisCanvas2 uses queued signals
  * with an argument of KisNodeSP type, so we should
  * register it beforehand
  */
 struct KisUpdateInfoSPStaticRegistrar {
     KisUpdateInfoSPStaticRegistrar() {
         qRegisterMetaType<KisUpdateInfoSP>("KisUpdateInfoSP");
     }
 };
 static KisUpdateInfoSPStaticRegistrar __registrar;
 
 KisUpdateInfo::KisUpdateInfo()
 {
 }
 
 KisUpdateInfo::~KisUpdateInfo()
 {
 }
 
 QRect KisUpdateInfo::dirtyViewportRect()
 {
     return QRect();
 }
 
 QRect KisPPUpdateInfo::dirtyViewportRect() {
     return viewportRect.toAlignedRect();
 }
 
 QRect KisPPUpdateInfo::dirtyImageRect() const {
     return dirtyImageRectVar;
 }
 
 int KisPPUpdateInfo::levelOfDetail() const
 {
     return 0;
 }
 
-KisOpenGLUpdateInfo::KisOpenGLUpdateInfo(ConversionOptions options)
-    : m_options(options),
-      m_levelOfDetail(0)
+KisOpenGLUpdateInfo::KisOpenGLUpdateInfo()
+    : m_levelOfDetail(0)
 {
 }
 
 QRect KisOpenGLUpdateInfo::dirtyViewportRect() {
     qFatal("Not implemented yet!");
     return QRect();
 }
 
 void KisOpenGLUpdateInfo::assignDirtyImageRect(const QRect &rect)
 {
     m_dirtyImageRect = rect;
 }
 
 void KisOpenGLUpdateInfo::assignLevelOfDetail(int lod)
 {
     m_levelOfDetail = lod;
 }
 
 QRect KisOpenGLUpdateInfo::dirtyImageRect() const
 {
     return m_dirtyImageRect;
 }
 
-bool KisOpenGLUpdateInfo::needsConversion() const
+int KisOpenGLUpdateInfo::levelOfDetail() const
 {
-    return m_options.m_needsConversion;
+    return m_levelOfDetail;
 }
-void KisOpenGLUpdateInfo::convertColorSpace()
+
+bool KisOpenGLUpdateInfo::tryMergeWith(const KisOpenGLUpdateInfo &rhs)
 {
-    KIS_ASSERT_RECOVER_RETURN(needsConversion());
+    if (m_levelOfDetail != rhs.m_levelOfDetail) return false;
 
-    Q_FOREACH (KisTextureTileUpdateInfoSP tileInfo, tileList) {
-        tileInfo->convertTo(m_options.m_destinationColorSpace,
-                            m_options.m_renderingIntent,
-                            m_options.m_conversionFlags);
-    }
-}
+    // TODO: that makes the algorithm of updates compressor incorrect!
+    m_dirtyImageRect |= rhs.m_dirtyImageRect;
 
-int KisOpenGLUpdateInfo::levelOfDetail() const
-{
-    return m_levelOfDetail;
+    tileList.append(rhs.tileList);
+
+    return true;
 }
diff --git a/libs/ui/canvas/kis_update_info.h b/libs/ui/canvas/kis_update_info.h
index 2106518168..bebf2519cb 100644
--- a/libs/ui/canvas/kis_update_info.h
+++ b/libs/ui/canvas/kis_update_info.h
@@ -1,147 +1,145 @@
 /*
  *  Copyright (c) 2010, Dmitry Kazakov <dimula73@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_UPDATE_INFO_H_
 #define KIS_UPDATE_INFO_H_
 
 #include <QPainter>
 
 #include "kis_image_patch.h"
 #include "kis_shared.h"
 #include "kritaui_export.h"
 #include "opengl/kis_texture_tile_update_info.h"
 
 #include "kis_ui_types.h"
 
 class KRITAUI_EXPORT KisUpdateInfo : public KisShared
 {
 public:
     KisUpdateInfo();
     virtual ~KisUpdateInfo();
 
     virtual QRect dirtyViewportRect();
     virtual QRect dirtyImageRect() const = 0;
     virtual int levelOfDetail() const = 0;
 };
 
 Q_DECLARE_METATYPE(KisUpdateInfoSP)
 
 
 struct ConversionOptions {
     ConversionOptions() : m_needsConversion(false) {}
     ConversionOptions(const KoColorSpace *destinationColorSpace,
                       KoColorConversionTransformation::Intent renderingIntent,
                       KoColorConversionTransformation::ConversionFlags conversionFlags)
         : m_needsConversion(true),
           m_destinationColorSpace(destinationColorSpace),
           m_renderingIntent(renderingIntent),
           m_conversionFlags(conversionFlags)
     {
     }
 
 
     bool m_needsConversion;
     const KoColorSpace *m_destinationColorSpace;
     KoColorConversionTransformation::Intent m_renderingIntent;
     KoColorConversionTransformation::ConversionFlags m_conversionFlags;
 };
 
 class KisOpenGLUpdateInfo;
 typedef KisSharedPtr<KisOpenGLUpdateInfo> KisOpenGLUpdateInfoSP;
 
 class KisOpenGLUpdateInfo : public KisUpdateInfo
 {
 public:
-    KisOpenGLUpdateInfo(ConversionOptions options);
+    KisOpenGLUpdateInfo();
 
     KisTextureTileUpdateInfoSPList tileList;
 
     QRect dirtyViewportRect() override;
     QRect dirtyImageRect() const override;
 
     void assignDirtyImageRect(const QRect &rect);
     void assignLevelOfDetail(int lod);
 
-    bool needsConversion() const;
-    void convertColorSpace();
-
     int levelOfDetail() const override;
 
+    bool tryMergeWith(const KisOpenGLUpdateInfo& rhs);
+
 private:
     QRect m_dirtyImageRect;
-    ConversionOptions m_options;
     int m_levelOfDetail;
 };
 
 
 class KisPPUpdateInfo : public KisUpdateInfo
 {
 public:
     enum TransferType {
         DIRECT,
         PATCH
     };
 
     QRect dirtyViewportRect() override;
     QRect dirtyImageRect() const override;
     int levelOfDetail() const override;
 
     /**
      * The rect that was reported by KisImage as dirty
      */
     QRect dirtyImageRectVar;
 
     /**
      * Rect of KisImage corresponding to @viewportRect.
      * It is cropped and aligned corresponding to the canvas.
      */
     QRect imageRect;
 
     /**
      * Rect of canvas widget corresponding to @imageRect
      */
     QRectF viewportRect;
 
     qreal scaleX;
     qreal scaleY;
 
     /**
      * Defines the way the source image is painted onto
      * prescaled QImage
      */
     TransferType transfer;
 
     /**
      * Render hints for painting the direct painting/patch painting
      */
     QPainter::RenderHints renderHints;
 
     /**
      * The number of additional pixels those should be added
      * to the patch
      */
     qint32 borderWidth;
 
     /**
      * Used for temporary sorage of KisImage's data
      * by KisProjectionCache
      */
     KisImagePatch patch;
 };
 
 #endif /* KIS_UPDATE_INFO_H_ */
diff --git a/libs/ui/dialogs/KisAsyncAnimationRenderDialogBase.cpp b/libs/ui/dialogs/KisAsyncAnimationRenderDialogBase.cpp
index 28059211fb..622bd2a9e4 100644
--- a/libs/ui/dialogs/KisAsyncAnimationRenderDialogBase.cpp
+++ b/libs/ui/dialogs/KisAsyncAnimationRenderDialogBase.cpp
@@ -1,333 +1,344 @@
 /*
  *  Copyright (c) 2017 Dmitry Kazakov <dimula73@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 "KisAsyncAnimationRenderDialogBase.h"
 
 #include <QEventLoop>
 #include <QProgressDialog>
 #include <QElapsedTimer>
 #include <QApplication>
 #include <QThread>
 #include <QTime>
 #include <QList>
 #include <QtMath>
 
 #include <klocalizedstring.h>
 
 #include "KisViewManager.h"
 #include "KisAsyncAnimationRendererBase.h"
 #include "kis_time_range.h"
 #include "kis_image.h"
 #include "kis_image_config.h"
 #include "kis_memory_statistics_server.h"
 
 #include <vector>
 #include <memory>
 
 namespace {
 struct RendererPair {
     std::unique_ptr<KisAsyncAnimationRendererBase> renderer;
     KisImageSP image;
 
     RendererPair() {}
     RendererPair(KisAsyncAnimationRendererBase *_renderer, KisImageSP _image)
         : renderer(_renderer),
           image(_image)
     {
     }
     RendererPair(RendererPair &&rhs)
         : renderer(std::move(rhs.renderer)),
           image(rhs.image)
     {
     }
 };
 
 int calculateNumberMemoryAllowedClones(KisImageSP image)
 {
     KisMemoryStatisticsServer::Statistics stats =
         KisMemoryStatisticsServer::instance()
         ->fetchMemoryStatistics(image);
 
     const qint64 allowedMemory = 0.8 * stats.tilesHardLimit - stats.realMemorySize;
     const qint64 cloneSize = stats.projectionsSize;
 
     return cloneSize > 0 ? allowedMemory / cloneSize : 0;
 }
 
 }
 
 
 struct KisAsyncAnimationRenderDialogBase::Private
 {
     Private(const QString &_actionTitle, KisImageSP _image, int _busyWait)
         : actionTitle(_actionTitle),
           image(_image),
           busyWait(_busyWait)
     {
     }
 
     QString actionTitle;
     KisImageSP image;
     int busyWait;
     bool isBatchMode = false;
 
     std::vector<RendererPair> asyncRenderers;
     bool memoryLimitReached = false;
 
     QElapsedTimer processingTime;
     QScopedPointer<QProgressDialog> progressDialog;
     QEventLoop waitLoop;
 
     QList<int> stillDirtyFrames;
     QList<int> framesInProgress;
     int dirtyFramesCount = 0;
     Result result = RenderComplete;
+    QRegion regionOfInterest;
 
     int numDirtyFramesLeft() const {
         return stillDirtyFrames.size() + framesInProgress.size();
     }
 
 };
 
 KisAsyncAnimationRenderDialogBase::KisAsyncAnimationRenderDialogBase(const QString &actionTitle, KisImageSP image, int busyWait)
     : m_d(new Private(actionTitle, image, busyWait))
 {
 }
 
 KisAsyncAnimationRenderDialogBase::~KisAsyncAnimationRenderDialogBase()
 {
 }
 
 KisAsyncAnimationRenderDialogBase::Result
 KisAsyncAnimationRenderDialogBase::regenerateRange(KisViewManager *viewManager)
 {
     {
         /**
          * Since this method can be called from the places where no
          * view manager is available, we need this manually crafted
          * ugly construction to "try-lock-cance" the image.
          */
 
         bool imageIsIdle = true;
 
         if (viewManager) {
             imageIsIdle = viewManager->blockUntilOperationsFinished(m_d->image);
         } else {
             imageIsIdle = false;
             if (m_d->image->tryBarrierLock(true)) {
                 m_d->image->unlock();
                 imageIsIdle = true;
             }
         }
 
         if (!imageIsIdle) {
             return RenderCancelled;
         }
     }
 
     m_d->stillDirtyFrames = calcDirtyFrames();
     m_d->framesInProgress.clear();
     m_d->result = RenderComplete;
     m_d->dirtyFramesCount = m_d->stillDirtyFrames.size();
 
     if (!m_d->isBatchMode) {
         QWidget *parentWidget = viewManager ? viewManager->mainWindow() : 0;
         m_d->progressDialog.reset(new QProgressDialog(m_d->actionTitle, i18n("Cancel"), 0, 0, parentWidget));
         m_d->progressDialog->setWindowModality(Qt::ApplicationModal);
         m_d->progressDialog->setMinimum(0);
         m_d->progressDialog->setMaximum(m_d->dirtyFramesCount);
         m_d->progressDialog->setMinimumDuration(m_d->busyWait);
         connect(m_d->progressDialog.data(), SIGNAL(canceled()), SLOT(slotCancelRegeneration()));
     }
 
     if (m_d->dirtyFramesCount <= 0) return m_d->result;
 
     m_d->processingTime.start();
 
     KisImageConfig cfg;
 
     const int maxThreads = cfg.maxNumberOfThreads();
     const int numAllowedWorker = 1 + calculateNumberMemoryAllowedClones(m_d->image);
     const int proposedNumWorkers = qMin(m_d->dirtyFramesCount, cfg.frameRenderingClones());
     const int numWorkers = qMin(proposedNumWorkers, numAllowedWorker);
     const int numThreadsPerWorker = qMax(1, qCeil(qreal(maxThreads) / numWorkers));
 
     m_d->memoryLimitReached = numWorkers < proposedNumWorkers;
 
     const int oldWorkingThreadsLimit = m_d->image->workingThreadsLimit();
 
     ENTER_FUNCTION() << ppVar(numWorkers) << ppVar(numThreadsPerWorker);
 
     for (int i = 0; i < numWorkers; i++) {
         // reuse the image for one of the workers
         KisImageSP image = i == numWorkers - 1 ? m_d->image : m_d->image->clone(true);
 
         image->setWorkingThreadsLimit(numThreadsPerWorker);
         KisAsyncAnimationRendererBase *renderer = createRenderer(image);
 
         connect(renderer, SIGNAL(sigFrameCompleted(int)), SLOT(slotFrameCompleted(int)));
         connect(renderer, SIGNAL(sigFrameCancelled(int)), SLOT(slotFrameCancelled(int)));
 
         m_d->asyncRenderers.push_back(RendererPair(renderer, image));
     }
 
     ENTER_FUNCTION() << "Copying done in" << m_d->processingTime.elapsed();
 
     tryInitiateFrameRegeneration();
     updateProgressLabel();
 
     if (m_d->numDirtyFramesLeft() > 0) {
         m_d->waitLoop.exec();
     }
 
     ENTER_FUNCTION() << "Full regeneration done in" << m_d->processingTime.elapsed();
 
     for (auto &pair : m_d->asyncRenderers) {
         KIS_SAFE_ASSERT_RECOVER_NOOP(!pair.renderer->isActive());
         if (viewManager) {
             viewManager->blockUntilOperationsFinishedForced(pair.image);
         } else {
             pair.image->barrierLock(true);
             pair.image->unlock();
         }
 
     }
     m_d->asyncRenderers.clear();
 
     if (viewManager) {
         viewManager->blockUntilOperationsFinishedForced(m_d->image);
     } else {
         m_d->image->barrierLock(true);
         m_d->image->unlock();
     }
 
     m_d->image->setWorkingThreadsLimit(oldWorkingThreadsLimit);
 
     m_d->progressDialog.reset();
 
     return m_d->result;
 }
 
+void KisAsyncAnimationRenderDialogBase::setRegionOfInterest(const QRegion &roi)
+{
+    m_d->regionOfInterest = roi;
+}
+
+QRegion KisAsyncAnimationRenderDialogBase::regionOfInterest() const
+{
+    return m_d->regionOfInterest;
+}
+
 void KisAsyncAnimationRenderDialogBase::slotFrameCompleted(int frame)
 {
     Q_UNUSED(frame);
 
     m_d->framesInProgress.removeOne(frame);
 
     tryInitiateFrameRegeneration();
     updateProgressLabel();
 }
 
 void KisAsyncAnimationRenderDialogBase::slotFrameCancelled(int frame)
 {
     Q_UNUSED(frame);
 
     cancelProcessingImpl(false);
 }
 
 void KisAsyncAnimationRenderDialogBase::slotCancelRegeneration()
 {
     cancelProcessingImpl(true);
 }
 
 void KisAsyncAnimationRenderDialogBase::cancelProcessingImpl(bool isUserCancelled)
 {
     for (auto &pair : m_d->asyncRenderers) {
         if (pair.renderer->isActive()) {
             pair.renderer->cancelCurrentFrameRendering();
         }
         KIS_SAFE_ASSERT_RECOVER_NOOP(!pair.renderer->isActive());
     }
 
     m_d->stillDirtyFrames.clear();
     m_d->framesInProgress.clear();
     m_d->result = isUserCancelled ? RenderCancelled : RenderFailed;
     updateProgressLabel();
 }
 
 
 void KisAsyncAnimationRenderDialogBase::tryInitiateFrameRegeneration()
 {
     bool hadWorkOnPreviousCycle = false;
 
     while (!m_d->stillDirtyFrames.isEmpty()) {
         for (auto &pair : m_d->asyncRenderers) {
             if (!pair.renderer->isActive()) {
                 const int currentDirtyFrame = m_d->stillDirtyFrames.takeFirst();
 
                 initializeRendererForFrame(pair.renderer.get(), pair.image, currentDirtyFrame);
-                pair.renderer->startFrameRegeneration(pair.image, currentDirtyFrame);
+                pair.renderer->startFrameRegeneration(pair.image, currentDirtyFrame, m_d->regionOfInterest);
                 hadWorkOnPreviousCycle = true;
                 m_d->framesInProgress.append(currentDirtyFrame);
                 break;
             }
         }
 
         if (!hadWorkOnPreviousCycle) break;
         hadWorkOnPreviousCycle = false;
     }
 }
 
 void KisAsyncAnimationRenderDialogBase::updateProgressLabel()
 {
     const int processedFramesCount = m_d->dirtyFramesCount - m_d->numDirtyFramesLeft();
 
     const qint64 elapsedMSec = m_d->processingTime.elapsed();
     const qint64 estimatedMSec =
         !processedFramesCount ? 0 :
         elapsedMSec * m_d->dirtyFramesCount / processedFramesCount;
 
     const QTime elapsedTime = QTime::fromMSecsSinceStartOfDay(elapsedMSec);
     const QTime estimatedTime = QTime::fromMSecsSinceStartOfDay(estimatedMSec);
 
     const QString timeFormat = estimatedTime.hour() > 0 ? "HH:mm:ss" : "mm:ss";
 
     const QString elapsedTimeString = elapsedTime.toString(timeFormat);
     const QString estimatedTimeString = estimatedTime.toString(timeFormat);
 
     const QString memoryLimitMessage(
         i18n("\n\nMemory limit is reached!\nThe number of clones is limited to %1\n\n",
              m_d->asyncRenderers.size()));
 
 
     const QString progressLabel(i18n("%1\n\nElapsed: %2\nEstimated: %3\n\n%4",
                                      m_d->actionTitle,
                                      elapsedTimeString,
                                      estimatedTimeString,
                                      m_d->memoryLimitReached ? memoryLimitMessage : QString()));
     if (m_d->progressDialog) {
         m_d->progressDialog->setLabelText(progressLabel);
         m_d->progressDialog->setValue(processedFramesCount);
     }
 
     if (!m_d->numDirtyFramesLeft()) {
         m_d->waitLoop.quit();
     }
 }
 
 
 
 void KisAsyncAnimationRenderDialogBase::setBatchMode(bool value)
 {
     m_d->isBatchMode = value;
 }
 
 bool KisAsyncAnimationRenderDialogBase::batchMode() const
 {
     return m_d->isBatchMode;
 }
diff --git a/libs/ui/dialogs/KisAsyncAnimationRenderDialogBase.h b/libs/ui/dialogs/KisAsyncAnimationRenderDialogBase.h
index 029e5e97a6..f66bdf8795 100644
--- a/libs/ui/dialogs/KisAsyncAnimationRenderDialogBase.h
+++ b/libs/ui/dialogs/KisAsyncAnimationRenderDialogBase.h
@@ -1,140 +1,151 @@
 /*
  *  Copyright (c) 2017 Dmitry Kazakov <dimula73@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 KISASYNCANIMATIONRENDERDIALOGBASE_H
 #define KISASYNCANIMATIONRENDERDIALOGBASE_H
 
 #include <QObject>
 #include "kis_types.h"
 #include "kritaui_export.h"
 
 class KisTimeRange;
 class KisAsyncAnimationRendererBase;
 class KisViewManager;
 
 /**
  * @brief KisAsyncAnimationRenderDialogBase is a special class for rendering multiple
  *        frames of the image and putting them somewhere (saving into a file or just
  *        pushing into an openGL cache)
  *
  * The class handles a lot of boilerplate code for you and optimizes regeneration of
  * the frames using multithreading, according to the user's settings. The responsibilities
  * of the class are the following:
  *
  * Rendering itself:
  *   - fetch the list of dirtly frames using calcDirtyFrames()
  *   - create some clones of the image according to the user's settings
  *     to facilitate multithreaded rendering and processing of the frames
  *   - if the user doesn't have anough RAM, the clones will not be created
  *     (the memory overhead is calculated using "projections" metric of the
  *      statistics server).
  *   - feed the images/threads with dirty frames until the all the frames
  *     are done
  *
  * Progress reporting:
  *   - if batchMode() is false, the user will see a progress dialog showing
  *     the current progress with estimate about total processing timer
  *   - the user can also cancel the regeneration by pressing Cancel button
  *
  * Usage Details:
  *   - one should implement two methods to make the rendering work:
  *     - calcDirtyFrames()
  *     - createRenderer(KisImageSP image)
  *   - these methids will be called on the start of the rendering
  */
 class KRITAUI_EXPORT KisAsyncAnimationRenderDialogBase : public QObject
 {
     Q_OBJECT
 public:
     enum Result {
         RenderComplete,
         RenderCancelled,
         RenderFailed
     };
 
 public:
     /**
      * @brief construct and initialize the dialog
      * @param actionTitle the first line of the status reports that the user sees in the dialog
      * @param image the image that will be as a source of frames. Make sure the image is *not*
      *              locked by the time regenerateRange() is called
      * @param busyWait the dialog will not show for the specified time (in milliseconds)
      */
     KisAsyncAnimationRenderDialogBase(const QString &actionTitle, KisImageSP image, int busyWait = 200);
     virtual ~KisAsyncAnimationRenderDialogBase();
 
     /**
      * @brief start generation of frames and (if not in batch mode) show the dialog
      *
      * The link to view manager is used to barrier lock with visual feedback in the
      * end of the operation
      */
     virtual Result regenerateRange(KisViewManager *viewManager);
 
+    /**
+     * Set area of image that will be regenerated. If \p roi is empty,
+     * full area of the image is regenerated.
+     */
+    void setRegionOfInterest(const QRegion &roi);
+
+    /**
+     * @see setRegionOfInterest()
+     */
+    QRegion regionOfInterest() const;
+
     /**
      * @brief setting batch mode to true will prevent any dialogs or message boxes from
      *        showing on screen. Please take it into account that using batch mode prevents
      *        some potentially dangerous recovery execution paths (e.g. delete the existing
      *        frames in the destination folder). In such case the rendering will be stopped with
      *        RenderFailed result.
      */
     void setBatchMode(bool value);
 
     /**
      * @see setBatchMode
      */
     bool batchMode() const;
 
 private Q_SLOTS:
     void slotFrameCompleted(int frame);
     void slotFrameCancelled(int frame);
 
     void slotCancelRegeneration();
 
 private:
     void tryInitiateFrameRegeneration();
     void updateProgressLabel();
     void cancelProcessingImpl(bool isUserCancelled);
 
 protected:
     /**
      * @brief returns a list of frames that should be regenerated by the dialog
      *
      * Called by the dialog in the very beginning of regenerateRange()
      */
     virtual QList<int> calcDirtyFrames() const = 0;
 
     /**
      * @brief create a renderer object linked to \p image
      *
      * Renderer are special objects that connect to the individual image signals,
      * react on them and fetch the final frames data
      *
      * @see KisAsyncAnimationRendererBase
      */
     virtual KisAsyncAnimationRendererBase* createRenderer(KisImageSP image) = 0;
 
     virtual void initializeRendererForFrame(KisAsyncAnimationRendererBase *renderer,
                                             KisImageSP image, int frame) = 0;
 
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 };
 
 #endif // KISASYNCANIMATIONRENDERDIALOGBASE_H
diff --git a/libs/ui/dialogs/kis_dlg_preferences.cc b/libs/ui/dialogs/kis_dlg_preferences.cc
index 045eedbe6d..f47d0e32a2 100644
--- a/libs/ui/dialogs/kis_dlg_preferences.cc
+++ b/libs/ui/dialogs/kis_dlg_preferences.cc
@@ -1,1374 +1,1400 @@
 /*
  *  preferencesdlg.cc - part of KImageShop
  *
  *  Copyright (c) 1999 Michael Koch <koch@kde.org>
  *  Copyright (c) 2003-2011 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_dlg_preferences.h"
 
 #include <opengl/kis_opengl.h>
 
 #include <QBitmap>
 #include <QCheckBox>
 #include <QCursor>
 #include <QLabel>
 #include <QLayout>
 #include <QLineEdit>
 #include <QPushButton>
 #include <QSlider>
 #include <QToolButton>
 #include <QThread>
 #include <QStandardPaths>
 #include <QGridLayout>
 #include <QRadioButton>
 #include <QGroupBox>
 #include <QMdiArea>
 #include <QMessageBox>
 #include <QDesktopWidget>
 #include <QFileDialog>
 #include <QFormLayout>
 #include <QSettings>
 
 #include <KisDocument.h>
 #include <KoColorProfile.h>
 #include <KisApplication.h>
 #include <KoFileDialog.h>
 #include <KisPart.h>
 #include <KoColorSpaceEngine.h>
 #include <kis_icon.h>
 #include <KoConfig.h>
 #include "KoID.h"
 #include <KoConfigAuthorPage.h>
 #include <KoVBox.h>
 
 #include <klocalizedstring.h>
 #include <kundo2stack.h>
 #include <KoResourcePaths.h>
 #include "kis_action_registry.h"
 #include <kis_image.h>
 #include <squeezedcombobox.h>
 #include "kis_clipboard.h"
 #include "widgets/kis_cmb_idlist.h"
 #include "KoColorSpace.h"
 #include "KoColorSpaceRegistry.h"
 #include "KoColorConversionTransformation.h"
 #include "kis_cursor.h"
 #include "kis_config.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_preference_set_registry.h"
 #include "kis_color_manager.h"
 #include "KisProofingConfiguration.h"
 #include "kis_image_config.h"
 
 #include "slider_and_spin_box_sync.h"
 
 // for the performance update
 #include <kis_cubic_curve.h>
 #include <kis_signals_blocker.h>
 
 #include "input/config/kis_input_configuration_page.h"
 #include "input/wintab/drawpile_tablettester/tablettester.h"
 
 #ifdef Q_OS_WIN
 #  include <kis_tablet_support_win8.h>
 #endif
 
 
 GeneralTab::GeneralTab(QWidget *_parent, const char *_name)
     : WdgGeneralSettings(_parent, _name)
 {
     KisConfig cfg;
 
     //
     // Cursor Tab
     //
     m_cmbCursorShape->addItem(i18n("No Cursor"));
     m_cmbCursorShape->addItem(i18n("Tool Icon"));
     m_cmbCursorShape->addItem(i18n("Arrow"));
     m_cmbCursorShape->addItem(i18n("Small Circle"));
     m_cmbCursorShape->addItem(i18n("Crosshair"));
     m_cmbCursorShape->addItem(i18n("Triangle Righthanded"));
     m_cmbCursorShape->addItem(i18n("Triangle Lefthanded"));
     m_cmbCursorShape->addItem(i18n("Black Pixel"));
     m_cmbCursorShape->addItem(i18n("White Pixel"));
 
     m_cmbCursorShape->setCurrentIndex(cfg.newCursorStyle());
 
     m_cmbOutlineShape->addItem(i18n("No Outline"));
     m_cmbOutlineShape->addItem(i18n("Circle Outline"));
     m_cmbOutlineShape->addItem(i18n("Preview Outline"));
     m_cmbOutlineShape->addItem(i18n("Tilt Outline"));
 
     m_cmbOutlineShape->setCurrentIndex(cfg.newOutlineStyle());
 
     m_showOutlinePainting->setChecked(cfg.showOutlineWhilePainting());
 
     KoColor cursorColor(KoColorSpaceRegistry::instance()->rgb8());
     cursorColor.fromQColor(cfg.getCursorMainColor());
     cursorColorBtutton->setColor(cursorColor);
 
     //
     // Window Tab
     //
     m_cmbMDIType->setCurrentIndex(cfg.readEntry<int>("mdi_viewmode", (int)QMdiArea::TabbedView));
 
     m_backgroundimage->setText(cfg.getMDIBackgroundImage());
     connect(m_bnFileName, SIGNAL(clicked()), SLOT(getBackgroundImage()));
     connect(clearBgImageButton, SIGNAL(clicked()), SLOT(clearBackgroundImage()));
 
     KoColor mdiColor;
     mdiColor.fromQColor(cfg.getMDIBackgroundColor());
     m_mdiColor->setColor(mdiColor);
 
     m_chkRubberBand->setChecked(cfg.readEntry<int>("mdi_rubberband", cfg.useOpenGL()));
 
     m_chkCanvasMessages->setChecked(cfg.showCanvasMessages());
 
     const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
     QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
     m_chkHiDPI->setChecked(kritarc.value("EnableHiDPI", false).toBool());
 
     m_chkSingleApplication->setChecked(kritarc.value("EnableSingleApplication", true).toBool());
 
     //
     // Tools tab
     //
     m_radioToolOptionsInDocker->setChecked(cfg.toolOptionsInDocker());
     m_chkSwitchSelectionCtrlAlt->setChecked(cfg.switchSelectionCtrlAlt());
     chkEnableTouch->setChecked(!cfg.disableTouchOnCanvas());
 
     m_cmbKineticScrollingGesture->addItem(i18n("Disabled"));
     m_cmbKineticScrollingGesture->addItem(i18n("On Touch Drag"));
     m_cmbKineticScrollingGesture->addItem(i18n("On Click Drag"));
 
     m_cmbKineticScrollingGesture->setCurrentIndex(cfg.kineticScrollingGesture());
     m_kineticScrollingSensitivity->setValue(cfg.kineticScrollingSensitivity());
     m_chkKineticScrollingScrollbar->setChecked(cfg.kineticScrollingScrollbar());
 
     //
     // Miscellaneous
     //
     cmbStartupSession->addItem(i18n("Open default window"));
     cmbStartupSession->addItem(i18n("Load previous session"));
     cmbStartupSession->addItem(i18n("Show session manager"));
     cmbStartupSession->setCurrentIndex(cfg.sessionOnStartup());
 
     chkSaveSessionOnQuit->setChecked(cfg.saveSessionOnQuit(false));
 
     int autosaveInterval = cfg.autoSaveInterval();
     //convert to minutes
     m_autosaveSpinBox->setValue(autosaveInterval / 60);
     m_autosaveCheckBox->setChecked(autosaveInterval > 0);
 
     m_chkCompressKra->setChecked(cfg.compressKra());
 
     m_backupFileCheckBox->setChecked(cfg.backupFile());
 
     m_chkConvertOnImport->setChecked(cfg.convertToImageColorspaceOnImport());
 
     m_undoStackSize->setValue(cfg.undoStackLimit());
 
     m_favoritePresetsSpinBox->setValue(cfg.favoritePresets());
 
     chkShowRootLayer->setChecked(cfg.showRootLayer());
 
     m_hideSplashScreen->setChecked(cfg.hideSplashScreen());
 
     KConfigGroup group = KSharedConfig::openConfig()->group("File Dialogs");
     bool dontUseNative = true;
 #ifdef Q_OS_UNIX
     if (qgetenv("XDG_CURRENT_DESKTOP") == "KDE") {
         dontUseNative = false;
     }
 #endif
 #ifdef Q_OS_WIN
     dontUseNative = false;
 #endif
     m_chkNativeFileDialog->setChecked(!group.readEntry("DontUseNativeFileDialog", dontUseNative));
 
     intMaxBrushSize->setValue(cfg.readEntry("maximumBrushSize", 1000));
-
-    m_chkCacheAnimatioInBackground->setChecked(cfg.calculateAnimationCacheInBackground());
-
-
 }
 
 void GeneralTab::setDefault()
 {
     KisConfig cfg;
 
     m_cmbCursorShape->setCurrentIndex(cfg.newCursorStyle(true));
     m_cmbOutlineShape->setCurrentIndex(cfg.newOutlineStyle(true));
     chkShowRootLayer->setChecked(cfg.showRootLayer(true));
     m_autosaveCheckBox->setChecked(cfg.autoSaveInterval(true) > 0);
     //convert to minutes
     m_autosaveSpinBox->setValue(cfg.autoSaveInterval(true) / 60);
     m_undoStackSize->setValue(cfg.undoStackLimit(true));
     m_backupFileCheckBox->setChecked(cfg.backupFile(true));
     m_showOutlinePainting->setChecked(cfg.showOutlineWhilePainting(true));
     m_hideSplashScreen->setChecked(cfg.hideSplashScreen(true));
 
     m_chkNativeFileDialog->setChecked(false);
     intMaxBrushSize->setValue(1000);
 
     m_cmbMDIType->setCurrentIndex((int)QMdiArea::TabbedView);
     m_chkRubberBand->setChecked(cfg.useOpenGL(true));
     m_favoritePresetsSpinBox->setValue(cfg.favoritePresets(true));
     KoColor mdiColor;
     mdiColor.fromQColor(cfg.getMDIBackgroundColor(true));
     m_mdiColor->setColor(mdiColor);
     m_backgroundimage->setText(cfg.getMDIBackgroundImage(true));
     m_chkCanvasMessages->setChecked(cfg.showCanvasMessages(true));
     m_chkCompressKra->setChecked(cfg.compressKra(true));
     m_chkHiDPI->setChecked(false);
     m_chkSingleApplication->setChecked(true);
 
     m_chkHiDPI->setChecked(true);
     m_radioToolOptionsInDocker->setChecked(cfg.toolOptionsInDocker(true));
     m_cmbKineticScrollingGesture->setCurrentIndex(cfg.kineticScrollingGesture(true));
     m_kineticScrollingSensitivity->setValue(cfg.kineticScrollingSensitivity(true));
     m_chkKineticScrollingScrollbar->setChecked(cfg.kineticScrollingScrollbar(true));
     m_chkSwitchSelectionCtrlAlt->setChecked(cfg.switchSelectionCtrlAlt(true));
     chkEnableTouch->setChecked(!cfg.disableTouchOnCanvas(true));
     m_chkConvertOnImport->setChecked(cfg.convertToImageColorspaceOnImport(true));
-    m_chkCacheAnimatioInBackground->setChecked(cfg.calculateAnimationCacheInBackground(true));
 
     KoColor cursorColor(KoColorSpaceRegistry::instance()->rgb8());
     cursorColor.fromQColor(cfg.getCursorMainColor(true));
     cursorColorBtutton->setColor(cursorColor);
 }
 
 CursorStyle GeneralTab::cursorStyle()
 {
     return (CursorStyle)m_cmbCursorShape->currentIndex();
 }
 
 OutlineStyle GeneralTab::outlineStyle()
 {
     return (OutlineStyle)m_cmbOutlineShape->currentIndex();
 }
 
 KisConfig::SessionOnStartup GeneralTab::sessionOnStartup() const
 {
     return (KisConfig::SessionOnStartup)cmbStartupSession->currentIndex();
 }
 
 bool GeneralTab::saveSessionOnQuit() const
 {
     return chkSaveSessionOnQuit->isChecked();
 }
 
 bool GeneralTab::showRootLayer()
 {
     return chkShowRootLayer->isChecked();
 }
 
 int GeneralTab::autoSaveInterval()
 {
     //convert to seconds
     return m_autosaveCheckBox->isChecked() ? m_autosaveSpinBox->value() * 60 : 0;
 }
 
 int GeneralTab::undoStackSize()
 {
     return m_undoStackSize->value();
 }
 
 bool GeneralTab::showOutlineWhilePainting()
 {
     return m_showOutlinePainting->isChecked();
 }
 
 bool GeneralTab::hideSplashScreen()
 {
     return m_hideSplashScreen->isChecked();
 }
 
 int GeneralTab::mdiMode()
 {
     return m_cmbMDIType->currentIndex();
 }
 
 int GeneralTab::favoritePresets()
 {
     return m_favoritePresetsSpinBox->value();
 }
 
 bool GeneralTab::showCanvasMessages()
 {
     return m_chkCanvasMessages->isChecked();
 }
 
 bool GeneralTab::compressKra()
 {
     return m_chkCompressKra->isChecked();
 }
 
 bool GeneralTab::toolOptionsInDocker()
 {
     return m_radioToolOptionsInDocker->isChecked();
 }
 
 int GeneralTab::kineticScrollingGesture()
 {
     return m_cmbKineticScrollingGesture->currentIndex();
 }
 
 int GeneralTab::kineticScrollingSensitivity()
 {
     return m_kineticScrollingSensitivity->value();
 }
 
 bool GeneralTab::kineticScrollingScrollbar()
 {
     return m_chkKineticScrollingScrollbar->isChecked();
 }
 
 bool GeneralTab::switchSelectionCtrlAlt()
 {
     return m_chkSwitchSelectionCtrlAlt->isChecked();
 
 }
 
 bool GeneralTab::convertToImageColorspaceOnImport()
 {
     return m_chkConvertOnImport->isChecked();
 }
 
-bool GeneralTab::calculateAnimationCacheInBackground()
-{
-    return m_chkCacheAnimatioInBackground->isChecked();
-}
-
-
 void GeneralTab::getBackgroundImage()
 {
     KoFileDialog dialog(this, KoFileDialog::OpenFile, "BackgroundImages");
     dialog.setCaption(i18n("Select a Background Image"));
     dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
     dialog.setImageFilters();
 
     QString fn = dialog.filename();
     // dialog box was canceled or somehow no file was selected
     if (fn.isEmpty()) {
         return;
     }
 
     QImage image(fn);
     if (image.isNull()) {
         QMessageBox::warning(this, i18nc("@title:window", "Krita"), i18n("%1 is not a valid image file!", fn));
     }
     else {
         m_backgroundimage->setText(fn);
     }
 }
 
 void GeneralTab::clearBackgroundImage()
 {
     // clearing the background image text will implicitly make the background color be used
     m_backgroundimage->setText("");
 }
 
 #include "kactioncollection.h"
 #include "KisActionsSnapshot.h"
 
 ShortcutSettingsTab::ShortcutSettingsTab(QWidget *parent, const char *name)
     : QWidget(parent)
 {
     setObjectName(name);
 
     QGridLayout * l = new QGridLayout(this);
     l->setMargin(0);
     m_page = new WdgShortcutSettings(this);
     l->addWidget(m_page, 0, 0);
 
 
     m_snapshot.reset(new KisActionsSnapshot);
 
     KActionCollection *collection =
         KisPart::instance()->currentMainwindow()->actionCollection();
 
     Q_FOREACH (QAction *action, collection->actions()) {
         m_snapshot->addAction(action->objectName(), action);
     }
 
     QMap<QString, KActionCollection*> sortedCollections =
         m_snapshot->actionCollections();
 
     for (auto it = sortedCollections.constBegin(); it != sortedCollections.constEnd(); ++it) {
         m_page->addCollection(it.value(), it.key());
     }
 }
 
 ShortcutSettingsTab::~ShortcutSettingsTab()
 {
 }
 
 void ShortcutSettingsTab::setDefault()
 {
     m_page->allDefault();
 }
 
 void ShortcutSettingsTab::saveChanges()
 {
     m_page->save();
     KisActionRegistry::instance()->settingsPageSaved();
 }
 
 void ShortcutSettingsTab::cancelChanges()
 {
     m_page->undo();
 }
 
 ColorSettingsTab::ColorSettingsTab(QWidget *parent, const char *name)
     : QWidget(parent)
 {
     setObjectName(name);
 
     // XXX: Make sure only profiles that fit the specified color model
     // are shown in the profile combos
 
     QGridLayout * l = new QGridLayout(this);
     l->setMargin(0);
     m_page = new WdgColorSettings(this);
     l->addWidget(m_page, 0, 0);
 
     KisConfig cfg;
 
     m_page->chkUseSystemMonitorProfile->setChecked(cfg.useSystemMonitorProfile());
     connect(m_page->chkUseSystemMonitorProfile, SIGNAL(toggled(bool)), this, SLOT(toggleAllowMonitorProfileSelection(bool)));
 
     m_page->cmbWorkingColorSpace->setIDList(KoColorSpaceRegistry::instance()->listKeys());
     m_page->cmbWorkingColorSpace->setCurrent(cfg.workingColorSpace());
 
     m_page->bnAddColorProfile->setIcon(KisIconUtils::loadIcon("document-open"));
     m_page->bnAddColorProfile->setToolTip( i18n("Open Color Profile") );
     connect(m_page->bnAddColorProfile, SIGNAL(clicked()), SLOT(installProfile()));
 
     QFormLayout *monitorProfileGrid = new QFormLayout(m_page->monitorprofileholder);
     for(int i = 0; i < QApplication::desktop()->screenCount(); ++i) {
         QLabel *lbl = new QLabel(i18nc("The number of the screen", "Screen %1:", i + 1));
         m_monitorProfileLabels << lbl;
         SqueezedComboBox *cmb = new SqueezedComboBox();
         cmb->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed);
         monitorProfileGrid->addRow(lbl, cmb);
         m_monitorProfileWidgets << cmb;
     }
 
     refillMonitorProfiles(KoID("RGBA", ""));
 
     for(int i = 0; i < QApplication::desktop()->screenCount(); ++i) {
         if (m_monitorProfileWidgets[i]->contains(cfg.monitorProfile(i))) {
             m_monitorProfileWidgets[i]->setCurrent(cfg.monitorProfile(i));
         }
     }
 
     m_page->chkBlackpoint->setChecked(cfg.useBlackPointCompensation());
     m_page->chkAllowLCMSOptimization->setChecked(cfg.allowLCMSOptimization());
 
     KisImageConfig cfgImage;
 
     KisProofingConfigurationSP proofingConfig = cfgImage.defaultProofingconfiguration();
     m_page->sldAdaptationState->setMaximum(20);
     m_page->sldAdaptationState->setMinimum(0);
     m_page->sldAdaptationState->setValue((int)proofingConfig->adaptationState*20);
 
     //probably this should become the screenprofile?
     KoColor ga(KoColorSpaceRegistry::instance()->rgb8());
     ga.fromKoColor(proofingConfig->warningColor);
     m_page->gamutAlarm->setColor(ga);
 
     const KoColorSpace *proofingSpace =  KoColorSpaceRegistry::instance()->colorSpace(proofingConfig->proofingModel,
                                                                                       proofingConfig->proofingDepth,
                                                                                       proofingConfig->proofingProfile);
     if (proofingSpace) {
         m_page->proofingSpaceSelector->setCurrentColorSpace(proofingSpace);
     }
 
     m_page->cmbProofingIntent->setCurrentIndex((int)proofingConfig->intent);
     m_page->ckbProofBlackPoint->setChecked(proofingConfig->conversionFlags.testFlag(KoColorConversionTransformation::BlackpointCompensation));
 
     m_pasteBehaviourGroup.addButton(m_page->radioPasteWeb, PASTE_ASSUME_WEB);
     m_pasteBehaviourGroup.addButton(m_page->radioPasteMonitor, PASTE_ASSUME_MONITOR);
     m_pasteBehaviourGroup.addButton(m_page->radioPasteAsk, PASTE_ASK);
 
     QAbstractButton *button = m_pasteBehaviourGroup.button(cfg.pasteBehaviour());
     Q_ASSERT(button);
 
     if (button) {
         button->setChecked(true);
     }
 
     m_page->cmbMonitorIntent->setCurrentIndex(cfg.monitorRenderIntent());
 
     toggleAllowMonitorProfileSelection(cfg.useSystemMonitorProfile());
 
 }
 
 void ColorSettingsTab::installProfile()
 {
     KoFileDialog dialog(this, KoFileDialog::OpenFiles, "OpenDocumentICC");
     dialog.setCaption(i18n("Install Color Profiles"));
     dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::HomeLocation));
     dialog.setMimeTypeFilters(QStringList() << "application/vnd.iccprofile", "application/vnd.iccprofile");
     QStringList profileNames = dialog.filenames();
 
     KoColorSpaceEngine *iccEngine = KoColorSpaceEngineRegistry::instance()->get("icc");
     Q_ASSERT(iccEngine);
 
     QString saveLocation = KoResourcePaths::saveLocation("icc_profiles");
 
     Q_FOREACH (const QString &profileName, profileNames) {
         if (!QFile::copy(profileName, saveLocation + QFileInfo(profileName).fileName())) {
             qWarning() << "Could not install profile!" << saveLocation + QFileInfo(profileName).fileName();
             continue;
         }
         iccEngine->addProfile(saveLocation + QFileInfo(profileName).fileName());
     }
 
     KisConfig cfg;
     refillMonitorProfiles(KoID("RGBA", ""));
 
     for(int i = 0; i < QApplication::desktop()->screenCount(); ++i) {
         if (m_monitorProfileWidgets[i]->contains(cfg.monitorProfile(i))) {
             m_monitorProfileWidgets[i]->setCurrent(cfg.monitorProfile(i));
         }
     }
 
 }
 
 void ColorSettingsTab::toggleAllowMonitorProfileSelection(bool useSystemProfile)
 {
     if (useSystemProfile) {
         KisConfig cfg;
         QStringList devices = KisColorManager::instance()->devices();
         if (devices.size() == QApplication::desktop()->screenCount()) {
             for(int i = 0; i < QApplication::desktop()->screenCount(); ++i) {
                 m_monitorProfileWidgets[i]->clear();
                 QString monitorForScreen = cfg.monitorForScreen(i, devices[i]);
                 Q_FOREACH (const QString &device, devices) {
                     m_monitorProfileLabels[i]->setText(i18nc("The display/screen we got from Qt", "Screen %1:", i + 1));
                     m_monitorProfileWidgets[i]->addSqueezedItem(KisColorManager::instance()->deviceName(device), device);
                     if (devices[i] == monitorForScreen) {
                         m_monitorProfileWidgets[i]->setCurrentIndex(i);
                     }
                 }
             }
         }
     }
     else {
         KisConfig cfg;
         refillMonitorProfiles(KoID("RGBA", ""));
 
         for(int i = 0; i < QApplication::desktop()->screenCount(); ++i) {
             if (m_monitorProfileWidgets[i]->contains(cfg.monitorProfile(i))) {
                 m_monitorProfileWidgets[i]->setCurrent(cfg.monitorProfile(i));
             }
         }
     }
 }
 
 void ColorSettingsTab::setDefault()
 {
     m_page->cmbWorkingColorSpace->setCurrent("RGBA");
 
     refillMonitorProfiles(KoID("RGBA", ""));
 
     KisConfig cfg;
     KisImageConfig cfgImage;
     KisProofingConfigurationSP proofingConfig =  cfgImage.defaultProofingconfiguration();
     const KoColorSpace *proofingSpace =  KoColorSpaceRegistry::instance()->colorSpace(proofingConfig->proofingModel,proofingConfig->proofingDepth,proofingConfig->proofingProfile);
     if (proofingSpace) {
         m_page->proofingSpaceSelector->setCurrentColorSpace(proofingSpace);
     }
     m_page->cmbProofingIntent->setCurrentIndex((int)proofingConfig->intent);
     m_page->ckbProofBlackPoint->setChecked(proofingConfig->conversionFlags.testFlag(KoColorConversionTransformation::BlackpointCompensation));
     m_page->sldAdaptationState->setValue(0);
 
     //probably this should become the screenprofile?
     KoColor ga(KoColorSpaceRegistry::instance()->rgb8());
     ga.fromKoColor(proofingConfig->warningColor);
     m_page->gamutAlarm->setColor(ga);
 
     m_page->chkBlackpoint->setChecked(cfg.useBlackPointCompensation(true));
     m_page->chkAllowLCMSOptimization->setChecked(cfg.allowLCMSOptimization(true));
     m_page->cmbMonitorIntent->setCurrentIndex(cfg.monitorRenderIntent(true));
     m_page->chkUseSystemMonitorProfile->setChecked(cfg.useSystemMonitorProfile(true));
     QAbstractButton *button = m_pasteBehaviourGroup.button(cfg.pasteBehaviour(true));
     Q_ASSERT(button);
     if (button) {
         button->setChecked(true);
     }
 }
 
 
 void ColorSettingsTab::refillMonitorProfiles(const KoID & colorSpaceId)
 {
     for (int i = 0; i < QApplication::desktop()->screenCount(); ++i) {
         m_monitorProfileWidgets[i]->clear();
     }
 
     QMap<QString, const KoColorProfile *>  profileList;
     Q_FOREACH(const KoColorProfile *profile, KoColorSpaceRegistry::instance()->profilesFor(colorSpaceId.id())) {
         profileList[profile->name()] = profile;
     }
 
     Q_FOREACH (const KoColorProfile *profile, profileList.values()) {
         //qDebug() << "Profile" << profile->name() << profile->isSuitableForDisplay() << csf->defaultProfile();
         if (profile->isSuitableForDisplay()) {
             for (int i = 0; i < QApplication::desktop()->screenCount(); ++i) {
                 m_monitorProfileWidgets[i]->addSqueezedItem(profile->name());
             }
         }
     }
 
     for (int i = 0; i < QApplication::desktop()->screenCount(); ++i) {
         m_monitorProfileLabels[i]->setText(i18nc("The number of the screen", "Screen %1:", i + 1));
         m_monitorProfileWidgets[i]->setCurrent(KoColorSpaceRegistry::instance()->defaultProfileForColorSpace(colorSpaceId.id()));
     }
 }
 
 
 //---------------------------------------------------------------------------------------------------
 
 void TabletSettingsTab::setDefault()
 {
     KisCubicCurve curve;
     curve.fromString(DEFAULT_CURVE_STRING);
     m_page->pressureCurve->setCurve(curve);
 
 #ifdef Q_OS_WIN
     if (KisTabletSupportWin8::isAvailable()) {
         KisConfig cfg;
         m_page->radioWintab->setChecked(!cfg.useWin8PointerInput(true));
         m_page->radioWin8PointerInput->setChecked(cfg.useWin8PointerInput(true));
     } else {
         m_page->radioWintab->setChecked(true);
         m_page->radioWin8PointerInput->setChecked(false);
     }
 #endif
 }
 
 TabletSettingsTab::TabletSettingsTab(QWidget* parent, const char* name): QWidget(parent)
 {
     setObjectName(name);
 
     QGridLayout * l = new QGridLayout(this);
     l->setMargin(0);
     m_page = new WdgTabletSettings(this);
     l->addWidget(m_page, 0, 0);
 
     KisConfig cfg;
     KisCubicCurve curve;
     curve.fromString( cfg.pressureTabletCurve() );
 
     m_page->pressureCurve->setMaximumSize(QSize(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX));
     m_page->pressureCurve->setCurve(curve);
 
 #ifdef Q_OS_WIN
     if (KisTabletSupportWin8::isAvailable()) {
         m_page->radioWintab->setChecked(!cfg.useWin8PointerInput());
         m_page->radioWin8PointerInput->setChecked(cfg.useWin8PointerInput());
     } else {
         m_page->radioWintab->setChecked(true);
         m_page->radioWin8PointerInput->setChecked(false);
         m_page->grpTabletApi->setVisible(false);
     }
 #else
     m_page->grpTabletApi->setVisible(false);
 #endif
     connect(m_page->btnTabletTest, SIGNAL(clicked()), SLOT(slotTabletTest()));
 }
 
 void TabletSettingsTab::slotTabletTest()
 {
     TabletTestDialog tabletTestDialog(this);
     tabletTestDialog.exec();
 }
 
 
 //---------------------------------------------------------------------------------------------------
 #include "kis_acyclic_signal_connector.h"
 
 int getTotalRAM() {
     KisImageConfig cfg;
     return cfg.totalRAM();
 }
 
 int PerformanceTab::realTilesRAM()
 {
     return intMemoryLimit->value() - intPoolLimit->value();
 }
 
 PerformanceTab::PerformanceTab(QWidget *parent, const char *name)
     : WdgPerformanceSettings(parent, name)
 {
     KisImageConfig cfg;
     const int totalRAM = cfg.totalRAM();
     lblTotalMemory->setText(i18n("%1 MiB", totalRAM));
 
     sliderMemoryLimit->setSuffix(i18n(" %"));
     sliderMemoryLimit->setRange(1, 100, 2);
     sliderMemoryLimit->setSingleStep(0.01);
 
     sliderPoolLimit->setSuffix(i18n(" %"));
     sliderPoolLimit->setRange(0, 20, 2);
     sliderMemoryLimit->setSingleStep(0.01);
 
     sliderUndoLimit->setSuffix(i18n(" %"));
     sliderUndoLimit->setRange(0, 50, 2);
     sliderMemoryLimit->setSingleStep(0.01);
 
     intMemoryLimit->setMinimumWidth(80);
     intPoolLimit->setMinimumWidth(80);
     intUndoLimit->setMinimumWidth(80);
 
 
     SliderAndSpinBoxSync *sync1 =
         new SliderAndSpinBoxSync(sliderMemoryLimit,
                                  intMemoryLimit,
                                  getTotalRAM);
 
     sync1->slotParentValueChanged();
     m_syncs << sync1;
 
     SliderAndSpinBoxSync *sync2 =
         new SliderAndSpinBoxSync(sliderPoolLimit,
                                  intPoolLimit,
                                  std::bind(&KisIntParseSpinBox::value,
                                              intMemoryLimit));
 
 
     connect(intMemoryLimit, SIGNAL(valueChanged(int)), sync2, SLOT(slotParentValueChanged()));
     sync2->slotParentValueChanged();
     m_syncs << sync2;
 
     SliderAndSpinBoxSync *sync3 =
         new SliderAndSpinBoxSync(sliderUndoLimit,
                                  intUndoLimit,
                                  std::bind(&PerformanceTab::realTilesRAM,
                                              this));
 
 
     connect(intPoolLimit, SIGNAL(valueChanged(int)), sync3, SLOT(slotParentValueChanged()));
     sync3->slotParentValueChanged();
     m_syncs << sync3;
 
     sliderSwapSize->setSuffix(i18n(" GiB"));
     sliderSwapSize->setRange(1, 64);
     intSwapSize->setRange(1, 64);
 
 
     KisAcyclicSignalConnector *swapSizeConnector = new KisAcyclicSignalConnector(this);
 
     swapSizeConnector->connectForwardInt(sliderSwapSize, SIGNAL(valueChanged(int)),
                                          intSwapSize, SLOT(setValue(int)));
 
     swapSizeConnector->connectBackwardInt(intSwapSize, SIGNAL(valueChanged(int)),
                                           sliderSwapSize, SLOT(setValue(int)));
 
     lblSwapFileLocation->setText(cfg.swapDir());
     connect(bnSwapFile, SIGNAL(clicked()), SLOT(selectSwapDir()));
 
     sliderThreadsLimit->setRange(1, QThread::idealThreadCount());
     sliderFrameClonesLimit->setRange(1, QThread::idealThreadCount());
     sliderFpsLimit->setRange(20, 100);
     sliderFpsLimit->setSuffix(i18n(" fps"));
 
     connect(sliderThreadsLimit, SIGNAL(valueChanged(int)), SLOT(slotThreadsLimitChanged(int)));
     connect(sliderFrameClonesLimit, SIGNAL(valueChanged(int)), SLOT(slotFrameClonesLimitChanged(int)));
 
+    intCachedFramesSizeLimit->setRange(1, 10000);
+    intCachedFramesSizeLimit->setSuffix(i18n(" px"));
+    intCachedFramesSizeLimit->setSingleStep(1);
+    intCachedFramesSizeLimit->setPageStep(1000);
+
+    intRegionOfInterestMargin->setRange(1, 100);
+    intRegionOfInterestMargin->setSuffix(i18n(" %"));
+    intRegionOfInterestMargin->setSingleStep(1);
+    intRegionOfInterestMargin->setPageStep(10);
+
+    connect(chkCachedFramesSizeLimit, SIGNAL(toggled(bool)), intCachedFramesSizeLimit, SLOT(setEnabled(bool)));
+    connect(chkUseRegionOfInterest, SIGNAL(toggled(bool)), intRegionOfInterestMargin, SLOT(setEnabled(bool)));
+
     load(false);
 }
 
 PerformanceTab::~PerformanceTab()
 {
     qDeleteAll(m_syncs);
 }
 
 void PerformanceTab::load(bool requestDefault)
 {
     KisImageConfig cfg;
 
     sliderMemoryLimit->setValue(cfg.memoryHardLimitPercent(requestDefault));
     sliderPoolLimit->setValue(cfg.memoryPoolLimitPercent(requestDefault));
     sliderUndoLimit->setValue(cfg.memorySoftLimitPercent(requestDefault));
 
     chkPerformanceLogging->setChecked(cfg.enablePerfLog(requestDefault));
     chkProgressReporting->setChecked(cfg.enableProgressReporting(requestDefault));
 
     sliderSwapSize->setValue(cfg.maxSwapSize(requestDefault) / 1024);
     lblSwapFileLocation->setText(cfg.swapDir(requestDefault));
 
     m_lastUsedThreadsLimit = cfg.maxNumberOfThreads(requestDefault);
     m_lastUsedClonesLimit = cfg.frameRenderingClones(requestDefault);
 
     sliderThreadsLimit->setValue(m_lastUsedThreadsLimit);
     sliderFrameClonesLimit->setValue(m_lastUsedClonesLimit);
 
     sliderFpsLimit->setValue(cfg.fpsLimit(requestDefault));
 
     {
         KisConfig cfg2;
         chkOpenGLFramerateLogging->setChecked(cfg2.enableOpenGLFramerateLogging(requestDefault));
         chkBrushSpeedLogging->setChecked(cfg2.enableBrushSpeedLogging(requestDefault));
         chkDisableVectorOptimizations->setChecked(cfg2.enableAmdVectorizationWorkaround(requestDefault));
+        chkBackgroundCacheGeneration->setChecked(cfg2.calculateAnimationCacheInBackground(requestDefault));
     }
+
+    if (cfg.useOnDiskAnimationCacheSwapping(requestDefault)) {
+        optOnDisk->setChecked(true);
+    } else {
+        optInMemory->setChecked(true);
+    }
+
+    chkCachedFramesSizeLimit->setChecked(cfg.useAnimationCacheFrameSizeLimit(requestDefault));
+    intCachedFramesSizeLimit->setValue(cfg.animationCacheFrameSizeLimit(requestDefault));
+    intCachedFramesSizeLimit->setEnabled(chkCachedFramesSizeLimit->isChecked());
+
+    chkUseRegionOfInterest->setChecked(cfg.useAnimationCacheRegionOfInterest(requestDefault));
+    intRegionOfInterestMargin->setValue(cfg.animationCacheRegionOfInterestMargin(requestDefault) * 100.0);
+    intRegionOfInterestMargin->setEnabled(chkUseRegionOfInterest->isChecked());
 }
 
 void PerformanceTab::save()
 {
     KisImageConfig cfg;
 
     cfg.setMemoryHardLimitPercent(sliderMemoryLimit->value());
     cfg.setMemorySoftLimitPercent(sliderUndoLimit->value());
     cfg.setMemoryPoolLimitPercent(sliderPoolLimit->value());
 
     cfg.setEnablePerfLog(chkPerformanceLogging->isChecked());
     cfg.setEnableProgressReporting(chkProgressReporting->isChecked());
 
     cfg.setMaxSwapSize(sliderSwapSize->value() * 1024);
 
     cfg.setSwapDir(lblSwapFileLocation->text());
 
     cfg.setMaxNumberOfThreads(sliderThreadsLimit->value());
     cfg.setFrameRenderingClones(sliderFrameClonesLimit->value());
     cfg.setFpsLimit(sliderFpsLimit->value());
 
     {
         KisConfig cfg2;
         cfg2.setEnableOpenGLFramerateLogging(chkOpenGLFramerateLogging->isChecked());
         cfg2.setEnableBrushSpeedLogging(chkBrushSpeedLogging->isChecked());
         cfg2.setEnableAmdVectorizationWorkaround(chkDisableVectorOptimizations->isChecked());
+        cfg2.setCalculateAnimationCacheInBackground(chkBackgroundCacheGeneration->isChecked());
     }
+
+    cfg.setUseOnDiskAnimationCacheSwapping(optOnDisk->isChecked());
+
+    cfg.setUseAnimationCacheFrameSizeLimit(chkCachedFramesSizeLimit->isChecked());
+    cfg.setAnimationCacheFrameSizeLimit(intCachedFramesSizeLimit->value());
+
+    cfg.setUseAnimationCacheRegionOfInterest(chkUseRegionOfInterest->isChecked());
+    cfg.setAnimationCacheRegionOfInterestMargin(intRegionOfInterestMargin->value() / 100.0);
+
 }
 
 void PerformanceTab::selectSwapDir()
 {
     KisImageConfig cfg;
     QString swapDir = cfg.swapDir();
     swapDir = QFileDialog::getExistingDirectory(0, i18nc("@title:window", "Select a swap directory"), swapDir);
     if (swapDir.isEmpty()) {
         return;
     }
     lblSwapFileLocation->setText(swapDir);
 }
 
 void PerformanceTab::slotThreadsLimitChanged(int value)
 {
     KisSignalsBlocker b(sliderFrameClonesLimit);
     sliderFrameClonesLimit->setValue(qMin(m_lastUsedClonesLimit, value));
     m_lastUsedThreadsLimit = value;
 }
 
 void PerformanceTab::slotFrameClonesLimitChanged(int value)
 {
     KisSignalsBlocker b(sliderThreadsLimit);
     sliderThreadsLimit->setValue(qMax(m_lastUsedThreadsLimit, value));
     m_lastUsedClonesLimit = value;
 }
 
 //---------------------------------------------------------------------------------------------------
 
 #include "KoColor.h"
 
 DisplaySettingsTab::DisplaySettingsTab(QWidget *parent, const char *name)
     : WdgDisplaySettings(parent, name)
 {
     KisConfig cfg;
 
     const QString rendererOpenGLText = i18nc("canvas renderer", "OpenGL");
     const QString rendererAngleText = i18nc("canvas renderer", "Direct3D 11 via ANGLE");
 #ifdef Q_OS_WIN
     cmbRenderer->clear();
     QString qtPreferredRendererText;
     if (KisOpenGL::getQtPreferredOpenGLRenderer() == KisOpenGL::RendererAngle) {
         qtPreferredRendererText = rendererAngleText;
     } else {
         qtPreferredRendererText = rendererOpenGLText;
     }
     cmbRenderer->addItem(i18nc("canvas renderer", "Auto (%1)", qtPreferredRendererText), KisOpenGL::RendererAuto);
     cmbRenderer->setCurrentIndex(0);
     if (KisOpenGL::getSupportedOpenGLRenderers() & KisOpenGL::RendererDesktopGL) {
         cmbRenderer->addItem(rendererOpenGLText, KisOpenGL::RendererDesktopGL);
         if (KisOpenGL::getNextUserOpenGLRendererConfig() == KisOpenGL::RendererDesktopGL) {
             cmbRenderer->setCurrentIndex(cmbRenderer->count() - 1);
         }
     }
     if (KisOpenGL::getSupportedOpenGLRenderers() & KisOpenGL::RendererAngle) {
         cmbRenderer->addItem(rendererAngleText, KisOpenGL::RendererAngle);
         if (KisOpenGL::getNextUserOpenGLRendererConfig() == KisOpenGL::RendererAngle) {
             cmbRenderer->setCurrentIndex(cmbRenderer->count() - 1);
         }
     }
 #else
     lblRenderer->setEnabled(false);
     cmbRenderer->setEnabled(false);
     cmbRenderer->clear();
     cmbRenderer->addItem(rendererOpenGLText);
     cmbRenderer->setCurrentIndex(0);
 #endif
 
 #ifdef Q_OS_WIN
     if (!(KisOpenGL::getSupportedOpenGLRenderers() &
             (KisOpenGL::RendererDesktopGL | KisOpenGL::RendererAngle))) {
 #else
     if (!KisOpenGL::hasOpenGL()) {
 #endif
         grpOpenGL->setEnabled(false);
         grpOpenGL->setChecked(false);
         chkUseTextureBuffer->setEnabled(false);
         chkDisableVsync->setEnabled(false);
         cmbFilterMode->setEnabled(false);
     } else {
         grpOpenGL->setEnabled(true);
         grpOpenGL->setChecked(cfg.useOpenGL());
         chkUseTextureBuffer->setEnabled(cfg.useOpenGL());
         chkUseTextureBuffer->setChecked(cfg.useOpenGLTextureBuffer());
         chkDisableVsync->setVisible(cfg.showAdvancedOpenGLSettings());
         chkDisableVsync->setEnabled(cfg.useOpenGL());
         chkDisableVsync->setChecked(cfg.disableVSync());
         cmbFilterMode->setEnabled(cfg.useOpenGL());
         cmbFilterMode->setCurrentIndex(cfg.openGLFilteringMode());
         // Don't show the high quality filtering mode if it's not available
         if (!KisOpenGL::supportsLoD()) {
             cmbFilterMode->removeItem(3);
         }
     }
 
     const QStringList openglWarnings = KisOpenGL::getOpenGLWarnings();
     if (openglWarnings.isEmpty()) {
         lblOpenGLWarnings->setVisible(false);
     } else {
         QString text("<span style=\"color: yellow;\">&#x26A0;</span> ");
         text.append(i18n("Warning(s):"));
         text.append("<ul>");
         Q_FOREACH (const QString &warning, openglWarnings) {
             text.append("<li>");
             text.append(warning.toHtmlEscaped());
             text.append("</li>");
         }
         text.append("</ul>");
         lblOpenGLWarnings->setText(text);
         lblOpenGLWarnings->setVisible(true);
     }
 
     if (qApp->applicationName() == "kritasketch" || qApp->applicationName() == "kritagemini") {
        grpOpenGL->setVisible(false);
        grpOpenGL->setMaximumHeight(0);
     }
 
     KoColor c;
     c.fromQColor(cfg.selectionOverlayMaskColor());
     c.setOpacity(1.0);
     btnSelectionOverlayColor->setColor(c);
     sldSelectionOverlayOpacity->setRange(0.0, 1.0, 2);
     sldSelectionOverlayOpacity->setSingleStep(0.05);
     sldSelectionOverlayOpacity->setValue(cfg.selectionOverlayMaskColor().alphaF());
 
     intCheckSize->setValue(cfg.checkSize());
     chkMoving->setChecked(cfg.scrollCheckers());
     KoColor ck1(KoColorSpaceRegistry::instance()->rgb8());
     ck1.fromQColor(cfg.checkersColor1());
     colorChecks1->setColor(ck1);
     KoColor ck2(KoColorSpaceRegistry::instance()->rgb8());
     ck2.fromQColor(cfg.checkersColor2());
     colorChecks2->setColor(ck2);
     KoColor cb(KoColorSpaceRegistry::instance()->rgb8());
     cb.fromQColor(cfg.canvasBorderColor());
     canvasBorder->setColor(cb);
     hideScrollbars->setChecked(cfg.hideScrollbars());
     chkCurveAntialiasing->setChecked(cfg.antialiasCurves());
     chkSelectionOutlineAntialiasing->setChecked(cfg.antialiasSelectionOutline());
     chkChannelsAsColor->setChecked(cfg.showSingleChannelAsColor());
     chkHidePopups->setChecked(cfg.hidePopups());
 
     connect(grpOpenGL, SIGNAL(toggled(bool)), SLOT(slotUseOpenGLToggled(bool)));
 
     KoColor gridColor(KoColorSpaceRegistry::instance()->rgb8());
     gridColor.fromQColor(cfg.getPixelGridColor());
     pixelGridColorButton->setColor(gridColor);
     pixelGridDrawingThresholdBox->setValue(cfg.getPixelGridDrawingThreshold() * 100);
 }
 
 void DisplaySettingsTab::setDefault()
 {
     KisConfig cfg;
     cmbRenderer->setCurrentIndex(0);
 #ifdef Q_OS_WIN
     if (!(KisOpenGL::getSupportedOpenGLRenderers() &
             (KisOpenGL::RendererDesktopGL | KisOpenGL::RendererAngle))) {
 #else
     if (!KisOpenGL::hasOpenGL()) {
 #endif
         grpOpenGL->setEnabled(false);
         grpOpenGL->setChecked(false);
         chkUseTextureBuffer->setEnabled(false);
         chkDisableVsync->setEnabled(false);
         cmbFilterMode->setEnabled(false);
     }
     else {
         grpOpenGL->setEnabled(true);
         grpOpenGL->setChecked(cfg.useOpenGL(true));
         chkUseTextureBuffer->setChecked(cfg.useOpenGLTextureBuffer(true));
         chkUseTextureBuffer->setEnabled(true);
         chkDisableVsync->setEnabled(true);
         chkDisableVsync->setChecked(cfg.disableVSync(true));
         cmbFilterMode->setEnabled(true);
         cmbFilterMode->setCurrentIndex(cfg.openGLFilteringMode(true));
     }
 
     chkMoving->setChecked(cfg.scrollCheckers(true));
     intCheckSize->setValue(cfg.checkSize(true));
     KoColor ck1(KoColorSpaceRegistry::instance()->rgb8());
     ck1.fromQColor(cfg.checkersColor1(true));
     colorChecks1->setColor(ck1);
     KoColor ck2(KoColorSpaceRegistry::instance()->rgb8());
     ck2.fromQColor(cfg.checkersColor2(true));
     colorChecks2->setColor(ck2);
     KoColor cvb(KoColorSpaceRegistry::instance()->rgb8());
     cvb.fromQColor(cfg.canvasBorderColor(true));
     canvasBorder->setColor(cvb);
     hideScrollbars->setChecked(cfg.hideScrollbars(true));
     chkCurveAntialiasing->setChecked(cfg.antialiasCurves(true));
     chkSelectionOutlineAntialiasing->setChecked(cfg.antialiasSelectionOutline(true));
     chkChannelsAsColor->setChecked(cfg.showSingleChannelAsColor(true));
     chkHidePopups->setChecked(cfg.hidePopups(true));
 
     KoColor gridColor(KoColorSpaceRegistry::instance()->rgb8());
     gridColor.fromQColor(cfg.getPixelGridColor(true));
     pixelGridColorButton->setColor(gridColor);
     pixelGridDrawingThresholdBox->setValue(cfg.getPixelGridDrawingThreshold(true) * 100);
 }
 
 void DisplaySettingsTab::slotUseOpenGLToggled(bool isChecked)
 {
     chkUseTextureBuffer->setEnabled(isChecked);
     chkDisableVsync->setEnabled(isChecked);
     cmbFilterMode->setEnabled(isChecked);
 }
 
 //---------------------------------------------------------------------------------------------------
 FullscreenSettingsTab::FullscreenSettingsTab(QWidget* parent) : WdgFullscreenSettingsBase(parent)
 {
     KisConfig cfg;
 
     chkDockers->setChecked(cfg.hideDockersFullscreen());
     chkMenu->setChecked(cfg.hideMenuFullscreen());
     chkScrollbars->setChecked(cfg.hideScrollbarsFullscreen());
     chkStatusbar->setChecked(cfg.hideStatusbarFullscreen());
     chkTitlebar->setChecked(cfg.hideTitlebarFullscreen());
     chkToolbar->setChecked(cfg.hideToolbarFullscreen());
 
 }
 
 void FullscreenSettingsTab::setDefault()
 {
     KisConfig cfg;
     chkDockers->setChecked(cfg.hideDockersFullscreen(true));
     chkMenu->setChecked(cfg.hideMenuFullscreen(true));
     chkScrollbars->setChecked(cfg.hideScrollbarsFullscreen(true));
     chkStatusbar->setChecked(cfg.hideStatusbarFullscreen(true));
     chkTitlebar->setChecked(cfg.hideTitlebarFullscreen(true));
     chkToolbar->setChecked(cfg.hideToolbarFullscreen(true));
 }
 
 
 //---------------------------------------------------------------------------------------------------
 
 KisDlgPreferences::KisDlgPreferences(QWidget* parent, const char* name)
     : KPageDialog(parent)
 {
     Q_UNUSED(name);
     setWindowTitle(i18n("Configure Krita"));
     setStandardButtons(QDialogButtonBox::Ok | QDialogButtonBox::Cancel | QDialogButtonBox::RestoreDefaults);
     button(QDialogButtonBox::Ok)->setDefault(true);
 
     setFaceType(KPageDialog::Tree);
 
     // General
     KoVBox *vbox = new KoVBox();
     KPageWidgetItem *page = new KPageWidgetItem(vbox, i18n("General"));
     page->setObjectName("general");
     page->setHeader(i18n("General"));
     page->setIcon(KisIconUtils::loadIcon("go-home"));
     addPage(page);
     m_general = new GeneralTab(vbox);
 
     // Shortcuts
     vbox = new KoVBox();
     page = new KPageWidgetItem(vbox, i18n("Keyboard Shortcuts"));
     page->setObjectName("shortcuts");
     page->setHeader(i18n("Shortcuts"));
     page->setIcon(KisIconUtils::loadIcon("document-export"));
     addPage(page);
     m_shortcutSettings = new ShortcutSettingsTab(vbox);
     connect(this, SIGNAL(accepted()), m_shortcutSettings, SLOT(saveChanges()));
     connect(this, SIGNAL(rejected()), m_shortcutSettings, SLOT(cancelChanges()));
 
     // Canvas input settings
     m_inputConfiguration = new KisInputConfigurationPage();
     page = addPage(m_inputConfiguration, i18n("Canvas Input Settings"));
     page->setHeader(i18n("Canvas Input"));
     page->setObjectName("canvasinput");
     page->setIcon(KisIconUtils::loadIcon("configure"));
 
     // Display
     vbox = new KoVBox();
     page = new KPageWidgetItem(vbox, i18n("Display"));
     page->setObjectName("display");
     page->setHeader(i18n("Display"));
     page->setIcon(KisIconUtils::loadIcon("preferences-desktop-display"));
     addPage(page);
     m_displaySettings = new DisplaySettingsTab(vbox);
 
     // Color
     vbox = new KoVBox();
     page = new KPageWidgetItem(vbox, i18n("Color Management"));
     page->setObjectName("colormanagement");
     page->setHeader(i18n("Color"));
     page->setIcon(KisIconUtils::loadIcon("preferences-desktop-color"));
     addPage(page);
     m_colorSettings = new ColorSettingsTab(vbox);
 
     // Performance
     vbox = new KoVBox();
     page = new KPageWidgetItem(vbox, i18n("Performance"));
     page->setObjectName("performance");
     page->setHeader(i18n("Performance"));
     page->setIcon(KisIconUtils::loadIcon("applications-system"));
     addPage(page);
     m_performanceSettings = new PerformanceTab(vbox);
 
     // Tablet
     vbox = new KoVBox();
     page = new KPageWidgetItem(vbox, i18n("Tablet settings"));
     page->setObjectName("tablet");
     page->setHeader(i18n("Tablet"));
     page->setIcon(KisIconUtils::loadIcon("document-edit"));
     addPage(page);
     m_tabletSettings = new TabletSettingsTab(vbox);
 
     // full-screen mode
     vbox = new KoVBox();
     page = new KPageWidgetItem(vbox, i18n("Canvas-only settings"));
     page->setObjectName("canvasonly");
     page->setHeader(i18n("Canvas-only"));
     page->setIcon(KisIconUtils::loadIcon("folder-pictures"));
     addPage(page);
     m_fullscreenSettings = new FullscreenSettingsTab(vbox);
 
     // Author profiles
     m_authorPage = new KoConfigAuthorPage();
     page = addPage(m_authorPage, i18nc("@title:tab Author page", "Author" ));
     page->setObjectName("author");
     page->setHeader(i18n("Author"));
     page->setIcon(KisIconUtils::loadIcon("im-user"));
 
 
     QPushButton *restoreDefaultsButton = button(QDialogButtonBox::RestoreDefaults);
     restoreDefaultsButton->setText("Restore Defaults");
 
     connect(this, SIGNAL(accepted()), m_inputConfiguration, SLOT(saveChanges()));
     connect(this, SIGNAL(rejected()), m_inputConfiguration, SLOT(revertChanges()));
 
     KisPreferenceSetRegistry *preferenceSetRegistry = KisPreferenceSetRegistry::instance();
     Q_FOREACH (KisAbstractPreferenceSetFactory *preferenceSetFactory, preferenceSetRegistry->values()) {
         KisPreferenceSet* preferenceSet = preferenceSetFactory->createPreferenceSet();
         vbox = new KoVBox();
         page = new KPageWidgetItem(vbox, preferenceSet->name());
         page->setHeader(preferenceSet->header());
         page->setIcon(preferenceSet->icon());
         addPage(page);
         preferenceSet->setParent(vbox);
         preferenceSet->loadPreferences();
 
         connect(restoreDefaultsButton, SIGNAL(clicked(bool)), preferenceSet, SLOT(loadDefaultPreferences()), Qt::UniqueConnection);
         connect(this, SIGNAL(accepted()), preferenceSet, SLOT(savePreferences()), Qt::UniqueConnection);
     }
 
 
     connect(restoreDefaultsButton, SIGNAL(clicked(bool)), this, SLOT(slotDefault()));
 
 }
 
 KisDlgPreferences::~KisDlgPreferences()
 {
 }
 
 void KisDlgPreferences::slotDefault()
 {
     if (currentPage()->objectName() == "general") {
         m_general->setDefault();
     }
     else if (currentPage()->objectName() == "shortcuts") {
         m_shortcutSettings->setDefault();
     }
     else if (currentPage()->objectName() == "display") {
         m_displaySettings->setDefault();
     }
     else if (currentPage()->objectName() == "colormanagement") {
         m_colorSettings->setDefault();
     }
     else if (currentPage()->objectName() == "performance") {
         m_performanceSettings->load(true);
     }
     else if (currentPage()->objectName() == "tablet") {
         m_tabletSettings->setDefault();
     }
     else if (currentPage()->objectName() == "canvasonly") {
         m_fullscreenSettings->setDefault();
     }
     else if (currentPage()->objectName() == "canvasinput") {
         m_inputConfiguration->setDefaults();
     }
 }
 
 bool KisDlgPreferences::editPreferences()
 {
     KisDlgPreferences* dialog;
 
     dialog = new KisDlgPreferences();
     bool baccept = (dialog->exec() == Accepted);
     if (baccept) {
         // General settings
         KisConfig cfg;
         cfg.setNewCursorStyle(dialog->m_general->cursorStyle());
         cfg.setNewOutlineStyle(dialog->m_general->outlineStyle());
         cfg.setShowRootLayer(dialog->m_general->showRootLayer());
         cfg.setShowOutlineWhilePainting(dialog->m_general->showOutlineWhilePainting());
         cfg.setHideSplashScreen(dialog->m_general->hideSplashScreen());
         cfg.setSessionOnStartup(dialog->m_general->sessionOnStartup());
         cfg.setSaveSessionOnQuit(dialog->m_general->saveSessionOnQuit());
-        cfg.setCalculateAnimationCacheInBackground(dialog->m_general->calculateAnimationCacheInBackground());
 
         KConfigGroup group = KSharedConfig::openConfig()->group("File Dialogs");
         group.writeEntry("DontUseNativeFileDialog", !dialog->m_general->m_chkNativeFileDialog->isChecked());
 
         cfg.writeEntry<int>("maximumBrushSize", dialog->m_general->intMaxBrushSize->value());
 
         cfg.writeEntry<int>("mdi_viewmode", dialog->m_general->mdiMode());
         cfg.setMDIBackgroundColor(dialog->m_general->m_mdiColor->color().toQColor());
         cfg.setMDIBackgroundImage(dialog->m_general->m_backgroundimage->text());
         cfg.setAutoSaveInterval(dialog->m_general->autoSaveInterval());
         cfg.setBackupFile(dialog->m_general->m_backupFileCheckBox->isChecked());
         cfg.setShowCanvasMessages(dialog->m_general->showCanvasMessages());
         cfg.setCompressKra(dialog->m_general->compressKra());
 
         const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
         QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
         kritarc.setValue("EnableHiDPI", dialog->m_general->m_chkHiDPI->isChecked());
         kritarc.setValue("EnableSingleApplication", dialog->m_general->m_chkSingleApplication->isChecked());
 
         cfg.setToolOptionsInDocker(dialog->m_general->toolOptionsInDocker());
         cfg.setKineticScrollingGesture(dialog->m_general->kineticScrollingGesture());
         cfg.setKineticScrollingSensitivity(dialog->m_general->kineticScrollingSensitivity());
         cfg.setKineticScrollingScrollbar(dialog->m_general->kineticScrollingScrollbar());
         cfg.setSwitchSelectionCtrlAlt(dialog->m_general->switchSelectionCtrlAlt());
         cfg.setDisableTouchOnCanvas(!dialog->m_general->chkEnableTouch->isChecked());
         cfg.setConvertToImageColorspaceOnImport(dialog->m_general->convertToImageColorspaceOnImport());
         cfg.setUndoStackLimit(dialog->m_general->undoStackSize());
         cfg.setFavoritePresets(dialog->m_general->favoritePresets());
 
         // Color settings
         cfg.setUseSystemMonitorProfile(dialog->m_colorSettings->m_page->chkUseSystemMonitorProfile->isChecked());
         for (int i = 0; i < QApplication::desktop()->screenCount(); ++i) {
             if (dialog->m_colorSettings->m_page->chkUseSystemMonitorProfile->isChecked()) {
                 int currentIndex = dialog->m_colorSettings->m_monitorProfileWidgets[i]->currentIndex();
                 QString monitorid = dialog->m_colorSettings->m_monitorProfileWidgets[i]->itemData(currentIndex).toString();
                 cfg.setMonitorForScreen(i, monitorid);
             }
             else {
                 cfg.setMonitorProfile(i,
                                       dialog->m_colorSettings->m_monitorProfileWidgets[i]->itemHighlighted(),
                                       dialog->m_colorSettings->m_page->chkUseSystemMonitorProfile->isChecked());
             }
         }
         cfg.setWorkingColorSpace(dialog->m_colorSettings->m_page->cmbWorkingColorSpace->currentItem().id());
 
         KisImageConfig cfgImage;
         cfgImage.setDefaultProofingConfig(dialog->m_colorSettings->m_page->proofingSpaceSelector->currentColorSpace(),
                                           dialog->m_colorSettings->m_page->cmbProofingIntent->currentIndex(),
                                           dialog->m_colorSettings->m_page->ckbProofBlackPoint->isChecked(),
                                           dialog->m_colorSettings->m_page->gamutAlarm->color(),
                                           (double)dialog->m_colorSettings->m_page->sldAdaptationState->value()/20);
         cfg.setUseBlackPointCompensation(dialog->m_colorSettings->m_page->chkBlackpoint->isChecked());
         cfg.setAllowLCMSOptimization(dialog->m_colorSettings->m_page->chkAllowLCMSOptimization->isChecked());
         cfg.setPasteBehaviour(dialog->m_colorSettings->m_pasteBehaviourGroup.checkedId());
         cfg.setRenderIntent(dialog->m_colorSettings->m_page->cmbMonitorIntent->currentIndex());
 
         // Tablet settings
         cfg.setPressureTabletCurve( dialog->m_tabletSettings->m_page->pressureCurve->curve().toString() );
 #ifdef Q_OS_WIN
         if (KisTabletSupportWin8::isAvailable()) {
             cfg.setUseWin8PointerInput(dialog->m_tabletSettings->m_page->radioWin8PointerInput->isChecked());
         }
 #endif
 
         dialog->m_performanceSettings->save();
 
 #ifdef Q_OS_WIN
         {
             KisOpenGL::OpenGLRenderer renderer = static_cast<KisOpenGL::OpenGLRenderer>(
                     dialog->m_displaySettings->cmbRenderer->itemData(
                             dialog->m_displaySettings->cmbRenderer->currentIndex()).toInt());
             KisOpenGL::setNextUserOpenGLRendererConfig(renderer);
             const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
             QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
             kritarc.setValue("OpenGLRenderer", KisOpenGL::convertOpenGLRendererToConfig(renderer));
         }
 #endif
         if (!cfg.useOpenGL() && dialog->m_displaySettings->grpOpenGL->isChecked())
             cfg.setCanvasState("TRY_OPENGL");
         cfg.setUseOpenGL(dialog->m_displaySettings->grpOpenGL->isChecked());
         cfg.setUseOpenGLTextureBuffer(dialog->m_displaySettings->chkUseTextureBuffer->isChecked());
         cfg.setOpenGLFilteringMode(dialog->m_displaySettings->cmbFilterMode->currentIndex());
         cfg.setDisableVSync(dialog->m_displaySettings->chkDisableVsync->isChecked());
 
         cfg.setCheckSize(dialog->m_displaySettings->intCheckSize->value());
         cfg.setScrollingCheckers(dialog->m_displaySettings->chkMoving->isChecked());
         cfg.setCheckersColor1(dialog->m_displaySettings->colorChecks1->color().toQColor());
         cfg.setCheckersColor2(dialog->m_displaySettings->colorChecks2->color().toQColor());
         cfg.setCanvasBorderColor(dialog->m_displaySettings->canvasBorder->color().toQColor());
         cfg.setHideScrollbars(dialog->m_displaySettings->hideScrollbars->isChecked());
         KoColor c = dialog->m_displaySettings->btnSelectionOverlayColor->color();
         c.setOpacity(dialog->m_displaySettings->sldSelectionOverlayOpacity->value());
         cfg.setSelectionOverlayMaskColor(c.toQColor());
         cfg.setAntialiasCurves(dialog->m_displaySettings->chkCurveAntialiasing->isChecked());
         cfg.setAntialiasSelectionOutline(dialog->m_displaySettings->chkSelectionOutlineAntialiasing->isChecked());
         cfg.setShowSingleChannelAsColor(dialog->m_displaySettings->chkChannelsAsColor->isChecked());
         cfg.setHidePopups(dialog->m_displaySettings->chkHidePopups->isChecked());
 
         cfg.setHideDockersFullscreen(dialog->m_fullscreenSettings->chkDockers->checkState());
         cfg.setHideMenuFullscreen(dialog->m_fullscreenSettings->chkMenu->checkState());
         cfg.setHideScrollbarsFullscreen(dialog->m_fullscreenSettings->chkScrollbars->checkState());
         cfg.setHideStatusbarFullscreen(dialog->m_fullscreenSettings->chkStatusbar->checkState());
         cfg.setHideTitlebarFullscreen(dialog->m_fullscreenSettings->chkTitlebar->checkState());
         cfg.setHideToolbarFullscreen(dialog->m_fullscreenSettings->chkToolbar->checkState());
 
         cfg.setCursorMainColor(dialog->m_general->cursorColorBtutton->color().toQColor());
         cfg.setPixelGridColor(dialog->m_displaySettings->pixelGridColorButton->color().toQColor());
         cfg.setPixelGridDrawingThreshold(dialog->m_displaySettings->pixelGridDrawingThresholdBox->value() / 100);
 
         dialog->m_authorPage->apply();
 
     }
     delete dialog;
     return baccept;
 }
 
diff --git a/libs/ui/dialogs/kis_dlg_preferences.h b/libs/ui/dialogs/kis_dlg_preferences.h
index 25c7926f0b..d04778d935 100644
--- a/libs/ui/dialogs/kis_dlg_preferences.h
+++ b/libs/ui/dialogs/kis_dlg_preferences.h
@@ -1,350 +1,348 @@
 /*
  *  preferencesdlg.h - part of KImageShop^WKrita
  *
  *  Copyright (c) 1999 Michael Koch <koch@kde.org>
  *  Copyright (c) 2003-2011 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef _KIS_DLG_PREFERENCES_H_
 #define _KIS_DLG_PREFERENCES_H_
 
 #include <QWidget>
 #include <QButtonGroup>
 
 #include <kpagedialog.h>
 #include <kis_config.h>
 
 #include "kis_global.h"
 #include <squeezedcombobox.h>
 
 #include "ui_wdggeneralsettings.h"
 #include "ui_wdgdisplaysettings.h"
 #include "ui_wdgcolorsettings.h"
 #include "ui_wdgtabletsettings.h"
 #include "ui_wdgperformancesettings.h"
 #include "ui_wdgfullscreensettings.h"
 #include "KisShortcutsDialog.h"
 
 class KoID;
 class KisInputConfigurationPage;
 class KoConfigAuthorPage;
 
 /**
  *  "General"-tab for preferences dialog
  */
 
 class WdgGeneralSettings : public QWidget, public Ui::WdgGeneralSettings
 {
     Q_OBJECT
 
 public:
     WdgGeneralSettings(QWidget *parent, const char *name) : QWidget(parent) {
         setObjectName(name);
         setupUi(this);
         chkShowRootLayer->setVisible(false);
     }
 };
 
 class GeneralTab : public WdgGeneralSettings
 {
     Q_OBJECT
 
 public:
 
     GeneralTab(QWidget *parent = 0, const char *name = 0);
 
     CursorStyle cursorStyle();
     OutlineStyle outlineStyle();
 
     KisConfig::SessionOnStartup sessionOnStartup() const;
     bool saveSessionOnQuit() const;
 
     bool showRootLayer();
     int autoSaveInterval();
     void setDefault();
     int undoStackSize();
     bool showOutlineWhilePainting();
     bool hideSplashScreen();
 
     int mdiMode();
     int favoritePresets();
     bool showCanvasMessages();
     bool compressKra();
     bool toolOptionsInDocker();
     int kineticScrollingGesture();
     int kineticScrollingSensitivity();
     bool kineticScrollingScrollbar();
     bool switchSelectionCtrlAlt();
     bool convertToImageColorspaceOnImport();
 
-    bool calculateAnimationCacheInBackground();
-
 private Q_SLOTS:
     void getBackgroundImage();
     void clearBackgroundImage();
 
 };
 
 
 
 /**
  *  "Shortcuts" tab for preferences dialog
  */
 
 class WdgShortcutSettings : public KisShortcutsDialog
 {
     Q_OBJECT
 
 public:
     WdgShortcutSettings(QWidget *parent)
         : KisShortcutsDialog(KisShortcutsEditor::AllActions,
                              KisShortcutsEditor::LetterShortcutsAllowed,
                              parent)
     { }
 };
 
 class KisActionsSnapshot;
 
 class ShortcutSettingsTab : public QWidget
 {
     Q_OBJECT
 
 public:
 
     ShortcutSettingsTab(QWidget *parent = 0, const char *name = 0);
     ~ShortcutSettingsTab() override;
 
 public:
     void setDefault();
     WdgShortcutSettings  *m_page;
     QScopedPointer<KisActionsSnapshot> m_snapshot;
 
 
 public Q_SLOTS:
     void saveChanges();
     void cancelChanges();
 };
 
 
 
 /**
  *  "Color" tab for preferences dialog
  */
 
 class WdgColorSettings : public QWidget, public Ui::WdgColorSettings
 {
     Q_OBJECT
 
 public:
     WdgColorSettings(QWidget *parent) : QWidget(parent) {
         setupUi(this);
     }
 };
 
 class ColorSettingsTab : public QWidget
 {
     Q_OBJECT
 
 public:
 
     ColorSettingsTab(QWidget *parent = 0, const char  *name = 0);
 
 private Q_SLOTS:
 
     void refillMonitorProfiles(const KoID & s);
     void installProfile();
     void toggleAllowMonitorProfileSelection(bool useSystemProfile);
 
 public:
     void setDefault();
     WdgColorSettings  *m_page;
     QButtonGroup m_pasteBehaviourGroup;
     QList<QLabel*> m_monitorProfileLabels;
     QList<SqueezedComboBox*> m_monitorProfileWidgets;
 };
 
 //=======================
 
 class WdgTabletSettings : public QWidget, public Ui::WdgTabletSettings {
 
     Q_OBJECT
 
 public:
     WdgTabletSettings(QWidget *parent) : QWidget(parent) {
         setupUi(this);
     }
 
 };
 
 class TabletSettingsTab : public QWidget {
     Q_OBJECT
 public:
     TabletSettingsTab(QWidget *parent = 0, const char  *name = 0);
 
 private Q_SLOTS:
     void slotTabletTest();
 
 public:
     void setDefault();
     WdgTabletSettings  *m_page;
 
 
 };
 
 //=======================
 
 /**
   * "Performance"-tab for preferences dialog
  */
 
 class SliderAndSpinBoxSync;
 
 class WdgPerformanceSettings : public QWidget, public Ui::WdgPerformanceSettings
 {
     Q_OBJECT
 
 public:
     WdgPerformanceSettings(QWidget *parent, const char *name) : QWidget(parent) {
         setObjectName(name); setupUi(this);
     }
 };
 
 class PerformanceTab : public WdgPerformanceSettings
 {
     Q_OBJECT
 
 public:
     PerformanceTab(QWidget *parent = 0, const char *name = 0);
 
     ~PerformanceTab() override;
 
     void load(bool requestDefault);
     void save();
 
 private Q_SLOTS:
 
     void selectSwapDir();
 
     void slotThreadsLimitChanged(int value);
     void slotFrameClonesLimitChanged(int value);
 
 private:
     int realTilesRAM();
 
 private:
     QVector<SliderAndSpinBoxSync*> m_syncs;
     int m_lastUsedThreadsLimit;
     int m_lastUsedClonesLimit;
 };
 
 //=======================
 
 class WdgDisplaySettings : public QWidget, public Ui::WdgDisplaySettings
 {
     Q_OBJECT
 
 public:
     WdgDisplaySettings(QWidget *parent, const char *name) : QWidget(parent) {
         setObjectName(name); setupUi(this);
     }
 };
 
 /**
  *  Display settings tab for preferences dialog
  */
 
 
 class DisplaySettingsTab : public WdgDisplaySettings
 {
     Q_OBJECT
 
 public:
     DisplaySettingsTab(QWidget *parent = 0, const char *name = 0);
 
 public:
     void setDefault();
 protected Q_SLOTS:
     void slotUseOpenGLToggled(bool isChecked);
 
 public:
 };
 
 //=======================
 
 /**
  *  Full screen settings tab for preferences dialog
  */
 
 class WdgFullscreenSettingsBase : public QWidget, public Ui::WdgFullscreenSettings
 {
     Q_OBJECT
 
 public:
     WdgFullscreenSettingsBase(QWidget *parent) : QWidget(parent) {
         setupUi(this);
     }
 };
 
 class FullscreenSettingsTab : public WdgFullscreenSettingsBase
 {
     Q_OBJECT
 public:
     FullscreenSettingsTab(QWidget *parent);
 public:
     void setDefault();
 };
 
 
 //=======================
 
 
 /**
  *  Preferences dialog of KImageShop^WKrayon^WKrita
  */
 class KisDlgPreferences : public KPageDialog
 {
     Q_OBJECT
 
 public:
 
     static bool editPreferences();
 
 
 protected:
 
     KisDlgPreferences(QWidget *parent = 0, const char *name = 0);
     ~KisDlgPreferences() override;
 
 protected:
 
     GeneralTab *m_general;
     ShortcutSettingsTab  *m_shortcutSettings;
     ColorSettingsTab *m_colorSettings;
     PerformanceTab *m_performanceSettings;
     DisplaySettingsTab  *m_displaySettings;
     TabletSettingsTab *m_tabletSettings;
     FullscreenSettingsTab *m_fullscreenSettings;
     KisInputConfigurationPage *m_inputConfiguration;
     KoConfigAuthorPage *m_authorPage;
 
 protected Q_SLOTS:
 
     void slotDefault();
 
 };
 
 #endif
diff --git a/libs/ui/forms/wdggeneralsettings.ui b/libs/ui/forms/wdggeneralsettings.ui
index 59358dc411..33ff353576 100644
--- a/libs/ui/forms/wdggeneralsettings.ui
+++ b/libs/ui/forms/wdggeneralsettings.ui
@@ -1,788 +1,781 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>WdgGeneralSettings</class>
  <widget class="QWidget" name="WdgGeneralSettings">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>759</width>
     <height>468</height>
    </rect>
   </property>
   <property name="sizePolicy">
    <sizepolicy hsizetype="Preferred" vsizetype="Minimum">
     <horstretch>0</horstretch>
     <verstretch>0</verstretch>
    </sizepolicy>
   </property>
   <property name="minimumSize">
    <size>
     <width>552</width>
     <height>295</height>
    </size>
   </property>
   <property name="layoutDirection">
    <enum>Qt::LeftToRight</enum>
   </property>
   <layout class="QGridLayout" name="gridLayout">
    <item row="0" column="0">
     <widget class="QTabWidget" name="tabWidget">
      <property name="currentIndex">
       <number>0</number>
      </property>
      <widget class="QWidget" name="tab">
       <attribute name="title">
        <string>Cursor</string>
       </attribute>
       <layout class="QGridLayout" name="gridLayout_2">
        <item row="1" column="0">
         <layout class="QFormLayout" name="formLayout_2">
          <property name="horizontalSpacing">
           <number>10</number>
          </property>
          <property name="verticalSpacing">
           <number>10</number>
          </property>
          <property name="leftMargin">
           <number>10</number>
          </property>
          <property name="topMargin">
           <number>10</number>
          </property>
          <property name="rightMargin">
           <number>10</number>
          </property>
          <property name="bottomMargin">
           <number>10</number>
          </property>
          <item row="0" column="0">
           <widget class="QLabel" name="textLabel1">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="text">
             <string>Cursor Shape:</string>
            </property>
            <property name="alignment">
             <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
            </property>
           </widget>
          </item>
          <item row="0" column="1">
           <widget class="QComboBox" name="m_cmbCursorShape"/>
          </item>
          <item row="1" column="0">
           <widget class="QLabel" name="textLabel1_2">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="text">
             <string>Outline Shape:</string>
            </property>
            <property name="alignment">
             <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
            </property>
           </widget>
          </item>
          <item row="1" column="1">
           <widget class="QComboBox" name="m_cmbOutlineShape"/>
          </item>
          <item row="2" column="1">
           <widget class="QCheckBox" name="m_showOutlinePainting">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="minimumSize">
             <size>
              <width>200</width>
              <height>0</height>
             </size>
            </property>
            <property name="text">
             <string>Show brush outline while painting</string>
            </property>
           </widget>
          </item>
          <item row="3" column="0">
           <widget class="QLabel" name="label_11">
            <property name="text">
             <string>Cursor Color:</string>
            </property>
           </widget>
          </item>
          <item row="3" column="1">
           <widget class="KisColorButton" name="cursorColorBtutton">
            <property name="maximumSize">
             <size>
              <width>48</width>
              <height>25</height>
             </size>
            </property>
            <property name="text">
             <string/>
            </property>
           </widget>
          </item>
         </layout>
        </item>
        <item row="2" column="0">
         <spacer name="verticalSpacer_3">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>40</height>
           </size>
          </property>
         </spacer>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="tab_3">
       <attribute name="title">
        <string>Window</string>
       </attribute>
       <layout class="QFormLayout" name="formLayout">
        <item row="0" column="0">
         <widget class="QLabel" name="label_2">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="text">
           <string>Multiple Document Mode:</string>
          </property>
          <property name="alignment">
           <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
          </property>
         </widget>
        </item>
        <item row="0" column="1">
         <widget class="QComboBox" name="m_cmbMDIType">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="currentIndex">
           <number>1</number>
          </property>
          <item>
           <property name="text">
            <string>Subwindows</string>
           </property>
          </item>
          <item>
           <property name="text">
            <string>Tabs</string>
           </property>
          </item>
         </widget>
        </item>
        <item row="1" column="0">
         <widget class="QLabel" name="label_5">
          <property name="text">
           <string>Background Image (overrides color):</string>
          </property>
         </widget>
        </item>
        <item row="1" column="1">
         <layout class="QHBoxLayout" name="horizontalLayout" stretch="0,0,0">
          <item>
           <widget class="QLabel" name="m_backgroundimage">
            <property name="minimumSize">
             <size>
              <width>200</width>
              <height>0</height>
             </size>
            </property>
            <property name="frameShape">
             <enum>QFrame::StyledPanel</enum>
            </property>
            <property name="frameShadow">
             <enum>QFrame::Sunken</enum>
            </property>
            <property name="text">
             <string/>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QToolButton" name="m_bnFileName">
            <property name="text">
             <string>...</string>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QPushButton" name="clearBgImageButton">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="text">
             <string>Clear</string>
            </property>
           </widget>
          </item>
         </layout>
        </item>
        <item row="2" column="0">
         <widget class="QLabel" name="label_4">
          <property name="text">
           <string>Window Background:</string>
          </property>
          <property name="alignment">
           <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
          </property>
         </widget>
        </item>
        <item row="2" column="1">
         <widget class="KisColorButton" name="m_mdiColor">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="text">
           <string/>
          </property>
         </widget>
        </item>
        <item row="3" column="0">
         <widget class="QLabel" name="label_6">
          <property name="text">
           <string>Don't show contents when moving sub-windows:</string>
          </property>
         </widget>
        </item>
        <item row="3" column="1">
         <widget class="QCheckBox" name="m_chkRubberBand">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="text">
           <string/>
          </property>
         </widget>
        </item>
        <item row="4" column="0">
         <widget class="QLabel" name="label_7">
          <property name="text">
           <string>Show on-canvas popup messages:</string>
          </property>
         </widget>
        </item>
        <item row="4" column="1">
         <widget class="QCheckBox" name="m_chkCanvasMessages">
          <property name="text">
           <string/>
          </property>
         </widget>
        </item>
        <item row="7" column="0" colspan="2">
         <spacer name="verticalSpacer">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>40</height>
           </size>
          </property>
         </spacer>
        </item>
        <item row="5" column="1">
         <widget class="QCheckBox" name="m_chkHiDPI">
          <property name="text">
           <string/>
          </property>
         </widget>
        </item>
        <item row="5" column="0">
         <widget class="QLabel" name="label_8">
          <property name="text">
           <string>Enable Hi-DPI support:</string>
          </property>
         </widget>
        </item>
        <item row="6" column="1">
         <widget class="QCheckBox" name="m_chkSingleApplication">
          <property name="text">
           <string/>
          </property>
         </widget>
        </item>
        <item row="6" column="0">
         <widget class="QLabel" name="label_r98">
          <property name="text">
           <string>Allow only one instance of Krita:</string>
          </property>
         </widget>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="Tools">
       <attribute name="title">
        <string>Tools</string>
       </attribute>
       <layout class="QGridLayout" name="gridLayout_4">
        <item row="1" column="1">
         <layout class="QVBoxLayout" name="verticalLayout">
          <property name="spacing">
           <number>10</number>
          </property>
          <property name="leftMargin">
           <number>10</number>
          </property>
          <property name="topMargin">
           <number>10</number>
          </property>
          <property name="rightMargin">
           <number>10</number>
          </property>
          <property name="bottomMargin">
           <number>10</number>
          </property>
          <item>
           <widget class="QGroupBox" name="groupBox_4">
            <property name="title">
             <string>Tool Options Location (needs restart)</string>
            </property>
            <layout class="QVBoxLayout" name="verticalLayout_3">
             <item>
              <widget class="QRadioButton" name="m_radioToolOptionsInDocker">
               <property name="text">
                <string>In Doc&amp;ker</string>
               </property>
              </widget>
             </item>
             <item>
              <widget class="QRadioButton" name="m_radioToolOptionsInToolbar">
               <property name="text">
                <string>In Tool&amp;bar</string>
               </property>
               <property name="checked">
                <bool>true</bool>
               </property>
              </widget>
             </item>
            </layout>
           </widget>
          </item>
          <item>
           <widget class="QCheckBox" name="m_chkSwitchSelectionCtrlAlt">
            <property name="text">
             <string>Switch Control/Alt Selection Modifiers</string>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QCheckBox" name="chkEnableTouch">
            <property name="text">
             <string>Enable Touch Painting</string>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QGroupBox" name="groupBoxKineticScrollingSettings">
            <property name="title">
             <string>Kinetic Scrolling (needs restart)</string>
            </property>
            <layout class="QVBoxLayout" name="verticalLayoutKineticScrollingSettings">
             <item>
              <widget class="QComboBox" name="m_cmbKineticScrollingGesture"/>
             </item>
             <item>
              <layout class="QHBoxLayout" name="horizontalLayoutKineticScrollingSensitivity">
               <item>
                <widget class="QLabel" name="labelKineticScrollingSensitivity">
                 <property name="text">
                  <string>Sensitivity (0-100):</string>
                 </property>
                </widget>
               </item>
               <item>
                <widget class="KisIntParseSpinBox" name="m_kineticScrollingSensitivity">
                 <property name="sizePolicy">
                  <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
                   <horstretch>0</horstretch>
                   <verstretch>0</verstretch>
                  </sizepolicy>
                 </property>
                 <property name="minimumSize">
                  <size>
                   <width>50</width>
                   <height>0</height>
                  </size>
                 </property>
                 <property name="minimum">
                  <number>0</number>
                 </property>
                 <property name="maximum">
                  <number>100</number>
                 </property>
                 <property name="singleStep">
                  <number>1</number>
                 </property>
                 <property name="value">
                  <number>75</number>
                 </property>
                </widget>
               </item>
              </layout>
             </item>
             <item>
              <widget class="QCheckBox" name="m_chkKineticScrollingScrollbar">
               <property name="text">
                <string>Show Scrollbar</string>
               </property>
              </widget>
             </item>
            </layout>
           </widget>
          </item>
          <item>
           <spacer name="verticalSpacer_2">
            <property name="orientation">
             <enum>Qt::Vertical</enum>
            </property>
            <property name="sizeHint" stdset="0">
             <size>
              <width>20</width>
              <height>40</height>
             </size>
            </property>
           </spacer>
          </item>
         </layout>
        </item>
        <item row="1" column="2">
         <spacer name="horizontalSpacer_6">
          <property name="orientation">
           <enum>Qt::Horizontal</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>40</width>
            <height>20</height>
           </size>
          </property>
         </spacer>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="Miscellaneous">
       <attribute name="title">
        <string>Miscellaneous</string>
       </attribute>
       <layout class="QFormLayout" name="formLayout_3">
+       <item row="0" column="0">
+        <widget class="QLabel" name="label_12">
+         <property name="sizePolicy">
+          <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
+           <horstretch>0</horstretch>
+           <verstretch>0</verstretch>
+          </sizepolicy>
+         </property>
+         <property name="text">
+          <string>When Krita starts</string>
+         </property>
+         <property name="alignment">
+          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+         </property>
+        </widget>
+       </item>
+       <item row="0" column="1">
+        <widget class="QComboBox" name="cmbStartupSession"/>
+       </item>
+       <item row="1" column="1">
+        <widget class="QCheckBox" name="chkSaveSessionOnQuit">
+         <property name="text">
+          <string>Save session when Krita closes</string>
+         </property>
+        </widget>
+       </item>
        <item row="2" column="0">
         <widget class="QCheckBox" name="m_autosaveCheckBox">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="layoutDirection">
           <enum>Qt::RightToLeft</enum>
          </property>
          <property name="text">
           <string>Autosave every:</string>
          </property>
          <property name="checked">
           <bool>true</bool>
          </property>
         </widget>
        </item>
        <item row="2" column="1">
         <widget class="KisIntParseSpinBox" name="m_autosaveSpinBox">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="minimumSize">
           <size>
            <width>75</width>
            <height>0</height>
           </size>
          </property>
          <property name="suffix">
           <string> min</string>
          </property>
          <property name="minimum">
           <number>1</number>
          </property>
          <property name="maximum">
           <number>1440</number>
          </property>
          <property name="singleStep">
           <number>5</number>
          </property>
          <property name="value">
           <number>15</number>
          </property>
         </widget>
        </item>
        <item row="3" column="1">
         <widget class="QCheckBox" name="m_chkCompressKra">
          <property name="text">
           <string>Compress .kra files more (slows loading/saving)</string>
          </property>
         </widget>
        </item>
        <item row="5" column="1">
         <widget class="QCheckBox" name="m_backupFileCheckBox">
          <property name="text">
           <string>Create backup file </string>
          </property>
         </widget>
        </item>
        <item row="7" column="1">
         <widget class="QCheckBox" name="m_chkConvertOnImport">
          <property name="text">
           <string>On importing images as layers, convert to the image colorspace</string>
          </property>
         </widget>
        </item>
        <item row="9" column="0">
         <widget class="QLabel" name="label">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="text">
           <string>Undo stack size:</string>
          </property>
          <property name="alignment">
           <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
          </property>
         </widget>
        </item>
        <item row="9" column="1">
         <widget class="KisIntParseSpinBox" name="m_undoStackSize">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="minimumSize">
           <size>
            <width>75</width>
            <height>0</height>
           </size>
          </property>
          <property name="minimum">
           <number>0</number>
          </property>
          <property name="maximum">
           <number>1000</number>
          </property>
          <property name="singleStep">
           <number>5</number>
          </property>
          <property name="value">
           <number>30</number>
          </property>
         </widget>
        </item>
        <item row="10" column="0">
         <widget class="QLabel" name="label_3">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="text">
           <string>Number of Palette Presets</string>
          </property>
          <property name="alignment">
           <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
          </property>
         </widget>
        </item>
        <item row="11" column="1">
         <widget class="KisIntParseSpinBox" name="m_favoritePresetsSpinBox">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="minimumSize">
           <size>
            <width>75</width>
            <height>0</height>
           </size>
          </property>
          <property name="minimum">
           <number>10</number>
          </property>
          <property name="maximum">
           <number>30</number>
          </property>
         </widget>
        </item>
        <item row="12" column="1">
         <widget class="QCheckBox" name="chkShowRootLayer">
          <property name="text">
           <string>Show root layer</string>
          </property>
         </widget>
        </item>
        <item row="13" column="1">
         <widget class="QCheckBox" name="m_hideSplashScreen">
          <property name="text">
           <string>Hide splash screen on startup</string>
          </property>
         </widget>
        </item>
        <item row="14" column="1">
         <widget class="QCheckBox" name="m_chkNativeFileDialog">
          <property name="toolTip">
           <string>Warning: if you enable this setting and the file dialogs do weird stuff, do not report a bug.</string>
          </property>
          <property name="text">
           <string>Enable native file dialogs (warning: may not work correctly on some systems)</string>
          </property>
         </widget>
        </item>
        <item row="16" column="0">
         <widget class="QLabel" name="label_9">
          <property name="text">
           <string>Maximum brush size:</string>
          </property>
         </widget>
        </item>
        <item row="16" column="1">
         <layout class="QHBoxLayout" name="horizontalLayout_2">
          <item>
           <widget class="QSpinBox" name="intMaxBrushSize">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="toolTip">
             <string>The maximum diameter of a brush in pixels.</string>
            </property>
            <property name="suffix">
             <string comment="pixel">px</string>
            </property>
            <property name="minimum">
             <number>100</number>
            </property>
            <property name="maximum">
             <number>10000</number>
            </property>
            <property name="value">
             <number>1000</number>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QLabel" name="label_10">
            <property name="text">
             <string>(Needs restart)</string>
            </property>
           </widget>
          </item>
         </layout>
        </item>
        <item row="17" column="1">
-        <widget class="QCheckBox" name="m_chkCacheAnimatioInBackground">
-         <property name="text">
-          <string>Recalculate animation cache in background</string>
-         </property>
-        </widget>
-       </item>
-       <item row="18" column="1">
         <spacer name="verticalSpacer_4">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>504</width>
            <height>13</height>
           </size>
          </property>
         </spacer>
        </item>
-       <item row="0" column="1">
-        <widget class="QComboBox" name="cmbStartupSession"/>
-       </item>
-       <item row="0" column="0">
-        <widget class="QLabel" name="label_12">
-         <property name="sizePolicy">
-          <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
-           <horstretch>0</horstretch>
-           <verstretch>0</verstretch>
-          </sizepolicy>
-         </property>
-         <property name="text">
-          <string>When Krita starts</string>
-         </property>
-         <property name="alignment">
-          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
-         </property>
-        </widget>
-       </item>
-       <item row="1" column="1">
-        <widget class="QCheckBox" name="chkSaveSessionOnQuit">
-         <property name="text">
-          <string>Save session when Krita closes</string>
-         </property>
-        </widget>
-       </item>
       </layout>
      </widget>
     </widget>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>KisIntParseSpinBox</class>
    <extends>QSpinBox</extends>
    <header>kis_int_parse_spin_box.h</header>
   </customwidget>
   <customwidget>
    <class>KisColorButton</class>
    <extends>QPushButton</extends>
    <header>kis_color_button.h</header>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>
diff --git a/libs/ui/forms/wdgperformancesettings.ui b/libs/ui/forms/wdgperformancesettings.ui
index 8554263387..4abfc09189 100644
--- a/libs/ui/forms/wdgperformancesettings.ui
+++ b/libs/ui/forms/wdgperformancesettings.ui
@@ -1,442 +1,543 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>WdgPerformanceSettings</class>
  <widget class="QWidget" name="WdgPerformanceSettings">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>505</width>
     <height>446</height>
    </rect>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout_3">
    <item>
     <widget class="QLabel" name="label_10">
      <property name="font">
       <font>
        <weight>75</weight>
        <bold>true</bold>
       </font>
      </property>
      <property name="text">
       <string>Note: Krita will need to be restarted for changes to take effect</string>
      </property>
     </widget>
    </item>
    <item>
     <widget class="QTabWidget" name="tabWidget">
      <property name="currentIndex">
       <number>0</number>
      </property>
      <widget class="QWidget" name="tab">
       <attribute name="title">
        <string>General</string>
       </attribute>
       <layout class="QVBoxLayout" name="verticalLayout_2">
        <item>
         <widget class="QGroupBox" name="groupBox">
          <property name="title">
           <string>RAM</string>
          </property>
          <layout class="QFormLayout" name="formLayout">
           <item row="0" column="0">
            <widget class="QLabel" name="label_2">
             <property name="text">
              <string>Memory available:</string>
             </property>
            </widget>
           </item>
           <item row="0" column="1">
            <widget class="QLabel" name="lblTotalMemory">
             <property name="sizePolicy">
              <sizepolicy hsizetype="MinimumExpanding" vsizetype="Preferred">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="text">
              <string>XXX MiB</string>
             </property>
             <property name="alignment">
              <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignVCenter</set>
             </property>
            </widget>
           </item>
           <item row="1" column="0">
            <widget class="QLabel" name="label">
             <property name="toolTip">
              <string>Krita will not use more memory than this limit.</string>
             </property>
             <property name="text">
              <string>Memory Limit:</string>
             </property>
            </widget>
           </item>
           <item row="1" column="1">
            <layout class="QHBoxLayout" name="horizontalLayout">
             <item>
              <widget class="KisDoubleSliderSpinBox" name="sliderMemoryLimit" native="true">
               <property name="sizePolicy">
                <sizepolicy hsizetype="MinimumExpanding" vsizetype="Minimum">
                 <horstretch>0</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
               <property name="toolTip">
                <string>Krita will not use more memory than this limit.</string>
               </property>
              </widget>
             </item>
             <item>
              <widget class="KisIntParseSpinBox" name="intMemoryLimit">
               <property name="suffix">
                <string> MiB</string>
               </property>
              </widget>
             </item>
            </layout>
           </item>
           <item row="2" column="0">
            <widget class="QLabel" name="label_5">
             <property name="text">
              <string>Internal Pool:</string>
             </property>
            </widget>
           </item>
           <item row="2" column="1">
            <layout class="QHBoxLayout" name="horizontalLayout_3">
             <item>
              <widget class="KisDoubleSliderSpinBox" name="sliderPoolLimit" native="true">
               <property name="sizePolicy">
                <sizepolicy hsizetype="MinimumExpanding" vsizetype="Minimum">
                 <horstretch>0</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
              </widget>
             </item>
             <item>
              <widget class="KisIntParseSpinBox" name="intPoolLimit">
               <property name="suffix">
                <string> MiB</string>
               </property>
              </widget>
             </item>
            </layout>
           </item>
           <item row="3" column="0">
            <widget class="QLabel" name="label_4">
             <property name="toolTip">
              <string>When undo information reaches this limit, it will be stored in a temporary file and memory will be freed. Undo will be slower.</string>
             </property>
             <property name="text">
              <string>Swap Undo After:</string>
             </property>
            </widget>
           </item>
           <item row="3" column="1">
            <layout class="QHBoxLayout" name="horizontalLayout_2">
             <item>
              <widget class="KisDoubleSliderSpinBox" name="sliderUndoLimit" native="true">
               <property name="sizePolicy">
                <sizepolicy hsizetype="MinimumExpanding" vsizetype="Minimum">
                 <horstretch>0</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
               <property name="toolTip">
                <string>When undo information reaches this limit, it will be stored in a temporary file and memory will be freed. Undo will be slower.</string>
               </property>
              </widget>
             </item>
             <item>
              <widget class="KisIntParseSpinBox" name="intUndoLimit">
               <property name="suffix">
                <string> MiB</string>
               </property>
              </widget>
             </item>
            </layout>
           </item>
          </layout>
         </widget>
        </item>
        <item>
         <widget class="QGroupBox" name="groupBox_2">
          <property name="title">
           <string>Swap File Size</string>
          </property>
          <layout class="QFormLayout" name="formLayout_2">
           <property name="bottomMargin">
            <number>6</number>
           </property>
           <item row="0" column="0">
            <widget class="QLabel" name="label_6">
             <property name="toolTip">
              <string>The swap file will not be bigger than this limit.</string>
             </property>
             <property name="text">
              <string>File Size Limit:</string>
             </property>
            </widget>
           </item>
           <item row="0" column="1">
            <layout class="QHBoxLayout" name="horizontalLayout_4">
             <item>
              <widget class="KisSliderSpinBox" name="sliderSwapSize" native="true">
               <property name="sizePolicy">
                <sizepolicy hsizetype="MinimumExpanding" vsizetype="Minimum">
                 <horstretch>0</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
               <property name="toolTip">
                <string>The swap file will not be bigger than this limit.</string>
               </property>
              </widget>
             </item>
             <item>
              <widget class="KisIntParseSpinBox" name="intSwapSize">
               <property name="suffix">
                <string> GiB</string>
               </property>
              </widget>
             </item>
            </layout>
           </item>
           <item row="1" column="0">
            <widget class="QLabel" name="label_3">
             <property name="text">
              <string>Swap File Location:</string>
             </property>
            </widget>
           </item>
           <item row="1" column="1">
            <layout class="QHBoxLayout" name="horizontalLayout_5">
             <item>
              <widget class="QLabel" name="lblSwapFileLocation">
               <property name="sizePolicy">
                <sizepolicy hsizetype="MinimumExpanding" vsizetype="Minimum">
                 <horstretch>0</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
               <property name="frameShape">
                <enum>QFrame::Box</enum>
               </property>
               <property name="text">
                <string>TextLabel</string>
               </property>
              </widget>
             </item>
             <item>
              <widget class="QToolButton" name="bnSwapFile">
               <property name="toolTip">
                <string>Select the location where Krita writes its swap files.</string>
               </property>
               <property name="text">
                <string>...</string>
               </property>
              </widget>
             </item>
            </layout>
           </item>
          </layout>
         </widget>
        </item>
        <item>
         <spacer name="verticalSpacer_2">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>5</height>
           </size>
          </property>
         </spacer>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="tab_2">
       <attribute name="title">
        <string>Advanced</string>
       </attribute>
       <layout class="QVBoxLayout" name="verticalLayout">
        <item>
         <widget class="QGroupBox" name="groupBox_4">
          <property name="title">
           <string>Multithreading</string>
          </property>
          <layout class="QFormLayout" name="formLayout_3">
           <item row="0" column="0">
            <widget class="QLabel" name="label_8">
             <property name="text">
              <string>CPU Limit:</string>
             </property>
            </widget>
           </item>
           <item row="0" column="1">
            <widget class="KisSliderSpinBox" name="sliderThreadsLimit" native="true">
             <property name="sizePolicy">
              <sizepolicy hsizetype="MinimumExpanding" vsizetype="Minimum">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="toolTip">
              <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Krita will not use more CPU cores than selected by this limit&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
             </property>
            </widget>
           </item>
           <item row="1" column="0">
            <widget class="QLabel" name="label_9">
             <property name="text">
              <string>Frame Rendering Clones Limit</string>
             </property>
            </widget>
           </item>
           <item row="1" column="1">
            <widget class="KisSliderSpinBox" name="sliderFrameClonesLimit" native="true">
             <property name="sizePolicy">
              <sizepolicy hsizetype="MinimumExpanding" vsizetype="Minimum">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="toolTip">
              <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;When rendering animation frames (into files or during animation cache regeneration), Krita will make the specified number of copies of your image and will work on them in parallel. Each copy will demand more RAM for its storage (about 20% of the size of you image), so raise this limit only if you have enough RAM installed.&lt;/p&gt;&lt;p&gt;&lt;br/&gt;&lt;/p&gt;&lt;p&gt;&lt;span style=&quot; font-weight:600;&quot;&gt;Recommended value:&lt;/span&gt; set Clones Limit to the number of &lt;span style=&quot; text-decoration: underline;&quot;&gt;physical&lt;/span&gt; (non-hyperthreaded) cores your CPU has&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
             </property>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item>
         <layout class="QFormLayout" name="formLayout_limitFps">
          <item row="0" column="0">
           <widget class="QLabel" name="label_fps">
            <property name="text">
             <string>Limit frames per second while painting:</string>
            </property>
           </widget>
          </item>
          <item row="0" column="1">
           <widget class="KisSliderSpinBox" name="sliderFpsLimit" native="true">
            <property name="sizePolicy">
             <sizepolicy hsizetype="MinimumExpanding" vsizetype="Preferred">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="toolTip">
             <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Krita will try to limit the number of screen updates per second to the given number. A lower number will decrease visual responsiveness but increase stylus precision on some systems like macOS.&lt;p&gt;&lt;/body&gt;&lt;/html&gt;</string>
            </property>
           </widget>
          </item>
         </layout>
        </item>
        <item>
         <widget class="QCheckBox" name="chkOpenGLFramerateLogging">
          <property name="text">
           <string>Debug logging of OpenGL framerate</string>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QCheckBox" name="chkBrushSpeedLogging">
          <property name="text">
           <string>Debug logging for brush rendering speed</string>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QCheckBox" name="chkDisableVectorOptimizations">
          <property name="text">
           <string>Disable vector optimizations (for AMD CPUs)</string>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QCheckBox" name="chkProgressReporting">
          <property name="text">
           <string>Progress reporting (might affect performance)</string>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QCheckBox" name="chkPerformanceLogging">
          <property name="text">
           <string>Performance logging</string>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QLabel" name="label_7">
          <property name="frameShape">
           <enum>QFrame::NoFrame</enum>
          </property>
          <property name="text">
           <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;When performance logging is enabled Krita saves timing information into the '&amp;lt;working_dir&amp;gt;/log' folder. If you experience performance problems and want to help us, enable this option and add the contents of the directory to a bug report.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
          </property>
          <property name="wordWrap">
           <bool>true</bool>
          </property>
         </widget>
        </item>
        <item>
         <spacer name="verticalSpacer_3">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>5</height>
           </size>
          </property>
         </spacer>
        </item>
       </layout>
      </widget>
+     <widget class="QWidget" name="tab_3">
+      <attribute name="title">
+       <string>Animation Cache</string>
+      </attribute>
+      <layout class="QVBoxLayout" name="verticalLayout_5" stretch="0,1">
+       <item>
+        <widget class="QGroupBox" name="groupBox_3">
+         <property name="title">
+          <string>Cache Storage Backend</string>
+         </property>
+         <layout class="QVBoxLayout" name="verticalLayout_4">
+          <item>
+           <widget class="QRadioButton" name="optInMemory">
+            <property name="toolTip">
+             <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Animation frame cache will be stored in RAM completely without any limitations&lt;/p&gt;&lt;p&gt;&lt;span style=&quot; font-weight:600;&quot;&gt;WARNING:&lt;/span&gt; please make sure your computer has enough RAM &lt;span style=&quot; text-decoration: underline;&quot;&gt;above&lt;/span&gt; the amount you requested in General tab. Otherwise you migh face system freezes.&lt;/p&gt;&lt;p&gt;* for 1 second of FullHD@25fps video you need extra 200 MiB of memory&lt;/p&gt;&lt;p&gt;* for 1 second of 4K UltraHD@25fps video you need extra 800 MiB of memory&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+            </property>
+            <property name="text">
+             <string>In-memory</string>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QRadioButton" name="optOnDisk">
+            <property name="toolTip">
+             <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Animation frames are stored on hard disk in the same folder as swap file. The cache is stored in a compressed way. Little amount of extra RAM is needed.&lt;/p&gt;&lt;p&gt;Since data transfer speed of the hard drive is low, you might want to limit cached frame size to be able to play your video at 25 fps. The limit of 2500 px is usually a good choice.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+            </property>
+            <property name="text">
+             <string>On-disk</string>
+            </property>
+           </widget>
+          </item>
+         </layout>
+        </widget>
+       </item>
+       <item>
+        <widget class="QGroupBox" name="groupBox_5">
+         <property name="title">
+          <string>Cache Generation Options</string>
+         </property>
+         <layout class="QFormLayout" name="formLayout_4">
+          <item row="0" column="0">
+           <widget class="QCheckBox" name="chkCachedFramesSizeLimit">
+            <property name="toolTip">
+             <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Render scaled down version of the frame if the image is bigger than the provided limit. Make sure you enable this option when using on-disk storage backend.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+            </property>
+            <property name="text">
+             <string>Limit cached frame size:</string>
+            </property>
+           </widget>
+          </item>
+          <item row="0" column="1">
+           <widget class="KisSliderSpinBox" name="intCachedFramesSizeLimit" native="true">
+            <property name="sizePolicy">
+             <sizepolicy hsizetype="MinimumExpanding" vsizetype="Minimum">
+              <horstretch>0</horstretch>
+              <verstretch>0</verstretch>
+             </sizepolicy>
+            </property>
+            <property name="toolTip">
+             <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Size limit after which the frames will be scaled down&lt;/p&gt;&lt;p&gt;&lt;span style=&quot; font-weight:600;&quot;&gt;Recommended value:&lt;/span&gt; 2500&amp;nbsp;px&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+            </property>
+           </widget>
+          </item>
+          <item row="1" column="0">
+           <widget class="QCheckBox" name="chkUseRegionOfInterest">
+            <property name="toolTip">
+             <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;When the image is too big, render only currently visible part of it&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+            </property>
+            <property name="text">
+             <string>Use region of interest</string>
+            </property>
+           </widget>
+          </item>
+          <item row="1" column="1">
+           <widget class="KisSliderSpinBox" name="intRegionOfInterestMargin" native="true">
+            <property name="sizePolicy">
+             <sizepolicy hsizetype="MinimumExpanding" vsizetype="Minimum">
+              <horstretch>0</horstretch>
+              <verstretch>0</verstretch>
+             </sizepolicy>
+            </property>
+            <property name="toolTip">
+             <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Add extra area to the region of interest to each side of the canvas.&lt;/p&gt;&lt;p&gt;&lt;span style=&quot; font-weight:600;&quot;&gt;Recommended value:&lt;/span&gt; 25%. The region of interest will be extended by 25% to each side.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+            </property>
+           </widget>
+          </item>
+          <item row="2" column="0">
+           <widget class="QCheckBox" name="chkBackgroundCacheGeneration">
+            <property name="toolTip">
+             <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Automatically prerender animation cache in background when the user is idle&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+            </property>
+            <property name="text">
+             <string>Enable background cache generation</string>
+            </property>
+           </widget>
+          </item>
+         </layout>
+        </widget>
+       </item>
+      </layout>
+     </widget>
     </widget>
    </item>
    <item>
     <spacer name="verticalSpacer">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>20</width>
        <height>5</height>
       </size>
      </property>
     </spacer>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>KisIntParseSpinBox</class>
    <extends>QSpinBox</extends>
    <header>kis_int_parse_spin_box.h</header>
   </customwidget>
   <customwidget>
    <class>KisDoubleSliderSpinBox</class>
    <extends>QWidget</extends>
    <header>kis_slider_spin_box.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>KisSliderSpinBox</class>
    <extends>QWidget</extends>
    <header>kis_slider_spin_box.h</header>
    <container>1</container>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>
diff --git a/libs/ui/kis_animation_cache_populator.cpp b/libs/ui/kis_animation_cache_populator.cpp
index 9979375c67..6ba4ea582d 100644
--- a/libs/ui/kis_animation_cache_populator.cpp
+++ b/libs/ui/kis_animation_cache_populator.cpp
@@ -1,313 +1,317 @@
 /*
  *  Copyright (c) 2015 Jouni Pentikäinen <joupent@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_animation_cache_populator.h"
 
 #include <functional>
 
 #include <QTimer>
 #include <QMutex>
 #include <QtConcurrent>
 
 #include "kis_config.h"
 #include "kis_config_notifier.h"
 #include "KisPart.h"
 #include "KisDocument.h"
 #include "kis_image.h"
 #include "kis_image_animation_interface.h"
 #include "kis_canvas2.h"
 #include "kis_time_range.h"
 #include "kis_animation_frame_cache.h"
 #include "kis_update_info.h"
 #include "kis_signal_auto_connection.h"
 #include "kis_idle_watcher.h"
 #include "KisViewManager.h"
 #include "kis_node_manager.h"
 #include "kis_keyframe_channel.h"
 
 #include "KisAsyncAnimationCacheRenderer.h"
 #include "dialogs/KisAsyncAnimationCacheRenderDialog.h"
 
 
 struct KisAnimationCachePopulator::Private
 {
     KisAnimationCachePopulator *q;
     KisPart *part;
 
     QTimer timer;
 
     /**
      * Counts up the number of subsequent times Krita has been detected idle.
      */
     int idleCounter;
     static const int IDLE_COUNT_THRESHOLD = 4;
     static const int IDLE_CHECK_INTERVAL = 500;
     static const int BETWEEN_FRAMES_INTERVAL = 10;
 
     int requestedFrame;
     KisAnimationFrameCacheSP requestCache;
     KisOpenGLUpdateInfoSP requestInfo;
     KisSignalAutoConnectionsStore imageRequestConnections;
 
     QFutureWatcher<void> infoConversionWatcher;
 
     KisAsyncAnimationCacheRenderer regenerator;
     bool calculateAnimationCacheInBackground = true;
 
 
 
     enum State {
         NotWaitingForAnything,
         WaitingForIdle,
         WaitingForFrame,
         BetweenFrames
     };
     State state;
 
     Private(KisAnimationCachePopulator *_q, KisPart *_part)
         : q(_q),
           part(_part),
           idleCounter(0),
           requestedFrame(-1),
           state(WaitingForIdle)
     {
         timer.setSingleShot(true);
     }
 
     void timerTimeout() {
         switch (state) {
         case WaitingForIdle:
         case BetweenFrames:
             generateIfIdle();
             break;
         case WaitingForFrame:
             KIS_ASSERT_RECOVER_NOOP(0 && "WaitingForFrame cannot have a timeout. Just skip this message and report a bug");
             break;
         case NotWaitingForAnything:
             KIS_ASSERT_RECOVER_NOOP(0 && "NotWaitingForAnything cannot have a timeout. Just skip this message and report a bug");
             break;
         }
     }
 
     void generateIfIdle()
     {
         if (part->idleWatcher()->isIdle()) {
             idleCounter++;
 
             if (idleCounter >= IDLE_COUNT_THRESHOLD) {
                 if (!tryRequestGeneration()) {
                     enterState(NotWaitingForAnything);
                 }
                 return;
             }
         } else {
             idleCounter = 0;
         }
 
         enterState(WaitingForIdle);
     }
 
 
     bool tryRequestGeneration()
     {
         // Prioritize the active document
         KisAnimationFrameCacheSP activeDocumentCache = KisAnimationFrameCacheSP(0);
 
         KisMainWindow *activeWindow = part->currentMainwindow();
         if (activeWindow && activeWindow->activeView()) {
             KisCanvas2 *activeCanvas = activeWindow->activeView()->canvasBase();
 
             if (activeCanvas && activeCanvas->frameCache()) {
                 activeDocumentCache = activeCanvas->frameCache();
 
                 // Let's skip frames affected by changes to the active node (on the active document)
                 // This avoids constant invalidation and regeneration while drawing
                 KisNodeSP activeNode = activeCanvas->viewManager()->nodeManager()->activeNode();
                 KisTimeRange skipRange;
                 if (activeNode) {
                     int currentTime = activeCanvas->currentImage()->animationInterface()->currentUITime();
 
                     if (!activeNode->keyframeChannels().isEmpty()) {
                         Q_FOREACH (const KisKeyframeChannel *channel, activeNode->keyframeChannels()) {
                             skipRange |= channel->affectedFrames(currentTime);
                         }
                     } else {
                         skipRange = KisTimeRange::infinite(0);
                     }
                 }
 
                 bool requested = tryRequestGeneration(activeDocumentCache, skipRange);
                 if (requested) return true;
             }
         }
 
         QList<KisAnimationFrameCache*> caches = KisAnimationFrameCache::caches();
         KisAnimationFrameCache *cache;
         Q_FOREACH (cache, caches) {
             if (cache == activeDocumentCache.data()) {
                 // We already handled this one...
                 continue;
             }
 
             bool requested = tryRequestGeneration(cache, KisTimeRange());
             if (requested) return true;
         }
 
         return false;
     }
 
     bool tryRequestGeneration(KisAnimationFrameCacheSP cache, KisTimeRange skipRange)
     {
         KisImageSP image = cache->image();
         if (!image) return false;
 
         KisImageAnimationInterface *animation = image->animationInterface();
         KisTimeRange currentRange = animation->fullClipRange();
 
         const int frame = KisAsyncAnimationCacheRenderDialog::calcFirstDirtyFrame(cache, currentRange, skipRange);
 
         if (frame >= 0) {
             return regenerate(cache, frame);
         }
 
         return false;
     }
 
     bool regenerate(KisAnimationFrameCacheSP cache, int frame)
     {
         if (state == WaitingForFrame) {
             // Already busy, deny request
             return false;
         }
 
         /**
          * We should enter the state before the frame is
          * requested. Otherwise the signal may come earlier than we
          * enter it.
          */
         enterState(WaitingForFrame);
 
         regenerator.setFrameCache(cache);
+
+        // if we ever decide to add ROI to background cache
+        // regeneration, it should be added here :)
         regenerator.startFrameRegeneration(cache->image(), frame);
 
         return true;
     }
 
     QString debugStateToString(State newState) {
         QString str = "<unknown>";
 
         switch (newState) {
         case WaitingForIdle:
             str = "WaitingForIdle";
             break;
         case WaitingForFrame:
             str = "WaitingForFrame";
             break;
         case NotWaitingForAnything:
             str = "NotWaitingForAnything";
             break;
         case BetweenFrames:
             str = "BetweenFrames";
             break;
         }
 
         return str;
     }
 
     void enterState(State newState)
     {
         //ENTER_FUNCTION() << debugStateToString(state) << "->" << debugStateToString(newState);
 
         state = newState;
         int timerTimeout = -1;
 
         switch (state) {
         case WaitingForIdle:
             timerTimeout = IDLE_CHECK_INTERVAL;
             break;
         case WaitingForFrame:
             // the timeout is handled by the regenerator now
             timerTimeout = -1;
             break;
         case NotWaitingForAnything:
             // frame conversion cannot be cancelled,
             // so there is no timeout
             timerTimeout = -1;
             break;
         case BetweenFrames:
             timerTimeout = BETWEEN_FRAMES_INTERVAL;
             break;
         }
 
         if (timerTimeout >= 0) {
             timer.start(timerTimeout);
         } else {
             timer.stop();
         }
     }
 };
 
 KisAnimationCachePopulator::KisAnimationCachePopulator(KisPart *part)
     : m_d(new Private(this, part))
 {
     connect(&m_d->timer, SIGNAL(timeout()), this, SLOT(slotTimer()));
 
     connect(&m_d->regenerator, SIGNAL(sigFrameCancelled(int)), SLOT(slotRegeneratorFrameCancelled()));
     connect(&m_d->regenerator, SIGNAL(sigFrameCompleted(int)), SLOT(slotRegeneratorFrameReady()));
 
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotConfigChanged()));
     slotConfigChanged();
 }
 
 KisAnimationCachePopulator::~KisAnimationCachePopulator()
 {}
 
 bool KisAnimationCachePopulator::regenerate(KisAnimationFrameCacheSP cache, int frame)
 {
     return m_d->regenerate(cache, frame);
 }
 
 void KisAnimationCachePopulator::slotTimer()
 {
     m_d->timerTimeout();
 }
 
 void KisAnimationCachePopulator::slotRequestRegeneration()
 {
     // skip if the user forbade background regeneration
     if (!m_d->calculateAnimationCacheInBackground) return;
 
     m_d->enterState(Private::WaitingForIdle);
 }
 
 void KisAnimationCachePopulator::slotRegeneratorFrameCancelled()
 {
     KIS_ASSERT_RECOVER_RETURN(m_d->state == Private::WaitingForFrame);
     m_d->enterState(Private::NotWaitingForAnything);
 }
 
 void KisAnimationCachePopulator::slotRegeneratorFrameReady()
 {
     m_d->enterState(Private::BetweenFrames);
 }
 
 void KisAnimationCachePopulator::slotConfigChanged()
 {
     KisConfig cfg;
     m_d->calculateAnimationCacheInBackground = cfg.calculateAnimationCacheInBackground();
+    QTimer::singleShot(1000, this, SLOT(slotRequestRegeneration()));
 }
diff --git a/libs/ui/kis_animation_frame_cache.cpp b/libs/ui/kis_animation_frame_cache.cpp
index d14eed1335..f377acf40d 100644
--- a/libs/ui/kis_animation_frame_cache.cpp
+++ b/libs/ui/kis_animation_frame_cache.cpp
@@ -1,239 +1,410 @@
 /*
  *  Copyright (c) 2015 Jouni Pentikäinen <joupent@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_animation_frame_cache.h"
 
 #include <QMap>
 
 #include "kis_debug.h"
 
 #include "kis_image.h"
 #include "kis_image_animation_interface.h"
 #include "kis_time_range.h"
 #include "KisPart.h"
 #include "kis_animation_cache_populator.h"
 
+#include <KisAbstractFrameCacheSwapper.h>
+#include "KisFrameCacheSwapper.h"
+#include "KisInMemoryFrameCacheSwapper.h"
+
+#include "kis_image_config.h"
+#include "kis_config_notifier.h"
+
 #include "opengl/kis_opengl_image_textures.h"
 
+#include <kis_algebra_2d.h>
+#include <cmath>
+
 
 struct KisAnimationFrameCache::Private
 {
     Private(KisOpenGLImageTexturesSP _textures)
         : textures(_textures)
     {
         image = textures->image();
     }
 
     ~Private()
     {
-        qDeleteAll(frames);
     }
 
     KisOpenGLImageTexturesSP textures;
     KisImageWSP image;
 
+    QScopedPointer<KisAbstractFrameCacheSwapper> swapper;
+    int frameSizeLimit = 777;
+
+    KisOpenGLUpdateInfoSP fetchFrameDataImpl(KisImageSP image, const QRect &requestedRect, int lod);
+
     struct Frame
     {
         KisOpenGLUpdateInfoSP openGlFrame;
         int length;
 
         Frame(KisOpenGLUpdateInfoSP info, int length)
             : openGlFrame(info), length(length)
         {}
     };
 
-    QMap<int, Frame*> frames;
+    QMap<int, int> newFrames;
 
-    Frame *getFrame(int time)
+    int getFrameIdAtTime(int time) const
     {
-        if (frames.isEmpty()) return 0;
+        if (newFrames.isEmpty()) return -1;
 
-        QMap<int, Frame*>::iterator it = frames.upperBound(time);
+        auto it = newFrames.upperBound(time);
 
-        if (it != frames.begin()) it--;
+        if (it != newFrames.constBegin()) it--;
 
-        Q_ASSERT(it != frames.end());
-        int start = it.key();
-        int length = it.value()->length;
+        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(it != newFrames.constEnd(), 0);
+        const int start = it.key();
+        const int length = it.value();
+
+        bool foundFrameValid = false;
 
         if (length == -1) {
-            if (start <= time) return it.value();
+            if (start <= time) {
+                foundFrameValid = true;
+            }
         } else {
             int end = start + length - 1;
-            if (start <= time && time <= end) return it.value();
+            if (start <= time && time <= end) {
+                foundFrameValid = true;
+            }
         }
 
-        return 0;
+        return foundFrameValid ? start : -1;
+    }
+
+    bool hasFrame(int time) const {
+        return getFrameIdAtTime(time) >= 0;
+    }
+
+    KisOpenGLUpdateInfoSP getFrame(int time)
+    {
+        const int frameId = getFrameIdAtTime(time);
+        return frameId >= 0 ? swapper->loadFrame(frameId) : 0;
     }
 
     void addFrame(KisOpenGLUpdateInfoSP info, const KisTimeRange& range)
     {
         invalidate(range);
 
-        int length = range.isInfinite() ? -1 : range.end() - range.start() + 1;
-        Frame *frame = new Frame(info, length);
-
-        frames.insert(range.start(), frame);
+        const int length = range.isInfinite() ? -1 : range.end() - range.start() + 1;
+        newFrames.insert(range.start(), length);
+        swapper->saveFrame(range.start(), info, image->bounds());
     }
 
     /**
      * Invalidate any cached frames within the given time range.
      * @param range
      * @return true if frames were invalidated, false if nothing was changed
      */
     bool invalidate(const KisTimeRange& range)
     {
-        if (frames.isEmpty()) return false;
+        if (newFrames.isEmpty()) return false;
 
         bool cacheChanged = false;
 
-        QMap<int, Frame*>::iterator it = frames.lowerBound(range.start());
-        if (it.key() != range.start() && it != frames.begin()) it--;
+        auto it = newFrames.lowerBound(range.start());
+        if (it.key() != range.start() && it != newFrames.begin()) it--;
 
-        while (it != frames.end()) {
-            Frame *frame = it.value();
-            int start = it.key();
-            int length = it.value()->length;
-            bool frameIsInfinite = (length == -1);
-            int end = start + length - 1;
+        while (it != newFrames.end()) {
+            const int start = it.key();
+            const int length = it.value();
+            const bool frameIsInfinite = (length == -1);
+            const int end = start + length - 1;
 
             if (start >= range.start()) {
                 if (!range.isInfinite() && start > range.end()) {
                     break;
                 }
 
                 if (!range.isInfinite() && (frameIsInfinite || end > range.end())) {
                     // Reinsert with a later start
                     int newStart = range.end() + 1;
                     int newLength = frameIsInfinite ? -1 : (end - newStart + 1);
-                    frames.insert(newStart, new Frame(frame->openGlFrame, newLength));
+
+                    newFrames.insert(newStart, newLength);
+                    swapper->moveFrame(start, newStart);
+                } else {
+                    swapper->forgetFrame(start);
                 }
 
-                it = frames.erase(it);
-                delete frame;
+                it = newFrames.erase(it);
 
                 cacheChanged = true;
                 continue;
 
             } else if (frameIsInfinite || end >= range.start()) {
-                int newEnd = range.start() - 1;
-                frame->length = newEnd - start + 1;
+                const int newEnd = range.start() - 1;
+                *it = newEnd - start + 1;
 
                 cacheChanged = true;
             }
 
             it++;
         }
 
         return cacheChanged;
     }
 
+    int effectiveLevelOfDetail(const QRect &rc) const {
+        if (!frameSizeLimit) return 0;
+
+        const int maxDimension = KisAlgebra2D::maxDimension(rc);
+
+        const qreal minLod = -std::log2(qreal(frameSizeLimit) / maxDimension);
+        const int lodLimit = qMax(0, qCeil(minLod));
+        return lodLimit;
+    }
+
+
     // TODO: verify that we don't have any leak here!
     typedef QMap<KisOpenGLImageTexturesSP, KisAnimationFrameCache*> CachesMap;
     static CachesMap caches;
 };
 
 KisAnimationFrameCache::Private::CachesMap KisAnimationFrameCache::Private::caches;
 
 KisAnimationFrameCacheSP KisAnimationFrameCache::getFrameCache(KisOpenGLImageTexturesSP textures)
 {
     KisAnimationFrameCache *cache;
 
     Private::CachesMap::iterator it = Private::caches.find(textures);
     if (it == Private::caches.end()) {
         cache = new KisAnimationFrameCache(textures);
         Private::caches.insert(textures, cache);
     } else {
         cache = it.value();
     }
 
     return cache;
 }
 
 const QList<KisAnimationFrameCache *> KisAnimationFrameCache::caches()
 {
     return Private::caches.values();
 }
 
 KisAnimationFrameCache::KisAnimationFrameCache(KisOpenGLImageTexturesSP textures)
     : m_d(new Private(textures))
 {
+    // create swapping backend
+    slotConfigChanged();
+
     connect(m_d->image->animationInterface(), SIGNAL(sigFramesChanged(KisTimeRange,QRect)), this, SLOT(framesChanged(KisTimeRange,QRect)));
+    connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotConfigChanged()));
 }
 
 KisAnimationFrameCache::~KisAnimationFrameCache()
 {
     Private::caches.remove(m_d->textures);
 }
 
 bool KisAnimationFrameCache::uploadFrame(int time)
 {
-    Private::Frame *frame = m_d->getFrame(time);
+    KisOpenGLUpdateInfoSP info = m_d->getFrame(time);
 
-    if (!frame) {
-        KisPart::instance()->cachePopulator()->regenerate(this, time);
+    if (!info) {
+        // Do nothing!
+        //
+        // Previously we were trying to start cache regeneration in this point,
+        // but it caused even bigger slowdowns when scrubbing
     } else {
-        m_d->textures->recalculateCache(frame->openGlFrame);
+        m_d->textures->recalculateCache(info);
     }
 
-    return frame != 0;
+    return bool(info);
+}
+
+bool KisAnimationFrameCache::shouldUploadNewFrame(int newTime, int oldTime) const
+{
+    if (oldTime < 0) return true;
+
+    const int oldKeyframeStart = m_d->getFrameIdAtTime(oldTime);
+    if (oldKeyframeStart < 0) return true;
+
+    const int oldKeyFrameLength = m_d->newFrames[oldKeyframeStart];
+    return !(newTime >= oldKeyframeStart && (newTime < oldKeyframeStart + oldKeyFrameLength || oldKeyFrameLength == -1));
 }
 
 KisAnimationFrameCache::CacheStatus KisAnimationFrameCache::frameStatus(int time) const
 {
-    Private::Frame *frame = m_d->getFrame(time);
-    return (frame) ? Cached : Uncached;
+    return m_d->hasFrame(time) ? Cached : Uncached;
 }
 
 KisImageWSP KisAnimationFrameCache::image()
 {
     return m_d->image;
 }
 
 void KisAnimationFrameCache::framesChanged(const KisTimeRange &range, const QRect &rect)
 {
     Q_UNUSED(rect);
 
     if (!range.isValid()) return;
 
     bool cacheChanged = m_d->invalidate(range);
 
     if (cacheChanged) {
         emit changed();
     }
 }
 
-KisOpenGLUpdateInfoSP KisAnimationFrameCache::fetchFrameData(int time, KisImageSP image) const
+void KisAnimationFrameCache::slotConfigChanged()
+{
+    m_d->newFrames.clear();
+
+    KisImageConfig cfg;
+
+    if (cfg.useOnDiskAnimationCacheSwapping()) {
+        m_d->swapper.reset(new KisFrameCacheSwapper(m_d->textures->updateInfoBuilder(), cfg.swapDir()));
+    } else {
+        m_d->swapper.reset(new KisInMemoryFrameCacheSwapper());
+    }
+
+    m_d->frameSizeLimit = cfg.useAnimationCacheFrameSizeLimit() ? cfg.animationCacheFrameSizeLimit() : 0;
+    emit changed();
+}
+
+KisOpenGLUpdateInfoSP KisAnimationFrameCache::Private::fetchFrameDataImpl(KisImageSP image, const QRect &requestedRect, int lod)
+{
+    if (lod > 0) {
+        KisPaintDeviceSP tempDevice = new KisPaintDevice(image->projection()->colorSpace());
+        tempDevice->prepareClone(image->projection());
+        image->projection()->generateLodCloneDevice(tempDevice, image->projection()->extent(), lod);
+
+        const QRect fetchRect = KisLodTransform::alignedRect(requestedRect, lod);
+        return textures->updateInfoBuilder().buildUpdateInfo(fetchRect, tempDevice, image->bounds(), lod, true);
+    } else {
+        return textures->updateCache(requestedRect, image);
+    }
+}
+
+KisOpenGLUpdateInfoSP KisAnimationFrameCache::fetchFrameData(int time, KisImageSP image, const QRegion &requestedRegion) const
 {
     if (time != image->animationInterface()->currentTime()) {
         qWarning() << "WARNING: KisAnimationFrameCache::frameReady image's time doesn't coincide with the requested time!";
         qWarning() << "    "  << ppVar(image->animationInterface()->currentTime()) << ppVar(time);
     }
 
-    return m_d->textures->updateCache(image->bounds(), image);
+    // the frames are always generated at full scale
+    KIS_SAFE_ASSERT_RECOVER_NOOP(image->currentLevelOfDetail() == 0);
+
+    const int lod = m_d->effectiveLevelOfDetail(requestedRegion.boundingRect());
+
+    KisOpenGLUpdateInfoSP totalInfo;
+
+    Q_FOREACH (const QRect &rc, requestedRegion.rects()) {
+        KisOpenGLUpdateInfoSP info = m_d->fetchFrameDataImpl(image, rc, lod);
+        if (!totalInfo) {
+            totalInfo = info;
+        } else {
+            const bool result = totalInfo->tryMergeWith(*info);
+            KIS_SAFE_ASSERT_RECOVER_NOOP(result);
+        }
+    }
+
+    return totalInfo;
 }
 
 void KisAnimationFrameCache::addConvertedFrameData(KisOpenGLUpdateInfoSP info, int time)
 {
     KisTimeRange identicalRange = KisTimeRange::infinite(0);
     KisTimeRange::calculateTimeRangeRecursive(m_d->image->root(), time, identicalRange, true);
 
     m_d->addFrame(info, identicalRange);
 
     emit changed();
 }
+
+void KisAnimationFrameCache::dropLowQualityFrames(const KisTimeRange &range, const QRect &regionOfInterest, const QRect &minimalRect)
+{
+    if (m_d->newFrames.isEmpty()) return;
+
+    auto it = m_d->newFrames.upperBound(range.start());
+
+    if (it != m_d->newFrames.begin()) it--;
+
+    while (it.key() <= range.end()) {
+        const int frameId = it.key();
+        const int frameLength = it.value();
+
+        if (frameId + frameLength - 1 < range.start()) {
+            ++it;
+            continue;
+        }
+
+        const QRect frameRect = m_d->swapper->frameDirtyRect(frameId);
+        const int frameLod = m_d->swapper->frameLevelOfDetail(frameId);
+
+        if (frameLod > m_d->effectiveLevelOfDetail(regionOfInterest) || !frameRect.contains(minimalRect)) {
+            m_d->swapper->forgetFrame(frameId);
+            it = m_d->newFrames.erase(it);
+        } else {
+            ++it;
+        }
+    }
+}
+
+bool KisAnimationFrameCache::framesHaveValidRoi(const KisTimeRange &range, const QRect &regionOfInterest)
+{
+    if (m_d->newFrames.isEmpty()) return false;
+
+    auto it = m_d->newFrames.upperBound(range.start());
+
+    if (it != m_d->newFrames.begin()) it--;
+
+    int expectedNextFrameStart = it.key();
+
+    while (it.key() <= range.end()) {
+        const int frameId = it.key();
+        const int frameLength = it.value();
+
+        if (frameId + frameLength - 1 < range.start()) {
+            expectedNextFrameStart = frameId + frameLength;
+            ++it;
+            continue;
+        }
+
+        if (expectedNextFrameStart != frameId) {
+            KIS_SAFE_ASSERT_RECOVER_NOOP(expectedNextFrameStart < frameId);
+            return false;
+        }
+
+        if (!m_d->swapper->frameDirtyRect(frameId).contains(regionOfInterest)) {
+            return false;
+        }
+
+        expectedNextFrameStart = frameId + frameLength;
+        ++it;
+    }
+
+    return true;
+}
diff --git a/libs/ui/kis_animation_frame_cache.h b/libs/ui/kis_animation_frame_cache.h
index e74ecdf385..d5321fceb1 100644
--- a/libs/ui/kis_animation_frame_cache.h
+++ b/libs/ui/kis_animation_frame_cache.h
@@ -1,78 +1,89 @@
 /*
  *  Copyright (c) 2015 Jouni Pentikäinen <joupent@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef KIS_ANIMATION_FRAME_CACHE_H
 #define KIS_ANIMATION_FRAME_CACHE_H
 
 #include <QImage>
 #include <QObject>
 
 #include "kritaui_export.h"
 #include "kis_types.h"
 #include "kis_shared.h"
 
 class KisImage;
 class KisImageAnimationInterface;
 class KisTimeRange;
 
 class KisOpenGLImageTextures;
 typedef KisSharedPtr<KisOpenGLImageTextures> KisOpenGLImageTexturesSP;
 
 class KisOpenGLUpdateInfo;
 typedef KisSharedPtr<KisOpenGLUpdateInfo> KisOpenGLUpdateInfoSP;
 
 class KRITAUI_EXPORT KisAnimationFrameCache : public QObject, public KisShared
 {
     Q_OBJECT
 
 public:
 
     static KisAnimationFrameCacheSP getFrameCache(KisOpenGLImageTexturesSP textures);
     static const QList<KisAnimationFrameCache*> caches();
 
     KisAnimationFrameCache(KisOpenGLImageTexturesSP textures);
     ~KisAnimationFrameCache() override;
 
     QImage getFrame(int time);
     bool uploadFrame(int time);
 
+    bool shouldUploadNewFrame(int newTime, int oldTime) const;
+
     enum CacheStatus {
         Cached,
         Uncached,
     };
 
     CacheStatus frameStatus(int time) const;
 
     KisImageWSP image();
 
-    KisOpenGLUpdateInfoSP fetchFrameData(int time, KisImageSP image) const;
+    KisOpenGLUpdateInfoSP fetchFrameData(int time, KisImageSP image, const QRegion &requestedRegion) const;
     void addConvertedFrameData(KisOpenGLUpdateInfoSP info, int time);
 
+    /**
+     * Drops all the frames with worse level of detail values than the current
+     * desired level of detail.
+     */
+    void dropLowQualityFrames(const KisTimeRange &range, const QRect &regionOfInterest, const QRect &minimalRect);
+
+    bool framesHaveValidRoi(const KisTimeRange &range, const QRect &regionOfInterest);
+
 Q_SIGNALS:
     void changed();
 
 private:
 
     struct Private;
     QScopedPointer<Private> m_d;
 
 private Q_SLOTS:
     void framesChanged(const KisTimeRange &range, const QRect &rect);
+    void slotConfigChanged();
 };
 
 #endif
diff --git a/libs/ui/opengl/KisOpenGLUpdateInfoBuilder.cpp b/libs/ui/opengl/KisOpenGLUpdateInfoBuilder.cpp
new file mode 100644
index 0000000000..c34367cbd0
--- /dev/null
+++ b/libs/ui/opengl/KisOpenGLUpdateInfoBuilder.cpp
@@ -0,0 +1,272 @@
+/*
+ *  Copyright (c) 2018 Dmitry Kazakov <dimula73@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 "KisOpenGLUpdateInfoBuilder.h"
+
+// TODO: conversion options into a separate file!
+#include "kis_update_info.h"
+#include "opengl/kis_texture_tile_info_pool.h"
+
+#include "KisProofingConfiguration.h"
+
+#include <QReadWriteLock>
+#include <QReadLocker>
+#include <QWriteLocker>
+
+
+struct KRITAUI_NO_EXPORT KisOpenGLUpdateInfoBuilder::Private
+{
+    ConversionOptions conversionOptions;
+
+    QBitArray channelFlags;
+    bool onlyOneChannelSelected = false;
+    int selectedChannelIndex = -1;
+
+    int textureBorder = 0;
+    QSize effectiveTextureSize;
+
+    KisProofingConfigurationSP proofingConfig;
+    QScopedPointer<KoColorConversionTransformation> proofingTransform;
+
+    KisTextureTileInfoPoolSP pool;
+    QReadWriteLock lock;
+};
+
+
+KisOpenGLUpdateInfoBuilder::KisOpenGLUpdateInfoBuilder()
+    : m_d(new Private)
+{
+}
+
+KisOpenGLUpdateInfoBuilder::~KisOpenGLUpdateInfoBuilder()
+{
+}
+
+KisOpenGLUpdateInfoSP KisOpenGLUpdateInfoBuilder::buildUpdateInfo(const QRect &rect, KisImageSP srcImage, bool convertColorSpace)
+{
+    return buildUpdateInfo(rect, srcImage->projection(), srcImage->bounds(), srcImage->currentLevelOfDetail(), convertColorSpace);
+}
+
+KisOpenGLUpdateInfoSP KisOpenGLUpdateInfoBuilder::buildUpdateInfo(const QRect &rect, KisPaintDeviceSP projection, const QRect &bounds, int levelOfDetail, bool convertColorSpace)
+{
+    KisOpenGLUpdateInfoSP info = new KisOpenGLUpdateInfo();
+
+    QRect updateRect = rect & bounds;
+    if (updateRect.isEmpty()) return info;
+
+    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(m_d->pool, info);
+    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(m_d->conversionOptions.m_destinationColorSpace, info);
+
+    auto needCreateProofingTransform =
+        [this] () {
+            return !m_d->proofingTransform &&
+                m_d->proofingConfig &&
+                m_d->proofingConfig->conversionFlags.testFlag(KoColorConversionTransformation::SoftProofing);
+        };
+
+    // lazily create transform
+    if (convertColorSpace && needCreateProofingTransform()) {
+
+        QWriteLocker locker(&m_d->lock);
+        if (needCreateProofingTransform()) {
+            const KoColorSpace *proofingSpace = KoColorSpaceRegistry::instance()->colorSpace(m_d->proofingConfig->proofingModel,
+                                                                                             m_d->proofingConfig->proofingDepth,
+                                                                                             m_d->proofingConfig->proofingProfile);
+
+            m_d->proofingTransform.reset(KisTextureTileUpdateInfo::generateProofingTransform(
+                                             projection->colorSpace(),
+                                             m_d->conversionOptions.m_destinationColorSpace,
+                                             proofingSpace,
+                                             m_d->conversionOptions.m_renderingIntent,
+                                             m_d->proofingConfig->intent,
+                                             m_d->proofingConfig->conversionFlags,
+                                             m_d->proofingConfig->warningColor,
+                                             m_d->proofingConfig->adaptationState));
+        }
+    }
+
+    QReadLocker locker(&m_d->lock);
+
+    /**
+     * Why the rect is artificial? That's easy!
+     * It does not represent any real piece of the image. It is
+     * intentionally stretched to get through the overlappping
+     * stripes of neutrality and poke neighbouring tiles.
+     * Thanks to the rect we get the coordinates of all the tiles
+     * involved into update process
+     */
+
+    QRect artificialRect = kisGrowRect(updateRect, m_d->textureBorder);
+    artificialRect &= bounds;
+
+    int firstColumn = xToCol(artificialRect.left());
+    int lastColumn = xToCol(artificialRect.right());
+    int firstRow = yToRow(artificialRect.top());
+    int lastRow = yToRow(artificialRect.bottom());
+
+    QBitArray channelFlags; // empty by default
+
+    if (!m_d->channelFlags.isEmpty() &&
+        m_d->channelFlags.size() == projection->colorSpace()->channels().size()) {
+
+        channelFlags = m_d->channelFlags;
+    }
+
+    qint32 numItems = (lastColumn - firstColumn + 1) * (lastRow - firstRow + 1);
+    info->tileList.reserve(numItems);
+
+    QRect alignedUpdateRect = updateRect;
+    QRect alignedBounds = bounds;
+
+    if (levelOfDetail) {
+        alignedUpdateRect = KisLodTransform::alignedRect(alignedUpdateRect, levelOfDetail);
+        alignedBounds = KisLodTransform::alignedRect(alignedBounds, levelOfDetail);
+    }
+
+    for (int col = firstColumn; col <= lastColumn; col++) {
+        for (int row = firstRow; row <= lastRow; row++) {
+
+            const QRect alignedTileTextureRect = calculatePhysicalTileRect(col, row, bounds, levelOfDetail);
+
+            KisTextureTileUpdateInfoSP tileInfo(
+                        new KisTextureTileUpdateInfo(col, row,
+                                                     alignedTileTextureRect,
+                                                     alignedUpdateRect,
+                                                     alignedBounds,
+                                                     levelOfDetail,
+                                                     m_d->pool));
+            // Don't update empty tiles
+            if (tileInfo->valid()) {
+                tileInfo->retrieveData(projection, channelFlags, m_d->onlyOneChannelSelected, m_d->selectedChannelIndex);
+
+                if (convertColorSpace) {
+                    if (m_d->proofingTransform) {
+                        tileInfo->proofTo(m_d->conversionOptions.m_destinationColorSpace, m_d->proofingConfig->conversionFlags, m_d->proofingTransform.data());
+                    } else {
+                        tileInfo->convertTo(m_d->conversionOptions.m_destinationColorSpace, m_d->conversionOptions.m_renderingIntent, m_d->conversionOptions.m_conversionFlags);
+                    }
+                }
+
+                info->tileList.append(tileInfo);
+            }
+            else {
+                dbgUI << "Trying to create an empty tileinfo record" << col << row << alignedTileTextureRect << updateRect << bounds;
+            }
+        }
+    }
+
+    info->assignDirtyImageRect(rect);
+    info->assignLevelOfDetail(levelOfDetail);
+    return info;
+}
+
+QRect KisOpenGLUpdateInfoBuilder::calculateEffectiveTileRect(int col, int row, const QRect &imageBounds) const
+{
+    return imageBounds &
+            QRect(col * m_d->effectiveTextureSize.width(),
+                  row * m_d->effectiveTextureSize.height(),
+                  m_d->effectiveTextureSize.width(),
+                  m_d->effectiveTextureSize.height());
+}
+
+QRect KisOpenGLUpdateInfoBuilder::calculatePhysicalTileRect(int col, int row, const QRect &imageBounds, int levelOfDetail) const
+{
+    const QRect tileRect = calculateEffectiveTileRect(col, row, imageBounds);
+    const QRect tileTextureRect = kisGrowRect(tileRect, m_d->textureBorder);
+
+    const QRect alignedTileTextureRect = levelOfDetail ?
+                KisLodTransform::alignedRect(tileTextureRect, levelOfDetail) :
+                tileTextureRect;
+
+    return alignedTileTextureRect;
+}
+
+
+int KisOpenGLUpdateInfoBuilder::xToCol(int x) const
+{
+    return x / m_d->effectiveTextureSize.width();
+}
+
+int KisOpenGLUpdateInfoBuilder::yToRow(int y) const
+{
+    return y / m_d->effectiveTextureSize.height();
+}
+
+const KoColorSpace *KisOpenGLUpdateInfoBuilder::destinationColorSpace() const
+{
+    QReadLocker lock(&m_d->lock);
+
+    return m_d->conversionOptions.m_destinationColorSpace;
+}
+
+void KisOpenGLUpdateInfoBuilder::setConversionOptions(const ConversionOptions &options)
+{
+    QWriteLocker lock(&m_d->lock);
+
+    m_d->conversionOptions = options;
+}
+
+void KisOpenGLUpdateInfoBuilder::setChannelFlags(const QBitArray &channelFrags, bool onlyOneChannelSelected, int selectedChannelIndex)
+{
+    QWriteLocker lock(&m_d->lock);
+
+    m_d->channelFlags = channelFrags;
+    m_d->onlyOneChannelSelected = onlyOneChannelSelected;
+    m_d->selectedChannelIndex = selectedChannelIndex;
+}
+
+void KisOpenGLUpdateInfoBuilder::setTextureBorder(int value)
+{
+    QWriteLocker lock(&m_d->lock);
+
+    m_d->textureBorder = value;
+}
+
+void KisOpenGLUpdateInfoBuilder::setEffectiveTextureSize(const QSize &size)
+{
+    QWriteLocker lock(&m_d->lock);
+
+    m_d->effectiveTextureSize = size;
+}
+
+void KisOpenGLUpdateInfoBuilder::setTextureInfoPool(KisTextureTileInfoPoolSP pool)
+{
+    QWriteLocker lock(&m_d->lock);
+
+    m_d->pool = pool;
+}
+
+KisTextureTileInfoPoolSP KisOpenGLUpdateInfoBuilder::textureInfoPool() const
+{
+    QReadLocker lock(&m_d->lock);
+    return m_d->pool;
+}
+
+void KisOpenGLUpdateInfoBuilder::setProofingConfig(KisProofingConfigurationSP config)
+{
+    QWriteLocker lock(&m_d->lock);
+
+    m_d->proofingConfig = config;
+    m_d->proofingTransform.reset();
+}
+
+KisProofingConfigurationSP KisOpenGLUpdateInfoBuilder::proofingConfig() const
+{
+    QReadLocker lock(&m_d->lock);
+
+    return m_d->proofingConfig;
+}
diff --git a/libs/ui/opengl/KisOpenGLUpdateInfoBuilder.h b/libs/ui/opengl/KisOpenGLUpdateInfoBuilder.h
new file mode 100644
index 0000000000..3700f64eff
--- /dev/null
+++ b/libs/ui/opengl/KisOpenGLUpdateInfoBuilder.h
@@ -0,0 +1,80 @@
+/*
+ *  Copyright (c) 2018 Dmitry Kazakov <dimula73@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 KISOPENGLUPDATEINFOBUILDER_H
+#define KISOPENGLUPDATEINFOBUILDER_H
+
+#include "kritaui_export.h"
+#include <QScopedPointer>
+#include <QSharedPointer>
+
+class KisProofingConfiguration;
+typedef QSharedPointer<KisProofingConfiguration> KisProofingConfigurationSP;
+
+class KisTextureTileInfoPool;
+typedef QSharedPointer<KisTextureTileInfoPool> KisTextureTileInfoPoolSP;
+
+template<class T>
+class KisSharedPtr;
+
+class KisImage;
+typedef KisSharedPtr<KisImage> KisImageSP;
+
+class KisPaintDevice;
+typedef KisSharedPtr<KisPaintDevice> KisPaintDeviceSP;
+
+class KisOpenGLUpdateInfo;
+typedef KisSharedPtr<KisOpenGLUpdateInfo> KisOpenGLUpdateInfoSP;
+
+class KoColorSpace;
+struct ConversionOptions;
+
+
+class KRITAUI_EXPORT KisOpenGLUpdateInfoBuilder
+{
+public:
+    KisOpenGLUpdateInfoBuilder();
+    ~KisOpenGLUpdateInfoBuilder();
+
+    KisOpenGLUpdateInfoSP buildUpdateInfo(const QRect& rect, KisImageSP srcImage, bool convertColorSpace);
+    KisOpenGLUpdateInfoSP buildUpdateInfo(const QRect& rect, KisPaintDeviceSP projection, const QRect &bounds, int levelOfDetail, bool convertColorSpace);
+
+    QRect calculatePhysicalTileRect(int col, int row, const QRect &imageBounds, int levelOfDetail) const;
+    QRect calculateEffectiveTileRect(int col, int row, const QRect &imageBounds) const;
+    int xToCol(int x) const;
+    int yToRow(int y) const;
+
+    const KoColorSpace* destinationColorSpace() const;
+
+    void setConversionOptions(const ConversionOptions &options);
+    void setChannelFlags(const QBitArray &channelFrags, bool onlyOneChannelSelected, int selectedChannelIndex);
+
+    void setTextureBorder(int value);
+    void setEffectiveTextureSize(const QSize &size);
+
+    void setTextureInfoPool(KisTextureTileInfoPoolSP pool);
+    KisTextureTileInfoPoolSP textureInfoPool() const;
+
+    void setProofingConfig(KisProofingConfigurationSP config);
+    KisProofingConfigurationSP proofingConfig() const;
+
+private:
+    struct Private;
+    const QScopedPointer<Private> m_d;
+};
+
+#endif // KISOPENGLUPDATEINFOBUILDER_H
diff --git a/libs/ui/opengl/kis_opengl_canvas2.cpp b/libs/ui/opengl/kis_opengl_canvas2.cpp
index 97cccb1072..678cfe5972 100644
--- a/libs/ui/opengl/kis_opengl_canvas2.cpp
+++ b/libs/ui/opengl/kis_opengl_canvas2.cpp
@@ -1,931 +1,952 @@
 /* This file is part of the KDE project
  * Copyright (C) Boudewijn Rempt <boud@valdyas.org>, (C) 2006-2013
  * Copyright (C) 2015 Michael Abrahams <miabraha@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.
  */
 
 #define GL_GLEXT_PROTOTYPES
 
 #include "opengl/kis_opengl_canvas2.h"
 #include "opengl/kis_opengl_canvas2_p.h"
 
 #include "opengl/kis_opengl_shader_loader.h"
 #include "opengl/kis_opengl_canvas_debugger.h"
 #include "canvas/kis_canvas2.h"
 #include "canvas/kis_coordinates_converter.h"
 #include "canvas/kis_display_filter.h"
 #include "canvas/kis_display_color_converter.h"
 #include "kis_config.h"
 #include "kis_config_notifier.h"
 #include "kis_debug.h"
 
 #include <QPainter>
 #include <QPainterPath>
 #include <QPointF>
 #include <QMatrix>
 #include <QTransform>
 #include <QThread>
 #include <QFile>
 #include <QOpenGLShaderProgram>
 #include <QOpenGLVertexArrayObject>
 #include <QOpenGLBuffer>
 #include <QMessageBox>
 
 #ifndef Q_OS_OSX
 #include <QOpenGLFunctions_2_1>
 #endif
 
 #define NEAR_VAL -1000.0
 #define FAR_VAL 1000.0
 
 #ifndef GL_CLAMP_TO_EDGE
 #define GL_CLAMP_TO_EDGE 0x812F
 #endif
 
 #define PROGRAM_VERTEX_ATTRIBUTE 0
 #define PROGRAM_TEXCOORD_ATTRIBUTE 1
 
 static bool OPENGL_SUCCESS = false;
 
 struct KisOpenGLCanvas2::Private
 {
 public:
     ~Private() {
         delete displayShader;
         delete checkerShader;
         delete solidColorShader;
         Sync::deleteSync(glSyncObject);
     }
 
     bool canvasInitialized{false};
 
     KisOpenGLImageTexturesSP openGLImageTextures;
 
     KisOpenGLShaderLoader shaderLoader;
     KisShaderProgram *displayShader{0};
     KisShaderProgram *checkerShader{0};
     KisShaderProgram *solidColorShader{0};
     bool displayShaderCompiledWithDisplayFilterSupport{false};
 
     GLfloat checkSizeScale;
     bool scrollCheckers;
 
     QSharedPointer<KisDisplayFilter> displayFilter;
     KisOpenGL::FilterMode filterMode;
     bool proofingConfigIsUpdated=false;
 
     GLsync glSyncObject{0};
 
     bool wrapAroundMode{false};
 
     // Stores a quad for drawing the canvas
     QOpenGLVertexArrayObject quadVAO;
     QOpenGLBuffer quadBuffers[2];
 
     // Stores data for drawing tool outlines
     QOpenGLVertexArrayObject outlineVAO;
     QOpenGLBuffer lineBuffer;
 
     QVector3D vertices[6];
     QVector2D texCoords[6];
 
 #ifndef Q_OS_OSX
     QOpenGLFunctions_2_1 *glFn201;
 #endif
 
     qreal pixelGridDrawingThreshold;
     bool pixelGridEnabled;
     QColor gridColor;
     QColor cursorColor;
 
     int xToColWithWrapCompensation(int x, const QRect &imageRect) {
         int firstImageColumn = openGLImageTextures->xToCol(imageRect.left());
         int lastImageColumn = openGLImageTextures->xToCol(imageRect.right());
 
         int colsPerImage = lastImageColumn - firstImageColumn + 1;
         int numWraps = floor(qreal(x) / imageRect.width());
         int remainder = x - imageRect.width() * numWraps;
 
         return colsPerImage * numWraps + openGLImageTextures->xToCol(remainder);
     }
 
     int yToRowWithWrapCompensation(int y, const QRect &imageRect) {
         int firstImageRow = openGLImageTextures->yToRow(imageRect.top());
         int lastImageRow = openGLImageTextures->yToRow(imageRect.bottom());
 
         int rowsPerImage = lastImageRow - firstImageRow + 1;
         int numWraps = floor(qreal(y) / imageRect.height());
         int remainder = y - imageRect.height() * numWraps;
 
         return rowsPerImage * numWraps + openGLImageTextures->yToRow(remainder);
     }
 
 };
 
 KisOpenGLCanvas2::KisOpenGLCanvas2(KisCanvas2 *canvas,
                                    KisCoordinatesConverter *coordinatesConverter,
                                    QWidget *parent,
                                    KisImageWSP image,
                                    KisDisplayColorConverter *colorConverter)
     : QOpenGLWidget(parent)
     , KisCanvasWidgetBase(canvas, coordinatesConverter)
     , d(new Private())
 {
     KisConfig cfg;
     cfg.setCanvasState("OPENGL_STARTED");
 
     d->openGLImageTextures =
             KisOpenGLImageTextures::getImageTextures(image,
                                                      colorConverter->monitorProfile(),
                                                      colorConverter->renderingIntent(),
                                                      colorConverter->conversionFlags());
 
     setAcceptDrops(true);
     setAutoFillBackground(false);
 
     setFocusPolicy(Qt::StrongFocus);
     setAttribute(Qt::WA_NoSystemBackground, true);
 #ifdef Q_OS_OSX
     setAttribute(Qt::WA_AcceptTouchEvents, false);
 #else
     setAttribute(Qt::WA_AcceptTouchEvents, true);
 #endif
     setAttribute(Qt::WA_InputMethodEnabled, false);
     setAttribute(Qt::WA_DontCreateNativeAncestors, true);
 
     setDisplayFilterImpl(colorConverter->displayFilter(), true);
 
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotConfigChanged()));
     connect(KisConfigNotifier::instance(), SIGNAL(pixelGridModeChanged()), SLOT(slotPixelGridModeChanged()));
     slotConfigChanged();
     slotPixelGridModeChanged();
     cfg.writeEntry("canvasState", "OPENGL_SUCCESS");
 }
 
 KisOpenGLCanvas2::~KisOpenGLCanvas2()
 {
     delete d;
 }
 
 void KisOpenGLCanvas2::setDisplayFilter(QSharedPointer<KisDisplayFilter> displayFilter)
 {
     setDisplayFilterImpl(displayFilter, false);
 }
 
 void KisOpenGLCanvas2::setDisplayFilterImpl(QSharedPointer<KisDisplayFilter> displayFilter, bool initializing)
 {
     bool needsInternalColorManagement =
             !displayFilter || displayFilter->useInternalColorManagement();
 
     bool needsFullRefresh = d->openGLImageTextures->setInternalColorManagementActive(needsInternalColorManagement);
 
     d->displayFilter = displayFilter;
 
     if (!initializing && needsFullRefresh) {
         canvas()->startUpdateInPatches(canvas()->image()->bounds());
     }
     else if (!initializing)  {
         canvas()->updateCanvas();
     }
 }
 
 void KisOpenGLCanvas2::setWrapAroundViewingMode(bool value)
 {
     d->wrapAroundMode = value;
     update();
 }
 
 inline void rectToVertices(QVector3D* vertices, const QRectF &rc)
 {
     vertices[0] = QVector3D(rc.left(),  rc.bottom(), 0.f);
     vertices[1] = QVector3D(rc.left(),  rc.top(),    0.f);
     vertices[2] = QVector3D(rc.right(), rc.bottom(), 0.f);
     vertices[3] = QVector3D(rc.left(),  rc.top(), 0.f);
     vertices[4] = QVector3D(rc.right(), rc.top(), 0.f);
     vertices[5] = QVector3D(rc.right(), rc.bottom(),    0.f);
 }
 
 inline void rectToTexCoords(QVector2D* texCoords, const QRectF &rc)
 {
     texCoords[0] = QVector2D(rc.left(), rc.bottom());
     texCoords[1] = QVector2D(rc.left(), rc.top());
     texCoords[2] = QVector2D(rc.right(), rc.bottom());
     texCoords[3] = QVector2D(rc.left(), rc.top());
     texCoords[4] = QVector2D(rc.right(), rc.top());
     texCoords[5] = QVector2D(rc.right(), rc.bottom());
 }
 
 void KisOpenGLCanvas2::initializeGL()
 {
     KisOpenGL::initializeContext(context());
     initializeOpenGLFunctions();
 #ifndef Q_OS_OSX
     if (!KisOpenGL::hasOpenGLES()) {
         d->glFn201 = context()->versionFunctions<QOpenGLFunctions_2_1>();
         if (!d->glFn201) {
             warnUI << "Cannot obtain QOpenGLFunctions_2_1, glLogicOp cannot be used";
         }
     } else {
         d->glFn201 = nullptr;
     }
 #endif
 
     KisConfig cfg;
     d->openGLImageTextures->setProofingConfig(canvas()->proofingConfiguration());
     d->openGLImageTextures->initGL(context()->functions());
     d->openGLImageTextures->generateCheckerTexture(createCheckersImage(cfg.checkSize()));
 
     initializeShaders();
 
     // If we support OpenGL 3.2, then prepare our VAOs and VBOs for drawing
     if (KisOpenGL::hasOpenGL3()) {
         d->quadVAO.create();
         d->quadVAO.bind();
 
         glEnableVertexAttribArray(PROGRAM_VERTEX_ATTRIBUTE);
         glEnableVertexAttribArray(PROGRAM_TEXCOORD_ATTRIBUTE);
 
         // Create the vertex buffer object, it has 6 vertices with 3 components
         d->quadBuffers[0].create();
         d->quadBuffers[0].setUsagePattern(QOpenGLBuffer::StaticDraw);
         d->quadBuffers[0].bind();
         d->quadBuffers[0].allocate(d->vertices, 6 * 3 * sizeof(float));
         glVertexAttribPointer(PROGRAM_VERTEX_ATTRIBUTE, 3, GL_FLOAT, GL_FALSE, 0, 0);
 
         // Create the texture buffer object, it has 6 texture coordinates with 2 components
         d->quadBuffers[1].create();
         d->quadBuffers[1].setUsagePattern(QOpenGLBuffer::StaticDraw);
         d->quadBuffers[1].bind();
         d->quadBuffers[1].allocate(d->texCoords, 6 * 2 * sizeof(float));
         glVertexAttribPointer(PROGRAM_TEXCOORD_ATTRIBUTE, 2, GL_FLOAT, GL_FALSE, 0, 0);
 
         // Create the outline buffer, this buffer will store the outlines of
         // tools and will frequently change data
         d->outlineVAO.create();
         d->outlineVAO.bind();
 
         glEnableVertexAttribArray(PROGRAM_VERTEX_ATTRIBUTE);
 
         // The outline buffer has a StreamDraw usage pattern, because it changes constantly
         d->lineBuffer.create();
         d->lineBuffer.setUsagePattern(QOpenGLBuffer::StreamDraw);
         d->lineBuffer.bind();
         glVertexAttribPointer(PROGRAM_VERTEX_ATTRIBUTE, 3, GL_FLOAT, GL_FALSE, 0, 0);
     }
 
     Sync::init(context());
 
     d->canvasInitialized = true;
 }
 
 /**
  * Loads all shaders and reports compilation problems
  */
 void KisOpenGLCanvas2::initializeShaders()
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(!d->canvasInitialized);
 
     delete d->checkerShader;
     delete d->solidColorShader;
     d->checkerShader = 0;
     d->solidColorShader = 0;
 
     try {
         d->checkerShader = d->shaderLoader.loadCheckerShader();
         d->solidColorShader = d->shaderLoader.loadSolidColorShader();
     } catch (const ShaderLoaderException &e) {
         reportFailedShaderCompilation(e.what());
     }
 
     initializeDisplayShader();
 }
 
 void KisOpenGLCanvas2::initializeDisplayShader()
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(!d->canvasInitialized);
 
     bool useHiQualityFiltering = d->filterMode == KisOpenGL::HighQualityFiltering;
 
     delete d->displayShader;
     d->displayShader = 0;
 
     try {
         d->displayShader = d->shaderLoader.loadDisplayShader(d->displayFilter, useHiQualityFiltering);
         d->displayShaderCompiledWithDisplayFilterSupport = d->displayFilter;
     } catch (const ShaderLoaderException &e) {
         reportFailedShaderCompilation(e.what());
     }
 }
 
 /**
  * Displays a message box telling the user that
  * shader compilation failed and turns off OpenGL.
  */
 void KisOpenGLCanvas2::reportFailedShaderCompilation(const QString &context)
 {
     KisConfig cfg;
 
     qDebug() << "Shader Compilation Failure: " << context;
     QMessageBox::critical(this, i18nc("@title:window", "Krita"),
                           QString(i18n("Krita could not initialize the OpenGL canvas:\n\n%1\n\n Krita will disable OpenGL and close now.")).arg(context),
                           QMessageBox::Close);
 
     cfg.setUseOpenGL(false);
     cfg.setCanvasState("OPENGL_FAILED");
 }
 
 void KisOpenGLCanvas2::resizeGL(int width, int height)
 {
     coordinatesConverter()->setCanvasWidgetSize(QSize(width, height));
     paintGL();
 }
 
 void KisOpenGLCanvas2::paintGL()
 {
     if (!OPENGL_SUCCESS) {
         KisConfig cfg;
         cfg.writeEntry("canvasState", "OPENGL_PAINT_STARTED");
     }
 
     KisOpenglCanvasDebugger::instance()->nofityPaintRequested();
 
     renderCanvasGL();
 
     if (d->glSyncObject) {
         Sync::deleteSync(d->glSyncObject);
     }
     d->glSyncObject = Sync::getSync();
 
     QPainter gc(this);
     renderDecorations(&gc);
     gc.end();
 
     if (!OPENGL_SUCCESS) {
         KisConfig cfg;
         cfg.writeEntry("canvasState", "OPENGL_SUCCESS");
         OPENGL_SUCCESS = true;
     }
 }
 
 void KisOpenGLCanvas2::paintToolOutline(const QPainterPath &path)
 {
     if (!d->solidColorShader->bind()) {
         return;
     }
 
     // setup the mvp transformation
     QMatrix4x4 projectionMatrix;
     projectionMatrix.setToIdentity();
     projectionMatrix.ortho(0, width(), height(), 0, NEAR_VAL, FAR_VAL);
 
     // Set view/projection matrices
     QMatrix4x4 modelMatrix(coordinatesConverter()->flakeToWidgetTransform());
     modelMatrix.optimize();
     modelMatrix = projectionMatrix * modelMatrix;
     d->solidColorShader->setUniformValue(d->solidColorShader->location(Uniform::ModelViewProjection), modelMatrix);
 
     if (!KisOpenGL::hasOpenGLES()) {
         glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
 
         glEnable(GL_COLOR_LOGIC_OP);
 #ifndef Q_OS_OSX
         if (d->glFn201) {
             d->glFn201->glLogicOp(GL_XOR);
         }
 #else
         glLogicOp(GL_XOR);
 #endif
     } else {
         glEnable(GL_BLEND);
         glBlendFuncSeparate(GL_ONE_MINUS_DST_COLOR, GL_ZERO, GL_ONE, GL_ONE);
     }
 
     d->solidColorShader->setUniformValue(
                 d->solidColorShader->location(Uniform::FragmentColor),
                 QVector4D(d->cursorColor.redF(), d->cursorColor.greenF(), d->cursorColor.blueF(), 1.0f));
 
     // Paint the tool outline
     if (KisOpenGL::hasOpenGL3()) {
         d->outlineVAO.bind();
         d->lineBuffer.bind();
     }
 
     // Convert every disjointed subpath to a polygon and draw that polygon
     QList<QPolygonF> subPathPolygons = path.toSubpathPolygons();
     for (int i = 0; i < subPathPolygons.size(); i++) {
         const QPolygonF& polygon = subPathPolygons.at(i);
 
         QVector<QVector3D> vertices;
         vertices.resize(polygon.count());
 
         for (int j = 0; j < polygon.count(); j++) {
             QPointF p = polygon.at(j);
             vertices[j].setX(p.x());
             vertices[j].setY(p.y());
         }
         if (KisOpenGL::hasOpenGL3()) {
             d->lineBuffer.allocate(vertices.constData(), 3 * vertices.size() * sizeof(float));
         }
         else {
             d->solidColorShader->enableAttributeArray(PROGRAM_VERTEX_ATTRIBUTE);
             d->solidColorShader->setAttributeArray(PROGRAM_VERTEX_ATTRIBUTE, vertices.constData());
         }
 
         glDrawArrays(GL_LINE_STRIP, 0, vertices.size());
     }
 
     if (KisOpenGL::hasOpenGL3()) {
         d->lineBuffer.release();
         d->outlineVAO.release();
     }
 
     if (!KisOpenGL::hasOpenGLES()) {
         glDisable(GL_COLOR_LOGIC_OP);
     } else {
         glDisable(GL_BLEND);
     }
 
     d->solidColorShader->release();
 }
 
 bool KisOpenGLCanvas2::isBusy() const
 {
     const bool isBusyStatus = Sync::syncStatus(d->glSyncObject) == Sync::Unsignaled;
     KisOpenglCanvasDebugger::instance()->nofitySyncStatus(isBusyStatus);
 
     return isBusyStatus;
 }
 
 void KisOpenGLCanvas2::drawCheckers()
 {
     if (!d->checkerShader) {
         return;
     }
 
     KisCoordinatesConverter *converter = coordinatesConverter();
     QTransform textureTransform;
     QTransform modelTransform;
     QRectF textureRect;
     QRectF modelRect;
 
     QRectF viewportRect = !d->wrapAroundMode ?
                 converter->imageRectInViewportPixels() :
                 converter->widgetToViewport(this->rect());
 
+    if (!canvas()->renderingLimit().isEmpty()) {
+        const QRect vrect = converter->imageToViewport(canvas()->renderingLimit()).toAlignedRect();
+        viewportRect &= vrect;
+    }
+
     converter->getOpenGLCheckersInfo(viewportRect,
                                      &textureTransform, &modelTransform, &textureRect, &modelRect, d->scrollCheckers);
 
     textureTransform *= QTransform::fromScale(d->checkSizeScale / KisOpenGLImageTextures::BACKGROUND_TEXTURE_SIZE,
                                               d->checkSizeScale / KisOpenGLImageTextures::BACKGROUND_TEXTURE_SIZE);
 
     if (!d->checkerShader->bind()) {
         qWarning() << "Could not bind checker shader";
         return;
     }
 
     QMatrix4x4 projectionMatrix;
     projectionMatrix.setToIdentity();
     projectionMatrix.ortho(0, width(), height(), 0, NEAR_VAL, FAR_VAL);
 
     // Set view/projection matrices
     QMatrix4x4 modelMatrix(modelTransform);
     modelMatrix.optimize();
     modelMatrix = projectionMatrix * modelMatrix;
     d->checkerShader->setUniformValue(d->checkerShader->location(Uniform::ModelViewProjection), modelMatrix);
 
     QMatrix4x4 textureMatrix(textureTransform);
     d->checkerShader->setUniformValue(d->checkerShader->location(Uniform::TextureMatrix), textureMatrix);
 
     //Setup the geometry for rendering
     if (KisOpenGL::hasOpenGL3()) {
         rectToVertices(d->vertices, modelRect);
         d->quadBuffers[0].bind();
         d->quadBuffers[0].write(0, d->vertices, 3 * 6 * sizeof(float));
 
         rectToTexCoords(d->texCoords, textureRect);
         d->quadBuffers[1].bind();
         d->quadBuffers[1].write(0, d->texCoords, 2 * 6 * sizeof(float));
     }
     else {
         rectToVertices(d->vertices, modelRect);
         d->checkerShader->enableAttributeArray(PROGRAM_VERTEX_ATTRIBUTE);
         d->checkerShader->setAttributeArray(PROGRAM_VERTEX_ATTRIBUTE, d->vertices);
 
         rectToTexCoords(d->texCoords, textureRect);
         d->checkerShader->enableAttributeArray(PROGRAM_TEXCOORD_ATTRIBUTE);
         d->checkerShader->setAttributeArray(PROGRAM_TEXCOORD_ATTRIBUTE, d->texCoords);
     }
 
     // render checkers
     glActiveTexture(GL_TEXTURE0);
     glBindTexture(GL_TEXTURE_2D, d->openGLImageTextures->checkerTexture());
 
     glDrawArrays(GL_TRIANGLES, 0, 6);
 
     glBindTexture(GL_TEXTURE_2D, 0);
     d->checkerShader->release();
     glBindBuffer(GL_ARRAY_BUFFER, 0);
 }
 
 void KisOpenGLCanvas2::drawGrid()
 {
     if (!d->solidColorShader->bind()) {
         return;
     }
 
     QMatrix4x4 projectionMatrix;
     projectionMatrix.setToIdentity();
     projectionMatrix.ortho(0, width(), height(), 0, NEAR_VAL, FAR_VAL);
 
     // Set view/projection matrices
     QMatrix4x4 modelMatrix(coordinatesConverter()->imageToWidgetTransform());
     modelMatrix.optimize();
     modelMatrix = projectionMatrix * modelMatrix;
     d->solidColorShader->setUniformValue(d->solidColorShader->location(Uniform::ModelViewProjection), modelMatrix);
 
     glEnable(GL_BLEND);
     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
     d->solidColorShader->setUniformValue(
                 d->solidColorShader->location(Uniform::FragmentColor),
                 QVector4D(d->gridColor.redF(), d->gridColor.greenF(), d->gridColor.blueF(), 0.5f));
 
     if (KisOpenGL::hasOpenGL3()) {
         d->outlineVAO.bind();
         d->lineBuffer.bind();
     }
 
     QRectF widgetRect(0,0, width(), height());
     QRectF widgetRectInImagePixels = coordinatesConverter()->documentToImage(coordinatesConverter()->widgetToDocument(widgetRect));
     QRect wr = widgetRectInImagePixels.toAlignedRect();
 
     if (!d->wrapAroundMode) {
         wr &= d->openGLImageTextures->storedImageBounds();
     }
 
     QPoint topLeftCorner = wr.topLeft();
     QPoint bottomRightCorner = wr.bottomRight() + QPoint(1, 1);
     QVector<QVector3D> grid;
 
     for (int i = topLeftCorner.x(); i <= bottomRightCorner.x(); ++i) {
         grid.append(QVector3D(i, topLeftCorner.y(), 0));
         grid.append(QVector3D(i, bottomRightCorner.y(), 0));
     }
     for (int i = topLeftCorner.y(); i <= bottomRightCorner.y(); ++i) {
         grid.append(QVector3D(topLeftCorner.x(), i, 0));
         grid.append(QVector3D(bottomRightCorner.x(), i, 0));
     }
 
     if (KisOpenGL::hasOpenGL3()) {
         d->lineBuffer.allocate(grid.constData(), 3 * grid.size() * sizeof(float));
     }
     else {
         d->solidColorShader->enableAttributeArray(PROGRAM_VERTEX_ATTRIBUTE);
         d->solidColorShader->setAttributeArray(PROGRAM_VERTEX_ATTRIBUTE, grid.constData());
     }
 
     glDrawArrays(GL_LINES, 0, grid.size());
 
     if (KisOpenGL::hasOpenGL3()) {
         d->lineBuffer.release();
         d->outlineVAO.release();
     }
 
     d->solidColorShader->release();
     glDisable(GL_BLEND);
 }
 
 void KisOpenGLCanvas2::drawImage()
 {
     if (!d->displayShader) {
         return;
     }
 
     glEnable(GL_BLEND);
     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
     KisCoordinatesConverter *converter = coordinatesConverter();
 
     d->displayShader->bind();
 
     QMatrix4x4 projectionMatrix;
     projectionMatrix.setToIdentity();
     projectionMatrix.ortho(0, width(), height(), 0, NEAR_VAL, FAR_VAL);
 
     // Set view/projection matrices
     QMatrix4x4 modelMatrix(converter->imageToWidgetTransform());
     modelMatrix.optimize();
     modelMatrix = projectionMatrix * modelMatrix;
     d->displayShader->setUniformValue(d->displayShader->location(Uniform::ModelViewProjection), modelMatrix);
 
     QMatrix4x4 textureMatrix;
     textureMatrix.setToIdentity();
     d->displayShader->setUniformValue(d->displayShader->location(Uniform::TextureMatrix), textureMatrix);
 
     QRectF widgetRect(0,0, width(), height());
     QRectF widgetRectInImagePixels = converter->documentToImage(converter->widgetToDocument(widgetRect));
 
+    const QRect renderingLimit = canvas()->renderingLimit();
+
+    if (!renderingLimit.isEmpty()) {
+        widgetRectInImagePixels &= renderingLimit;
+    }
+
     qreal scaleX, scaleY;
     converter->imageScale(&scaleX, &scaleY);
     d->displayShader->setUniformValue(d->displayShader->location(Uniform::ViewportScale), (GLfloat) scaleX);
     d->displayShader->setUniformValue(d->displayShader->location(Uniform::TexelSize), (GLfloat) d->openGLImageTextures->texelSize());
 
     QRect ir = d->openGLImageTextures->storedImageBounds();
     QRect wr = widgetRectInImagePixels.toAlignedRect();
 
     if (!d->wrapAroundMode) {
         // if we don't want to paint wrapping images, just limit the
         // processing area, and the code will handle all the rest
         wr &= ir;
     }
 
     int firstColumn = d->xToColWithWrapCompensation(wr.left(), ir);
     int lastColumn = d->xToColWithWrapCompensation(wr.right(), ir);
     int firstRow = d->yToRowWithWrapCompensation(wr.top(), ir);
     int lastRow = d->yToRowWithWrapCompensation(wr.bottom(), ir);
 
     int minColumn = d->openGLImageTextures->xToCol(ir.left());
     int maxColumn = d->openGLImageTextures->xToCol(ir.right());
     int minRow = d->openGLImageTextures->yToRow(ir.top());
     int maxRow = d->openGLImageTextures->yToRow(ir.bottom());
 
     int imageColumns = maxColumn - minColumn + 1;
     int imageRows = maxRow - minRow + 1;
 
     for (int col = firstColumn; col <= lastColumn; col++) {
         for (int row = firstRow; row <= lastRow; row++) {
 
             int effectiveCol = col;
             int effectiveRow = row;
             QPointF tileWrappingTranslation;
 
             if (effectiveCol > maxColumn || effectiveCol < minColumn) {
                 int translationStep = floor(qreal(col) / imageColumns);
                 int originCol = translationStep * imageColumns;
                 effectiveCol = col - originCol;
                 tileWrappingTranslation.rx() = translationStep * ir.width();
             }
 
             if (effectiveRow > maxRow || effectiveRow < minRow) {
                 int translationStep = floor(qreal(row) / imageRows);
                 int originRow = translationStep * imageRows;
                 effectiveRow = row - originRow;
                 tileWrappingTranslation.ry() = translationStep * ir.height();
             }
 
             KisTextureTile *tile =
                     d->openGLImageTextures->getTextureTileCR(effectiveCol, effectiveRow);
 
             if (!tile) {
                 warnUI << "OpenGL: Trying to paint texture tile but it has not been created yet.";
                 continue;
             }
 
             /*
              * We create a float rect here to workaround Qt's
              * "history reasons" in calculation of right()
              * and bottom() coordinates of integer rects.
              */
-            QRectF textureRect(tile->tileRectInTexturePixels());
-            QRectF modelRect(tile->tileRectInImagePixels().translated(tileWrappingTranslation.x(), tileWrappingTranslation.y()));
+
+            QRectF textureRect;
+            QRectF modelRect;
+
+            if (renderingLimit.isEmpty()) {
+                textureRect = tile->tileRectInTexturePixels();
+                modelRect = tile->tileRectInImagePixels().translated(tileWrappingTranslation.x(), tileWrappingTranslation.y());
+            } else {
+                const QRect limitedTileRect = tile->tileRectInImagePixels() & renderingLimit;
+                textureRect = tile->imageRectInTexturePixels(limitedTileRect);
+                modelRect = limitedTileRect.translated(tileWrappingTranslation.x(), tileWrappingTranslation.y());
+            }
 
             //Setup the geometry for rendering
             if (KisOpenGL::hasOpenGL3()) {
                 rectToVertices(d->vertices, modelRect);
                 d->quadBuffers[0].bind();
                 d->quadBuffers[0].write(0, d->vertices, 3 * 6 * sizeof(float));
 
                 rectToTexCoords(d->texCoords, textureRect);
                 d->quadBuffers[1].bind();
                 d->quadBuffers[1].write(0, d->texCoords, 2 * 6 * sizeof(float));
             }
             else {
                 rectToVertices(d->vertices, modelRect);
                 d->displayShader->enableAttributeArray(PROGRAM_VERTEX_ATTRIBUTE);
                 d->displayShader->setAttributeArray(PROGRAM_VERTEX_ATTRIBUTE, d->vertices);
 
                 rectToTexCoords(d->texCoords, textureRect);
                 d->displayShader->enableAttributeArray(PROGRAM_TEXCOORD_ATTRIBUTE);
                 d->displayShader->setAttributeArray(PROGRAM_TEXCOORD_ATTRIBUTE, d->texCoords);
             }
 
             if (d->displayFilter) {
                 glActiveTexture(GL_TEXTURE0 + 1);
                 glBindTexture(GL_TEXTURE_3D, d->displayFilter->lutTexture());
                 d->displayShader->setUniformValue(d->displayShader->location(Uniform::Texture1), 1);
             }
 
             int currentLodPlane = tile->currentLodPlane();
             if (d->displayShader->location(Uniform::FixedLodLevel) >= 0) {
                 d->displayShader->setUniformValue(d->displayShader->location(Uniform::FixedLodLevel),
                                                   (GLfloat) currentLodPlane);
             }
 
             glActiveTexture(GL_TEXTURE0);
             tile->bindToActiveTexture();
 
             if (currentLodPlane > 0) {
                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
             } else if (SCALE_MORE_OR_EQUAL_TO(scaleX, scaleY, 2.0)) {
                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
             } else {
                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 
                 switch(d->filterMode) {
                 case KisOpenGL::NearestFilterMode:
                     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
                     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
                     break;
                 case KisOpenGL::BilinearFilterMode:
                     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
                     break;
                 case KisOpenGL::TrilinearFilterMode:
                     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
                     break;
                 case KisOpenGL::HighQualityFiltering:
                     if (SCALE_LESS_THAN(scaleX, scaleY, 0.5)) {
                         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
                     } else {
                         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
                     }
                     break;
                 }
             }
 
             glDrawArrays(GL_TRIANGLES, 0, 6);
         }
     }
 
     glBindTexture(GL_TEXTURE_2D, 0);
     d->displayShader->release();
     glBindBuffer(GL_ARRAY_BUFFER, 0);
     glDisable(GL_BLEND);
 }
 
 void KisOpenGLCanvas2::slotConfigChanged()
 {
     KisConfig cfg;
     d->checkSizeScale = KisOpenGLImageTextures::BACKGROUND_TEXTURE_CHECK_SIZE / static_cast<GLfloat>(cfg.checkSize());
     d->scrollCheckers = cfg.scrollCheckers();
 
     d->openGLImageTextures->generateCheckerTexture(createCheckersImage(cfg.checkSize()));
     d->openGLImageTextures->updateConfig(cfg.useOpenGLTextureBuffer(), cfg.numMipmapLevels());
     d->filterMode = (KisOpenGL::FilterMode) cfg.openGLFilteringMode();
 
     d->cursorColor = cfg.getCursorMainColor();
 
     notifyConfigChanged();
 }
 
 void KisOpenGLCanvas2::slotPixelGridModeChanged()
 {
     KisConfig cfg;
 
     d->pixelGridDrawingThreshold = cfg.getPixelGridDrawingThreshold();
     d->pixelGridEnabled = cfg.pixelGridEnabled();
     d->gridColor = cfg.getPixelGridColor();
 
     update();
 }
 
 QVariant KisOpenGLCanvas2::inputMethodQuery(Qt::InputMethodQuery query) const
 {
     return processInputMethodQuery(query);
 }
 
 void KisOpenGLCanvas2::inputMethodEvent(QInputMethodEvent *event)
 {
     processInputMethodEvent(event);
 }
 
 void KisOpenGLCanvas2::renderCanvasGL()
 {
     // Draw the border (that is, clear the whole widget to the border color)
     QColor widgetBackgroundColor = borderColor();
     glClearColor(widgetBackgroundColor.redF(), widgetBackgroundColor.greenF(), widgetBackgroundColor.blueF(), 1.0);
     glClear(GL_COLOR_BUFFER_BIT);
 
     if ((d->displayFilter && d->displayFilter->updateShader()) ||
         (bool(d->displayFilter) != d->displayShaderCompiledWithDisplayFilterSupport)) {
 
         KIS_SAFE_ASSERT_RECOVER_NOOP(d->canvasInitialized);
 
         d->canvasInitialized = false; // TODO: check if actually needed?
         initializeDisplayShader();
         d->canvasInitialized = true;
     }
 
     if (KisOpenGL::hasOpenGL3()) {
         d->quadVAO.bind();
     }
 
     drawCheckers();
     drawImage();
     if ((coordinatesConverter()->effectiveZoom() > d->pixelGridDrawingThreshold - 0.00001) && d->pixelGridEnabled) {
         drawGrid();
     }
     if (KisOpenGL::hasOpenGL3()) {
         d->quadVAO.release();
     }
 }
 
 void KisOpenGLCanvas2::renderDecorations(QPainter *painter)
 {
     QRect boundingRect = coordinatesConverter()->imageRectInWidgetPixels().toAlignedRect();
     drawDecorations(*painter, boundingRect);
 }
 
 
 void KisOpenGLCanvas2::setDisplayProfile(KisDisplayColorConverter *colorConverter)
 {
     d->openGLImageTextures->setMonitorProfile(colorConverter->monitorProfile(),
                                               colorConverter->renderingIntent(),
                                               colorConverter->conversionFlags());
 }
 
 void KisOpenGLCanvas2::channelSelectionChanged(const QBitArray &channelFlags)
 {
     d->openGLImageTextures->setChannelFlags(channelFlags);
 }
 
 
 void KisOpenGLCanvas2::finishResizingImage(qint32 w, qint32 h)
 {
     if (d->canvasInitialized) {
         d->openGLImageTextures->slotImageSizeChanged(w, h);
     }
 }
 
 KisUpdateInfoSP KisOpenGLCanvas2::startUpdateCanvasProjection(const QRect & rc, const QBitArray &channelFlags)
 {
     d->openGLImageTextures->setChannelFlags(channelFlags);
     if (canvas()->proofingConfigUpdated()) {
         d->openGLImageTextures->setProofingConfig(canvas()->proofingConfiguration());
         canvas()->setProofingConfigUpdated(false);
     }
     return d->openGLImageTextures->updateCache(rc, d->openGLImageTextures->image());
 }
 
 
 QRect KisOpenGLCanvas2::updateCanvasProjection(KisUpdateInfoSP info)
 {
     // See KisQPainterCanvas::updateCanvasProjection for more info
     bool isOpenGLUpdateInfo = dynamic_cast<KisOpenGLUpdateInfo*>(info.data());
     if (isOpenGLUpdateInfo) {
         d->openGLImageTextures->recalculateCache(info);
     }
     return QRect(); // FIXME: Implement dirty rect for OpenGL
 }
 
 QVector<QRect> KisOpenGLCanvas2::updateCanvasProjection(const QVector<KisUpdateInfoSP> &infoObjects)
 {
 #ifdef Q_OS_OSX
     /**
      * On OSX openGL defferent (shared) contexts have different execution queues.
      * It means that the textures uploading and their painting can be easily reordered.
      * To overcome the issue, we should ensure that the textures are uploaded in the
      * same openGL context as the painting is done.
      */
 
     QOpenGLContext *oldContext = QOpenGLContext::currentContext();
     QSurface *oldSurface = oldContext ? oldContext->surface() : 0;
 
     this->makeCurrent();
 #endif
 
     QVector<QRect> result = KisCanvasWidgetBase::updateCanvasProjection(infoObjects);
 
 #ifdef Q_OS_OSX
     if (oldContext) {
         oldContext->makeCurrent(oldSurface);
     } else {
         this->doneCurrent();
     }
 #endif
 
     return result;
 }
 
 bool KisOpenGLCanvas2::callFocusNextPrevChild(bool next)
 {
     return focusNextPrevChild(next);
 }
 
 KisOpenGLImageTexturesSP KisOpenGLCanvas2::openGLImageTextures() const
 {
     return d->openGLImageTextures;
 }
diff --git a/libs/ui/opengl/kis_opengl_image_textures.cpp b/libs/ui/opengl/kis_opengl_image_textures.cpp
index e609de58dd..37eb946e5c 100644
--- a/libs/ui/opengl/kis_opengl_image_textures.cpp
+++ b/libs/ui/opengl/kis_opengl_image_textures.cpp
@@ -1,684 +1,597 @@
 /*
  *  Copyright (c) 2005-2007 Adrian Page <adrian@pagenet.plus.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 "opengl/kis_opengl_image_textures.h"
 
 #include <QOpenGLFunctions>
 #include <QOpenGLContext>
 
 #include <QMessageBox>
 #include <QApplication>
 #include <QDesktopWidget>
 
 #include <KoColorSpaceRegistry.h>
 #include <KoColorProfile.h>
 #include <KoColorModelStandardIds.h>
 
 #include "kis_image.h"
 #include "kis_config.h"
 #include "KisPart.h"
 
 #ifdef HAVE_OPENEXR
 #include <half.h>
 #endif
 
 #ifndef GL_CLAMP_TO_EDGE
 #define GL_CLAMP_TO_EDGE 0x812F
 #endif
 
 #ifndef GL_BGRA
 #define GL_BGRA 0x80E1
 #endif
 
 // GL_EXT_texture_format_BGRA8888
 #ifndef GL_BGRA_EXT
 #define GL_BGRA_EXT 0x80E1
 #endif
 #ifndef GL_BGRA8_EXT
 #define GL_BGRA8_EXT 0x93A1
 #endif
 
 
 KisOpenGLImageTextures::ImageTexturesMap KisOpenGLImageTextures::imageTexturesMap;
 
 KisOpenGLImageTextures::KisOpenGLImageTextures()
     : m_image(0)
     , m_monitorProfile(0)
-    , m_proofingConfig(0)
-    , m_createNewProofingTransform(true)
     , m_tilesDestinationColorSpace(0)
     , m_internalColorManagementActive(true)
     , m_checkerTexture(0)
     , m_glFuncs(0)
-    , m_allChannelsSelected(true)
     , m_useOcio(false)
     , m_initialized(false)
 {
     KisConfig cfg;
     m_renderingIntent = (KoColorConversionTransformation::Intent)cfg.monitorRenderIntent();
 
     m_conversionFlags = KoColorConversionTransformation::HighQuality;
     if (cfg.useBlackPointCompensation()) m_conversionFlags |= KoColorConversionTransformation::BlackpointCompensation;
     if (!cfg.allowLCMSOptimization()) m_conversionFlags |= KoColorConversionTransformation::NoOptimization;
     m_useOcio = cfg.useOcio();
 }
 
 KisOpenGLImageTextures::KisOpenGLImageTextures(KisImageWSP image,
                                                const KoColorProfile *monitorProfile,
                                                KoColorConversionTransformation::Intent renderingIntent,
                                                KoColorConversionTransformation::ConversionFlags conversionFlags)
     : m_image(image)
     , m_monitorProfile(monitorProfile)
     , m_renderingIntent(renderingIntent)
     , m_conversionFlags(conversionFlags)
-    , m_createNewProofingTransform(true)
     , m_tilesDestinationColorSpace(0)
     , m_internalColorManagementActive(true)
     , m_checkerTexture(0)
     , m_glFuncs(0)
-    , m_allChannelsSelected(true)
     , m_useOcio(false)
     , m_initialized(false)
 {
     Q_ASSERT(renderingIntent < 4);
 }
 
 void KisOpenGLImageTextures::initGL(QOpenGLFunctions *f)
 {
     if (f) {
         m_glFuncs = f;
     } else {
         errUI << "Tried to create OpenGLImageTextures with uninitialized QOpenGLFunctions";
     }
 
     getTextureSize(&m_texturesInfo);
 
     // we use local static object for creating pools shared among
     // different images
     static KisTextureTileInfoPoolRegistry s_poolRegistry;
-    m_infoChunksPool = s_poolRegistry.getPool(m_texturesInfo.width, m_texturesInfo.height);
+    m_updateInfoBuilder.setTextureInfoPool(s_poolRegistry.getPool(m_texturesInfo.width, m_texturesInfo.height));
 
     m_glFuncs->glGenTextures(1, &m_checkerTexture);
     createImageTextureTiles();
 
     KisOpenGLUpdateInfoSP info = updateCache(m_image->bounds(), m_image);
     recalculateCache(info);
 }
 
 KisOpenGLImageTextures::~KisOpenGLImageTextures()
 {
     ImageTexturesMap::iterator it = imageTexturesMap.find(m_image);
     if (it != imageTexturesMap.end()) {
         KisOpenGLImageTextures *textures = it.value();
         if (textures == this) {
             dbgUI << "Removing shared image context from map";
             imageTexturesMap.erase(it);
         }
     }
 
     destroyImageTextureTiles();
     m_glFuncs->glDeleteTextures(1, &m_checkerTexture);
 }
 
 KisImageSP KisOpenGLImageTextures::image() const
 {
     return m_image;
 }
 
 bool KisOpenGLImageTextures::imageCanShareTextures()
 {
     KisConfig cfg;
     if (cfg.useOcio()) return false;
     if (KisPart::instance()->mainwindowCount() == 1) return true;
     if (qApp->desktop()->screenCount() == 1) return true;
     for (int i = 1; i < qApp->desktop()->screenCount(); i++) {
         if (cfg.displayProfile(i) != cfg.displayProfile(i - 1)) {
             return false;
         }
     }
     return true;
 }
 
 KisOpenGLImageTexturesSP KisOpenGLImageTextures::getImageTextures(KisImageWSP image,
                                                                   const KoColorProfile *monitorProfile,
                                                                   KoColorConversionTransformation::Intent renderingIntent,
                                                                   KoColorConversionTransformation::ConversionFlags conversionFlags)
 {
     // Disabled until we figure out why we're deleting the shared textures on closing the second view on a single image
     if (false && imageCanShareTextures()) {
         ImageTexturesMap::iterator it = imageTexturesMap.find(image);
 
         if (it != imageTexturesMap.end()) {
             KisOpenGLImageTexturesSP textures = it.value();
             textures->setMonitorProfile(monitorProfile, renderingIntent, conversionFlags);
 
             return textures;
         } else {
             KisOpenGLImageTextures *imageTextures = new KisOpenGLImageTextures(image, monitorProfile, renderingIntent, conversionFlags);
             imageTexturesMap[image] = imageTextures;
             dbgUI << "Added shareable textures to map";
 
             return imageTextures;
         }
     } else {
         return new KisOpenGLImageTextures(image, monitorProfile, renderingIntent, conversionFlags);
     }
 }
 
-QRect KisOpenGLImageTextures::calculateTileRect(int col, int row) const
-{
-    return m_image->bounds() &
-            QRect(col * m_texturesInfo.effectiveWidth,
-                  row * m_texturesInfo.effectiveHeight,
-                  m_texturesInfo.effectiveWidth,
-                  m_texturesInfo.effectiveHeight);
-}
-
 void KisOpenGLImageTextures::createImageTextureTiles()
 {
 
     destroyImageTextureTiles();
     updateTextureFormat();
 
     if (!m_tilesDestinationColorSpace) {
         qDebug() << "No destination colorspace!!!!";
         return;
     }
 
 
     m_storedImageBounds = m_image->bounds();
     const int lastCol = xToCol(m_image->width());
     const int lastRow = yToRow(m_image->height());
 
     m_numCols = lastCol + 1;
 
     // Default color is transparent black
     const int pixelSize = m_tilesDestinationColorSpace->pixelSize();
     QByteArray emptyTileData((m_texturesInfo.width) * (m_texturesInfo.height) * pixelSize, 0);
 
     KisConfig config;
     KisOpenGL::FilterMode mode = (KisOpenGL::FilterMode)config.openGLFilteringMode();
 
     QOpenGLContext *ctx = QOpenGLContext::currentContext();
     if (ctx) {
         QOpenGLFunctions *f = ctx->functions();
 
         m_initialized = true;
         dbgUI  << "OpenGL: creating texture tiles of size" << m_texturesInfo.height << "x" << m_texturesInfo.width;
 
         m_textureTiles.reserve((lastRow+1)*m_numCols);
         for (int row = 0; row <= lastRow; row++) {
             for (int col = 0; col <= lastCol; col++) {
-                QRect tileRect = calculateTileRect(col, row);
+                QRect tileRect = m_updateInfoBuilder.calculateEffectiveTileRect(col, row, m_image->bounds());
 
                 KisTextureTile *tile = new KisTextureTile(tileRect,
                                                           &m_texturesInfo,
                                                           emptyTileData,
                                                           mode,
                                                           config.useOpenGLTextureBuffer(),
                                                           config.numMipmapLevels(),
                                                           f);
                 m_textureTiles.append(tile);
             }
         }
     }
     else {
         dbgUI << "Tried to init texture tiles without a current OpenGL Context.";
     }
 }
 
 void KisOpenGLImageTextures::destroyImageTextureTiles()
 {
     if (m_textureTiles.isEmpty()) return;
 
     Q_FOREACH (KisTextureTile *tile, m_textureTiles) {
         delete tile;
     }
     m_textureTiles.clear();
     m_storedImageBounds = QRect();
 }
 
 KisOpenGLUpdateInfoSP KisOpenGLImageTextures::updateCache(const QRect& rect, KisImageSP srcImage)
 {
     return updateCacheImpl(rect, srcImage, true);
 }
 
 KisOpenGLUpdateInfoSP KisOpenGLImageTextures::updateCacheNoConversion(const QRect& rect)
 {
     return updateCacheImpl(rect, m_image, false);
 }
 
 // TODO: add sanity checks about the conformance of the passed srcImage!
 KisOpenGLUpdateInfoSP KisOpenGLImageTextures::updateCacheImpl(const QRect& rect, KisImageSP srcImage, bool convertColorSpace)
 {
-    const KoColorSpace *dstCS = m_tilesDestinationColorSpace;
-
-    ConversionOptions options;
-
-    if (convertColorSpace) {
-        options = ConversionOptions(dstCS, m_renderingIntent, m_conversionFlags);
-    }
-
-    KisOpenGLUpdateInfoSP info = new KisOpenGLUpdateInfo(options);
-
-    QRect updateRect = rect & srcImage->bounds();
-    if (updateRect.isEmpty() || !(m_initialized)) return info;
-
-    /**
-     * Why the rect is artificial? That's easy!
-     * It does not represent any real piece of the image. It is
-     * intentionally stretched to get through the overlappping
-     * stripes of neutrality and poke neighbouring tiles.
-     * Thanks to the rect we get the coordinates of all the tiles
-     * involved into update process
-     */
-
-    QRect artificialRect = stretchRect(updateRect, m_texturesInfo.border);
-    artificialRect &= srcImage->bounds();
-
-    int firstColumn = xToCol(artificialRect.left());
-    int lastColumn = xToCol(artificialRect.right());
-    int firstRow = yToRow(artificialRect.top());
-    int lastRow = yToRow(artificialRect.bottom());
-
-    QBitArray channelFlags; // empty by default
-
-    if (m_channelFlags.size() != srcImage->projection()->colorSpace()->channels().size()) {
-        setChannelFlags(QBitArray());
-    }
-    if (!m_useOcio) { // Ocio does its own channel flipping
-        if (!m_allChannelsSelected) { // and we do it only if necessary
-            channelFlags = m_channelFlags;
-        }
-    }
-
-    qint32 numItems = (lastColumn - firstColumn + 1) * (lastRow - firstRow + 1);
-    info->tileList.reserve(numItems);
-
-    const QRect bounds = srcImage->bounds();
-    const int levelOfDetail = srcImage->currentLevelOfDetail();
-
-    QRect alignedUpdateRect = updateRect;
-    QRect alignedBounds = bounds;
-
-    if (levelOfDetail) {
-        alignedUpdateRect = KisLodTransform::alignedRect(alignedUpdateRect, levelOfDetail);
-        alignedBounds = KisLodTransform::alignedRect(alignedBounds, levelOfDetail);
-    }
-
-    for (int col = firstColumn; col <= lastColumn; col++) {
-        for (int row = firstRow; row <= lastRow; row++) {
-
-            const QRect tileRect = calculateTileRect(col, row);
-            const QRect tileTextureRect = stretchRect(tileRect, m_texturesInfo.border);
-
-            QRect alignedTileTextureRect = levelOfDetail ?
-                        KisLodTransform::alignedRect(tileTextureRect, levelOfDetail) :
-                        tileTextureRect;
-
-            KisTextureTileUpdateInfoSP tileInfo(
-                        new KisTextureTileUpdateInfo(col, row,
-                                                     alignedTileTextureRect,
-                                                     alignedUpdateRect,
-                                                     alignedBounds,
-                                                     levelOfDetail,
-                                                     m_infoChunksPool));
-            // Don't update empty tiles
-            if (tileInfo->valid()) {
-                tileInfo->retrieveData(srcImage->projection(), channelFlags, m_onlyOneChannelSelected, m_selectedChannelIndex);
-
-                //create transform
-                if (m_createNewProofingTransform) {
-                    const KoColorSpace *proofingSpace = KoColorSpaceRegistry::instance()->colorSpace(m_proofingConfig->proofingModel,m_proofingConfig->proofingDepth,m_proofingConfig->proofingProfile);
-                    m_proofingTransform.reset(tileInfo->generateProofingTransform(dstCS, proofingSpace, m_renderingIntent, m_proofingConfig->intent, m_proofingConfig->conversionFlags, m_proofingConfig->warningColor, m_proofingConfig->adaptationState));
-                    m_createNewProofingTransform = false;
-                }
-
-                if (convertColorSpace) {
-                    if (m_proofingConfig && m_proofingTransform && m_proofingConfig->conversionFlags.testFlag(KoColorConversionTransformation::SoftProofing)) {
-                        tileInfo->proofTo(dstCS, m_proofingConfig->conversionFlags, m_proofingTransform.data());
-                    } else {
-                        tileInfo->convertTo(dstCS, m_renderingIntent, m_conversionFlags);
-                    }
-                }
-
-                info->tileList.append(tileInfo);
-            }
-            else {
-                dbgUI << "Trying to create an empty tileinfo record" << col << row << tileTextureRect << updateRect << srcImage->bounds();
-            }
-        }
-    }
-
-    info->assignDirtyImageRect(rect);
-    info->assignLevelOfDetail(levelOfDetail);
-    return info;
+    if (!m_initialized) return new KisOpenGLUpdateInfo();
+    return m_updateInfoBuilder.buildUpdateInfo(rect, srcImage, convertColorSpace);
 }
 
 void KisOpenGLImageTextures::recalculateCache(KisUpdateInfoSP info)
 {
     if (!m_initialized) {
         dbgUI << "OpenGL: Tried to edit image texture cache before it was initialized.";
         return;
     }
 
     KisOpenGLUpdateInfoSP glInfo = dynamic_cast<KisOpenGLUpdateInfo*>(info.data());
     if(!glInfo) return;
 
     KisTextureTileUpdateInfoSP tileInfo;
     Q_FOREACH (tileInfo, glInfo->tileList) {
         KisTextureTile *tile = getTextureTileCR(tileInfo->tileCol(), tileInfo->tileRow());
         KIS_ASSERT_RECOVER_RETURN(tile);
 
         tile->update(*tileInfo);
     }
 }
 
 void KisOpenGLImageTextures::generateCheckerTexture(const QImage &checkImage)
 {
 
     QOpenGLContext *ctx = QOpenGLContext::currentContext();
     if (ctx) {
         QOpenGLFunctions *f = ctx->functions();
         dbgUI << "Attaching checker texture" << checkerTexture();
         f->glBindTexture(GL_TEXTURE_2D, checkerTexture());
 
         f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
         f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
         f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
         f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 
         f->glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 
         QImage img = checkImage;
         if (checkImage.width() != BACKGROUND_TEXTURE_SIZE || checkImage.height() != BACKGROUND_TEXTURE_SIZE) {
             img = checkImage.scaled(BACKGROUND_TEXTURE_SIZE, BACKGROUND_TEXTURE_SIZE);
         }
         GLint format = GL_BGRA, internalFormat = GL_RGBA8;
         if (KisOpenGL::hasOpenGLES()) {
             if (ctx->hasExtension(QByteArrayLiteral("GL_EXT_texture_format_BGRA8888"))) {
                 format = GL_BGRA_EXT;
                 internalFormat = GL_BGRA8_EXT;
             } else {
                 format = GL_RGBA;
             }
         }
         f->glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, BACKGROUND_TEXTURE_SIZE, BACKGROUND_TEXTURE_SIZE,
                         0, format, GL_UNSIGNED_BYTE, img.constBits());
     }
     else {
         dbgUI << "OpenGL: Tried to generate checker texture before OpenGL was initialized.";
     }
 
 }
 
 GLuint KisOpenGLImageTextures::checkerTexture()
 {
     if (m_glFuncs) {
         if (m_checkerTexture == 0) {
             m_glFuncs->glGenTextures(1, &m_checkerTexture);
         }
         return m_checkerTexture;
     }
     else {
         dbgUI << "Tried to access checker texture before OpenGL was initialized";
         return 0;
     }
 }
 
 void KisOpenGLImageTextures::updateConfig(bool useBuffer, int NumMipmapLevels)
 {
     if(m_textureTiles.isEmpty()) return;
 
     Q_FOREACH (KisTextureTile *tile, m_textureTiles) {
         tile->setUseBuffer(useBuffer);
         tile->setNumMipmapLevels(NumMipmapLevels);
     }
 }
 
 void KisOpenGLImageTextures::slotImageSizeChanged(qint32 /*w*/, qint32 /*h*/)
 {
     createImageTextureTiles();
 }
 
+KisOpenGLUpdateInfoBuilder &KisOpenGLImageTextures::updateInfoBuilder()
+{
+    return m_updateInfoBuilder;
+}
+
 void KisOpenGLImageTextures::setMonitorProfile(const KoColorProfile *monitorProfile, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags)
 {
     //dbgUI << "Setting monitor profile to" << monitorProfile->name() << renderingIntent << conversionFlags;
     m_monitorProfile = monitorProfile;
     m_renderingIntent = renderingIntent;
     m_conversionFlags = conversionFlags;
 
+    m_updateInfoBuilder.setConversionOptions(
+        ConversionOptions(m_tilesDestinationColorSpace,
+                          m_renderingIntent,
+                          m_conversionFlags));
+
     createImageTextureTiles();
 }
 
 void KisOpenGLImageTextures::setChannelFlags(const QBitArray &channelFlags)
 {
-    m_channelFlags = channelFlags;
+    QBitArray targetChannelFlags = channelFlags;
     int selectedChannels = 0;
     const KoColorSpace *projectionCs = m_image->projection()->colorSpace();
     QList<KoChannelInfo*> channelInfo = projectionCs->channels();
 
-    if (m_channelFlags.size() != channelInfo.size()) {
-        m_channelFlags = QBitArray();
+    if (targetChannelFlags.size() != channelInfo.size()) {
+        targetChannelFlags = QBitArray();
     }
 
-    for (int i = 0; i < m_channelFlags.size(); ++i) {
-        if (m_channelFlags.testBit(i) && channelInfo[i]->channelType() == KoChannelInfo::COLOR) {
+    int selectedChannelIndex = -1;
+
+    for (int i = 0; i < targetChannelFlags.size(); ++i) {
+        if (targetChannelFlags.testBit(i) && channelInfo[i]->channelType() == KoChannelInfo::COLOR) {
             selectedChannels++;
-            m_selectedChannelIndex = i;
+            selectedChannelIndex = i;
         }
     }
-    m_allChannelsSelected = (selectedChannels == m_channelFlags.size());
-    m_onlyOneChannelSelected = (selectedChannels == 1);
+    const bool allChannelsSelected = (selectedChannels == targetChannelFlags.size());
+    const bool onlyOneChannelSelected = (selectedChannels == 1);
+
+    // OCIO has its own channel swizzling
+    if (allChannelsSelected || m_useOcio) {
+        m_updateInfoBuilder.setChannelFlags(QBitArray(), false, -1);
+    } else {
+        m_updateInfoBuilder.setChannelFlags(targetChannelFlags, onlyOneChannelSelected, selectedChannelIndex);
+    }
 }
 
 void KisOpenGLImageTextures::setProofingConfig(KisProofingConfigurationSP proofingConfig)
 {
-    m_proofingConfig = proofingConfig;
-    m_createNewProofingTransform = true;
+    m_updateInfoBuilder.setProofingConfig(proofingConfig);
 }
 
 void KisOpenGLImageTextures::getTextureSize(KisGLTexturesInfo *texturesInfo)
 {
     KisConfig cfg;
 
     const GLint preferredTextureSize = cfg.openGLTextureSize();
 
     GLint maxTextureSize;
     if (m_glFuncs) {
         m_glFuncs->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxTextureSize);
     }
     else {
         dbgUI << "OpenGL: Tried to read texture size before OpenGL was initialized.";
         maxTextureSize = GL_MAX_TEXTURE_SIZE;
     }
 
     texturesInfo->width = qMin(preferredTextureSize, maxTextureSize);
     texturesInfo->height = qMin(preferredTextureSize, maxTextureSize);
 
     texturesInfo->border = cfg.textureOverlapBorder();
 
     texturesInfo->effectiveWidth = texturesInfo->width - 2 * texturesInfo->border;
     texturesInfo->effectiveHeight = texturesInfo->height - 2 * texturesInfo->border;
+
+    m_updateInfoBuilder.setTextureBorder(texturesInfo->border);
+    m_updateInfoBuilder.setEffectiveTextureSize(
+        QSize(texturesInfo->effectiveWidth, texturesInfo->effectiveHeight));
 }
 
 bool KisOpenGLImageTextures::internalColorManagementActive() const
 {
     return m_internalColorManagementActive;
 }
 
 bool KisOpenGLImageTextures::setInternalColorManagementActive(bool value)
 {
     bool needsFinalRegeneration = m_internalColorManagementActive != value;
 
     if (needsFinalRegeneration) {
         m_internalColorManagementActive = value;
         createImageTextureTiles();
 
         // at this point the value of m_internalColorManagementActive might
         // have been forcely reverted to 'false' in case of some problems
     }
 
     return needsFinalRegeneration;
 }
 
 void KisOpenGLImageTextures::updateTextureFormat()
 {
     QOpenGLContext *ctx = QOpenGLContext::currentContext();
     if (!(m_image && ctx)) return;
 
     if (!KisOpenGL::hasOpenGLES()) {
         m_texturesInfo.internalFormat = GL_RGBA8;
         m_texturesInfo.type = GL_UNSIGNED_BYTE;
         m_texturesInfo.format = GL_BGRA;
     } else {
         m_texturesInfo.internalFormat = GL_BGRA8_EXT;
         m_texturesInfo.type = GL_UNSIGNED_BYTE;
         m_texturesInfo.format = GL_BGRA_EXT;
         if(!ctx->hasExtension(QByteArrayLiteral("GL_EXT_texture_format_BGRA8888"))) {
             // The red and blue channels are swapped, but it will be re-swapped
             // by texture swizzle mask set in KisTextureTile::setTextureParameters
             m_texturesInfo.internalFormat = GL_RGBA8;
             m_texturesInfo.type = GL_UNSIGNED_BYTE;
             m_texturesInfo.format = GL_RGBA;
         }
     }
 
     KoID colorModelId = m_image->colorSpace()->colorModelId();
     KoID colorDepthId = m_image->colorSpace()->colorDepthId();
 
     KoID destinationColorModelId = RGBAColorModelID;
     KoID destinationColorDepthId = Integer8BitsColorDepthID;
 
     dbgUI << "Choosing texture format:";
 
     if (colorModelId == RGBAColorModelID) {
         if (colorDepthId == Float16BitsColorDepthID) {
 
             if (KisOpenGL::hasOpenGLES() || KisOpenGL::hasOpenGL3()) {
                 m_texturesInfo.internalFormat = GL_RGBA16F;
                 dbgUI << "Using half (GLES or GL3)";
             } else if (ctx->hasExtension("GL_ARB_texture_float")) {
                 m_texturesInfo.internalFormat = GL_RGBA16F_ARB;
                 dbgUI << "Using ARB half";
             }
             else if (ctx->hasExtension("GL_ATI_texture_float")) {
                 m_texturesInfo.internalFormat = GL_RGBA_FLOAT16_ATI;
                 dbgUI << "Using ATI half";
             }
 
             bool haveBuiltInOpenExr = false;
 #ifdef HAVE_OPENEXR
             haveBuiltInOpenExr = true;
 #endif
 
             if (haveBuiltInOpenExr && (KisOpenGL::hasOpenGLES() || KisOpenGL::hasOpenGL3())) {
                 m_texturesInfo.type = GL_HALF_FLOAT;
                 destinationColorDepthId = Float16BitsColorDepthID;
                 dbgUI << "Pixel type half (GLES or GL3)";
             } else if (haveBuiltInOpenExr && ctx->hasExtension("GL_ARB_half_float_pixel")) {
                 m_texturesInfo.type = GL_HALF_FLOAT_ARB;
                 destinationColorDepthId = Float16BitsColorDepthID;
                 dbgUI << "Pixel type half";
             } else {
                 m_texturesInfo.type = GL_FLOAT;
                 destinationColorDepthId = Float32BitsColorDepthID;
                 dbgUI << "Pixel type float";
             }
             m_texturesInfo.format = GL_RGBA;
         }
         else if (colorDepthId == Float32BitsColorDepthID) {
             if (KisOpenGL::hasOpenGLES() || KisOpenGL::hasOpenGL3()) {
                 m_texturesInfo.internalFormat = GL_RGBA32F;
                 dbgUI << "Using float (GLES or GL3)";
             } else if (ctx->hasExtension("GL_ARB_texture_float")) {
                 m_texturesInfo.internalFormat = GL_RGBA32F_ARB;
                 dbgUI << "Using ARB float";
             } else if (ctx->hasExtension("GL_ATI_texture_float")) {
                 m_texturesInfo.internalFormat = GL_RGBA_FLOAT32_ATI;
                 dbgUI << "Using ATI float";
             }
 
             m_texturesInfo.type = GL_FLOAT;
             m_texturesInfo.format = GL_RGBA;
             destinationColorDepthId = Float32BitsColorDepthID;
         }
         else if (colorDepthId == Integer16BitsColorDepthID) {
             if (!KisOpenGL::hasOpenGLES()) {
                 m_texturesInfo.internalFormat = GL_RGBA16;
                 m_texturesInfo.type = GL_UNSIGNED_SHORT;
                 m_texturesInfo.format = GL_BGRA;
                 destinationColorDepthId = Integer16BitsColorDepthID;
                 dbgUI << "Using 16 bits rgba";
             }
             // TODO: for ANGLE, see if we can convert to 16f to support 10-bit display
         }
     }
     else {
         // We will convert the colorspace to 16 bits rgba, instead of 8 bits
         if (colorDepthId == Integer16BitsColorDepthID && !KisOpenGL::hasOpenGLES()) {
             m_texturesInfo.internalFormat = GL_RGBA16;
             m_texturesInfo.type = GL_UNSIGNED_SHORT;
             m_texturesInfo.format = GL_BGRA;
             destinationColorDepthId = Integer16BitsColorDepthID;
             dbgUI << "Using conversion to 16 bits rgba";
         }
         // TODO: for ANGLE, see if we can convert to 16f to support 10-bit display
     }
 
     if (!m_internalColorManagementActive &&
             colorModelId != destinationColorModelId) {
 
         KisConfig cfg;
         KisConfig::OcioColorManagementMode cm = cfg.ocioColorManagementMode();
 
         if (cm != KisConfig::INTERNAL) {
             QMessageBox::critical(0,
                                   i18nc("@title:window", "Krita"),
                                   i18n("You enabled OpenColorIO based color management, but your image is not an RGB image.\n"
                                        "OpenColorIO-based color management only works with RGB images.\n"
                                        "Please check the settings in the LUT docker.\n"
                                        "OpenColorIO will now be deactivated."));
         }
 
         warnUI << "WARNING: Internal color management was forcibly enabled";
         warnUI << "Color Management Mode: " << cm;
         warnUI << ppVar(m_image->colorSpace());
         warnUI << ppVar(destinationColorModelId);
         warnUI << ppVar(destinationColorDepthId);
 
         cfg.setOcioColorManagementMode(KisConfig::INTERNAL);
         m_internalColorManagementActive = true;
     }
 
     const KoColorProfile *profile =
             m_internalColorManagementActive ||
             colorModelId != destinationColorModelId ?
                 m_monitorProfile : m_image->colorSpace()->profile();
 
     /**
      * TODO: add an optimization so that the tile->convertTo() method
      *       would not be called when not needed (DK)
      */
 
     m_tilesDestinationColorSpace =
             KoColorSpaceRegistry::instance()->colorSpace(destinationColorModelId.id(),
                                                          destinationColorDepthId.id(),
                                                          profile);
+
+    m_updateInfoBuilder.setConversionOptions(
+        ConversionOptions(m_tilesDestinationColorSpace,
+                          m_renderingIntent,
+                          m_conversionFlags));
 }
 
diff --git a/libs/ui/opengl/kis_opengl_image_textures.h b/libs/ui/opengl/kis_opengl_image_textures.h
index 6670a91a90..83032e6c1b 100644
--- a/libs/ui/opengl/kis_opengl_image_textures.h
+++ b/libs/ui/opengl/kis_opengl_image_textures.h
@@ -1,211 +1,204 @@
 /*
  *  Copyright (c) 2005-2007 Adrian Page <adrian@pagenet.plus.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_OPENGL_IMAGE_TEXTURES_H_
 #define KIS_OPENGL_IMAGE_TEXTURES_H_
 
 #include <QVector>
 #include <QMap>
 #include <QOpenGLFunctions>
 
 #include "kritaui_export.h"
 
 #include "kis_shared.h"
 
 #include "canvas/kis_update_info.h"
 #include "opengl/kis_texture_tile.h"
-#include "KisProofingConfiguration.h"
-#include <KoColorProofingConversionTransformation.h>
+#include "KisOpenGLUpdateInfoBuilder.h"
 
 class KisOpenGLImageTextures;
-
 typedef KisSharedPtr<KisOpenGLImageTextures> KisOpenGLImageTexturesSP;
 
 class KoColorProfile;
 class KisTextureTileUpdateInfoPoolCollection;
 typedef QSharedPointer<KisTextureTileInfoPool> KisTextureTileInfoPoolSP;
 
+class KisProofingConfiguration;
+typedef QSharedPointer<KisProofingConfiguration> KisProofingConfigurationSP;
+
 /**
  * A set of OpenGL textures that contains the projection of a KisImage.
  */
 class KRITAUI_EXPORT KisOpenGLImageTextures : public KisShared
 {
 public:
     /**
      * Obtain a KisOpenGLImageTextures object for the given image.
      * @param image The image
      * @param monitorProfile The profile of the display device
      */
     static KisOpenGLImageTexturesSP getImageTextures(KisImageWSP image,
                                                      const KoColorProfile *monitorProfile, KoColorConversionTransformation::Intent renderingIntent,
                                                      KoColorConversionTransformation::ConversionFlags conversionFlags);
 
     /**
      * Default constructor.
      */
     KisOpenGLImageTextures();
 
     /**
      * Destructor.
      */
     virtual ~KisOpenGLImageTextures();
 
     /**
      * \return the image associated with the textures
      */
     KisImageSP image() const;
 
     /**
      * Set the color profile of the display device.
      * @param profile The color profile of the display device
      */
     void setMonitorProfile(const KoColorProfile *monitorProfile,
                            KoColorConversionTransformation::Intent renderingIntent,
                            KoColorConversionTransformation::ConversionFlags conversionFlags);
 
     /**
      * Complete initialization can only happen once an OpenGL context has been created.
      * @param f Pointer to OpenGL functions. They must already be ininitialized.
      */
     void initGL(QOpenGLFunctions *f);
 
     void setChannelFlags(const QBitArray &channelFlags);
     void setProofingConfig(KisProofingConfigurationSP);
 
     bool internalColorManagementActive() const;
     bool setInternalColorManagementActive(bool value);
 
     /**
      * The background checkers texture.
      */
     static const int BACKGROUND_TEXTURE_CHECK_SIZE = 32;
     static const int BACKGROUND_TEXTURE_SIZE = BACKGROUND_TEXTURE_CHECK_SIZE * 2;
 
     /**
      * Generate a background texture from the given QImage. This is used for the checker
      * pattern on which the image is rendered.
      */
     void generateCheckerTexture(const QImage & checkImage);
     GLuint checkerTexture();
 
     void updateConfig(bool useBuffer, int NumMipmapLevels);
 
 public:
     inline QRect storedImageBounds() {
         return m_storedImageBounds;
     }
 
     inline int xToCol(int x) {
         return x / m_texturesInfo.effectiveWidth;
     }
 
     inline int yToRow(int y) {
         return y / m_texturesInfo.effectiveHeight;
     }
 
     inline KisTextureTile* getTextureTileCR(int col, int row) {
         if (m_initialized) {
             int tile = row * m_numCols + col;
             KIS_ASSERT_RECOVER_RETURN_VALUE(m_textureTiles.size() > tile, 0);
             return m_textureTiles[tile];
         }
         return 0;
     }
 
     inline qreal texelSize() const {
         Q_ASSERT(m_texturesInfo.width == m_texturesInfo.height);
         return 1.0 / m_texturesInfo.width;
     }
 
     KisOpenGLUpdateInfoSP updateCache(const QRect& rect, KisImageSP srcImage);
     KisOpenGLUpdateInfoSP updateCacheNoConversion(const QRect& rect);
 
     void recalculateCache(KisUpdateInfoSP info);
 
     void slotImageSizeChanged(qint32 w, qint32 h);
 
+    KisOpenGLUpdateInfoBuilder& updateInfoBuilder();
+
 protected:
 
     KisOpenGLImageTextures(KisImageWSP image, const KoColorProfile *monitorProfile,
                            KoColorConversionTransformation::Intent renderingIntent,
                            KoColorConversionTransformation::ConversionFlags conversionFlags);
 
     void createImageTextureTiles();
 
     void destroyImageTextureTiles();
 
     static bool imageCanShareTextures();
 
 private:
 
-    QRect calculateTileRect(int col, int row) const;
-
     void getTextureSize(KisGLTexturesInfo *texturesInfo);
 
     void updateTextureFormat();
     KisOpenGLUpdateInfoSP updateCacheImpl(const QRect& rect, KisImageSP srcImage, bool convertColorSpace);
 
 private:
     KisImageWSP m_image;
     QRect m_storedImageBounds;
     const KoColorProfile *m_monitorProfile;
     KoColorConversionTransformation::Intent m_renderingIntent;
     KoColorConversionTransformation::ConversionFlags m_conversionFlags;
 
-    KisProofingConfigurationSP m_proofingConfig;
-    QScopedPointer<KoColorConversionTransformation> m_proofingTransform;
-    bool m_createNewProofingTransform;
-
     /**
      * If the destination color space coincides with the one of the image,
      * then effectively, there is no conversion happens. That is used
      * for working with OCIO.
      */
     const KoColorSpace *m_tilesDestinationColorSpace;
 
     /**
      * Shows whether the internal color management should be enabled or not.
      * Please note that if you disable color management, *but* your image color
      * space will not be supported (non-RGB), then it will be enabled anyway.
      * And this valiable will hold the real state of affairs!
      */
     bool m_internalColorManagementActive;
 
     GLuint m_checkerTexture;
 
     KisGLTexturesInfo m_texturesInfo;
     int m_numCols;
     QVector<KisTextureTile*> m_textureTiles;
 
     QOpenGLFunctions *m_glFuncs;
-    QBitArray m_channelFlags;
-    bool m_allChannelsSelected;
-    bool m_onlyOneChannelSelected;
-    int m_selectedChannelIndex;
 
     bool m_useOcio;
     bool m_initialized;
 
-    KisTextureTileInfoPoolSP m_infoChunksPool;
+    KisOpenGLUpdateInfoBuilder m_updateInfoBuilder;
 
 private:
     typedef QMap<KisImageWSP, KisOpenGLImageTextures*> ImageTexturesMap;
     static ImageTexturesMap imageTexturesMap;
 };
 
 #endif // KIS_OPENGL_IMAGE_TEXTURES_H_
 
diff --git a/libs/ui/opengl/kis_texture_tile.cpp b/libs/ui/opengl/kis_texture_tile.cpp
index 21fb0c3379..63389c5205 100644
--- a/libs/ui/opengl/kis_texture_tile.cpp
+++ b/libs/ui/opengl/kis_texture_tile.cpp
@@ -1,398 +1,406 @@
 /*
  *  Copyright (c) 2010 Dmitry Kazakov <dimula73@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.
  */
 
 #define GL_GLEXT_PROTOTYPES
 #include "kis_texture_tile.h"
 #include "kis_texture_tile_update_info.h"
 
 #include <kis_debug.h>
 #if !defined(QT_OPENGL_ES)
 #include <QOpenGLBuffer>
 #endif
 
 #ifndef GL_BGRA
 #define GL_BGRA 0x814F
 #endif
 
 void KisTextureTile::setTextureParameters()
 {
 
     f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
     f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_LOD, 0);
     f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LOD, m_numMipmapLevels);
     f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
     f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, m_numMipmapLevels);
 
     if (m_texturesInfo->internalFormat == GL_RGBA8 && m_texturesInfo->format == GL_RGBA) {
         // If image format is RGBA8, swap the red and blue channels for the proper colour
         // This is for OpenGL ES support and only used if lacking GL_EXT_texture_format_BGRA8888
         f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, GL_BLUE);
         f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_RED);
     }
 
     f->glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 }
 
 inline QRectF relativeRect(const QRect &br /* baseRect */,
                            const QRect &cr /* childRect */,
                            const KisGLTexturesInfo *texturesInfo)
 {
     const qreal x = qreal(cr.x() - br.x()) / texturesInfo->width;
     const qreal y = qreal(cr.y() - br.y()) / texturesInfo->height;
     const qreal w = qreal(cr.width()) / texturesInfo->width;
     const qreal h = qreal(cr.height()) / texturesInfo->height;
 
     return QRectF(x, y, w, h);
 }
 
 
 KisTextureTile::KisTextureTile(const QRect &imageRect, const KisGLTexturesInfo *texturesInfo,
                                const QByteArray &fillData, KisOpenGL::FilterMode filter,
                                bool useBuffer, int numMipmapLevels, QOpenGLFunctions *fcn)
 
     : m_textureId(0)
 #ifdef USE_PIXEL_BUFFERS
     , m_glBuffer(0)
 #endif
     , m_tileRectInImagePixels(imageRect)
     , m_filter(filter)
     , m_texturesInfo(texturesInfo)
     , m_needsMipmapRegeneration(false)
     , m_currentLodPlane(0)
     , m_useBuffer(useBuffer)
     , m_numMipmapLevels(numMipmapLevels)
     , f(fcn)
 {
     const GLvoid *fd = fillData.constData();
 
     m_textureRectInImagePixels =
-            stretchRect(m_tileRectInImagePixels, texturesInfo->border);
+            kisGrowRect(m_tileRectInImagePixels, texturesInfo->border);
 
     m_tileRectInTexturePixels = relativeRect(m_textureRectInImagePixels,
                                              m_tileRectInImagePixels,
                                              m_texturesInfo);
 
     f->glGenTextures(1, &m_textureId);
     f->glBindTexture(GL_TEXTURE_2D, m_textureId);
 
     setTextureParameters();
 
 #ifdef USE_PIXEL_BUFFERS
     createTextureBuffer(fillData.constData(), fillData.size());
     // we set fill data to 0 so the next glTexImage2D call uses our buffer
     fd = 0;
 #endif
 
     f->glTexImage2D(GL_TEXTURE_2D, 0,
                  m_texturesInfo->internalFormat,
                  m_texturesInfo->width,
                  m_texturesInfo->height, 0,
                  m_texturesInfo->format,
                  m_texturesInfo->type, fd);
 
 #ifdef USE_PIXEL_BUFFERS
     if (m_useBuffer && m_glBuffer) {
         m_glBuffer->release();
     }
 #endif
 
     setNeedsMipmapRegeneration();
 }
 
 KisTextureTile::~KisTextureTile()
 {
 #ifdef USE_PIXEL_BUFFERS
     delete m_glBuffer;
 #endif
     f->glDeleteTextures(1, &m_textureId);
 }
 
 void KisTextureTile::bindToActiveTexture()
 {
     f->glBindTexture(GL_TEXTURE_2D, m_textureId);
 
     if (m_needsMipmapRegeneration) {
         f->glGenerateMipmap(GL_TEXTURE_2D);
         m_needsMipmapRegeneration = false;
     }
 }
 
 void KisTextureTile::setNeedsMipmapRegeneration()
 {
     if (m_filter == KisOpenGL::TrilinearFilterMode ||
         m_filter == KisOpenGL::HighQualityFiltering) {
 
         m_needsMipmapRegeneration = true;
     }
 
     m_currentLodPlane = 0;
 }
 
 int KisTextureTile::currentLodPlane() const
 {
     return m_currentLodPlane;
 }
 
 void KisTextureTile::setCurrentLodPlane(int lod)
 {
     m_currentLodPlane = lod;
     m_needsMipmapRegeneration = false;
 }
 
 void KisTextureTile::update(const KisTextureTileUpdateInfo &updateInfo)
 {
     f->initializeOpenGLFunctions();
     f->glBindTexture(GL_TEXTURE_2D, m_textureId);
 
     setTextureParameters();
 
     const int patchLevelOfDetail = updateInfo.patchLevelOfDetail();
     const QSize patchSize = updateInfo.realPatchSize();
     const QPoint patchOffset = updateInfo.realPatchOffset();
 
     const GLvoid *fd = updateInfo.data();
 #ifdef USE_PIXEL_BUFFERS
     if (!m_glBuffer) {
         createTextureBuffer((const char*)updateInfo.data(), updateInfo.patchPixelsLength());
     }
 #endif
 
     /**
      * In some special case, when the Lod0 stroke is cancelled the
      * following situation is possible:
      *
      * 1)  The stroke  is  cancelled,  Lod0 update  is  issued by  the
      *     image. LodN level of the openGL times is still dirty.
      *
      * 2) [here, ideally, the canvas should be re-rendered, so that
      *     the mipmap would be regenerated in bindToActiveTexture()
      *     call, by in some cases (if you cancel and paint to quickly,
      *     that doesn't have time to happen]
      *
      * 3) The new LodN stroke issues a *partial* update of a LodN
      *    plane of the tile. But the plane is still *dirty*! We update
      *    a part of it, but we cannot regenerate the mipmap anymore,
      *    because the Lod0 level is not known yet!
      *
      * To avoid this issue, we should regenerate the dirty mipmap
      * *before* doing anything with the low-resolution plane.
      */
     if (patchLevelOfDetail > 0 &&
         m_needsMipmapRegeneration &&
         !updateInfo.isEntireTileUpdated()) {
 
         f->glGenerateMipmap(GL_TEXTURE_2D);
         m_needsMipmapRegeneration = false;
     }
 
 
     if (updateInfo.isEntireTileUpdated()) {
 
 #ifdef USE_PIXEL_BUFFERS
         if (m_useBuffer) {
 
             m_glBuffer->bind();
             m_glBuffer->allocate(updateInfo.patchPixelsLength());
 
             void *vid = m_glBuffer->map(QOpenGLBuffer::WriteOnly);
             memcpy(vid, fd, updateInfo.patchPixelsLength());
             m_glBuffer->unmap();
 
             // we set fill data to 0 so the next glTexImage2D call uses our buffer
             fd = 0;
         }
 #endif
 
         f->glTexImage2D(GL_TEXTURE_2D, patchLevelOfDetail,
                      m_texturesInfo->internalFormat,
                      patchSize.width(),
                      patchSize.height(), 0,
                      m_texturesInfo->format,
                      m_texturesInfo->type,
                      fd);
 
 #ifdef USE_PIXEL_BUFFERS
         if (m_useBuffer) {
             m_glBuffer->release();
         }
 #endif
 
     }
     else {
 #ifdef USE_PIXEL_BUFFERS
         if (m_useBuffer) {
             m_glBuffer->bind();
-            quint32 size = patchSize.width() * patchSize.height() * updateInfo.pixelSize();
+            int size = patchSize.width() * patchSize.height() * updateInfo.pixelSize();
             m_glBuffer->allocate(size);
 
             void *vid = m_glBuffer->map(QOpenGLBuffer::WriteOnly);
             memcpy(vid, fd, size);
             m_glBuffer->unmap();
 
             // we set fill data to 0 so the next glTexImage2D call uses our buffer
             fd = 0;
         }
 #endif
 
         f->glTexSubImage2D(GL_TEXTURE_2D, patchLevelOfDetail,
                         patchOffset.x(), patchOffset.y(),
                         patchSize.width(), patchSize.height(),
                         m_texturesInfo->format,
                         m_texturesInfo->type,
                         fd);
 
 #ifdef USE_PIXEL_BUFFERS
         if (m_useBuffer) {
             m_glBuffer->release();
         }
 #endif
 
     }
 
     /**
      * On the boundaries of KisImage, there is a border-effect as well.
      * So we just repeat the bounding pixels of the image to make
      * bilinear interpolator happy.
      */
 
     /**
      * WARN: The width of the stripes will be equal to the broder
      *       width of the tiles.
      */
 
     const int pixelSize = updateInfo.pixelSize();
     const QSize tileSize = updateInfo.realTileSize();
 
     if(updateInfo.isTopmost()) {
         int start = 0;
         int end = patchOffset.y() - 1;
         for (int i = start; i <= end; i++) {
             f->glTexSubImage2D(GL_TEXTURE_2D, patchLevelOfDetail,
                             patchOffset.x(), i,
                             patchSize.width(), 1,
                             m_texturesInfo->format,
                             m_texturesInfo->type,
                             updateInfo.data());
         }
     }
 
     if (updateInfo.isBottommost()) {
         int shift = patchSize.width() * (patchSize.height() - 1) *
                 pixelSize;
 
         int start = patchOffset.y() + patchSize.height();
         int end = tileSize.height() - 1;
         for (int i = start; i < end; i++) {
             f->glTexSubImage2D(GL_TEXTURE_2D, patchLevelOfDetail,
                             patchOffset.x(), i,
                             patchSize.width(), 1,
                             m_texturesInfo->format,
                             m_texturesInfo->type,
                             updateInfo.data() + shift);
         }
     }
 
     if (updateInfo.isLeftmost()) {
 
         QByteArray columnBuffer(patchSize.height() * pixelSize, 0);
 
         quint8 *srcPtr = updateInfo.data();
         quint8 *dstPtr = (quint8*) columnBuffer.data();
         for(int i = 0; i < patchSize.height(); i++) {
             memcpy(dstPtr, srcPtr, pixelSize);
 
             srcPtr += patchSize.width() * pixelSize;
             dstPtr += pixelSize;
         }
 
         int start = 0;
         int end = patchOffset.x() - 1;
         for (int i = start; i <= end; i++) {
             f->glTexSubImage2D(GL_TEXTURE_2D, patchLevelOfDetail,
                             i, patchOffset.y(),
                             1, patchSize.height(),
                             m_texturesInfo->format,
                             m_texturesInfo->type,
                             columnBuffer.constData());
         }
     }
 
     if (updateInfo.isRightmost()) {
 
         QByteArray columnBuffer(patchSize.height() * pixelSize, 0);
 
         quint8 *srcPtr = updateInfo.data() + (patchSize.width() - 1) * pixelSize;
         quint8 *dstPtr = (quint8*) columnBuffer.data();
         for(int i = 0; i < patchSize.height(); i++) {
             memcpy(dstPtr, srcPtr, pixelSize);
 
             srcPtr += patchSize.width() * pixelSize;
             dstPtr += pixelSize;
         }
 
         int start = patchOffset.x() + patchSize.width();
         int end = tileSize.width() - 1;
         for (int i = start; i <= end; i++) {
             f->glTexSubImage2D(GL_TEXTURE_2D, patchLevelOfDetail,
                             i, patchOffset.y(),
                             1, patchSize.height(),
                             m_texturesInfo->format,
                             m_texturesInfo->type,
                             columnBuffer.constData());
         }
     }
 
     //// Uncomment this warning if you see any weird flickering when
     //// Instant Preview updates
     //
     // if (!patchLevelOfDetail &&
     //     m_currentLodPlane &&
     //     !updateInfo.isEntireTileUpdated()) {
     //     qDebug() << "WARNING: LodN -> Lod0 switch is requested for the partial tile update! Flickering is possible..." << ppVar(patchSize);
     // }
 
     if (!patchLevelOfDetail) {
         setNeedsMipmapRegeneration();
     } else {
         setCurrentLodPlane(patchLevelOfDetail);
     }
 }
 
+QRectF KisTextureTile::imageRectInTexturePixels(const QRect &imageRect) const
+{
+    return relativeRect(m_textureRectInImagePixels,
+                        imageRect,
+                        m_texturesInfo);
+
+}
+
 #ifdef USE_PIXEL_BUFFERS
 void KisTextureTile::createTextureBuffer(const char *data, int size)
 {
     if (m_useBuffer) {
         if (!m_glBuffer) {
             m_glBuffer = new QOpenGLBuffer(QOpenGLBuffer::PixelUnpackBuffer);
             m_glBuffer->setUsagePattern(QOpenGLBuffer::DynamicDraw);
             m_glBuffer->create();
             m_glBuffer->bind();
             m_glBuffer->allocate(size);
         }
         void *vid = m_glBuffer->map(QOpenGLBuffer::WriteOnly);
         memcpy(vid, data, size);
         m_glBuffer->unmap();
 
     }
     else {
         delete m_glBuffer;
         m_glBuffer = 0;
     }
 }
 #endif
diff --git a/libs/ui/opengl/kis_texture_tile.h b/libs/ui/opengl/kis_texture_tile.h
index 2b6ed9110b..d18dcee172 100644
--- a/libs/ui/opengl/kis_texture_tile.h
+++ b/libs/ui/opengl/kis_texture_tile.h
@@ -1,127 +1,124 @@
 /*
  *  Copyright (c) 2010 Dmitry Kazakov <dimula73@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_TEXTURE_TILE_H_
 #define KIS_TEXTURE_TILE_H_
 
 #include <QRect>
 #include <QRectF>
 // no forward-declaration, used to get GL* primitive types defined
 #include <QOpenGLFunctions>
 
 #include "kis_opengl.h"
 
 #if !defined(QT_OPENGL_ES)
 #define USE_PIXEL_BUFFERS
 #endif
 
 class KisTextureTileUpdateInfo;
 class QOpenGLBuffer;
 
 
 struct KisGLTexturesInfo {
 
     KisGLTexturesInfo()
         : width(0)
         , height(0)
         , effectiveWidth(1)
         , effectiveHeight(1)
         , border(0)
     {}
 
     // real width and height
     int width;
     int height;
 
     // width and height minus border padding?
     int effectiveWidth;
     int effectiveHeight;
 
     // size of the border padding
     int border;
 
     GLint internalFormat;
     GLint format;
     GLint type;
 };
 
-inline QRect stretchRect(const QRect &rc, int delta)
-{
-    return rc.adjusted(-delta, -delta, delta, delta);
-}
-
 class KisTextureTile
 {
 public:
     KisTextureTile(const QRect &imageRect, const KisGLTexturesInfo *texturesInfo,
                    const QByteArray &fillData, KisOpenGL::FilterMode mode,
                    bool useBuffer, int numMipmapLevels, QOpenGLFunctions *f);
     ~KisTextureTile();
 
     void setUseBuffer(bool useBuffer) {
         m_useBuffer = useBuffer;
     }
 
     void setNumMipmapLevels(int num) {
         m_numMipmapLevels = num;
     }
 
     void update(const KisTextureTileUpdateInfo &updateInfo);
 
     inline QRect tileRectInImagePixels() {
         return m_tileRectInImagePixels;
     }
 
     inline QRect textureRectInImagePixels() {
         return m_textureRectInImagePixels;
     }
 
     inline QRectF tileRectInTexturePixels() {
         return m_tileRectInTexturePixels;
     }
 
+    QRectF imageRectInTexturePixels(const QRect &imageRect) const;
+
     void bindToActiveTexture();
     int currentLodPlane() const;
 
 private:
     inline void setTextureParameters();
 
     void setNeedsMipmapRegeneration();
     void setCurrentLodPlane(int lod);
 
     GLuint m_textureId;
 
 #ifdef USE_PIXEL_BUFFERS
     void createTextureBuffer(const char*data, int size);
     QOpenGLBuffer *m_glBuffer;
 #endif
 
     QRect m_tileRectInImagePixels;
     QRectF m_tileRectInTexturePixels;
     QRect m_textureRectInImagePixels;
     KisOpenGL::FilterMode m_filter;
     const KisGLTexturesInfo *m_texturesInfo;
     bool m_needsMipmapRegeneration;
     int m_currentLodPlane;
     bool m_useBuffer;
     int m_numMipmapLevels;
     QOpenGLFunctions *f;
     Q_DISABLE_COPY(KisTextureTile)
 };
 
 #endif /* KIS_TEXTURE_TILE_H_ */
 
diff --git a/libs/ui/opengl/kis_texture_tile_info_pool.h b/libs/ui/opengl/kis_texture_tile_info_pool.h
index 87fab1c13a..c594bff0fa 100644
--- a/libs/ui/opengl/kis_texture_tile_info_pool.h
+++ b/libs/ui/opengl/kis_texture_tile_info_pool.h
@@ -1,231 +1,233 @@
 /*
  *  Copyright (c) 2016 Dmitry Kazakov <dimula73@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_TEXTURE_TILE_INFO_POOL_H
 #define __KIS_TEXTURE_TILE_INFO_POOL_H
 
 #include <boost/pool/pool.hpp>
 #include <QtGlobal>
 #include <QVector>
 
 #include <QMutex>
 #include <QMutexLocker>
 #include <QSharedPointer>
 #include <QApplication>
 
 #include "kis_assert.h"
 #include "kis_debug.h"
 #include "kis_global.h"
 #include "kis_signal_compressor.h"
 
+#include "kritaui_export.h"
+
 const int minPoolChunk = 32; // 8 MiB (default, with tilesize 256)
 const int maxPoolChunk = 128; // 32 MiB (default, with tilesize 256)
 const int freeThreshold = 64; // 16 MiB (default, with tilesize 256)
 
 
 /**
  * A pool for keeping the chunks of data of constant size. We have one
  * such pool per used openGL tile size. The size of the chunk
  * obviously depends on the size of the tile in pixels and the size of
  * a single pixel in bytes.
  *
  * As soon as the number of allocations drops to zero, all the memory
  * is returned back to the operating system. Please note, that there
  * is *no way* of reclaiming even unused pool memory until *all* the
  * allocated chunks are free'd.
  */
-class KisTextureTileInfoPoolSingleSize
+class KRITAUI_EXPORT KisTextureTileInfoPoolSingleSize
 {
 public:
     KisTextureTileInfoPoolSingleSize(int tileWidth, int tileHeight, int pixelSize)
         : m_chunkSize(tileWidth * tileHeight * pixelSize),
           m_pool(m_chunkSize, minPoolChunk, maxPoolChunk),
           m_numAllocations(0),
           m_maxAllocations(0),
           m_numFrees(0)
     {
     }
 
     quint8* malloc() {
         m_numAllocations++;
         m_maxAllocations = qMax(m_maxAllocations, m_numAllocations);
 
         return (quint8*)m_pool.malloc();
     }
 
     bool free(quint8 *ptr) {
         m_numAllocations--;
         m_numFrees++;
         m_pool.free(ptr);
 
         KIS_ASSERT_RECOVER_NOOP(m_numAllocations >= 0);
 
         return !m_numAllocations && m_maxAllocations > freeThreshold;
     }
 
     int chunkSize() const {
         return m_chunkSize;
     }
 
     int numFrees() const {
         return m_numFrees;
     }
 
     void tryPurge(int numFrees) {
         // checking numFrees here is asserting that there were no frees
         // between the time we originally indicated the purge and now.
         if (numFrees == m_numFrees && !m_numAllocations) {
             m_pool.purge_memory();
             m_maxAllocations = 0;
         }
     }
 
 private:
     const int m_chunkSize;
     boost::pool<boost::default_user_allocator_new_delete> m_pool;
     int m_numAllocations;
     int m_maxAllocations;
     int m_numFrees;
 };
 
 class KisTextureTileInfoPool;
 
-class KisTextureTileInfoPoolWorker : public QObject
+class KRITAUI_EXPORT KisTextureTileInfoPoolWorker : public QObject
 {
     Q_OBJECT
 public:
     KisTextureTileInfoPoolWorker(KisTextureTileInfoPool *pool);
 
 public Q_SLOTS:
     void slotPurge(int pixelSize, int numFrees);
     void slotDelayedPurge();
 
 private:
     KisTextureTileInfoPool *m_pool;
     KisSignalCompressor m_compressor;
     QMap<int, int> m_purge;
 };
 
 /**
  * A universal pool for keeping the openGL tile of different pixel
  * sizes.  The underlying pools are created for each pixel size on
  * demand.
  */
-class KisTextureTileInfoPool : public QObject
+class KRITAUI_EXPORT KisTextureTileInfoPool : public QObject
 {
     Q_OBJECT
 public:
     KisTextureTileInfoPool(int tileWidth, int tileHeight)
         : m_tileWidth(tileWidth),
           m_tileHeight(tileHeight)
     {
         m_worker = new KisTextureTileInfoPoolWorker(this);
         m_worker->moveToThread(QApplication::instance()->thread());
         connect(this, SIGNAL(purge(int, int)), m_worker, SLOT(slotPurge(int, int)));
     }
 
     ~KisTextureTileInfoPool() {
         delete m_worker;
         qDeleteAll(m_pools);
     }
 
     /**
      * Alloc a tile with the specified pixel size
      */
     quint8* malloc(int pixelSize) {
         QMutexLocker l(&m_mutex);
 
         if (m_pools.size() <= pixelSize) {
             m_pools.resize(pixelSize + 1);
         }
 
         if (!m_pools[pixelSize]) {
             m_pools[pixelSize] =
                 new KisTextureTileInfoPoolSingleSize(m_tileWidth, m_tileHeight, pixelSize);
         }
 
         return m_pools[pixelSize]->malloc();
     }
 
     /**
      * Free a tile with the specified pixel size
      */
     void free(quint8 *ptr, int pixelSize) {
         QMutexLocker l(&m_mutex);
         KisTextureTileInfoPoolSingleSize *pool = m_pools[pixelSize];
         if (pool->free(ptr)) {
             emit purge(pixelSize, pool->numFrees());
         }
     }
 
     /**
      * \return the length of the chunks stored in the pool
      */
     int chunkSize(int pixelSize) const {
         QMutexLocker l(&m_mutex);
         return m_pools[pixelSize]->chunkSize();
     }
 
     void tryPurge(int pixelSize, int numFrees) {
         QMutexLocker l(&m_mutex);
         m_pools[pixelSize]->tryPurge(numFrees);
     }
 
 Q_SIGNALS:
     void purge(int pixelSize, int numFrees);
 
 private:
     mutable QMutex m_mutex;
     const int m_tileWidth;
     const int m_tileHeight;
     QVector<KisTextureTileInfoPoolSingleSize*> m_pools;
     KisTextureTileInfoPoolWorker *m_worker;
 };
 
 typedef QSharedPointer<KisTextureTileInfoPool> KisTextureTileInfoPoolSP;
 
-class KisTextureTileInfoPoolRegistry
+class KRITAUI_EXPORT KisTextureTileInfoPoolRegistry
 {
     typedef QWeakPointer<KisTextureTileInfoPool> KisTextureTileInfoPoolWSP;
     typedef QPair<int, int> PoolId;
 
 public:
     KisTextureTileInfoPoolSP getPool(int tileWidth, int tileHeight) {
         QMutexLocker l(&m_mutex);
 
         PoolId id(tileWidth, tileHeight);
 
         KisTextureTileInfoPoolSP pool =
             m_storage[id].toStrongRef();
 
         if (!pool) {
             pool = toQShared(
                 new KisTextureTileInfoPool(tileWidth, tileHeight));
             m_storage[id] = pool;
         }
 
         return pool;
     }
 
 private:
     QMutex m_mutex;
     QHash<PoolId, KisTextureTileInfoPoolWSP> m_storage;
 };
 
 
 #endif /* __KIS_TEXTURE_TILE_INFO_POOL_H */
diff --git a/libs/ui/opengl/kis_texture_tile_update_info.h b/libs/ui/opengl/kis_texture_tile_update_info.h
index 3ad0bfe5fc..48dcb70dec 100644
--- a/libs/ui/opengl/kis_texture_tile_update_info.h
+++ b/libs/ui/opengl/kis_texture_tile_update_info.h
@@ -1,331 +1,375 @@
 /*
  *  Copyright (c) 2010, Dmitry Kazakov <dimula73@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_TEXTURE_TILE_UPDATE_INFO_H_
 #define KIS_TEXTURE_TILE_UPDATE_INFO_H_
 
 #include <QMessageBox>
 #include <QThreadStorage>
 #include <QScopedArrayPointer>
 
 #include <KoColorSpace.h>
 #include "kis_image.h"
 #include "kis_paint_device.h"
 #include "kis_config.h"
 #include <KoColorConversionTransformation.h>
 #include <KoChannelInfo.h>
 #include <kis_lod_transform.h>
 #include "kis_texture_tile_info_pool.h"
 
 
 class KisTextureTileUpdateInfo;
 typedef QSharedPointer<KisTextureTileUpdateInfo> KisTextureTileUpdateInfoSP;
 typedef QVector<KisTextureTileUpdateInfoSP> KisTextureTileUpdateInfoSPList;
 
 /**
  * A buffer object for temporary data needed during the update process.
  *
  * - the buffer is allocated from the common pool to avoid memory
  *   fragmentation
  *
  * - the buffer's lifetime defines the lifetime of the allocated chunk
  *   of memory, so you don't have to thing about free'ing the memory
  */
 
 class DataBuffer
 {
 public:
     DataBuffer(KisTextureTileInfoPoolSP pool)
         : m_data(0),
           m_pixelSize(0),
           m_pool(pool)
     {
     }
 
     DataBuffer(int pixelSize, KisTextureTileInfoPoolSP pool)
         : m_data(0),
           m_pixelSize(0),
           m_pool(pool)
     {
         allocate(pixelSize);
     }
 
+    DataBuffer(DataBuffer &&rhs)
+        : m_data(rhs.m_data),
+          m_pixelSize(rhs.m_pixelSize),
+          m_pool(rhs.m_pool)
+    {
+        rhs.m_data = 0;
+    }
+
+    DataBuffer& operator=(DataBuffer &&rhs) {
+        swap(rhs);
+        return *this;
+    }
+
     ~DataBuffer() {
         if (m_data) {
             m_pool->free(m_data, m_pixelSize);
         }
     }
 
     void allocate(int pixelSize) {
         Q_ASSERT(!m_data);
 
         m_pixelSize = pixelSize;
         m_data = m_pool->malloc(m_pixelSize);
     }
 
     inline quint8* data() const {
         return m_data;
     }
 
     void swap(DataBuffer &other) {
         std::swap(other.m_pixelSize, m_pixelSize);
         std::swap(other.m_data, m_data);
+        std::swap(other.m_pool, m_pool);
     }
 
     int size() const {
         return m_data ? m_pool->chunkSize(m_pixelSize) : 0;
     }
 
+    KisTextureTileInfoPoolSP pool() const {
+        return m_pool;
+    }
+
+    int pixelSize() const {
+        return m_pixelSize;
+    }
+
 private:
+    Q_DISABLE_COPY(DataBuffer)
+
     quint8 *m_data;
     int m_pixelSize;
     KisTextureTileInfoPoolSP m_pool;
 };
 
 class KisTextureTileUpdateInfo
 {
 public:
     KisTextureTileUpdateInfo(KisTextureTileInfoPoolSP pool)
         : m_patchPixels(pool),
           m_pool(pool)
     {
     }
 
     KisTextureTileUpdateInfo(qint32 col, qint32 row,
                              const QRect &tileRect, const QRect &updateRect, const QRect &currentImageRect,
                              int levelOfDetail,
                              KisTextureTileInfoPoolSP pool)
         : m_patchPixels(pool),
           m_pool(pool)
     {
         m_tileCol = col;
         m_tileRow = row;
         m_tileRect = tileRect;
         m_originalTileRect = m_tileRect;
         m_patchRect = m_tileRect & updateRect;
         m_originalPatchRect = m_patchRect;
         m_currentImageRect = currentImageRect;
 
         m_patchLevelOfDetail = levelOfDetail;
 
         if (m_patchLevelOfDetail) {
+            // TODO: check if isBottommost() works correctly when m_originalPatchRect gets aligned
+            //       and m_currentImageRect has non-aligned size
             m_originalPatchRect = KisLodTransform::alignedRect(m_originalPatchRect, m_patchLevelOfDetail);
             m_patchRect = KisLodTransform::scaledRect(m_originalPatchRect, m_patchLevelOfDetail);
             m_tileRect = KisLodTransform::scaledRect(m_originalTileRect, m_patchLevelOfDetail);
         }
     }
 
     ~KisTextureTileUpdateInfo() {
     }
 
     void retrieveData(KisPaintDeviceSP projectionDevice, const QBitArray &channelFlags, bool onlyOneChannelSelected, int selectedChannelIndex)
     {
         m_patchColorSpace = projectionDevice->colorSpace();
         m_patchPixels.allocate(m_patchColorSpace->pixelSize());
 
         projectionDevice->readBytes(m_patchPixels.data(),
                                        m_patchRect.x(), m_patchRect.y(),
                                        m_patchRect.width(), m_patchRect.height());
 
         // XXX: if the paint colorspace is rgb, we should do the channel swizzling in
         //      the display shader
         if (!channelFlags.isEmpty()) {
             DataBuffer conversionCache(m_patchColorSpace->pixelSize(), m_pool);
 
             QList<KoChannelInfo*> channelInfo = m_patchColorSpace->channels();
             int channelSize = channelInfo[selectedChannelIndex]->size();
             int pixelSize = m_patchColorSpace->pixelSize();
             quint32 numPixels = m_patchRect.width() * m_patchRect.height();
 
             KisConfig cfg;
 
             if (onlyOneChannelSelected && !cfg.showSingleChannelAsColor()) {
                 int selectedChannelPos = channelInfo[selectedChannelIndex]->pos();
                 for (uint pixelIndex = 0; pixelIndex < numPixels; ++pixelIndex) {
                     for (uint channelIndex = 0; channelIndex < m_patchColorSpace->channelCount(); ++channelIndex) {
 
                         if (channelInfo[channelIndex]->channelType() == KoChannelInfo::COLOR) {
                             memcpy(conversionCache.data() + (pixelIndex * pixelSize) + (channelIndex * channelSize),
                                    m_patchPixels.data() + (pixelIndex * pixelSize) + selectedChannelPos,
                                    channelSize);
                         }
                         else if (channelInfo[channelIndex]->channelType() == KoChannelInfo::ALPHA) {
                             memcpy(conversionCache.data() + (pixelIndex * pixelSize) + (channelIndex * channelSize),
                                    m_patchPixels.data() + (pixelIndex * pixelSize) + (channelIndex * channelSize),
                                    channelSize);
                         }
                     }
                 }
             }
             else {
                 for (uint pixelIndex = 0; pixelIndex < numPixels; ++pixelIndex) {
                     for (uint channelIndex = 0; channelIndex < m_patchColorSpace->channelCount(); ++channelIndex) {
                         if (channelFlags.testBit(channelIndex)) {
                             memcpy(conversionCache.data() + (pixelIndex * pixelSize) + (channelIndex * channelSize),
                                    m_patchPixels.data() + (pixelIndex * pixelSize) + (channelIndex * channelSize),
                                    channelSize);
                         }
                         else {
                             memset(conversionCache.data() + (pixelIndex * pixelSize) + (channelIndex * channelSize), 0, channelSize);
                         }
                     }
                 }
 
             }
 
             conversionCache.swap(m_patchPixels);
         }
 
     }
 
     void convertTo(const KoColorSpace* dstCS,
                    KoColorConversionTransformation::Intent renderingIntent,
                    KoColorConversionTransformation::ConversionFlags conversionFlags)
     {
         // we use two-stage check of the color space equivalence:
         // first check pointers, and if not, check the spaces themselves
         if ((dstCS == m_patchColorSpace || *dstCS == *m_patchColorSpace) &&
             conversionFlags == KoColorConversionTransformation::Empty) {
 
             return;
         }
 
         if (m_patchRect.isValid()) {
             const qint32 numPixels = m_patchRect.width() * m_patchRect.height();
             DataBuffer conversionCache(dstCS->pixelSize(), m_pool);
 
             m_patchColorSpace->convertPixelsTo(m_patchPixels.data(), conversionCache.data(), dstCS, numPixels, renderingIntent, conversionFlags);
 
             m_patchColorSpace = dstCS;
             conversionCache.swap(m_patchPixels);
         }
     }
 
     void proofTo(const KoColorSpace* dstCS,
                    KoColorConversionTransformation::ConversionFlags conversionFlags,
                    KoColorConversionTransformation *proofingTransform)
     {
         if (dstCS == m_patchColorSpace && conversionFlags == KoColorConversionTransformation::Empty) return;
 
         if (m_patchRect.isValid()) {
             const qint32 numPixels = m_patchRect.width() * m_patchRect.height();
             DataBuffer conversionCache(dstCS->pixelSize(), m_pool);
 
             m_patchColorSpace->proofPixelsTo(m_patchPixels.data(), conversionCache.data(), numPixels, proofingTransform);
 
             m_patchColorSpace = dstCS;
             conversionCache.swap(m_patchPixels);
         }
     }
 
-    KoColorConversionTransformation *generateProofingTransform(const KoColorSpace* dstCS, const KoColorSpace* proofingSpace,
-                                                       KoColorConversionTransformation::Intent renderingIntent,
-                                                       KoColorConversionTransformation::Intent proofingIntent,
-                                                       KoColorConversionTransformation::ConversionFlags conversionFlags,
-                                                       KoColor gamutWarning,
-                                                       double adaptationState)
+    static KoColorConversionTransformation *generateProofingTransform(const KoColorSpace* srcCS,
+                                                                      const KoColorSpace* dstCS, const KoColorSpace* proofingSpace,
+                                                                      KoColorConversionTransformation::Intent renderingIntent,
+                                                                      KoColorConversionTransformation::Intent proofingIntent,
+                                                                      KoColorConversionTransformation::ConversionFlags conversionFlags,
+                                                                      KoColor gamutWarning,
+                                                                      double adaptationState)
     {
-        return m_patchColorSpace->createProofingTransform(dstCS, proofingSpace, renderingIntent, proofingIntent, conversionFlags, gamutWarning.data(), adaptationState);
+        return srcCS->createProofingTransform(dstCS, proofingSpace, renderingIntent, proofingIntent, conversionFlags, gamutWarning.data(), adaptationState);
     }
 
     inline quint8* data() const {
         return m_patchPixels.data();
     }
 
     inline int patchLevelOfDetail() const {
         return m_patchLevelOfDetail;
     }
 
     inline QPoint realPatchOffset() const {
         return QPoint(m_patchRect.x() - m_tileRect.x(),
                       m_patchRect.y() - m_tileRect.y());
     }
 
     inline QSize realPatchSize() const {
         return m_patchRect.size();
     }
 
+    inline QRect realPatchRect() const {
+        return m_patchRect;
+    }
+
     inline QSize realTileSize() const {
         return m_tileRect.size();
     }
 
     inline bool isTopmost() const {
         return m_originalPatchRect.top() == m_currentImageRect.top();
     }
 
     inline bool isLeftmost() const {
         return m_originalPatchRect.left() == m_currentImageRect.left();
     }
 
     inline bool isRightmost() const {
         return m_originalPatchRect.right() == m_currentImageRect.right();
     }
 
     inline bool isBottommost() const {
         return m_originalPatchRect.bottom() == m_currentImageRect.bottom();
     }
 
     inline bool isEntireTileUpdated() const {
         return m_patchRect == m_tileRect;
     }
 
     inline qint32 tileCol() const {
         return m_tileCol;
     }
 
     inline qint32 tileRow() const {
         return m_tileRow;
     }
 
-    inline quint32 pixelSize() const {
+    inline int pixelSize() const {
         return m_patchColorSpace->pixelSize();
     }
 
+    inline const KoColorSpace* patchColorSpace() const {
+        return m_patchColorSpace;
+    }
+
     inline quint32 patchPixelsLength() const {
         return m_patchPixels.size();
     }
 
     inline bool valid() const {
         return m_patchRect.isValid();
     }
 
+    inline DataBuffer&& takePixelData() {
+        return std::move(m_patchPixels);
+    }
+
+    inline void putPixelData(DataBuffer &&buffer, const KoColorSpace *colorSpace) {
+        m_patchPixels = std::move(buffer);
+        m_patchColorSpace = colorSpace;
+    }
+
 private:
     Q_DISABLE_COPY(KisTextureTileUpdateInfo)
 
 private:
     qint32 m_tileCol;
     qint32 m_tileRow;
     QRect m_currentImageRect;
     QRect m_tileRect;
     QRect m_patchRect;
     const KoColorSpace* m_patchColorSpace;
 
     QRect m_realPatchRect;
     QRect m_realPatchOffset;
     QRect m_realTileSize;
     int m_patchLevelOfDetail;
 
     QRect m_originalPatchRect;
     QRect m_originalTileRect;
 
     DataBuffer m_patchPixels;
     KisTextureTileInfoPoolSP m_pool;
 };
 
 
 #endif /* KIS_TEXTURE_TILE_UPDATE_INFO_H_ */
 
diff --git a/libs/ui/tests/CMakeLists.txt b/libs/ui/tests/CMakeLists.txt
index a9c60cc191..decad8988f 100644
--- a/libs/ui/tests/CMakeLists.txt
+++ b/libs/ui/tests/CMakeLists.txt
@@ -1,182 +1,189 @@
 set( EXECUTABLE_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR} )
 
 #add_subdirectory(scratchpad)
 include_directories(${CMAKE_SOURCE_DIR}/libs/image/metadata 
                     ${CMAKE_SOURCE_DIR}/sdk/tests )
 
 include(ECMAddTests)
 
 macro_add_unittest_definitions()
 
 ecm_add_tests(
     kis_image_view_converter_test.cpp
     kis_shape_selection_test.cpp
     kis_recorded_action_editor_test.cpp
     kis_doc2_test.cpp
     kis_coordinates_converter_test.cpp
     kis_grid_config_test.cpp
     kis_stabilized_events_sampler_test.cpp
     kis_derived_resources_test.cpp
     kis_brush_hud_properties_config_test.cpp
     kis_shape_commands_test.cpp
     kis_shape_layer_test.cpp
     kis_stop_gradient_editor_test.cpp
     NAME_PREFIX "krita-ui-"
     LINK_LIBRARIES kritaui Qt5::Test
 )
 
 ecm_add_tests(
     kis_file_layer_test.cpp
     kis_multinode_property_test.cpp
     NAME_PREFIX "krita-ui-"
     LINK_LIBRARIES kritaui kritaimage Qt5::Test
 )
 
+ecm_add_test( KisFrameSerializerTest.cpp
+    TEST_NAME krita-ui-KisFrameSerializerTest
+    LINK_LIBRARIES kritaui kritaimage Qt5::Test)
+
+ecm_add_test( KisFrameCacheStoreTest.cpp
+    TEST_NAME krita-ui-KisFrameCacheStoreTest
+    LINK_LIBRARIES kritaui kritaimage Qt5::Test)
 
 ecm_add_test( kis_selection_decoration_test.cpp ../../../sdk/tests/stroke_testing_utils.cpp
     TEST_NAME krita-ui-KisSelectionDecorationTest
     LINK_LIBRARIES kritaui kritaimage Qt5::Test)
 
 ecm_add_test( kis_node_dummies_graph_test.cpp ../../../sdk/tests/testutil.cpp
     TEST_NAME krita-ui-KisNodeDummiesGraphTest
     LINK_LIBRARIES kritaui kritaimage Qt5::Test)
 
 ecm_add_test( kis_node_shapes_graph_test.cpp ../../../sdk/tests/testutil.cpp
     TEST_NAME krita-ui-KisNodeShapesGraphTest
     LINK_LIBRARIES kritaui kritaimage Qt5::Test)
 
 ecm_add_test( kis_model_index_converter_test.cpp ../../../sdk/tests/testutil.cpp
     TEST_NAME krita-ui-KisModelIndexConverterTest
     LINK_LIBRARIES kritaui kritaimage Qt5::Test)
 
 ecm_add_test( kis_categorized_list_model_test.cpp modeltest.cpp
     TEST_NAME krita-ui-KisCategorizedListModelTest
     LINK_LIBRARIES kritaui kritaimage Qt5::Test)
 
 ecm_add_test( kis_resource_server_provider_test.cpp modeltest.cpp
     TEST_NAME krita-ui-KisResourceServerProviderTest
     LINK_LIBRARIES kritaui kritaimage Qt5::Test)
 
 ecm_add_test( kis_node_juggler_compressed_test.cpp  ../../../sdk/tests/testutil.cpp
     TEST_NAME krita-image-BaseNodeTest
     LINK_LIBRARIES kritaimage kritaui Qt5::Test)
 
 ecm_add_test(
     kis_animation_exporter_test.cpp
     TEST_NAME kritaui-animation_exporter_test
     LINK_LIBRARIES kritaui kritaimage Qt5::Test)
 
 set(kis_node_view_test_SRCS kis_node_view_test.cpp  ../../../sdk/tests/testutil.cpp)
 qt5_add_resources(kis_node_view_test_SRCS ${krita_QRCS})
 ecm_add_test(${kis_node_view_test_SRCS}
     TEST_NAME krita-image-kis_node_view_test
     LINK_LIBRARIES kritaimage kritaui Qt5::Test)
 
 
 
 ##### Tests that currently fail and should be fixed #####
 
 include(KritaAddBrokenUnitTest)
 
 krita_add_broken_unit_test(
     kis_node_model_test.cpp modeltest.cpp
     TEST_NAME krita-ui-kis_node_model_test
     LINK_LIBRARIES kritaui Qt5::Test)
 
 krita_add_broken_unit_test(
     kis_shape_controller_test.cpp kis_dummies_facade_base_test.cpp
     TEST_NAME krita-ui-kis_shape_controller_test
     LINK_LIBRARIES kritaimage kritaui Qt5::Test)
 
 krita_add_broken_unit_test(
     kis_prescaled_projection_test.cpp
     TEST_NAME krita-ui-kis_prescaled_projection_test
     LINK_LIBRARIES kritaui Qt5::Test)
 
 krita_add_broken_unit_test(
     kis_exiv2_test.cpp
     TEST_NAME krita-ui-KisExiv2Test
     LINK_LIBRARIES kritaimage kritaui Qt5::Test)
 
 krita_add_broken_unit_test(
     kis_clipboard_test.cpp
     TEST_NAME krita-ui-KisClipboardTest
     LINK_LIBRARIES kritaui kritaimage Qt5::Test)
 
 krita_add_broken_unit_test(
     freehand_stroke_test.cpp ${CMAKE_SOURCE_DIR}/sdk/tests/stroke_testing_utils.cpp
     TEST_NAME krita-ui-FreehandStrokeTest
     LINK_LIBRARIES kritaui kritaimage Qt5::Test)
 
 krita_add_broken_unit_test(
     FreehandStrokeBenchmark.cpp ${CMAKE_SOURCE_DIR}/sdk/tests/stroke_testing_utils.cpp
     TEST_NAME krita-ui-FreehandStrokeBenchmark
     LINK_LIBRARIES kritaui kritaimage Qt5::Test)
 
 krita_add_broken_unit_test(
     fill_processing_visitor_test.cpp ${CMAKE_SOURCE_DIR}/sdk/tests/stroke_testing_utils.cpp
     TEST_NAME krita-ui-FillProcessingVisitorTest
     LINK_LIBRARIES kritaui kritaimage Qt5::Test)
 
 krita_add_broken_unit_test(
     filter_stroke_test.cpp ../../../sdk/tests/stroke_testing_utils.cpp
     TEST_NAME krita-ui-FilterStrokeTest
     LINK_LIBRARIES kritaui kritaimage Qt5::Test)
 
 krita_add_broken_unit_test(
     kis_selection_manager_test.cpp
     TEST_NAME krita-ui-KisSelectionManagerTest
     LINK_LIBRARIES kritaui kritaimage Qt5::Test)
 #set_tests_properties(krita-ui-KisSelectionManagerTest PROPERTIES TIMEOUT 300)
 
 krita_add_broken_unit_test(
     kis_node_manager_test.cpp
     TEST_NAME krita-ui-KisNodeManagerTest
     LINK_LIBRARIES kritaui kritaimage Qt5::Test)
 
 krita_add_broken_unit_test(
     kis_dummies_facade_test.cpp kis_dummies_facade_base_test.cpp ../../../sdk/tests/testutil.cpp
     TEST_NAME krita-ui-KisDummiesFacadeTest
     LINK_LIBRARIES kritaui kritaimage Qt5::Test)
 
 krita_add_broken_unit_test(
     kis_zoom_and_pan_test.cpp ../../../sdk/tests/testutil.cpp
     TEST_NAME krita-ui-KisZoomAndPanTest
     LINK_LIBRARIES kritaui kritaimage Qt5::Test)
 #set_tests_properties(krita-ui-KisZoomAndPanTest PROPERTIES TIMEOUT 300)
 
 krita_add_broken_unit_test(
     kis_action_manager_test.cpp
     TEST_NAME krita-ui-KisActionManagerTest
     LINK_LIBRARIES kritaui kritaimage Qt5::Test)
 
 krita_add_broken_unit_test(
     kis_categories_mapper_test.cpp testing_categories_mapper.cpp
     TEST_NAME krita-ui-KisCategoriesMapperTest
     LINK_LIBRARIES kritaui kritaimage Qt5::Test)
 
 krita_add_broken_unit_test(
     kis_asl_layer_style_serializer_test.cpp
     TEST_NAME krita-ui-KisAslLayerStyleSerializerTest
     LINK_LIBRARIES kritaui kritaimage Qt5::Test)
 
 krita_add_broken_unit_test(
     kis_animation_importer_test.cpp
     TEST_NAME kritaui-animation_importer_test
     LINK_LIBRARIES kritaui kritaimage Qt5::Test)
 
 krita_add_broken_unit_test(
     kis_animation_frame_cache_test.cpp
     TEST_NAME kritaui-animation_frame_cache_test
     LINK_LIBRARIES kritaui kritaimage Qt5::Test)
 
 krita_add_broken_unit_test(
     ResourceBundleTest.cpp
     TEST_NAME krita-resourcemanager-ResourceBundleTest
     LINK_LIBRARIES kritaui kritalibbrush kritalibpaintop Qt5::Test)
 
 # FIXME this test doesn't compile
 #ecm_add_test(
 #    kis_input_manager_test.cpp ../../../sdk/tests/testutil.cpp
 #    TEST_NAME krita-ui-KisInputManagerTest
 #    LINK_LIBRARIES kritaui kritaimage Qt5::Test)
diff --git a/libs/ui/tests/KisFrameCacheStoreTest.cpp b/libs/ui/tests/KisFrameCacheStoreTest.cpp
new file mode 100644
index 0000000000..7566cbf48f
--- /dev/null
+++ b/libs/ui/tests/KisFrameCacheStoreTest.cpp
@@ -0,0 +1,197 @@
+/*
+ *  Copyright (c) 2018 Dmitry Kazakov <dimula73@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 "KisFrameCacheStoreTest.h"
+
+#include <QTest>
+#include <testutil.h>
+
+#include <KoColor.h>
+#include "KisAsyncAnimationRendererBase.h"
+#include "kis_image_animation_interface.h"
+#include "opengl/KisOpenGLUpdateInfoBuilder.h"
+
+#include "KoColorSpaceRegistry.h"
+#include "KoColorSpace.h"
+
+// TODO: conversion options into a separate file!
+#include "kis_update_info.h"
+
+#include "opengl/kis_texture_tile_update_info.h"
+
+
+#include "KisFrameCacheStore.h"
+
+static const int maxTileSize = 256;
+
+bool compareTextureTileUpdateInfo(KisTextureTileUpdateInfoSP tile1, KisTextureTileUpdateInfoSP tile2)
+{
+    KIS_COMPARE_RF(tile1->patchLevelOfDetail(), tile2->patchLevelOfDetail());
+    KIS_COMPARE_RF(tile1->realPatchOffset(), tile2->realPatchOffset());
+    KIS_COMPARE_RF(tile1->realPatchRect(), tile2->realPatchRect());
+    KIS_COMPARE_RF(tile1->realTileSize(), tile2->realTileSize());
+    KIS_COMPARE_RF(tile1->isTopmost(), tile2->isTopmost());
+    KIS_COMPARE_RF(tile1->isLeftmost(), tile2->isLeftmost());
+    KIS_COMPARE_RF(tile1->isRightmost(), tile2->isRightmost());
+    KIS_COMPARE_RF(tile1->isBottommost(), tile2->isBottommost());
+    KIS_COMPARE_RF(tile1->isEntireTileUpdated(), tile2->isEntireTileUpdated());
+
+    KIS_COMPARE_RF(tile1->tileCol(), tile2->tileCol());
+    KIS_COMPARE_RF(tile1->tileRow(), tile2->tileRow());
+    KIS_COMPARE_RF(tile1->pixelSize(), tile2->pixelSize());
+    KIS_COMPARE_RF(tile1->valid(), tile2->valid());
+
+    KIS_COMPARE_RF(tile1->patchPixelsLength(), tile2->patchPixelsLength());
+
+
+    const int numRealPixelBytes = tile1->realPatchRect().width() * tile1->realPatchRect().height() * tile1->pixelSize();
+
+    if (memcmp(tile1->data(), tile2->data(), numRealPixelBytes) != 0) {
+        qWarning() << "Tile pixels differ!";
+        qWarning() << "    " << ppVar(tile1->tileCol()) << ppVar(tile1->tileRow());
+        qWarning() << "    " << ppVar(numRealPixelBytes);
+
+        quint8 *src = tile1->data();
+        quint8 *dst = tile2->data();
+
+        for (int i = 0; i < numRealPixelBytes; i++) {
+            if (*src != *dst) {
+                qDebug() << "    " << ppVar(i) << ppVar(*src) << ppVar(*dst);
+            }
+
+            src++;
+            dst++;
+        }
+
+        return false;
+    }
+
+    return true;
+}
+
+
+bool compareUpdateInfo(KisOpenGLUpdateInfoSP info1, KisOpenGLUpdateInfoSP info2)
+{
+    KIS_COMPARE_RF(info1->dirtyImageRect(), info2->dirtyImageRect());
+    KIS_COMPARE_RF(info1->levelOfDetail(), info2->levelOfDetail());
+    KIS_COMPARE_RF(info1->tileList.size(), info2->tileList.size());
+
+    for (int i = 0; i < info1->tileList.size(); i++) {
+        if (!compareTextureTileUpdateInfo(info1->tileList[i], info2->tileList[i])) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+
+class TestFramesRenderer : public KisAsyncAnimationRendererBase
+{
+    Q_OBJECT
+
+public:
+    TestFramesRenderer()
+        : m_pool(m_poolRegistry.getPool(maxTileSize, maxTileSize))
+    {
+        m_updateInfoBuilder.setTextureInfoPool(m_pool);
+
+        const KoColorSpace *dstColorSpace = KoColorSpaceRegistry::instance()->rgb8();
+        m_updateInfoBuilder.setConversionOptions(
+            ConversionOptions(dstColorSpace,
+                              KoColorConversionTransformation::internalRenderingIntent(),
+                              KoColorConversionTransformation::internalConversionFlags()));
+
+        // TODO: refactor setting texture size in raw values!
+        m_updateInfoBuilder.setTextureBorder(8);
+        m_updateInfoBuilder.setEffectiveTextureSize(QSize(256 - 16, 256 - 16));
+
+        connect(this, SIGNAL(sigCompleteRegenerationInternal(int)), SLOT(notifyFrameCompleted(int)));
+        connect(this, SIGNAL(sigCancelRegenerationInternal(int)), SLOT(notifyFrameCancelled(int)));
+    }
+
+    void frameCompletedCallback(int frame, const QRegion &requestedRegion) override {
+        ENTER_FUNCTION() << ppVar(frame);
+
+        KisImageSP image = requestedImage();
+        KIS_SAFE_ASSERT_RECOVER_NOOP(frame == image->animationInterface()->currentTime());
+
+        // by default we request update for the entire image
+        KIS_SAFE_ASSERT_RECOVER_NOOP(requestedRegion == image->bounds());
+
+        KisOpenGLUpdateInfoSP info = m_updateInfoBuilder.buildUpdateInfo(image->bounds(), image, true);
+
+        KIS_ASSERT_RECOVER_NOOP(info);
+        qDebug() << ppVar(info->tileList.size());
+
+        KisOpenGLUpdateInfoSP infoForSave = m_updateInfoBuilder.buildUpdateInfo(image->bounds(), image, true);
+        m_store.saveFrame(11, infoForSave, image->bounds());
+
+        KIS_SAFE_ASSERT_RECOVER_NOOP(m_store.hasFrame(11));
+
+        KisOpenGLUpdateInfoSP loadedInfo = m_store.loadFrame(11, m_updateInfoBuilder);
+
+        qDebug() << ppVar(loadedInfo->tileList.size());
+
+        KIS_SAFE_ASSERT_RECOVER_NOOP(compareUpdateInfo(info, loadedInfo));
+
+
+        emit sigCompleteRegenerationInternal(frame);
+    }
+
+    void frameCancelledCallback(int frame) {
+        emit sigCancelRegenerationInternal(frame);
+    }
+
+Q_SIGNALS:
+    void sigCompleteRegenerationInternal(int frame);
+    void sigCancelRegenerationInternal(int frame);
+
+private:
+    KisOpenGLUpdateInfoBuilder m_updateInfoBuilder;
+    KisTextureTileInfoPoolRegistry m_poolRegistry;
+    KisTextureTileInfoPoolSP m_pool;
+    KisFrameCacheStore m_store;
+};
+
+
+
+
+void KisFrameCacheStoreTest::test()
+{
+    QRect refRect(QRect(0,0,512,512));
+    TestUtil::MaskParent p(refRect);
+    const KoColor fillColor(Qt::red, p.image->colorSpace());
+
+    KisPaintLayerSP layer1 = p.layer;
+    layer1->paintDevice()->fill(QRect(100,100,300,300), fillColor);
+
+    TestFramesRenderer renderer;
+    renderer.startFrameRegeneration(p.image, 10);
+
+
+    p.image->waitForDone();
+
+    while (renderer.isActive()) {
+        QTest::qWait(500);
+    }
+
+}
+
+QTEST_MAIN(KisFrameCacheStoreTest)
+
+#include "KisFrameCacheStoreTest.moc"
diff --git a/plugins/dockers/animation/timeline_docker.h b/libs/ui/tests/KisFrameCacheStoreTest.h
similarity index 50%
copy from plugins/dockers/animation/timeline_docker.h
copy to libs/ui/tests/KisFrameCacheStoreTest.h
index d441ce29f6..e692e90d13 100644
--- a/plugins/dockers/animation/timeline_docker.h
+++ b/libs/ui/tests/KisFrameCacheStoreTest.h
@@ -1,53 +1,30 @@
 /*
- *  Copyright (c) 2015 Jouni Pentikäinen <joupent@gmail.com>
+ *  Copyright (c) 2018 Dmitry Kazakov <dimula73@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 KISFRAMECACHESTORETEST_H
+#define KISFRAMECACHESTORETEST_H
 
-#ifndef _TIMELINE_DOCKER_H_
-#define _TIMELINE_DOCKER_H_
+#include <QObject>
 
-#include "kritaimage_export.h"
-
-#include <QDockWidget>
-#include <kis_mainwindow_observer.h>
-
-#include <QScopedPointer>
-
-class KisCanvas2;
-class KisAction;
-
-class TimelineDocker : public QDockWidget, public KisMainwindowObserver
+class KisFrameCacheStoreTest : public QObject
 {
     Q_OBJECT
-public:
-    TimelineDocker();
-    ~TimelineDocker() override;
-
-    QString observerName() override { return "TimelineDocker"; }
-    void setCanvas(KoCanvasBase *canvas) override;
-    void unsetCanvas() override;
-    void setMainWindow(KisViewManager *kisview) override;
-
-public Q_SLOTS:
-    void slotUpdateIcons();
-
-private:
-    struct Private;
-    const QScopedPointer<Private> m_d;
+private Q_SLOTS:
+    void test();
 };
 
-
-#endif
+#endif // KISFRAMECACHESTORETEST_H
diff --git a/libs/ui/tests/KisFrameSerializerTest.cpp b/libs/ui/tests/KisFrameSerializerTest.cpp
new file mode 100644
index 0000000000..1cac91c386
--- /dev/null
+++ b/libs/ui/tests/KisFrameSerializerTest.cpp
@@ -0,0 +1,222 @@
+/*
+ *  Copyright (c) 2018 Dmitry Kazakov <dimula73@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 "KisFrameSerializerTest.h"
+
+#include <KisFrameDataSerializer.h>
+#include "opengl/kis_texture_tile_info_pool.h"
+
+#include <testutil.h>
+
+#include <QTest>
+
+static const int maxTileSize = 256;
+
+KisFrameDataSerializer::Frame generateTestFrame(int frameSeed, KisTextureTileInfoPoolSP pool)
+{
+    KisFrameDataSerializer::Frame frame;
+    frame.pixelSize = 4;
+
+    for (int i = 0; i < qBound(1, frameSeed * 5, 100); i++) {
+        KisFrameDataSerializer::FrameTile tile(pool);
+        tile.col = i * 10;
+        tile.row = i * 20;
+        tile.rect = QRect(QPoint(i, 2 * i), QSize(qMin(i * 5, maxTileSize), qMin(i * 7, maxTileSize)));
+        tile.data.allocate(frame.pixelSize);
+
+        const int numPixels = tile.rect.width() * tile.rect.height();
+        qint32 *dataPtr = reinterpret_cast<qint32*>(tile.data.data());
+
+        for (int j = 0; j < numPixels; j++) {
+            *dataPtr++ = frameSeed + j;
+        }
+
+        frame.frameTiles.push_back(std::move(tile));
+    }
+
+    return std::move(frame);
+}
+
+bool verifyTestFrame(int frameSeed, const KisFrameDataSerializer::Frame &frame)
+{
+    KIS_COMPARE_RF(frame.pixelSize, 4);
+    KIS_COMPARE_RF(int(frame.frameTiles.size()), qBound(1, frameSeed * 5, 100));
+
+    for (int i = 0; i < int(frame.frameTiles.size()); i++) {
+        const KisFrameDataSerializer::FrameTile &tile = frame.frameTiles[i];
+
+        KIS_COMPARE_RF(tile.col, i * 10);
+        KIS_COMPARE_RF(tile.row, i * 20);
+        KIS_COMPARE_RF(tile.rect.x(), i);
+        KIS_COMPARE_RF(tile.rect.y(), 2 * i);
+        KIS_COMPARE_RF(tile.rect.size(), QSize(qMin(i * 5, maxTileSize), qMin(i * 7, maxTileSize)));
+
+        const int numPixels = tile.rect.width() * tile.rect.height();
+        qint32 *dataPtr = reinterpret_cast<qint32*>(tile.data.data());
+
+        for (int j = 0; j < numPixels; j++) {
+            KIS_COMPARE_RF(*dataPtr++, frameSeed + j);
+        }
+    }
+
+    return true;
+}
+
+
+
+void KisFrameSerializerTest::testFrameDataSerialization()
+{
+    KisTextureTileInfoPoolRegistry poolRegistry;
+    KisTextureTileInfoPoolSP pool = poolRegistry.getPool(maxTileSize, maxTileSize);
+
+
+    KisFrameDataSerializer serializer;
+
+    KisFrameDataSerializer::Frame testFrame1 = generateTestFrame(2, pool);
+    KisFrameDataSerializer::Frame testFrame2 = generateTestFrame(3, pool);
+    KisFrameDataSerializer::Frame testFrame3 = generateTestFrame(503, pool);
+    int testFrameId1 = -1;
+    int testFrameId2 = -1;
+    int testFrameId3 = -1;
+
+
+
+    testFrameId1 = serializer.saveFrame(testFrame1);
+    QCOMPARE(serializer.hasFrame(testFrameId1), true);
+    QCOMPARE(serializer.hasFrame(testFrameId2), false);
+    QCOMPARE(serializer.hasFrame(testFrameId3), false);
+
+    testFrameId2 = serializer.saveFrame(testFrame2);
+    QCOMPARE(serializer.hasFrame(testFrameId1), true);
+    QCOMPARE(serializer.hasFrame(testFrameId2), true);
+    QCOMPARE(serializer.hasFrame(testFrameId3), false);
+
+    testFrameId3 = serializer.saveFrame(testFrame3);
+    QCOMPARE(serializer.hasFrame(testFrameId1), true);
+    QCOMPARE(serializer.hasFrame(testFrameId2), true);
+    QCOMPARE(serializer.hasFrame(testFrameId3), true);
+
+    QVERIFY(verifyTestFrame(2, serializer.loadFrame(testFrameId1, pool)));
+    QVERIFY(verifyTestFrame(3, serializer.loadFrame(testFrameId2, pool)));
+    QVERIFY(verifyTestFrame(503, serializer.loadFrame(testFrameId3, pool)));
+
+    serializer.forgetFrame(testFrameId2);
+    QCOMPARE(serializer.hasFrame(testFrameId1), true);
+    QCOMPARE(serializer.hasFrame(testFrameId2), false);
+    QCOMPARE(serializer.hasFrame(testFrameId3), true);
+
+    serializer.forgetFrame(testFrameId3);
+    QCOMPARE(serializer.hasFrame(testFrameId1), true);
+    QCOMPARE(serializer.hasFrame(testFrameId2), false);
+    QCOMPARE(serializer.hasFrame(testFrameId3), false);
+
+    serializer.forgetFrame(testFrameId1);
+    QCOMPARE(serializer.hasFrame(testFrameId1), false);
+    QCOMPARE(serializer.hasFrame(testFrameId2), false);
+    QCOMPARE(serializer.hasFrame(testFrameId3), false);
+}
+
+#include "kis_random_source.h"
+
+void randomizeFrame(KisFrameDataSerializer::Frame &frame, qreal portion)
+{
+    // randomly reset 50% of the pixels
+    KisRandomSource rnd(1);
+    for (KisFrameDataSerializer::FrameTile &tile : frame.frameTiles) {
+        const int numPixels = tile.rect.width() * tile.rect.height();
+        qint32 *pixelPtr = reinterpret_cast<qint32*>(tile.data.data());
+
+        for (int j = 0; j < numPixels; j++) {
+            if (rnd.generateNormalized() < portion) {
+                (*pixelPtr) = 0;
+            }
+
+            pixelPtr++;
+        }
+    }
+}
+
+void KisFrameSerializerTest::testFrameUniquenessEstimation()
+{
+    KisTextureTileInfoPoolRegistry poolRegistry;
+    KisTextureTileInfoPoolSP pool = poolRegistry.getPool(maxTileSize, maxTileSize);
+
+    KisFrameDataSerializer::Frame testFrame1 = generateTestFrame(2, pool);
+    KisFrameDataSerializer::Frame testFrame2 = generateTestFrame(2, pool);
+
+    boost::optional<qreal> result;
+
+    result = KisFrameDataSerializer::estimateFrameUniqueness(testFrame1, testFrame2, 0.1);
+    QVERIFY(result);
+    QVERIFY(qFuzzyCompare(*result, 0.0));
+
+    KisFrameDataSerializer::Frame testFrame3 = generateTestFrame(3, pool);
+
+    result = KisFrameDataSerializer::estimateFrameUniqueness(testFrame1, testFrame3, 0.1);
+    QVERIFY(!result);
+
+    // randomly reset 50% of the pixels
+    randomizeFrame(testFrame2, 0.5);
+
+    result = KisFrameDataSerializer::estimateFrameUniqueness(testFrame1, testFrame2, 0.01);
+    QVERIFY(result);
+    QVERIFY(*result >= 0.45);
+    QVERIFY(*result <= 0.55);
+}
+
+void KisFrameSerializerTest::testFrameArithmetics()
+{
+    KisTextureTileInfoPoolRegistry poolRegistry;
+    KisTextureTileInfoPoolSP pool = poolRegistry.getPool(maxTileSize, maxTileSize);
+
+    KisFrameDataSerializer::Frame testFrame1 = generateTestFrame(2, pool);
+    KisFrameDataSerializer::Frame testFrame2 = generateTestFrame(2, pool);
+    randomizeFrame(testFrame2, 0.2);
+
+    boost::optional<qreal> result =
+        KisFrameDataSerializer::estimateFrameUniqueness(testFrame1, testFrame2, 0.01);
+
+    QVERIFY(result);
+    QVERIFY(*result >= 0.15);
+    QVERIFY(*result <= 0.25);
+
+
+    {
+        KisFrameDataSerializer::Frame testFrame3 = generateTestFrame(2, pool);
+        randomizeFrame(testFrame3, 0.2);
+
+        const bool framesAreSame = KisFrameDataSerializer::subtractFrames(testFrame3, testFrame2);
+        QVERIFY(framesAreSame);
+    }
+
+    {
+        KisFrameDataSerializer::Frame testFrame3 = generateTestFrame(2, pool);
+        randomizeFrame(testFrame3, 0.2);
+
+        const bool framesAreSame = KisFrameDataSerializer::subtractFrames(testFrame3, testFrame1);
+        QVERIFY(!framesAreSame);
+
+        KisFrameDataSerializer::addFrames(testFrame3, testFrame1);
+
+        result = KisFrameDataSerializer::estimateFrameUniqueness(testFrame3, testFrame2, 1.0);
+        QVERIFY(result);
+        QVERIFY(*result == 0.0);
+    }
+}
+
+QTEST_MAIN(KisFrameSerializerTest)
diff --git a/plugins/dockers/animation/timeline_docker.h b/libs/ui/tests/KisFrameSerializerTest.h
similarity index 50%
copy from plugins/dockers/animation/timeline_docker.h
copy to libs/ui/tests/KisFrameSerializerTest.h
index d441ce29f6..6e57819750 100644
--- a/plugins/dockers/animation/timeline_docker.h
+++ b/libs/ui/tests/KisFrameSerializerTest.h
@@ -1,53 +1,35 @@
 /*
- *  Copyright (c) 2015 Jouni Pentikäinen <joupent@gmail.com>
+ *  Copyright (c) 2018 Dmitry Kazakov <dimula73@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 _TIMELINE_DOCKER_H_
-#define _TIMELINE_DOCKER_H_
+#ifndef KISFRAMESERIALIZERTEST_H
+#define KISFRAMESERIALIZERTEST_H
 
-#include "kritaimage_export.h"
+#include <QObject>
 
-#include <QDockWidget>
-#include <kis_mainwindow_observer.h>
-
-#include <QScopedPointer>
-
-class KisCanvas2;
-class KisAction;
-
-class TimelineDocker : public QDockWidget, public KisMainwindowObserver
+class KisFrameSerializerTest : public QObject
 {
     Q_OBJECT
-public:
-    TimelineDocker();
-    ~TimelineDocker() override;
 
-    QString observerName() override { return "TimelineDocker"; }
-    void setCanvas(KoCanvasBase *canvas) override;
-    void unsetCanvas() override;
-    void setMainWindow(KisViewManager *kisview) override;
+private Q_SLOTS:
+    void testFrameDataSerialization();
+    void testFrameUniquenessEstimation();
+    void testFrameArithmetics();
 
-public Q_SLOTS:
-    void slotUpdateIcons();
-
-private:
-    struct Private;
-    const QScopedPointer<Private> m_d;
 };
 
-
-#endif
+#endif // KISFRAMESERIALIZERTEST_H
diff --git a/libs/ui/utils/kis_document_aware_spin_box_unit_manager.cpp b/libs/ui/utils/kis_document_aware_spin_box_unit_manager.cpp
index 83eee67e71..4b01c77a3c 100644
--- a/libs/ui/utils/kis_document_aware_spin_box_unit_manager.cpp
+++ b/libs/ui/utils/kis_document_aware_spin_box_unit_manager.cpp
@@ -1,183 +1,187 @@
 /*
  *  Copyright (c) 2017 Laurent Valentin Jospin <laurent.valentin@famillejospin.ch>
  *
  *  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_document_aware_spin_box_unit_manager.h"
 
 #include "KisPart.h"
 #include "KisMainWindow.h"
 #include "KisView.h"
 #include "KisDocument.h"
 #include "kis_types.h"
 #include "kis_image.h"
 #include "kis_image_animation_interface.h"
 #include "kis_time_range.h"
 
 
 KisSpinBoxUnitManager* KisDocumentAwareSpinBoxUnitManagerBuilder::buildUnitManager(QObject* parent)
 {
     return new KisDocumentAwareSpinBoxUnitManager(parent);
 }
 
 void KisDocumentAwareSpinBoxUnitManager::setDocumentAwarnessToExistingUnitSpinBox(KisDoubleParseUnitSpinBox* spinBox, bool setUnitFromOutsideToggle)
 {
     KisDocumentAwareSpinBoxUnitManager* manager = new KisDocumentAwareSpinBoxUnitManager(spinBox);
     spinBox->setUnitManager(manager);
     spinBox->setUnitChangeFromOutsideBehavior(setUnitFromOutsideToggle);
 }
 
 KisDoubleParseUnitSpinBox* KisDocumentAwareSpinBoxUnitManager::createUnitSpinBoxWithDocumentAwarness(QWidget* parent)
 {
     KisDoubleParseUnitSpinBox* spinBox = new KisDoubleParseUnitSpinBox(parent);
     setDocumentAwarnessToExistingUnitSpinBox(spinBox);
 
     return spinBox;
 }
 
 KisDocumentAwareSpinBoxUnitManager::KisDocumentAwareSpinBoxUnitManager(QObject *parent, int pPixDir):
     KisSpinBoxUnitManager(parent)
 {
     if (pPixDir == PIX_DIR_Y) {
         pixDir = PIX_DIR_Y;
     } else {
         pixDir = PIX_DIR_X;
     }
 
     grantDocumentRelativeUnits(); //the purpose of this class is to manage document relative units.
 }
 
 
 qreal KisDocumentAwareSpinBoxUnitManager::getConversionFactor(int dim, QString psymbol) const
 {
     QString symbol = psymbol;
 
     if (symbol == "%") { //percent can be seen as vw or vh depending of the reference side in the image.
         if (pixDir == PIX_DIR_X) {
             symbol = "vw";
         } else {
             symbol = "vh";
         }
     }
 
     qreal factor = KisSpinBoxUnitManager::getConversionFactor(dim, symbol);
 
     if (factor > 0) {
         //no errors occurred at a lower level, so the conversion factor has been get.
         return factor;
     }
 
     factor = 1; //fall back to something natural in case document is unreachable (1 px = 1 pt = 1vw = 1vh). So a virtual document of 100x100 with a resolution of 1.
 
+    if (!KisPart::instance()->currentMainwindow()) {
+        return factor;
+    }
+
     KisView* view = KisPart::instance()->currentMainwindow()->activeView();
 
     if (view == nullptr) {
         return factor;
     }
 
     KisDocument* doc = view->document();
 
     if (doc == nullptr) {
         return factor;
     }
 
     KisImage* img = doc->image().data();
 
     if (img == nullptr) {
         return factor;
     }
 
     qreal resX = img->xRes();
     qreal resY = img->yRes();
     qreal sizeX = img->width();
     qreal sizeY = img->height();
 
     switch (dim) {
 
     case LENGTH:
         if (symbol == "px") {
 
             if (pixDir == PIX_DIR_X) {
                 factor = resX;
             } else {
                 factor = resY;
             }
         } else if (symbol == "vw") {
             qreal docWidth = sizeX/resX;
 
             factor = 100.0/docWidth; //1 vw is 1% of document width, 1 vw in point is docWidth/100 so 1 point in vw is the inverse.
         } else if (symbol == "vh") {
             qreal docHeight = sizeY/resY;
 
             factor = 100.0/docHeight;
         }
         break;
 
     case IMLENGTH:
 
         if (symbol == "vw") {
             factor = 100.0/sizeX; //1 vw is 1% of document width, 1 vw in pixel is sizeX/100 so 1 pixel in vw is the inverse.
 
         } else if (symbol == "vh") {
             factor = 100.0/sizeY;
         }
         break;
 
     case TIME:
     {
         if (symbol == "s") {
             qreal fps = img->animationInterface()->framerate();
 
             factor = 1/fps;
         } else if (symbol == "%") {
             const KisTimeRange & time_range = img->animationInterface()->fullClipRange();
             qreal n_frame = time_range.end() - time_range.start();
 
             factor = 100/n_frame;
         }
     }
         break;
 
     default:
         break;
 
     }
 
     return factor;
 }
 
 qreal KisDocumentAwareSpinBoxUnitManager::getConversionConstant(int dim, QString symbol) const
 {
     if (dim == TIME && symbol == "%") {
         KisImage* img = KisPart::instance()->currentMainwindow()->activeView()->document()->image().data();
         const KisTimeRange & time_range = img->animationInterface()->fullClipRange();
         qreal n_frame = time_range.end() - time_range.start();
 
         return -time_range.start()*100.0/n_frame;
     }
 
     return KisSpinBoxUnitManager::getConversionConstant(dim, symbol);
 }
 
 
 bool KisDocumentAwareSpinBoxUnitManager::hasPercent(int unitDim) const {
 
     if (unitDim == IMLENGTH || unitDim == LENGTH) {
         return true;
     }
 
     return KisSpinBoxUnitManager::hasPercent(unitDim);
 }
diff --git a/plugins/dockers/animation/animation_docker.cpp b/plugins/dockers/animation/animation_docker.cpp
index f2736847cc..da477d998f 100644
--- a/plugins/dockers/animation/animation_docker.cpp
+++ b/plugins/dockers/animation/animation_docker.cpp
@@ -1,658 +1,661 @@
 /*
  *  Copyright (c) 2015 Jouni Pentikäinen <joupent@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "animation_docker.h"
 
 #include "kis_global.h"
 
 #include "kis_canvas2.h"
 #include "kis_image.h"
 #include <QMenu>
 #include <kis_icon.h>
 #include <kis_transform_mask.h>
 #include "KisViewManager.h"
 #include "kis_action_manager.h"
 #include "kis_image_animation_interface.h"
 #include "kis_animation_player.h"
 #include "kis_time_range.h"
 #include "kundo2command.h"
 #include "kis_post_execution_undo_adapter.h"
 #include "kis_keyframe_channel.h"
 #include "kis_animation_utils.h"
 #include "krita_utils.h"
 #include "kis_image_config.h"
 #include "kis_config.h"
 #include "kis_signals_blocker.h"
 #include "kis_node_manager.h"
 #include "kis_transform_mask_params_factory_registry.h"
 
 
 #include "ui_wdg_animation.h"
 
 void setupActionButton(const QString &text,
                        KisAction::ActivationFlags flags,
                        bool defaultValue,
                        QToolButton *button,
                        KisAction **action)
 {
     *action = new KisAction(text, button);
     (*action)->setActivationFlags(flags);
     (*action)->setCheckable(true);
     (*action)->setChecked(defaultValue);
     button->setDefaultAction(*action);
 }
 
 AnimationDocker::AnimationDocker()
     : QDockWidget(i18n("Animation"))
     , m_canvas(0)
     , m_animationWidget(new Ui_WdgAnimation)
     , m_mainWindow(0)
 {
     QWidget* mainWidget = new QWidget(this);
     setWidget(mainWidget);
 
     m_animationWidget->setupUi(mainWidget);  
 }
 
 AnimationDocker::~AnimationDocker()
 {
     delete m_animationWidget;
 }
 
 void AnimationDocker::setCanvas(KoCanvasBase * canvas)
 {
     if(m_canvas == canvas)
         return;
 
     setEnabled(canvas != 0);
 
     if (m_canvas) {
         m_canvas->disconnectCanvasObserver(this);
         m_canvas->image()->disconnect(this);
         m_canvas->image()->animationInterface()->disconnect(this);
         m_canvas->animationPlayer()->disconnect(this);
         m_canvas->viewManager()->nodeManager()->disconnect(this);
     }
 
     m_canvas = dynamic_cast<KisCanvas2*>(canvas);
 
     if (m_canvas && m_canvas->image()) {
 
         KisImageAnimationInterface *animation = m_canvas->image()->animationInterface();
         {
             KisSignalsBlocker bloker(m_animationWidget->spinFromFrame,
                                      m_animationWidget->spinToFrame,
                                      m_animationWidget->intFramerate);
 
             m_animationWidget->spinFromFrame->setValue(animation->fullClipRange().start());
             m_animationWidget->spinToFrame->setValue(animation->fullClipRange().end());
             m_animationWidget->intFramerate->setValue(animation->framerate());
         }
 
 
         connect(animation, SIGNAL(sigUiTimeChanged(int)), this, SLOT(slotGlobalTimeChanged()));
         connect(m_canvas->animationPlayer(), SIGNAL(sigFrameChanged()), this, SLOT(slotGlobalTimeChanged()));
         connect(m_canvas->animationPlayer(), SIGNAL(sigPlaybackStopped()), this, SLOT(slotGlobalTimeChanged()));
         connect(m_canvas->animationPlayer(), SIGNAL(sigPlaybackStopped()), this, SLOT(updatePlayPauseIcon()));
+        connect(m_canvas->animationPlayer(), SIGNAL(sigPlaybackStarted()), this, SLOT(updatePlayPauseIcon()));
         connect(m_canvas->animationPlayer(), SIGNAL(sigPlaybackStatisticsUpdated()), this, SLOT(updateDropFramesIcon()));
         connect(m_animationWidget->doublePlaySpeed,
                 SIGNAL(valueChanged(double)),
                 m_canvas->animationPlayer(),
                 SLOT(slotUpdatePlaybackSpeed(double)));
 
         connect(m_canvas->viewManager()->nodeManager(), SIGNAL(sigNodeActivated(KisNodeSP)),
                 this, SLOT(slotCurrentNodeChanged(KisNodeSP)));
 
         connect (animation, SIGNAL(sigFullClipRangeChanged()), this, SLOT(updateClipRange()));
 
 
 
         slotGlobalTimeChanged();
         slotCurrentNodeChanged(m_canvas->viewManager()->nodeManager()->activeNode());
     }
+
+    slotUpdateIcons();
 }
 
 void AnimationDocker::unsetCanvas()
 {
     setCanvas(0);
 }
 
 void AnimationDocker::setMainWindow(KisViewManager *view)
 {
     setActions(view->actionManager());
 
     slotUpdateIcons();
     connect(view->mainWindow(), SIGNAL(themeChanged()), this, SLOT(slotUpdateIcons()));
     m_mainWindow = view->mainWindow();
 }
 
 void AnimationDocker::slotAddOpacityKeyframe()
 {
     addKeyframe(KisKeyframeChannel::Opacity.id(), false);
 }
 
 void AnimationDocker::slotDeleteOpacityKeyframe()
 {
     deleteKeyframe(KisKeyframeChannel::Opacity.id());
 }
 
 void AnimationDocker::slotAddTransformKeyframe()
 {
     if (!m_canvas) return;
 
     KisTransformMask *mask = dynamic_cast<KisTransformMask*>(m_canvas->viewManager()->activeNode().data());
     if (!mask) return;
 
     const int time = m_canvas->image()->animationInterface()->currentTime();
 
     KUndo2Command *command = new KUndo2Command(kundo2_i18n("Add transform keyframe"));
     KisTransformMaskParamsFactoryRegistry::instance()->autoAddKeyframe(mask, time, KisTransformMaskParamsInterfaceSP(), command);
 
     command->redo();
     m_canvas->currentImage()->postExecutionUndoAdapter()->addCommand(toQShared(command));
 }
 
 void AnimationDocker::slotDeleteTransformKeyframe()
 {
     deleteKeyframe(KisKeyframeChannel::TransformArguments.id());
 }
 
 void AnimationDocker::slotUIRangeChanged()
 {
     if (!m_canvas || !m_canvas->image()) return;
 
     int fromTime = m_animationWidget->spinFromFrame->value();
     int toTime = m_animationWidget->spinToFrame->value();
 
     m_canvas->image()->animationInterface()->setFullClipRange(KisTimeRange::fromTime(fromTime, toTime));
 }
 
 void AnimationDocker::slotUIFramerateChanged()
 {
     if (!m_canvas || !m_canvas->image()) return;
 
     m_canvas->image()->animationInterface()->setFramerate(m_animationWidget->intFramerate->value());
 }
 
 void AnimationDocker::slotOnionSkinOptions()
 {
     if (m_mainWindow) {
         QDockWidget *docker = m_mainWindow->dockWidget("OnionSkinsDocker");
         if (docker) {
             docker->setVisible(!docker->isVisible());
         }
     }
 }
 
 void AnimationDocker::slotGlobalTimeChanged()
 {
     int time = m_canvas->animationPlayer()->isPlaying() ?
                 m_canvas->animationPlayer()->currentTime() :
                 m_canvas->image()->animationInterface()->currentUITime();
 
     m_animationWidget->intCurrentTime->setValue(time);
 
     const int frameRate = m_canvas->image()->animationInterface()->framerate();
     const int msec = 1000 * time / frameRate;
 
     QTime realTime;
     realTime = realTime.addMSecs(msec);
 
     QString realTimeString = realTime.toString("hh:mm:ss.zzz");
     m_animationWidget->intCurrentTime->setToolTip(realTimeString);
 }
 
 void AnimationDocker::slotTimeSpinBoxChanged()
 {
     if (!m_canvas || !m_canvas->image()) return;
 
     int newTime = m_animationWidget->intCurrentTime->value();
     KisImageAnimationInterface *animation = m_canvas->image()->animationInterface();
 
     if (m_canvas->animationPlayer()->isPlaying() ||
         newTime == animation->currentUITime()) {
 
         return;
     }
 
     animation->requestTimeSwitchWithUndo(newTime);
 }
 
 void AnimationDocker::slotPreviousFrame()
 {
     if (!m_canvas) return;
     KisImageAnimationInterface *animation = m_canvas->image()->animationInterface();
 
     int time = animation->currentUITime() - 1;
     if (time >= 0) {
         animation->requestTimeSwitchWithUndo(time);
     }
 }
 
 void AnimationDocker::slotNextFrame()
 {
     if (!m_canvas) return;
     KisImageAnimationInterface *animation = m_canvas->image()->animationInterface();
 
     int time = animation->currentUITime() + 1;
     animation->requestTimeSwitchWithUndo(time);
 }
 
 void AnimationDocker::slotPreviousKeyFrame()
 {
     if (!m_canvas) return;
 
     KisNodeSP node = m_canvas->viewManager()->activeNode();
     if (!node) return;
 
     KisImageAnimationInterface *animation = m_canvas->image()->animationInterface();
     int time = animation->currentUITime();
 
     KisKeyframeChannel *content =
         node->getKeyframeChannel(KisKeyframeChannel::Content.id());
 
     if (!content) return;
 
     KisKeyframeSP dstKeyframe;
     KisKeyframeSP keyframe = content->keyframeAt(time);
 
     if (!keyframe) {
         dstKeyframe = content->activeKeyframeAt(time);
     } else {
         dstKeyframe = content->previousKeyframe(keyframe);
     }
 
     if (dstKeyframe) {
         animation->requestTimeSwitchWithUndo(dstKeyframe->time());
     }
 }
 
 void AnimationDocker::slotNextKeyFrame()
 {
     if (!m_canvas) return;
 
     KisNodeSP node = m_canvas->viewManager()->activeNode();
     if (!node) return;
 
     KisImageAnimationInterface *animation = m_canvas->image()->animationInterface();
     int time = animation->currentUITime();
 
     KisKeyframeChannel *content =
         node->getKeyframeChannel(KisKeyframeChannel::Content.id());
 
     if (!content) return;
 
     KisKeyframeSP dstKeyframe;
     KisKeyframeSP keyframe = content->activeKeyframeAt(time);
 
     if (keyframe) {
         dstKeyframe = content->nextKeyframe(keyframe);
     }
 
     if (dstKeyframe) {
         animation->requestTimeSwitchWithUndo(dstKeyframe->time());
     }
 }
 
 
 void AnimationDocker::slotFirstFrame()
 {
     if (!m_canvas) return;
 
     KisImageAnimationInterface *animation = m_canvas->image()->animationInterface();
     animation->requestTimeSwitchWithUndo(0);
 }
 
 void AnimationDocker::slotLastFrame()
 {
     if (!m_canvas) return;
 
     KisImageAnimationInterface *animation = m_canvas->image()->animationInterface();
     animation->requestTimeSwitchWithUndo(animation->totalLength() - 1);
 }
 
 
 void AnimationDocker::slotPlayPause()
 {
     if (!m_canvas) return;
 
     if (m_canvas->animationPlayer()->isPlaying()) {
         m_canvas->animationPlayer()->stop();
     } else {
         m_canvas->animationPlayer()->play();
     }
 
     updatePlayPauseIcon();
 }
 
 void AnimationDocker::updatePlayPauseIcon()
 {
     bool isPlaying = m_canvas && m_canvas->animationPlayer() && m_canvas->animationPlayer()->isPlaying();
 
     m_playPauseAction->setIcon(isPlaying ?
                                KisIconUtils::loadIcon("animation_stop") :
                                KisIconUtils::loadIcon("animation_play"));
 }
 
 void AnimationDocker::updateLazyFrameIcon()
 {
     KisImageConfig cfg;
 
     const bool value = cfg.lazyFrameCreationEnabled();
 
     m_lazyFrameAction->setIcon(value ?
                                KisIconUtils::loadIcon("lazyframeOn") :
                                KisIconUtils::loadIcon("lazyframeOff"));
 
     m_lazyFrameAction->setText(QString("%1 (%2)")
                                .arg(KisAnimationUtils::lazyFrameCreationActionName)
                                .arg(KritaUtils::toLocalizedOnOff(value)));
 }
 
 void AnimationDocker::updateDropFramesIcon()
 {
     qreal effectiveFps = 0.0;
     qreal realFps = 0.0;
     qreal framesDropped = 0.0;
     bool isPlaying = false;
 
     KisAnimationPlayer *player =
         m_canvas && m_canvas->animationPlayer() ?
         m_canvas->animationPlayer() : 0;
 
     if (player) {
         effectiveFps = player->effectiveFps();
         realFps = player->realFps();
         framesDropped = player->framesDroppedPortion();
         isPlaying = player->isPlaying();
     }
 
     KisConfig cfg;
     const bool value = cfg.animationDropFrames();
 
     m_dropFramesAction->setIcon(value ?
                                 KisIconUtils::loadIcon(framesDropped > 0.05 ? "droppedframes" : "dropframe") :
                                 KisIconUtils::loadIcon("dropframe"));
 
 
     QString text;
 
     if (!isPlaying) {
         text = QString("%1 (%2)")
             .arg(KisAnimationUtils::dropFramesActionName)
             .arg(KritaUtils::toLocalizedOnOff(value));
     } else {
         text = QString("%1 (%2)\n"
                        "%3\n"
                        "%4\n"
                        "%5")
             .arg(KisAnimationUtils::dropFramesActionName)
             .arg(KritaUtils::toLocalizedOnOff(value))
             .arg(i18n("Effective FPS:\t%1", effectiveFps))
             .arg(i18n("Real FPS:\t%1", realFps))
             .arg(i18n("Frames dropped:\t%1\%", framesDropped * 100));
     }
 
     m_dropFramesAction->setText(text);
 }
 
 void AnimationDocker::slotUpdateIcons()
 {
     m_previousFrameAction->setIcon(KisIconUtils::loadIcon("prevframe"));
     m_nextFrameAction->setIcon(KisIconUtils::loadIcon("nextframe"));
 
     m_previousKeyFrameAction->setIcon(KisIconUtils::loadIcon("prevkeyframe"));
     m_nextKeyFrameAction->setIcon(KisIconUtils::loadIcon("nextkeyframe"));
 
     m_firstFrameAction->setIcon(KisIconUtils::loadIcon("firstframe"));
     m_lastFrameAction->setIcon(KisIconUtils::loadIcon("lastframe"));
 
     updatePlayPauseIcon();
     updateLazyFrameIcon();
     updateDropFramesIcon();
 
     m_animationWidget->btnOnionSkinOptions->setIcon(KisIconUtils::loadIcon("onion_skin_options"));
     m_animationWidget->btnOnionSkinOptions->setIconSize(QSize(22, 22));
 
 
     m_animationWidget->btnNextKeyFrame->setIconSize(QSize(22, 22));
     m_animationWidget->btnPreviousKeyFrame->setIconSize(QSize(22, 22));
     m_animationWidget->btnFirstFrame->setIconSize(QSize(22, 22));
     m_animationWidget->btnLastFrame->setIconSize(QSize(22, 22));
 
     m_animationWidget->btnPreviousFrame->setIconSize(QSize(22, 22));
     m_animationWidget->btnPlay->setIconSize(QSize(22, 22));
     m_animationWidget->btnNextFrame->setIconSize(QSize(22, 22));
     m_animationWidget->btnAddKeyframe->setIconSize(QSize(22, 22));
     m_animationWidget->btnAddDuplicateFrame->setIconSize(QSize(22, 22));
     m_animationWidget->btnDeleteKeyframe->setIconSize(QSize(22, 22));
     m_animationWidget->btnLazyFrame->setIconSize(QSize(22, 22));
     m_animationWidget->btnDropFrames->setIconSize(QSize(22, 22));
 }
 
 void AnimationDocker::slotLazyFrameChanged(bool value)
 {
     KisImageConfig cfg;
 
     if (value != cfg.lazyFrameCreationEnabled()) {
         cfg.setLazyFrameCreationEnabled(value);
         updateLazyFrameIcon();
     }
 }
 
 void AnimationDocker::slotDropFramesChanged(bool value)
 {
     KisConfig cfg;
 
     if (value != cfg.animationDropFrames()) {
         cfg.setAnimationDropFrames(value);
         updateDropFramesIcon();
     }
 }
 
 void AnimationDocker::slotCurrentNodeChanged(KisNodeSP node)
 {
     bool isNodeAnimatable = false;
 
     m_newKeyframeMenu->clear();
     m_deleteKeyframeMenu->clear();
 
     if (!node.isNull()) {
         if (KisAnimationUtils::supportsContentFrames(node)) {
             isNodeAnimatable = true;
             KisActionManager::safePopulateMenu(m_newKeyframeMenu, "add_blank_frame", m_actionManager);
             KisActionManager::safePopulateMenu(m_deleteKeyframeMenu, "remove_frames", m_actionManager);
         }
 
         if (node->inherits("KisLayer")) {
             isNodeAnimatable = true;
             m_newKeyframeMenu->addAction(m_addOpacityKeyframeAction);
             m_deleteKeyframeMenu->addAction(m_deleteOpacityKeyframeAction);
         }
 
         /*
         if (node->inherits("KisTransformMask")) {
             isNodeAnimatable = true;
             m_newKeyframeMenu->addAction(m_addTransformKeyframeAction);
             m_deleteKeyframeMenu->addAction(m_deleteTransformKeyframeAction);
         }
         */
     }
 
     m_animationWidget->btnAddKeyframe->setEnabled(isNodeAnimatable);
     m_animationWidget->btnAddDuplicateFrame->setEnabled(isNodeAnimatable);
     m_animationWidget->btnDeleteKeyframe->setEnabled(isNodeAnimatable);
 }
 
 void AnimationDocker::updateClipRange()
 {
     m_animationWidget->spinFromFrame->setValue(m_canvas->image()->animationInterface()->fullClipRange().start());
     m_animationWidget->spinToFrame->setValue(m_canvas->image()->animationInterface()->fullClipRange().end());
 }
 
 void AnimationDocker::addKeyframe(const QString &channel, bool copy)
 {
     if (!m_canvas) return;
 
     KisNodeSP node = m_canvas->viewManager()->activeNode();
     if (!node) return;
 
     const int time = m_canvas->image()->animationInterface()->currentTime();
     KisAnimationUtils::createKeyframeLazy(m_canvas->image(), node, channel, time, copy);
 }
 
 void AnimationDocker::deleteKeyframe(const QString &channel)
 {
     if (!m_canvas) return;
 
     KisNodeSP node = m_canvas->viewManager()->activeNode();
     if (!node) return;
 
     const int time = m_canvas->image()->animationInterface()->currentTime();
     KisAnimationUtils::removeKeyframe(m_canvas->image(), node, channel, time);
 }
 
 void AnimationDocker::setActions(KisActionManager *actionMan)
 {
     m_actionManager = actionMan;
     if (!m_actionManager) return;
 
     m_previousFrameAction = new KisAction(i18n("Previous Frame"), m_animationWidget->btnPreviousFrame);
     m_previousFrameAction->setActivationFlags(KisAction::ACTIVE_IMAGE);
     m_animationWidget->btnPreviousFrame->setDefaultAction(m_previousFrameAction);
 
     m_nextFrameAction = new KisAction(i18n("Next Frame"), m_animationWidget->btnNextFrame);
     m_nextFrameAction->setActivationFlags(KisAction::ACTIVE_IMAGE);
     m_animationWidget->btnNextFrame->setDefaultAction(m_nextFrameAction);
 
     m_previousKeyFrameAction = new KisAction(i18n("Previous Key Frame"), m_animationWidget->btnPreviousKeyFrame);
     m_previousKeyFrameAction->setActivationFlags(KisAction::ACTIVE_IMAGE);
     m_animationWidget->btnPreviousKeyFrame->setDefaultAction(m_previousKeyFrameAction);
 
     m_nextKeyFrameAction = new KisAction(i18n("Next Key Frame"), m_animationWidget->btnNextKeyFrame);
     m_nextKeyFrameAction->setActivationFlags(KisAction::ACTIVE_IMAGE);
     m_animationWidget->btnNextKeyFrame->setDefaultAction(m_nextKeyFrameAction);
 
     m_firstFrameAction = new KisAction(i18n("First Frame"), m_animationWidget->btnFirstFrame);
     m_firstFrameAction->setActivationFlags(KisAction::ACTIVE_IMAGE);
     m_animationWidget->btnFirstFrame->setDefaultAction(m_firstFrameAction);
 
     m_lastFrameAction = new KisAction(i18n("Last Frame"), m_animationWidget->btnLastFrame);
     m_lastFrameAction->setActivationFlags(KisAction::ACTIVE_IMAGE);
     m_animationWidget->btnLastFrame->setDefaultAction(m_lastFrameAction);
 
 
     m_playPauseAction = new KisAction(i18n("Play / Stop"), m_animationWidget->btnPlay);
     m_playPauseAction->setActivationFlags(KisAction::ACTIVE_IMAGE);
     m_animationWidget->btnPlay->setDefaultAction(m_playPauseAction);
 
     KisAction *action = 0;
 
     action = m_actionManager->createAction("add_blank_frame");
     m_animationWidget->btnAddKeyframe->setDefaultAction(action);
 
     action = m_actionManager->createAction("add_duplicate_frame");
     m_animationWidget->btnAddDuplicateFrame->setDefaultAction(action);
 
     action = m_actionManager->createAction("remove_frames");
     m_animationWidget->btnDeleteKeyframe->setDefaultAction(action);
 
     m_newKeyframeMenu = new QMenu(this);
     m_animationWidget->btnAddKeyframe->setMenu(m_newKeyframeMenu);
     m_animationWidget->btnAddKeyframe->setPopupMode(QToolButton::MenuButtonPopup);
 
     m_deleteKeyframeMenu = new QMenu(this);
     m_animationWidget->btnDeleteKeyframe->setMenu(m_deleteKeyframeMenu);
     m_animationWidget->btnDeleteKeyframe->setPopupMode(QToolButton::MenuButtonPopup);
 
     m_addOpacityKeyframeAction = new KisAction(KisAnimationUtils::addOpacityKeyframeActionName);
     m_deleteOpacityKeyframeAction = new KisAction(KisAnimationUtils::removeOpacityKeyframeActionName);
 
     m_addTransformKeyframeAction = new KisAction(KisAnimationUtils::addTransformKeyframeActionName);
     m_deleteTransformKeyframeAction = new KisAction(KisAnimationUtils::removeTransformKeyframeActionName);
 
 
     // other new stuff
     m_actionManager->addAction("previous_frame", m_previousFrameAction);
     m_actionManager->addAction("next_frame", m_nextFrameAction);
 
     m_actionManager->addAction("previous_keyframe", m_previousKeyFrameAction);
     m_actionManager->addAction("next_keyframe", m_nextKeyFrameAction);
 
     m_actionManager->addAction("first_frame", m_firstFrameAction);
     m_actionManager->addAction("last_frame", m_lastFrameAction);
 
     {
         KisImageConfig cfg;
         setupActionButton(KisAnimationUtils::lazyFrameCreationActionName,
                           KisAction::ACTIVE_IMAGE,
                           cfg.lazyFrameCreationEnabled(),
                           m_animationWidget->btnLazyFrame,
                           &m_lazyFrameAction);
     }
 
     {
         KisConfig cfg;
         setupActionButton(KisAnimationUtils::dropFramesActionName,
                           KisAction::ACTIVE_IMAGE,
                           cfg.animationDropFrames(),
                           m_animationWidget->btnDropFrames,
                           &m_dropFramesAction);
     }
 
 
      // these actions are created in the setupActionButton() above, so we need to add actions after that
      m_actionManager->addAction("lazy_frame", m_lazyFrameAction);
      m_actionManager->addAction("drop_frames", m_dropFramesAction);
 
      m_actionManager->addAction("toggle_playback", m_playPauseAction);
 
     QFont font;
     font.setPointSize(1.7 * font.pointSize());
     font.setBold(true);
     m_animationWidget->intCurrentTime->setFont(font);
 
     connect(m_previousFrameAction, SIGNAL(triggered()), this, SLOT(slotPreviousFrame()));
     connect(m_nextFrameAction, SIGNAL(triggered()), this, SLOT(slotNextFrame()));
 
     connect(m_previousKeyFrameAction, SIGNAL(triggered()), this, SLOT(slotPreviousKeyFrame()));
     connect(m_nextKeyFrameAction, SIGNAL(triggered()), this, SLOT(slotNextKeyFrame()));
 
     connect(m_firstFrameAction, SIGNAL(triggered()), this, SLOT(slotFirstFrame()));
     connect(m_lastFrameAction, SIGNAL(triggered()), this, SLOT(slotLastFrame()));
 
     connect(m_playPauseAction, SIGNAL(triggered()), this, SLOT(slotPlayPause()));
 
     connect(m_lazyFrameAction, SIGNAL(toggled(bool)), this, SLOT(slotLazyFrameChanged(bool)));
     connect(m_dropFramesAction, SIGNAL(toggled(bool)), this, SLOT(slotDropFramesChanged(bool)));
 
     connect(m_addOpacityKeyframeAction, SIGNAL(triggered(bool)), this, SLOT(slotAddOpacityKeyframe()));
     connect(m_deleteOpacityKeyframeAction, SIGNAL(triggered(bool)), this, SLOT(slotDeleteOpacityKeyframe()));
 
     connect(m_addTransformKeyframeAction, SIGNAL(triggered(bool)), this, SLOT(slotAddTransformKeyframe()));
     connect(m_deleteTransformKeyframeAction, SIGNAL(triggered(bool)), this, SLOT(slotDeleteTransformKeyframe()));
 
     m_animationWidget->btnOnionSkinOptions->setToolTip(i18n("Onion Skins"));
     connect(m_animationWidget->btnOnionSkinOptions, SIGNAL(clicked()), this, SLOT(slotOnionSkinOptions()));
 
     connect(m_animationWidget->spinFromFrame, SIGNAL(valueChanged(int)), this, SLOT(slotUIRangeChanged()));
     connect(m_animationWidget->spinToFrame, SIGNAL(valueChanged(int)), this, SLOT(slotUIRangeChanged()));
     connect(m_animationWidget->intFramerate, SIGNAL(valueChanged(int)), this, SLOT(slotUIFramerateChanged()));
 
     connect(m_animationWidget->intCurrentTime, SIGNAL(valueChanged(int)), SLOT(slotTimeSpinBoxChanged()));
 }
diff --git a/plugins/dockers/animation/timeline_docker.cpp b/plugins/dockers/animation/timeline_docker.cpp
index ca90098274..9542dd0431 100644
--- a/plugins/dockers/animation/timeline_docker.cpp
+++ b/plugins/dockers/animation/timeline_docker.cpp
@@ -1,150 +1,159 @@
 /*
  *  Copyright (c) 2015 Jouni Pentikäinen <joupent@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "timeline_docker.h"
 
 #include "kis_canvas2.h"
 #include "kis_image.h"
 #include <KoIcon.h>
 #include "KisViewManager.h"
 #include "kis_paint_layer.h"
 #include "KisDocument.h"
 #include "kis_dummies_facade.h"
 #include "kis_shape_controller.h"
 #include "kis_action.h"
 #include "kis_action_manager.h"
 
 #include "timeline_frames_model.h"
 #include "timeline_frames_view.h"
 #include "kis_animation_frame_cache.h"
 #include "kis_image_animation_interface.h"
 #include "kis_signal_auto_connection.h"
 #include "kis_node_manager.h"
 
 #include <QPointer>
 
 struct TimelineDocker::Private
 {
     Private(QWidget *parent)
         : model(new TimelineFramesModel(parent)),
           view(new TimelineFramesView(parent))
     {
         view->setModel(model);
     }
 
     TimelineFramesModel *model;
     TimelineFramesView *view;
 
     QPointer<KisCanvas2> canvas;
 
     KisSignalAutoConnectionsStore canvasConnections;
 };
 
 TimelineDocker::TimelineDocker()
     : QDockWidget(i18n("Timeline"))
     , m_d(new Private(this))
 {
     setWidget(m_d->view);
 }
 
 TimelineDocker::~TimelineDocker()
 {
 }
 
 struct NodeManagerInterface : TimelineFramesModel::NodeManipulationInterface
 {
     NodeManagerInterface(KisNodeManager *manager) : m_manager(manager) {}
 
     KisLayerSP addPaintLayer() const override {
         return m_manager->createPaintLayer();
     }
 
     void removeNode(KisNodeSP node) const override {
         m_manager->removeSingleNode(node);
     }
 
 private:
     KisNodeManager *m_manager;
 };
 
 void TimelineDocker::setCanvas(KoCanvasBase * canvas)
 {
     if (canvas && m_d->canvas == canvas) return;
 
     if (m_d->model->hasConnectionToCanvas()) {
         m_d->canvasConnections.clear();
         m_d->model->setDummiesFacade(0, 0);
         m_d->model->setFrameCache(0);
         m_d->model->setAnimationPlayer(0);
         m_d->model->setNodeManipulationInterface(0);
 
         if (m_d->canvas) {
             m_d->canvas->disconnectCanvasObserver(this);
         }
     }
 
     m_d->canvas = dynamic_cast<KisCanvas2*>(canvas);
     setEnabled(m_d->canvas != 0);
 
     if(m_d->canvas) {
         KisDocument *doc = static_cast<KisDocument*>(m_d->canvas->imageView()->document());
         KisShapeController *kritaShapeController = dynamic_cast<KisShapeController*>(doc->shapeController());
         m_d->model->setDummiesFacade(kritaShapeController, m_d->canvas->image());
 
-        m_d->model->setFrameCache(m_d->canvas->frameCache());
+        slotUpdateFrameCache();
         m_d->model->setAnimationPlayer(m_d->canvas->animationPlayer());
 
         m_d->model->setNodeManipulationInterface(
             new NodeManagerInterface(m_d->canvas->viewManager()->nodeManager()));
 
         m_d->canvasConnections.addConnection(
             m_d->canvas->viewManager()->nodeManager(), SIGNAL(sigNodeActivated(KisNodeSP)),
             m_d->model, SLOT(slotCurrentNodeChanged(KisNodeSP)));
 
         m_d->canvasConnections.addConnection(
             m_d->model, SIGNAL(requestCurrentNodeChanged(KisNodeSP)),
             m_d->canvas->viewManager()->nodeManager(), SLOT(slotNonUiActivatedNode(KisNodeSP)));
 
         m_d->model->slotCurrentNodeChanged(m_d->canvas->viewManager()->activeNode());
 
         m_d->canvasConnections.addConnection(
                     m_d->canvas->viewManager()->mainWindow(), SIGNAL(themeChanged()),
-                    this, SLOT(slotUpdateIcons()) );
+                    this, SLOT(slotUpdateIcons()));
+
+        m_d->canvasConnections.addConnection(
+                    m_d->canvas, SIGNAL(sigCanvasEngineChanged()),
+                    this, SLOT(slotUpdateFrameCache()));
     }
 
 }
 
 void TimelineDocker::slotUpdateIcons()
 {
     if (m_d->view) {
         m_d->view->slotUpdateIcons();
     }
 }
 
+void TimelineDocker::slotUpdateFrameCache()
+{
+    m_d->model->setFrameCache(m_d->canvas->frameCache());
+}
+
 void TimelineDocker::unsetCanvas()
 {
     setCanvas(0);
 }
 
 void TimelineDocker::setMainWindow(KisViewManager *view)
 {
     KisActionManager *actionManager = view->actionManager();
 
     m_d->view->setShowInTimeline(actionManager->actionByName("show_in_timeline"));
     m_d->view->setActionManager(actionManager);
 }
diff --git a/plugins/dockers/animation/timeline_docker.h b/plugins/dockers/animation/timeline_docker.h
index d441ce29f6..a92967ac10 100644
--- a/plugins/dockers/animation/timeline_docker.h
+++ b/plugins/dockers/animation/timeline_docker.h
@@ -1,53 +1,54 @@
 /*
  *  Copyright (c) 2015 Jouni Pentikäinen <joupent@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef _TIMELINE_DOCKER_H_
 #define _TIMELINE_DOCKER_H_
 
 #include "kritaimage_export.h"
 
 #include <QDockWidget>
 #include <kis_mainwindow_observer.h>
 
 #include <QScopedPointer>
 
 class KisCanvas2;
 class KisAction;
 
 class TimelineDocker : public QDockWidget, public KisMainwindowObserver
 {
     Q_OBJECT
 public:
     TimelineDocker();
     ~TimelineDocker() override;
 
     QString observerName() override { return "TimelineDocker"; }
     void setCanvas(KoCanvasBase *canvas) override;
     void unsetCanvas() override;
     void setMainWindow(KisViewManager *kisview) override;
 
 public Q_SLOTS:
     void slotUpdateIcons();
+    void slotUpdateFrameCache();
 
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 };
 
 
 #endif
diff --git a/plugins/impex/libkra/kis_kra_loader.cpp b/plugins/impex/libkra/kis_kra_loader.cpp
index da08db4432..b31696e568 100644
--- a/plugins/impex/libkra/kis_kra_loader.cpp
+++ b/plugins/impex/libkra/kis_kra_loader.cpp
@@ -1,1199 +1,1197 @@
 /* This file is part of the KDE project
  * Copyright (C) Boudewijn Rempt <boud@valdyas.org>, (C) 2007
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "kis_kra_loader.h"
 
 #include <QApplication>
 #include <QStringList>
 
 #include <QMessageBox>
 
 #include <QUrl>
 #include <QBuffer>
 
 #include <KoStore.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorSpaceEngine.h>
 #include <KoColorProfile.h>
 #include <KoDocumentInfo.h>
 #include <KoFileDialog.h>
 #include <KisImportExportManager.h>
 #include <KoXmlReader.h>
 #include <KoStoreDevice.h>
 
 #include <filter/kis_filter.h>
 #include <filter/kis_filter_registry.h>
 #include <generator/kis_generator.h>
 #include <generator/kis_generator_layer.h>
 #include <generator/kis_generator_registry.h>
 #include <kis_adjustment_layer.h>
 #include <kis_annotation.h>
 #include <kis_base_node.h>
 #include <kis_clone_layer.h>
 #include <kis_debug.h>
 #include <kis_assert.h>
 #include <kis_external_layer_iface.h>
 #include <kis_filter_mask.h>
 #include <kis_transform_mask.h>
 #include "lazybrush/kis_colorize_mask.h"
 #include <kis_group_layer.h>
 #include <kis_image.h>
 #include <kis_layer.h>
 #include <kis_name_server.h>
 #include <kis_paint_layer.h>
 #include <kis_selection.h>
 #include <kis_selection_mask.h>
 #include <kis_shape_layer.h>
 #include <kis_transparency_mask.h>
 #include <kis_layer_composition.h>
 #include <kis_file_layer.h>
 #include <kis_psd_layer_style.h>
 #include <kis_psd_layer_style_resource.h>
 #include "KisResourceServerProvider.h"
 #include "kis_keyframe_channel.h"
 #include <kis_filter_configuration.h>
 #include "KisReferenceImagesLayer.h"
 #include "KisReferenceImage.h"
 
 #include "KisDocument.h"
 #include "kis_config.h"
 #include "kis_kra_tags.h"
 #include "kis_kra_utils.h"
 #include "kis_kra_load_visitor.h"
 #include "kis_dom_utils.h"
 #include "kis_image_animation_interface.h"
 #include "kis_time_range.h"
 #include "kis_grid_config.h"
 #include "kis_guides_config.h"
 #include "kis_image_config.h"
 #include "KisProofingConfiguration.h"
 #include "kis_layer_properties_icons.h"
 #include "kis_node_view_color_scheme.h"
 
 /*
 
   Color model id comparison through the ages:
 
 2.4        2.5          2.6         ideal
 
 ALPHA      ALPHA        ALPHA       ALPHAU8
 
 CMYK       CMYK         CMYK        CMYKAU8
            CMYKAF32     CMYKAF32
 CMYKA16    CMYKAU16     CMYKAU16
 
 GRAYA      GRAYA        GRAYA       GRAYAU8
 GrayF32    GRAYAF32     GRAYAF32
 GRAYA16    GRAYAU16     GRAYAU16
 
 LABA       LABA         LABA        LABAU16
            LABAF32      LABAF32
            LABAU8       LABAU8
 
 RGBA       RGBA         RGBA        RGBAU8
 RGBA16     RGBA16       RGBA16      RGBAU16
 RgbAF32    RGBAF32      RGBAF32
 RgbAF16    RgbAF16      RGBAF16
 
 XYZA16     XYZA16       XYZA16      XYZAU16
            XYZA8        XYZA8       XYZAU8
 XyzAF16    XyzAF16      XYZAF16
 XyzAF32    XYZAF32      XYZAF32
 
 YCbCrA     YCBCRA8      YCBCRA8     YCBCRAU8
 YCbCrAU16  YCBCRAU16    YCBCRAU16
            YCBCRF32     YCBCRF32
  */
 
 using namespace KRA;
 
 struct KisKraLoader::Private
 {
 public:
 
     KisDocument* document;
     QString imageName; // used to be stored in the image, is now in the documentInfo block
     QString imageComment; // used to be stored in the image, is now in the documentInfo block
     QMap<KisNode*, QString> layerFilenames; // temp storage during loading
     int syntaxVersion; // version of the fileformat we are loading
     vKisNodeSP selectedNodes; // the nodes that were active when saving the document.
     QMap<QString, QString> assistantsFilenames;
     QList<KisPaintingAssistantSP> assistants;
     QMap<KisNode*, QString> keyframeFilenames;
     QStringList errorMessages;
     QStringList warningMessages;
 };
 
 void convertColorSpaceNames(QString &colorspacename, QString &profileProductName) {
     if (colorspacename  == "Grayscale + Alpha") {
         colorspacename  = "GRAYA";
         profileProductName.clear();
     }
     else if (colorspacename == "RgbAF32") {
         colorspacename = "RGBAF32";
         profileProductName.clear();
     }
     else if (colorspacename == "RgbAF16") {
         colorspacename = "RGBAF16";
         profileProductName.clear();
     }
     else if (colorspacename == "CMYKA16") {
         colorspacename = "CMYKAU16";
     }
     else if (colorspacename == "GrayF32") {
         colorspacename =  "GRAYAF32";
         profileProductName.clear();
     }
     else if (colorspacename == "GRAYA16") {
         colorspacename  = "GRAYAU16";
     }
     else if (colorspacename == "XyzAF16") {
         colorspacename  = "XYZAF16";
         profileProductName.clear();
     }
     else if (colorspacename == "XyzAF32") {
         colorspacename  = "XYZAF32";
         profileProductName.clear();
     }
     else if (colorspacename == "YCbCrA") {
         colorspacename  = "YCBCRA8";
     }
     else if (colorspacename == "YCbCrAU16") {
         colorspacename  = "YCBCRAU16";
     }
 }
 
 KisKraLoader::KisKraLoader(KisDocument * document, int syntaxVersion)
         : m_d(new Private())
 {
     m_d->document = document;
     m_d->syntaxVersion = syntaxVersion;
 }
 
 
 KisKraLoader::~KisKraLoader()
 {
     delete m_d;
 }
 
 
 KisImageSP KisKraLoader::loadXML(const KoXmlElement& element)
 {
     QString attr;
     KisImageSP image = 0;
     QString name;
     qint32 width;
     qint32 height;
     QString profileProductName;
     double xres;
     double yres;
     QString colorspacename;
     const KoColorSpace * cs;
 
     if ((attr = element.attribute(MIME)) == NATIVE_MIMETYPE) {
 
         if ((m_d->imageName = element.attribute(NAME)).isNull()) {
             m_d->errorMessages << i18n("Image does not have a name.");
             return KisImageSP(0);
         }
 
         if ((attr = element.attribute(WIDTH)).isNull()) {
             m_d->errorMessages << i18n("Image does not specify a width.");
             return KisImageSP(0);
         }
         width = KisDomUtils::toInt(attr);
 
         if ((attr = element.attribute(HEIGHT)).isNull()) {
             m_d->errorMessages << i18n("Image does not specify a height.");
             return KisImageSP(0);
         }
 
         height = KisDomUtils::toInt(attr);
 
         m_d->imageComment = element.attribute(DESCRIPTION);
 
         xres = 100.0 / 72.0;
         if (!(attr = element.attribute(X_RESOLUTION)).isNull()) {
             qreal value = KisDomUtils::toDouble(attr);
 
             if (value > 1.0) {
                 xres = value / 72.0;
             }
         }
 
         yres = 100.0 / 72.0;
         if (!(attr = element.attribute(Y_RESOLUTION)).isNull()) {
             qreal value = KisDomUtils::toDouble(attr);
             if (value > 1.0) {
                 yres = value / 72.0;
             }
         }
 
         if ((colorspacename = element.attribute(COLORSPACE_NAME)).isNull()) {
             // An old file: take a reasonable default.
             // Krita didn't support anything else in those
             // days anyway.
             colorspacename = "RGBA";
         }
 
         profileProductName = element.attribute(PROFILE);
         // A hack for an old colorspacename
         convertColorSpaceNames(colorspacename, profileProductName);
 
         QString colorspaceModel = KoColorSpaceRegistry::instance()->colorSpaceColorModelId(colorspacename).id();
         QString colorspaceDepth = KoColorSpaceRegistry::instance()->colorSpaceColorDepthId(colorspacename).id();
 
         if (profileProductName.isNull()) {
             // no mention of profile so get default profile";
             cs = KoColorSpaceRegistry::instance()->colorSpace(colorspaceModel, colorspaceDepth, "");
         } else {
             cs = KoColorSpaceRegistry::instance()->colorSpace(colorspaceModel, colorspaceDepth, profileProductName);
         }
 
         if (cs == 0) {
             // try once more without the profile
             cs = KoColorSpaceRegistry::instance()->colorSpace(colorspaceModel, colorspaceDepth, "");
             if (cs == 0) {
                 m_d->errorMessages << i18n("Image specifies an unsupported color model: %1.", colorspacename);
                 return KisImageSP(0);
             }
         }
         KisImageConfig cfgImage;
         KisProofingConfigurationSP proofingConfig = cfgImage.defaultProofingconfiguration();
         if (!(attr = element.attribute(PROOFINGPROFILENAME)).isNull()) {
             proofingConfig->proofingProfile = attr;
         }
         if (!(attr = element.attribute(PROOFINGMODEL)).isNull()) {
             proofingConfig->proofingModel = attr;
         }
         if (!(attr = element.attribute(PROOFINGDEPTH)).isNull()) {
             proofingConfig->proofingDepth = attr;
         }
         if (!(attr = element.attribute(PROOFINGINTENT)).isNull()) {
             proofingConfig->intent = (KoColorConversionTransformation::Intent) KisDomUtils::toInt(attr);
         }
 
         if (!(attr = element.attribute(PROOFINGADAPTATIONSTATE)).isNull()) {
             proofingConfig->adaptationState = KisDomUtils::toDouble(attr);
         }
 
         if (m_d->document) {
             image = new KisImage(m_d->document->createUndoStore(), width, height, cs, name);
         }
         else {
             image = new KisImage(0, width, height, cs, name);
         }
         image->setResolution(xres, yres);
         loadNodes(element, image, const_cast<KisGroupLayer*>(image->rootLayer().data()));
 
 
         KoXmlNode child;
         for (child = element.lastChild(); !child.isNull(); child = child.previousSibling()) {
             KoXmlElement e = child.toElement();
             if(e.tagName() == CANVASPROJECTIONCOLOR) {
                 if (e.hasAttribute(COLORBYTEDATA)) {
                     QByteArray colorData = QByteArray::fromBase64(e.attribute(COLORBYTEDATA).toLatin1());
                     KoColor color((const quint8*)colorData.data(), image->colorSpace());
                     image->setDefaultProjectionColor(color);
                 }
             }
 
             if(e.tagName()== PROOFINGWARNINGCOLOR) {
                 QDomDocument dom;
                 KoXml::asQDomElement(dom, e);
                 QDomElement eq = dom.firstChildElement();
                 proofingConfig->warningColor = KoColor::fromXML(eq.firstChildElement(), Integer8BitsColorDepthID.id());
             }
 
             if (e.tagName().toLower() == "animation") {
                 loadAnimationMetadata(e, image);
             }
         }
 
         image->setProofingConfiguration(proofingConfig);
 
         for (child = element.lastChild(); !child.isNull(); child = child.previousSibling()) {
             KoXmlElement e = child.toElement();
             if(e.tagName() == "compositions") {
                 loadCompositions(e, image);
             }
         }
     }
     KoXmlNode child;
 
     for (child = element.lastChild(); !child.isNull(); child = child.previousSibling()) {
         KoXmlElement e = child.toElement();
         if (e.tagName() == "grid") {
             loadGrid(e);
         } else if (e.tagName() == "guides") {
             loadGuides(e);
         } else if (e.tagName() == "assistants") {
             loadAssistantsList(e);
         } else if (e.tagName() == "audio") {
             loadAudio(e, image);
         }
     }
 
     return image;
 }
 
 void KisKraLoader::loadBinaryData(KoStore * store, KisImageSP image, const QString & uri, bool external)
 {
     // icc profile: if present, this overrides the profile product name loaded in loadXML.
     QString location = external ? QString() : uri;
     location += m_d->imageName + ICC_PATH;
     if (store->hasFile(location)) {
         if (store->open(location)) {
             QByteArray data; data.resize(store->size());
             bool res = (store->read(data.data(), store->size()) > -1);
             store->close();
             if (res) {
                 const KoColorProfile *profile = KoColorSpaceRegistry::instance()->createColorProfile(image->colorSpace()->colorModelId().id(), image->colorSpace()->colorDepthId().id(), data);
                 if (profile && profile->valid()) {
                     res = image->assignImageProfile(profile);
                 }
                 if (!res) {
                     const QString defaultProfileId = KoColorSpaceRegistry::instance()->defaultProfileForColorSpace(image->colorSpace()->id());
                     profile = KoColorSpaceRegistry::instance()->profileByName(defaultProfileId);
                     Q_ASSERT(profile && profile->valid());
                     image->assignImageProfile(profile);
                 }
             }
         }
     }
     //load the embed proofing profile, it only needs to be loaded into Krita, not assigned.
     location = external ? QString() : uri;
     location += m_d->imageName + ICC_PROOFING_PATH;
     if (store->hasFile(location)) {
         if (store->open(location)) {
             QByteArray proofingData;
             proofingData.resize(store->size());
             bool proofingProfileRes = (store->read(proofingData.data(), store->size())>-1);
             store->close();
 
             KisProofingConfigurationSP proofingConfig = image->proofingConfiguration();
             if (!proofingConfig) {
                 proofingConfig = KisImageConfig().defaultProofingconfiguration();
             }
 
             if (proofingProfileRes) {
                 const KoColorProfile *proofingProfile = KoColorSpaceRegistry::instance()->createColorProfile(proofingConfig->proofingModel, proofingConfig->proofingDepth, proofingData);
                 if (proofingProfile->valid()){
                     KoColorSpaceRegistry::instance()->addProfile(proofingProfile);
                 }
             }
         }
     }
 
 
     // Load the layers data: if there is a profile associated with a layer it will be set now.
     KisKraLoadVisitor visitor(image, store, m_d->layerFilenames, m_d->keyframeFilenames, m_d->imageName, m_d->syntaxVersion);
 
     if (external) {
         visitor.setExternalUri(uri);
     }
 
     image->rootLayer()->accept(visitor);
     if (!visitor.errorMessages().isEmpty()) {
         m_d->errorMessages.append(visitor.errorMessages());
     }
     if (!visitor.warningMessages().isEmpty()) {
         m_d->warningMessages.append(visitor.warningMessages());
     }
 
     // annotations
     // exif
     location = external ? QString() : uri;
     location += m_d->imageName + EXIF_PATH;
     if (store->hasFile(location)) {
         QByteArray data;
         store->open(location);
         data = store->read(store->size());
         store->close();
         image->addAnnotation(KisAnnotationSP(new KisAnnotation("exif", "", data)));
     }
 
 
     // layer styles
     location = external ? QString() : uri;
     location += m_d->imageName + LAYER_STYLES_PATH;
     if (store->hasFile(location)) {
         KisPSDLayerStyleCollectionResource *collection =
             new KisPSDLayerStyleCollectionResource("Embedded Styles.asl");
 
         collection->setName(i18nc("Auto-generated layer style collection name for embedded styles (collection)", "<%1> (embedded)", m_d->imageName));
 
         KIS_ASSERT_RECOVER_NOOP(!collection->valid());
 
         store->open(location);
         {
             KoStoreDevice device(store);
             device.open(QIODevice::ReadOnly);
 
             /**
              * ASL loading code cannot work with non-sequential IO devices,
              * so convert the device beforehand!
              */
             QByteArray buf = device.readAll();
             QBuffer raDevice(&buf);
             raDevice.open(QIODevice::ReadOnly);
             collection->loadFromDevice(&raDevice);
         }
         store->close();
 
         if (collection->valid()) {
             KoResourceServer<KisPSDLayerStyleCollectionResource> *server = KisResourceServerProvider::instance()->layerStyleCollectionServer();
             server->addResource(collection, false);
 
             collection->assignAllLayerStyles(image->root());
         } else {
             warnKrita << "WARNING: Couldn't load layer styles library from .kra!";
             delete collection;
         }
     }
 
     if (m_d->document && m_d->document->documentInfo()->aboutInfo("title").isNull())
         m_d->document->documentInfo()->setAboutInfo("title", m_d->imageName);
     if (m_d->document && m_d->document->documentInfo()->aboutInfo("comment").isNull())
         m_d->document->documentInfo()->setAboutInfo("comment", m_d->imageComment);
 
     loadAssistants(store, uri, external);
 }
 
 vKisNodeSP KisKraLoader::selectedNodes() const
 {
     return m_d->selectedNodes;
 }
 
 QList<KisPaintingAssistantSP> KisKraLoader::assistants() const
 {
     return m_d->assistants;
 }
 
 QStringList KisKraLoader::errorMessages() const
 {
     return m_d->errorMessages;
 }
 
 QStringList KisKraLoader::warningMessages() const
 {
     return m_d->warningMessages;
 }
 
 
 void KisKraLoader::loadAssistants(KoStore *store, const QString &uri, bool external)
 {
     QString file_path;
     QString location;
     QMap<int ,KisPaintingAssistantHandleSP> handleMap;
     KisPaintingAssistant* assistant = 0;
     QMap<QString,QString>::const_iterator loadedAssistant = m_d->assistantsFilenames.constBegin();
     while (loadedAssistant != m_d->assistantsFilenames.constEnd()){
         const KisPaintingAssistantFactory* factory = KisPaintingAssistantFactoryRegistry::instance()->get(loadedAssistant.value());
         if (factory) {
             assistant = factory->createPaintingAssistant();
             location = external ? QString() : uri;
             location += m_d->imageName + ASSISTANTS_PATH;
             file_path = location + loadedAssistant.key();
             assistant->loadXml(store, handleMap, file_path);
 
             //If an assistant has too few handles than it should according to it's own setup, just don't load it//
             if (assistant->handles().size()==assistant->numHandles()){
                 m_d->assistants.append(toQShared(assistant));
             }
         }
         loadedAssistant++;
     }
 }
 
 void KisKraLoader::loadAnimationMetadata(const KoXmlElement &element, KisImageSP image)
 {
     QDomDocument qDom;
     KoXml::asQDomElement(qDom, element);
     QDomElement qElement = qDom.firstChildElement();
 
     float framerate;
     KisTimeRange range;
     int currentTime;
 
     KisImageAnimationInterface *animation = image->animationInterface();
 
     if (KisDomUtils::loadValue(qElement, "framerate", &framerate)) {
         animation->setFramerate(framerate);
     }
 
     if (KisDomUtils::loadValue(qElement, "range", &range)) {
         animation->setFullClipRange(range);
     }
 
     if (KisDomUtils::loadValue(qElement, "currentTime", &currentTime)) {
         animation->switchCurrentTimeAsync(currentTime);
     }
 }
 
 KisNodeSP KisKraLoader::loadNodes(const KoXmlElement& element, KisImageSP image, KisNodeSP parent)
 {
 
     KoXmlNode node = element.firstChild();
     KoXmlNode child;
 
     if (!node.isNull()) {
 
         if (node.isElement()) {
 
             if (node.nodeName().toUpper() == LAYERS.toUpper() || node.nodeName().toUpper() == MASKS.toUpper()) {
                 for (child = node.lastChild(); !child.isNull(); child = child.previousSibling()) {
-                    KisNodeSP node = loadNode(child.toElement(), image, parent);
+                    KisNodeSP node = loadNode(child.toElement(), image);
                     if (node) {
                         image->nextLayerName(); // Make sure the nameserver is current with the number of nodes.
                         image->addNode(node, parent);
                         if (node->inherits("KisLayer") && KoXml::childNodesCount(child) > 0) {
                             loadNodes(child.toElement(), image, node);
                         }
                     }
                 }
             }
         }
     }
 
     return parent;
 }
 
-KisNodeSP KisKraLoader::loadNode(const KoXmlElement& element, KisImageSP image, KisNodeSP parent)
+KisNodeSP KisKraLoader::loadNode(const KoXmlElement& element, KisImageSP image)
 {
     // Nota bene: If you add new properties to layers, you should
     // ALWAYS define a default value in case the property is not
     // present in the layer definition: this helps a LOT with backward
     // compatibility.
     QString name = element.attribute(NAME, "No Name");
 
     QUuid id = QUuid(element.attribute(UUID, QUuid().toString()));
 
     qint32 x = element.attribute(X, "0").toInt();
     qint32 y = element.attribute(Y, "0").toInt();
 
     qint32 opacity = element.attribute(OPACITY, QString::number(OPACITY_OPAQUE_U8)).toInt();
     if (opacity < OPACITY_TRANSPARENT_U8) opacity = OPACITY_TRANSPARENT_U8;
     if (opacity > OPACITY_OPAQUE_U8) opacity = OPACITY_OPAQUE_U8;
 
     const KoColorSpace* colorSpace = 0;
     if ((element.attribute(COLORSPACE_NAME)).isNull()) {
         dbgFile << "No attribute color space for layer: " << name;
         colorSpace = image->colorSpace();
     }
     else {
         QString colorspacename = element.attribute(COLORSPACE_NAME);
         QString profileProductName;
 
         convertColorSpaceNames(colorspacename, profileProductName);
 
         QString colorspaceModel = KoColorSpaceRegistry::instance()->colorSpaceColorModelId(colorspacename).id();
         QString colorspaceDepth = KoColorSpaceRegistry::instance()->colorSpaceColorDepthId(colorspacename).id();
         dbgFile << "Searching color space: " << colorspacename << colorspaceModel << colorspaceDepth << " for layer: " << name;
         // use default profile - it will be replaced later in completeLoading
 
         colorSpace = KoColorSpaceRegistry::instance()->colorSpace(colorspaceModel, colorspaceDepth, "");
         dbgFile << "found colorspace" << colorSpace;
         if (!colorSpace) {
             m_d->warningMessages << i18n("Layer %1 specifies an unsupported color model: %2.", name, colorspacename);
             return 0;
         }
     }
 
     const bool visible = element.attribute(VISIBLE, "1") == "0" ? false : true;
     const bool locked = element.attribute(LOCKED, "0") == "0" ? false : true;
     const bool collapsed = element.attribute(COLLAPSED, "0") == "0" ? false : true;
     int colorLabelIndex = element.attribute(COLOR_LABEL, "0").toInt();
     QVector<QColor> labels = KisNodeViewColorScheme::instance()->allColorLabels();
     if (colorLabelIndex >= labels.size()) {
         colorLabelIndex = labels.size() - 1;
     }
 
     // Now find out the layer type and do specific handling
     QString nodeType;
 
     if (m_d->syntaxVersion == 1) {
         nodeType = element.attribute("layertype");
         if (nodeType.isEmpty()) {
             nodeType = PAINT_LAYER;
         }
     }
     else {
         nodeType = element.attribute(NODE_TYPE);
     }
 
     if (nodeType.isEmpty()) {
         m_d->warningMessages << i18n("Layer %1 has an unsupported type.", name);
         return 0;
     }
 
 
     KisNodeSP node = 0;
 
     if (nodeType == PAINT_LAYER)
         node = loadPaintLayer(element, image, name, colorSpace, opacity);
     else if (nodeType == GROUP_LAYER)
         node = loadGroupLayer(element, image, name, colorSpace, opacity);
     else if (nodeType == ADJUSTMENT_LAYER)
         node = loadAdjustmentLayer(element, image, name, colorSpace, opacity);
     else if (nodeType == SHAPE_LAYER)
         node = loadShapeLayer(element, image, name, colorSpace, opacity);
     else if (nodeType == GENERATOR_LAYER)
         node = loadGeneratorLayer(element, image, name, colorSpace, opacity);
     else if (nodeType == CLONE_LAYER)
         node = loadCloneLayer(element, image, name, colorSpace, opacity);
     else if (nodeType == FILTER_MASK)
-        node = loadFilterMask(element, parent);
+        node = loadFilterMask(element);
     else if (nodeType == TRANSFORM_MASK)
-        node = loadTransformMask(element, parent);
+        node = loadTransformMask(element);
     else if (nodeType == TRANSPARENCY_MASK)
-        node = loadTransparencyMask(element, parent);
+        node = loadTransparencyMask(element);
     else if (nodeType == SELECTION_MASK)
-        node = loadSelectionMask(image, element, parent);
+        node = loadSelectionMask(image, element);
     else if (nodeType == COLORIZE_MASK)
-        node = loadColorizeMask(image, element, parent, colorSpace);
+        node = loadColorizeMask(image, element, colorSpace);
     else if (nodeType == FILE_LAYER)
         node = loadFileLayer(element, image, name, opacity);
     else if (nodeType == REFERENCE_IMAGES_LAYER)
         node = loadReferenceImagesLayer(element, image);
     else {
         m_d->warningMessages << i18n("Layer %1 has an unsupported type: %2.", name, nodeType);
         return 0;
     }
 
     // Loading the node went wrong. Return empty node and leave to
     // upstream to complain to the user
     if (!node) {
         m_d->warningMessages << i18n("Failure loading layer %1 of type: %2.", name, nodeType);
         return 0;
     }
 
     node->setVisible(visible, true);
     node->setUserLocked(locked);
     node->setCollapsed(collapsed);
     node->setColorLabelIndex(colorLabelIndex);
     node->setX(x);
     node->setY(y);
     node->setName(name);
 
     if (! id.isNull())          // if no uuid in file, new one has been generated already
         node->setUuid(id);
 
     if (node->inherits("KisLayer") || node->inherits("KisColorizeMask")) {
         QString compositeOpName = element.attribute(COMPOSITE_OP, "normal");
         node->setCompositeOpId(compositeOpName);
     }
 
     if (node->inherits("KisLayer")) {
         KisLayer* layer           = qobject_cast<KisLayer*>(node.data());
         QBitArray channelFlags    = stringToFlags(element.attribute(CHANNEL_FLAGS, ""), colorSpace->channelCount());
         layer->setChannelFlags(channelFlags);
 
         if (element.hasAttribute(LAYER_STYLE_UUID)) {
             QString uuidString = element.attribute(LAYER_STYLE_UUID);
             QUuid uuid(uuidString);
             if (!uuid.isNull()) {
                 KisPSDLayerStyleSP dumbLayerStyle(new KisPSDLayerStyle());
                 dumbLayerStyle->setUuid(uuid);
                 layer->setLayerStyle(dumbLayerStyle);
             } else {
                 warnKrita << "WARNING: Layer style for layer" << layer->name() << "contains invalid UUID" << uuidString;
             }
         }
     }
 
     if (node->inherits("KisGroupLayer")) {
         if (element.hasAttribute(PASS_THROUGH_MODE)) {
             bool value = element.attribute(PASS_THROUGH_MODE, "0") != "0";
 
             KisGroupLayer *group = qobject_cast<KisGroupLayer*>(node.data());
             group->setPassThroughMode(value);
         }
     }
 
     const bool timelineEnabled = element.attribute(VISIBLE_IN_TIMELINE, "0") == "0" ? false : true;
     node->setUseInTimeline(timelineEnabled);
 
     if (node->inherits("KisPaintLayer")) {
         KisPaintLayer* layer            = qobject_cast<KisPaintLayer*>(node.data());
         bool onionEnabled = element.attribute(ONION_SKIN_ENABLED, "0") == "0" ? false : true;
         layer->setOnionSkinEnabled(onionEnabled);
     }
 
     if (element.attribute(FILE_NAME).isNull()) {
         m_d->layerFilenames[node.data()] = name;
     }
     else {
         m_d->layerFilenames[node.data()] = element.attribute(FILE_NAME);
     }
 
     if (element.hasAttribute("selected") && element.attribute("selected") == "true")  {
         m_d->selectedNodes.append(node);
     }
 
     if (element.hasAttribute(KEYFRAME_FILE)) {
         m_d->keyframeFilenames.insert(node.data(), element.attribute(KEYFRAME_FILE));
     }
 
     return node;
 }
 
 
 KisNodeSP KisKraLoader::loadPaintLayer(const KoXmlElement& element, KisImageSP image,
                                       const QString& name, const KoColorSpace* cs, quint32 opacity)
 {
     Q_UNUSED(element);
     KisPaintLayer* layer;
 
     layer = new KisPaintLayer(image, name, opacity, cs);
     Q_CHECK_PTR(layer);
     return layer;
 
 }
 
 KisNodeSP KisKraLoader::loadFileLayer(const KoXmlElement& element, KisImageSP image, const QString& name, quint32 opacity)
 {
     QString filename = element.attribute("source", QString());
     if (filename.isNull()) return 0;
     bool scale = (element.attribute("scale", "true")  == "true");
     int scalingMethod = element.attribute("scalingmethod", "-1").toInt();
     if (scalingMethod < 0) {
         if (scale) {
             scalingMethod = KisFileLayer::ToImagePPI;
         }
         else {
             scalingMethod = KisFileLayer::None;
         }
     }
 
     QString documentPath;
     if (m_d->document) {
         documentPath = m_d->document->url().toLocalFile();
     }
     QFileInfo info(documentPath);
     QString basePath = info.absolutePath();
 
     QString fullPath = QDir(basePath).filePath(QDir::cleanPath(filename));
     if (!QFileInfo(fullPath).exists()) {
 
         qApp->setOverrideCursor(Qt::ArrowCursor);
         QString msg = i18nc(
             "@info",
             "The file associated to a file layer with the name \"%1\" is not found.\n\n"
             "Expected path:\n"
             "%2\n\n"
             "Do you want to locate it manually?", name, fullPath);
 
         int result = QMessageBox::warning(0, i18nc("@title:window", "File not found"), msg, QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes);
 
         if (result == QMessageBox::Yes) {
 
             KoFileDialog dialog(0, KoFileDialog::OpenFile, "OpenDocument");
             dialog.setMimeTypeFilters(KisImportExportManager::mimeFilter(KisImportExportManager::Import));
             dialog.setDefaultDir(basePath);
             QString url = dialog.filename();
 
             if (!QFileInfo(basePath).exists()) {
                 filename = url;
             } else {
                 QDir d(basePath);
                 filename = d.relativeFilePath(url);
             }
         }
 
         qApp->restoreOverrideCursor();
     }
 
     KisLayer *layer = new KisFileLayer(image, basePath, filename, (KisFileLayer::ScalingMethod)scalingMethod, name, opacity);
     Q_CHECK_PTR(layer);
 
     return layer;
 }
 
 KisNodeSP KisKraLoader::loadGroupLayer(const KoXmlElement& element, KisImageSP image,
                                       const QString& name, const KoColorSpace* cs, quint32 opacity)
 {
     Q_UNUSED(element);
     Q_UNUSED(cs);
     QString attr;
     KisGroupLayer* layer;
 
     layer = new KisGroupLayer(image, name, opacity);
     Q_CHECK_PTR(layer);
 
     return layer;
 
 }
 
 KisNodeSP KisKraLoader::loadAdjustmentLayer(const KoXmlElement& element, KisImageSP image,
         const QString& name, const KoColorSpace* cs, quint32 opacity)
 {
     // XXX: do something with filterversion?
     Q_UNUSED(cs);
     QString attr;
     KisAdjustmentLayer* layer;
     QString filtername;
     QString legacy = filtername;
 
     if ((filtername = element.attribute(FILTER_NAME)).isNull()) {
         // XXX: Invalid adjustmentlayer! We should warn about it!
         warnFile << "No filter in adjustment layer";
         return 0;
     }
 
     //get deprecated filters.
     if (filtername=="brightnesscontrast") {
         legacy = filtername;
         filtername = "perchannel";
     }
     if (filtername=="left edge detections"
             || filtername=="right edge detections"
             || filtername=="top edge detections"
             || filtername=="bottom edge detections") {
         legacy = filtername;
         filtername = "edge detection";
     }
 
     KisFilterSP f = KisFilterRegistry::instance()->value(filtername);
     if (!f) {
         warnFile << "No filter for filtername" << filtername << "";
         return 0; // XXX: We don't have this filter. We should warn about it!
     }
 
     KisFilterConfigurationSP  kfc = f->defaultConfiguration();
     kfc->setProperty("legacy", legacy);
     if (legacy=="brightnesscontrast") {
         kfc->setProperty("colorModel", cs->colorModelId().id());
     }
 
     // We'll load the configuration and the selection later.
     layer = new KisAdjustmentLayer(image, name, kfc, 0);
     Q_CHECK_PTR(layer);
 
     layer->setOpacity(opacity);
 
     return layer;
 
 }
 
 
 KisNodeSP KisKraLoader::loadShapeLayer(const KoXmlElement& element, KisImageSP image,
                                       const QString& name, const KoColorSpace* cs, quint32 opacity)
 {
 
     Q_UNUSED(element);
     Q_UNUSED(cs);
 
     QString attr;
     KoShapeBasedDocumentBase * shapeController = 0;
     if (m_d->document) {
         shapeController = m_d->document->shapeController();
     }
     KisShapeLayer* layer = new KisShapeLayer(shapeController, image, name, opacity);
     Q_CHECK_PTR(layer);
 
     return layer;
 
 }
 
 
 KisNodeSP KisKraLoader::loadGeneratorLayer(const KoXmlElement& element, KisImageSP image,
         const QString& name, const KoColorSpace* cs, quint32 opacity)
 {
     Q_UNUSED(cs);
     // XXX: do something with generator version?
     KisGeneratorLayer* layer;
     QString generatorname = element.attribute(GENERATOR_NAME);
 
     if (generatorname.isNull()) {
         // XXX: Invalid generator layer! We should warn about it!
         warnFile << "No generator in generator layer";
         return 0;
     }
 
     KisGeneratorSP generator = KisGeneratorRegistry::instance()->value(generatorname);
     if (!generator) {
         warnFile << "No generator for generatorname" << generatorname << "";
         return 0; // XXX: We don't have this generator. We should warn about it!
     }
 
     KisFilterConfigurationSP  kgc = generator->defaultConfiguration();
 
     // We'll load the configuration and the selection later.
     layer = new KisGeneratorLayer(image, name, kgc, 0);
     Q_CHECK_PTR(layer);
 
     layer->setOpacity(opacity);
 
     return layer;
 
 }
 
 KisNodeSP KisKraLoader::loadCloneLayer(const KoXmlElement& element, KisImageSP image,
                                       const QString& name, const KoColorSpace* cs, quint32 opacity)
 {
     Q_UNUSED(cs);
 
     KisCloneLayerSP layer = new KisCloneLayer(0, image, name, opacity);
 
     KisNodeUuidInfo info;
     if (! (element.attribute(CLONE_FROM_UUID)).isNull()) {
         info = KisNodeUuidInfo(QUuid(element.attribute(CLONE_FROM_UUID)));
     } else {
         if ((element.attribute(CLONE_FROM)).isNull()) {
             return 0;
         } else {
             info = KisNodeUuidInfo(element.attribute(CLONE_FROM));
         }
     }
     layer->setCopyFromInfo(info);
 
     if ((element.attribute(CLONE_TYPE)).isNull()) {
         return 0;
     } else {
         layer->setCopyType((CopyLayerType) element.attribute(CLONE_TYPE).toInt());
     }
 
     return layer;
 }
 
 
-KisNodeSP KisKraLoader::loadFilterMask(const KoXmlElement& element, KisNodeSP parent)
+KisNodeSP KisKraLoader::loadFilterMask(const KoXmlElement& element)
 {
-    Q_UNUSED(parent);
     QString attr;
     KisFilterMask* mask;
     QString filtername;
 
     // XXX: should we check the version?
 
     if ((filtername = element.attribute(FILTER_NAME)).isNull()) {
         // XXX: Invalid filter layer! We should warn about it!
         warnFile << "No filter in filter layer";
         return 0;
     }
 
     KisFilterSP f = KisFilterRegistry::instance()->value(filtername);
     if (!f) {
         warnFile << "No filter for filtername" << filtername << "";
         return 0; // XXX: We don't have this filter. We should warn about it!
     }
 
     KisFilterConfigurationSP  kfc = f->defaultConfiguration();
 
     // We'll load the configuration and the selection later.
     mask = new KisFilterMask();
     mask->setFilter(kfc);
     Q_CHECK_PTR(mask);
 
     return mask;
 }
 
-KisNodeSP KisKraLoader::loadTransformMask(const KoXmlElement& element, KisNodeSP parent)
+KisNodeSP KisKraLoader::loadTransformMask(const KoXmlElement& element)
 {
     Q_UNUSED(element);
-    Q_UNUSED(parent);
 
     KisTransformMask* mask;
 
     /**
      * We'll load the transform configuration later on a stage
      * of binary data loading
      */
     mask = new KisTransformMask();
     Q_CHECK_PTR(mask);
 
     return mask;
 }
 
-KisNodeSP KisKraLoader::loadTransparencyMask(const KoXmlElement& element, KisNodeSP parent)
+KisNodeSP KisKraLoader::loadTransparencyMask(const KoXmlElement& element)
 {
     Q_UNUSED(element);
-    Q_UNUSED(parent);
     KisTransparencyMask* mask = new KisTransparencyMask();
     Q_CHECK_PTR(mask);
 
     return mask;
 }
 
-KisNodeSP KisKraLoader::loadSelectionMask(KisImageSP image, const KoXmlElement& element, KisNodeSP parent)
+KisNodeSP KisKraLoader::loadSelectionMask(KisImageSP image, const KoXmlElement& element)
 {
-    Q_UNUSED(parent);
     KisSelectionMaskSP mask = new KisSelectionMask(image);
     bool active = element.attribute(ACTIVE, "1") == "0" ? false : true;
     mask->setActive(active);
     Q_CHECK_PTR(mask);
 
     return mask;
 }
 
-KisNodeSP KisKraLoader::loadColorizeMask(KisImageSP image, const KoXmlElement& element, KisNodeSP parent, const KoColorSpace *colorSpace)
+KisNodeSP KisKraLoader::loadColorizeMask(KisImageSP image, const KoXmlElement& element, const KoColorSpace *colorSpace)
 {
-    Q_UNUSED(parent);
     KisColorizeMaskSP mask = new KisColorizeMask();
     const bool editKeystrokes = element.attribute(COLORIZE_EDIT_KEYSTROKES, "1") == "0" ? false : true;
     const bool showColoring = element.attribute(COLORIZE_SHOW_COLORING, "1") == "0" ? false : true;
 
     KisLayerPropertiesIcons::setNodeProperty(mask, KisLayerPropertiesIcons::colorizeEditKeyStrokes, editKeystrokes, image);
     KisLayerPropertiesIcons::setNodeProperty(mask, KisLayerPropertiesIcons::colorizeShowColoring, showColoring, image);
 
     const bool useEdgeDetection = KisDomUtils::toInt(element.attribute(COLORIZE_USE_EDGE_DETECTION, "0"));
     const qreal edgeDetectionSize = KisDomUtils::toDouble(element.attribute(COLORIZE_EDGE_DETECTION_SIZE, "4"));
     const qreal radius = KisDomUtils::toDouble(element.attribute(COLORIZE_FUZZY_RADIUS, "0"));
     const int cleanUp = KisDomUtils::toInt(element.attribute(COLORIZE_CLEANUP, "0"));
     const bool limitToDevice = KisDomUtils::toInt(element.attribute(COLORIZE_LIMIT_TO_DEVICE, "0"));
 
     mask->setUseEdgeDetection(useEdgeDetection);
     mask->setEdgeDetectionSize(edgeDetectionSize);
     mask->setFuzzyRadius(radius);
     mask->setCleanUpAmount(qreal(cleanUp) / 100.0);
     mask->setLimitToDeviceBounds(limitToDevice);
 
     delete mask->setColorSpace(colorSpace);
     mask->setImage(image);
 
     return mask;
 }
 
 void KisKraLoader::loadCompositions(const KoXmlElement& elem, KisImageSP image)
 {
     KoXmlNode child;
 
     for (child = elem.firstChild(); !child.isNull(); child = child.nextSibling()) {
 
         KoXmlElement e = child.toElement();
         QString name = e.attribute("name");
         bool exportEnabled = e.attribute("exportEnabled", "1") == "0" ? false : true;
 
         KisLayerCompositionSP composition(new KisLayerComposition(image, name));
         composition->setExportEnabled(exportEnabled);
 
         KoXmlNode value;
         for (value = child.lastChild(); !value.isNull(); value = value.previousSibling()) {
             KoXmlElement e = value.toElement();
             QUuid uuid(e.attribute("uuid"));
             bool visible = e.attribute("visible", "1") == "0" ? false : true;
             composition->setVisible(uuid, visible);
             bool collapsed = e.attribute("collapsed", "1") == "0" ? false : true;
             composition->setCollapsed(uuid, collapsed);
         }
 
         image->addComposition(composition);
     }
 }
 
 void KisKraLoader::loadAssistantsList(const KoXmlElement &elem)
 {
     KoXmlNode child;
     int count = 0;
     for (child = elem.firstChild(); !child.isNull(); child = child.nextSibling()) {
         KoXmlElement e = child.toElement();
         QString type = e.attribute("type");
         QString file_name = e.attribute("filename");
         m_d->assistantsFilenames.insert(file_name,type);
         count++;
 
     }
 }
 
 void KisKraLoader::loadGrid(const KoXmlElement& elem)
 {
     QDomDocument dom;
     KoXml::asQDomElement(dom, elem);
     QDomElement domElement = dom.firstChildElement();
 
     KisGridConfig config;
     config.loadDynamicDataFromXml(domElement);
     config.loadStaticData();
     m_d->document->setGridConfig(config);
 }
 
 void KisKraLoader::loadGuides(const KoXmlElement& elem)
 {
     QDomDocument dom;
     KoXml::asQDomElement(dom, elem);
     QDomElement domElement = dom.firstChildElement();
 
     KisGuidesConfig guides;
     guides.loadFromXml(domElement);
     m_d->document->setGuidesConfig(guides);
 }
 
 void KisKraLoader::loadAudio(const KoXmlElement& elem, KisImageSP image)
 {
     QDomDocument dom;
     KoXml::asQDomElement(dom, elem);
     QDomElement qElement = dom.firstChildElement();
 
     QString fileName;
     if (KisDomUtils::loadValue(qElement, "masterChannelPath", &fileName)) {
         fileName = QDir::toNativeSeparators(fileName);
 
         QDir baseDirectory = QFileInfo(m_d->document->localFilePath()).absoluteDir();
         fileName = baseDirectory.absoluteFilePath(fileName);
 
         QFileInfo info(fileName);
 
         if (!info.exists()) {
             qApp->setOverrideCursor(Qt::ArrowCursor);
             QString msg = i18nc(
                 "@info",
                 "Audio channel file \"%1\" doesn't exist!\n\n"
                 "Expected path:\n"
                 "%2\n\n"
                 "Do you want to locate it manually?", info.fileName(), info.absoluteFilePath());
 
             int result = QMessageBox::warning(0, i18nc("@title:window", "File not found"), msg, QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes);
 
             if (result == QMessageBox::Yes) {
                 info.setFile(KisImportExportManager::askForAudioFileName(info.absolutePath(), 0));
             }
 
             qApp->restoreOverrideCursor();
         }
 
         if (info.exists()) {
             image->animationInterface()->setAudioChannelFileName(info.absoluteFilePath());
         }
     }
 
     bool audioMuted = false;
     if (KisDomUtils::loadValue(qElement, "audioMuted", &audioMuted)) {
         image->animationInterface()->setAudioMuted(audioMuted);
     }
 
     qreal audioVolume = 0.5;
     if (KisDomUtils::loadValue(qElement, "audioVolume", &audioVolume)) {
         image->animationInterface()->setAudioVolume(audioVolume);
     }
 }
 
 KisNodeSP KisKraLoader::loadReferenceImagesLayer(const KoXmlElement &elem, KisImageSP image)
 {
-    KisSharedPtr<KisReferenceImagesLayer> layer = m_d->document->createReferenceImagesLayer(image);
+    KisSharedPtr<KisReferenceImagesLayer> layer =
+        new KisReferenceImagesLayer(m_d->document->shapeController(), image);
+
+    m_d->document->setReferenceImagesLayer(layer);
 
     for (QDomElement child = elem.firstChildElement(); !child.isNull(); child = child.nextSiblingElement()) {
         if (child.nodeName().toLower() == "referenceimage") {
             auto* reference = KisReferenceImage::fromXml(child);
             layer->addShape(reference);
         }
     }
 
     return layer;
 }
diff --git a/plugins/impex/libkra/kis_kra_loader.h b/plugins/impex/libkra/kis_kra_loader.h
index f6784e9086..8bdeb429a9 100644
--- a/plugins/impex/libkra/kis_kra_loader.h
+++ b/plugins/impex/libkra/kis_kra_loader.h
@@ -1,119 +1,119 @@
 /* This file is part of the KDE project
  * Copyright (C) Boudewijn Rempt <boud@valdyas.org>, (C) 2007
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 #ifndef KIS_KRA_LOADER_H
 #define KIS_KRA_LOADER_H
 
 class QString;
 class QStringList;
 
 #include "KoXmlReaderForward.h"
 class KoStore;
 
 class KisDocument;
 class KoColorSpace;
 class KisPaintingAssistant;
 
 #include <kis_types.h>
 #include "kritalibkra_export.h"
 /**
  * Load old-style 1.x .kra files. Updated for 2.0, let's try to stay
  * compatible. But 2.0 won't be able to save 1.x .kra files unless we
  * implement an export filter.
  */
 class KRITALIBKRA_EXPORT KisKraLoader
 {
 
 public:
 
     KisKraLoader(KisDocument * document, int syntaxVersion);
 
     ~KisKraLoader();
 
     /**
      * Loading is done in two steps: first all xml is loaded, then, in finishLoading,
      * the actual layer data is loaded.
      */
     KisImageSP loadXML(const KoXmlElement& elem);
 
     void loadBinaryData(KoStore* store, KisImageSP image, const QString & uri, bool external);
 
     vKisNodeSP selectedNodes() const;
 
     // it's neater to follow the same design as with selectedNodes, so let's have a getter here
     QList<KisPaintingAssistantSP> assistants() const;
 
     /// if empty, loading didn't fail...
     QStringList errorMessages() const;
 
     /// if not empty, loading didn't fail, but there are problems
     QStringList warningMessages() const;
 
 private:
 
     // this needs to be private, for neatness sake
     void loadAssistants(KoStore* store, const QString & uri, bool external);
 
     void loadAnimationMetadata(const KoXmlElement& element, KisImageSP image);
 
     KisNodeSP loadNodes(const KoXmlElement& element, KisImageSP image, KisNodeSP parent);
 
-    KisNodeSP loadNode(const KoXmlElement& elem, KisImageSP image, KisNodeSP parent);
+    KisNodeSP loadNode(const KoXmlElement& elem, KisImageSP image);
 
     KisNodeSP loadPaintLayer(const KoXmlElement& elem, KisImageSP image, const QString& name, const KoColorSpace* cs, quint32 opacity);
 
     KisNodeSP loadGroupLayer(const KoXmlElement& elem, KisImageSP image, const QString& name, const KoColorSpace* cs, quint32 opacity);
 
     KisNodeSP loadAdjustmentLayer(const KoXmlElement& elem, KisImageSP image, const QString& name, const KoColorSpace* cs, quint32 opacity);
 
     KisNodeSP loadShapeLayer(const KoXmlElement& elem, KisImageSP image, const QString& name, const KoColorSpace* cs, quint32 opacity);
 
     KisNodeSP loadGeneratorLayer(const KoXmlElement& elem, KisImageSP image, const QString& name, const KoColorSpace* cs, quint32 opacity);
 
     KisNodeSP loadCloneLayer(const KoXmlElement& elem, KisImageSP image, const QString& name, const KoColorSpace* cs, quint32 opacity);
 
-    KisNodeSP loadFilterMask(const KoXmlElement& elem, KisNodeSP parent);
+    KisNodeSP loadFilterMask(const KoXmlElement& elem);
 
-    KisNodeSP loadTransformMask(const KoXmlElement& elem, KisNodeSP parent);
+    KisNodeSP loadTransformMask(const KoXmlElement& elem);
 
-    KisNodeSP loadTransparencyMask(const KoXmlElement& elem, KisNodeSP parent);
+    KisNodeSP loadTransparencyMask(const KoXmlElement& elem);
 
-    KisNodeSP loadSelectionMask(KisImageSP image, const KoXmlElement& elem, KisNodeSP parent);
+    KisNodeSP loadSelectionMask(KisImageSP image, const KoXmlElement& elem);
 
-    KisNodeSP loadColorizeMask(KisImageSP image, const KoXmlElement& elem, KisNodeSP parent, const KoColorSpace *colorSpace);
+    KisNodeSP loadColorizeMask(KisImageSP image, const KoXmlElement& elem, const KoColorSpace *colorSpace);
 
     KisNodeSP loadFileLayer(const KoXmlElement& elem, KisImageSP image, const QString& name, quint32 opacity);
 
     KisNodeSP loadReferenceImagesLayer(const KoXmlElement& elem, KisImageSP image);
 
     void loadNodeKeyframes(KoStore *store, const QString &location, KisNodeSP node);
 
     void loadCompositions(const KoXmlElement& elem, KisImageSP image);
 
     void loadAssistantsList(const KoXmlElement& elem);
     void loadGrid(const KoXmlElement& elem);
     void loadGuides(const KoXmlElement& elem);
     void loadAudio(const KoXmlElement& elem, KisImageSP image);
 private:
 
     struct Private;
     Private * const m_d;
 
 };
 
 #endif
diff --git a/plugins/tools/defaulttool/referenceimagestool/ToolReferenceImages.cpp b/plugins/tools/defaulttool/referenceimagestool/ToolReferenceImages.cpp
index a6627aa181..ad35993897 100644
--- a/plugins/tools/defaulttool/referenceimagestool/ToolReferenceImages.cpp
+++ b/plugins/tools/defaulttool/referenceimagestool/ToolReferenceImages.cpp
@@ -1,229 +1,229 @@
 /*
  * Copyright (c) 2017 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This library is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; version 2.1 of the License.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "ToolReferenceImages.h"
 
 #include <QDesktopServices>
 #include <QFile>
 #include <QLayout>
 #include <QMenu>
 #include <QMessageBox>
 #include <QVector>
 
 #include <KoShapeRegistry.h>
 #include <KoShapeManager.h>
 #include <KoShapeController.h>
 #include <KoFileDialog.h>
 
 #include <kis_canvas2.h>
 #include <kis_canvas_resource_provider.h>
 #include <KisViewManager.h>
 #include <KisDocument.h>
 #include <KisReferenceImagesLayer.h>
 
 #include "ToolReferenceImagesWidget.h"
 #include "KisReferenceImageCollection.h"
 
 ToolReferenceImages::ToolReferenceImages(KoCanvasBase * canvas)
     : DefaultTool(canvas)
 {
     setObjectName("ToolReferenceImages");
 }
 
 ToolReferenceImages::~ToolReferenceImages()
 {
 }
 
 void ToolReferenceImages::activate(ToolActivation toolActivation, const QSet<KoShape*> &shapes)
 {
     // Add code here to initialize your tool when it got activated
     DefaultTool::activate(toolActivation, shapes);
 
     KisReferenceImagesLayer *layer = getOrCreteReferenceImagesLayer();
     connect(layer, SIGNAL(selectionChanged()), this, SLOT(slotSelectionChanged()));
 }
 
 void ToolReferenceImages::deactivate()
 {
     DefaultTool::deactivate();
 }
 
 void ToolReferenceImages::addReferenceImage()
 {
     auto kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
     KIS_ASSERT_RECOVER_RETURN(kisCanvas)
 
     KoFileDialog dialog(kisCanvas->viewManager()->mainWindow(), KoFileDialog::OpenFile, "OpenReferenceImage");
     dialog.setCaption(i18n("Select a Reference Image"));
 
     QStringList locations = QStandardPaths::standardLocations(QStandardPaths::PicturesLocation);
     if (!locations.isEmpty()) {
         dialog.setDefaultDir(locations.first());
     }
 
     QString filename = dialog.filename();
     if (filename.isEmpty()) return;
     if (!QFileInfo(filename).exists()) return;
 
     auto *reference = KisReferenceImage::fromFile(filename, *kisCanvas->coordinatesConverter());
     KisReferenceImagesLayer *layer = getOrCreteReferenceImagesLayer();
     kisCanvas->imageView()->document()->addCommand(layer->addReferenceImage(reference));
 }
 
 void ToolReferenceImages::removeAllReferenceImages()
 {
     KisReferenceImagesLayer *layer = getOrCreteReferenceImagesLayer();
     canvas()->addCommand(canvas()->shapeController()->removeShapes(layer->shapes()));
 }
 
 void ToolReferenceImages::loadReferenceImages()
 {
       auto kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
     KIS_ASSERT_RECOVER_RETURN(kisCanvas)
 
     KoFileDialog dialog(kisCanvas->viewManager()->mainWindow(), KoFileDialog::OpenFile, "OpenReferenceImageCollection");
     dialog.setMimeTypeFilters(QStringList() << "application/x-krita-reference-images");
     dialog.setCaption(i18n("Load Reference Images"));
 
     QStringList locations = QStandardPaths::standardLocations(QStandardPaths::PicturesLocation);
     if (!locations.isEmpty()) {
         dialog.setDefaultDir(locations.first());
     }
 
     QString filename = dialog.filename();
     if (filename.isEmpty()) return;
     if (!QFileInfo(filename).exists()) return;
 
     QFile file(filename);
     if (!file.open(QIODevice::ReadOnly)) {
         QMessageBox::critical(nullptr, i18nc("@title:window", "Krita"), i18n("Could not open '%1'.", filename));
         return;
     }
 
     KisReferenceImageCollection collection;
     if (collection.load(&file)) {
         KisReferenceImagesLayer *layer = referenceImagesLayer();
 
         Q_FOREACH(KisReferenceImage *reference, collection.referenceImages()) {
             layer->addShape(reference);
         }
     } else {
         QMessageBox::critical(nullptr, i18nc("@title:window", "Krita"), i18n("Could not load reference images from '%1'.", filename));
     }
     file.close();
 }
 
 void ToolReferenceImages::saveReferenceImages()
 {
     auto kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
     KIS_ASSERT_RECOVER_RETURN(kisCanvas)
 
     KoFileDialog dialog(kisCanvas->viewManager()->mainWindow(), KoFileDialog::SaveFile, "SaveReferenceImageCollection");
     dialog.setMimeTypeFilters(QStringList() << "application/x-krita-reference-images");
     dialog.setCaption(i18n("Save Reference Images"));
 
     QStringList locations = QStandardPaths::standardLocations(QStandardPaths::PicturesLocation);
     if (!locations.isEmpty()) {
         dialog.setDefaultDir(locations.first());
     }
 
     QString filename = dialog.filename();
     if (filename.isEmpty()) return;
 
     QFile file(filename);
     if (!file.open(QIODevice::WriteOnly)) {
         QMessageBox::critical(nullptr, i18nc("@title:window", "Krita"), i18n("Could not open '%1' for saving.", filename));
         return;
     }
 
     KisReferenceImageCollection collection(referenceImagesLayer()->referenceImages());
     bool ok = collection.save(&file);
     file.close();
 
     if (!ok) {
         QMessageBox::critical(nullptr, i18nc("@title:window", "Krita"), i18n("Failed to save reference images.", filename));
     }
 }
 
 void ToolReferenceImages::slotSelectionChanged()
 {
     KisReferenceImagesLayer *layer = getOrCreteReferenceImagesLayer();
     m_optionsWidget->selectionChanged(layer->shapeManager()->selection());
     updateActions();
 }
 
 QList<QPointer<QWidget>> ToolReferenceImages::createOptionWidgets()
 {
     // Instead of inheriting DefaultTool's multi-tab implementation, inherit straight from KoToolBase
     return KoToolBase::createOptionWidgets();
 }
 
 QWidget *ToolReferenceImages::createOptionWidget()
 {
     if (!m_optionsWidget) {
         m_optionsWidget = new ToolReferenceImagesWidget(this);
         // See https://bugs.kde.org/show_bug.cgi?id=316896
         QWidget *specialSpacer = new QWidget(m_optionsWidget);
         specialSpacer->setObjectName("SpecialSpacer");
         specialSpacer->setFixedSize(0, 0);
         m_optionsWidget->layout()->addWidget(specialSpacer);
     }
     return m_optionsWidget;
  }
 
 bool ToolReferenceImages::isValidForCurrentLayer() const
 {
     return true;
 }
 
 KoShapeManager *ToolReferenceImages::shapeManager() const
 {
     auto layer = referenceImagesLayer();
     return layer ? referenceImagesLayer()->shapeManager() : nullptr;
 }
 
 KisReferenceImagesLayer *ToolReferenceImages::referenceImagesLayer() const
 {
     auto kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
     KisDocument *document = kisCanvas->imageView()->document();
 
     return document->referenceImagesLayer();
 }
 
 KisReferenceImagesLayer *ToolReferenceImages::getOrCreteReferenceImagesLayer()
 {
     auto kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
     KisDocument *document = kisCanvas->imageView()->document();
 
-    return document->createReferenceImagesLayer().data();
+    return document->getOrCreateReferenceImagesLayer().data();
 }
 
 KoSelection *ToolReferenceImages::koSelection() const
 {
     auto manager = shapeManager();
     return manager ? manager->selection() : nullptr;
 }
 
 void ToolReferenceImages::updateDistinctiveActions(const QList<KoShape*> &)
 {
     action("object_group")->setEnabled(false);
     action("object_unite")->setEnabled(false);
     action("object_intersect")->setEnabled(false);
     action("object_subtract")->setEnabled(false);
     action("object_split")->setEnabled(false);
     action("object_ungroup")->setEnabled(false);
 }
diff --git a/sdk/tests/testutil.h b/sdk/tests/testutil.h
index feedf40f32..0cc62921f8 100644
--- a/sdk/tests/testutil.h
+++ b/sdk/tests/testutil.h
@@ -1,519 +1,527 @@
 /*
  *  Copyright (c) 2007 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef TEST_UTIL
 #define TEST_UTIL
 
 #include <QProcessEnvironment>
 
 #include <QList>
 #include <QTime>
 #include <QDir>
 
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorProfile.h>
 #include <KoProgressProxy.h>
 #include <kis_paint_device.h>
 #include <kis_node.h>
 #include <kis_undo_adapter.h>
 #include "kis_node_graph_listener.h"
 #include "kis_iterator_ng.h"
 #include "kis_image.h"
 #include "testing_nodes.h"
 
 
 #ifndef FILES_DATA_DIR
 #define FILES_DATA_DIR "."
 #endif
 
 #ifndef FILES_DEFAULT_DATA_DIR
 #define FILES_DEFAULT_DATA_DIR "."
 #endif
 
 #include "qimage_test_util.h"
 
+#define KIS_COMPARE_RF(expr, ref) \
+    if ((expr) != (ref)) { \
+        qDebug() << "Compared values are not the same at line" << __LINE__; \
+        qDebug() << "    Actual  : " << #expr << "=" << (expr); \
+        qDebug() << "    Expected: " << #ref << "=" << (ref); \
+        return false; \
+    }
+
 /**
  * Routines that are useful for writing efficient tests
  */
 
 namespace TestUtil
 {
 
 inline KisNodeSP findNode(KisNodeSP root, const QString &name) {
     if(root->name() == name) return root;
 
     KisNodeSP child = root->firstChild();
     while (child) {
         if((root = findNode(child, name))) return root;
         child = child->nextSibling();
     }
 
     return KisNodeSP();
 }
 
 inline void dumpNodeStack(KisNodeSP node, QString prefix = QString("\t"))
 {
     qDebug() << node->name();
     KisNodeSP child = node->firstChild();
 
     while (child) {
 
         if (child->childCount() > 0) {
             dumpNodeStack(child, prefix + "\t");
         } else {
             qDebug() << prefix << child->name();
         }
         child = child->nextSibling();
     }
 }
 
 class TestProgressBar : public KoProgressProxy {
 public:
     TestProgressBar()
         : m_min(0), m_max(0), m_value(0)
     {}
 
     int maximum() const override {
         return m_max;
     }
     void setValue(int value) override {
         m_value = value;
     }
     void setRange(int min, int max) override {
         m_min = min;
         m_max = max;
     }
     void setFormat(const QString &format) override {
         m_format = format;
     }
 
     void setAutoNestedName(const QString &name) {
         m_autoNestedName = name;
         KoProgressProxy::setAutoNestedName(name);
     }
 
     int min() { return m_min; }
     int max() { return m_max; }
     int value() { return m_value; }
     QString format() { return m_format; }
     QString autoNestedName() { return m_autoNestedName; }
 
 
 private:
     int m_min;
     int m_max;
     int m_value;
     QString m_format;
     QString m_autoNestedName;
 };
 
 inline bool comparePaintDevices(QPoint & pt, const KisPaintDeviceSP dev1, const KisPaintDeviceSP dev2)
 {
     //     QTime t;
     //     t.start();
 
     QRect rc1 = dev1->exactBounds();
     QRect rc2 = dev2->exactBounds();
 
     if (rc1 != rc2) {
         pt.setX(-1);
         pt.setY(-1);
     }
 
     KisHLineConstIteratorSP iter1 = dev1->createHLineConstIteratorNG(0, 0, rc1.width());
     KisHLineConstIteratorSP iter2 = dev2->createHLineConstIteratorNG(0, 0, rc1.width());
 
     int pixelSize = dev1->pixelSize();
 
     for (int y = 0; y < rc1.height(); ++y) {
 
         do {
             if (memcmp(iter1->oldRawData(), iter2->oldRawData(), pixelSize) != 0)
                 return false;
         } while (iter1->nextPixel() && iter2->nextPixel());
 
         iter1->nextRow();
         iter2->nextRow();
     }
     //     qDebug() << "comparePaintDevices time elapsed:" << t.elapsed();
     return true;
 }
 
 template <typename channel_type>
 inline bool comparePaintDevicesClever(const KisPaintDeviceSP dev1, const KisPaintDeviceSP dev2, channel_type alphaThreshold = 0)
 {
     QRect rc1 = dev1->exactBounds();
     QRect rc2 = dev2->exactBounds();
 
     if (rc1 != rc2) {
         qDebug() << "Devices have different size" << ppVar(rc1) << ppVar(rc2);
         return false;
     }
 
     KisHLineConstIteratorSP iter1 = dev1->createHLineConstIteratorNG(0, 0, rc1.width());
     KisHLineConstIteratorSP iter2 = dev2->createHLineConstIteratorNG(0, 0, rc1.width());
 
     int pixelSize = dev1->pixelSize();
 
     for (int y = 0; y < rc1.height(); ++y) {
 
         do {
             if (memcmp(iter1->oldRawData(), iter2->oldRawData(), pixelSize) != 0) {
                 const channel_type* p1 = reinterpret_cast<const channel_type*>(iter1->oldRawData());
                 const channel_type* p2 = reinterpret_cast<const channel_type*>(iter2->oldRawData());
 
                 if (p1[3] < alphaThreshold && p2[3] < alphaThreshold) continue;
 
                 qDebug() << "Failed compare paint devices:" << iter1->x() << iter1->y();
                 qDebug() << "src:" << p1[0] << p1[1] << p1[2] << p1[3];
                 qDebug() << "dst:" << p2[0] << p2[1] << p2[2] << p2[3];
                 return false;
             }
         } while (iter1->nextPixel() && iter2->nextPixel());
 
         iter1->nextRow();
         iter2->nextRow();
     }
 
     return true;
 }
 
 #ifdef FILES_OUTPUT_DIR
 
 struct ReferenceImageChecker
 {
     enum StorageType {
         InternalStorage = 0,
         ExternalStorage
     };
 
     ReferenceImageChecker(const QString &prefix, const QString &testName, StorageType storageType = ExternalStorage)
         : m_storageType(storageType),
           m_prefix(prefix),
           m_testName(testName),
           m_success(true),
           m_maxFailingPixels(100),
           m_fuzzy(1)
         {
         }
 
 
     void setMaxFailingPixels(int value) {
         m_maxFailingPixels = value;
     }
 
     void setFuzzy(int fuzzy){
         m_fuzzy = fuzzy;
     }
 
     bool testPassed() const {
         return m_success;
     }
 
     inline bool checkDevice(KisPaintDeviceSP device, KisImageSP image, const QString &caseName) {
         bool result = false;
 
 
         if (m_storageType == ExternalStorage) {
             result = checkQImageExternal(device->convertToQImage(0, image->bounds()),
                                          m_testName,
                                          m_prefix,
                                          caseName, m_fuzzy, m_fuzzy, m_maxFailingPixels);
         } else {
             result = checkQImage(device->convertToQImage(0, image->bounds()),
                                  m_testName,
                                  m_prefix,
                                  caseName, m_fuzzy, m_fuzzy, m_maxFailingPixels);
         }
 
         m_success &= result;
         return result;
     }
 
     inline bool checkImage(KisImageSP image, const QString &testName) {
         bool result = checkDevice(image->projection(), image, testName);
 
         m_success &= result;
         return result;
     }
 
 private:
     bool m_storageType;
 
     QString m_prefix;
     QString m_testName;
 
     bool m_success;
     int m_maxFailingPixels;
     int m_fuzzy;
 };
 
 
 #endif
 
 inline quint8 alphaDevicePixel(KisPaintDeviceSP dev, qint32 x, qint32 y)
 {
     KisHLineConstIteratorSP iter = dev->createHLineConstIteratorNG(x, y, 1);
     const quint8 *pix = iter->oldRawData();
     return *pix;
 }
 
 inline void alphaDeviceSetPixel(KisPaintDeviceSP dev, qint32 x, qint32 y, quint8 s)
 {
     KisHLineIteratorSP iter = dev->createHLineIteratorNG(x, y, 1);
     quint8 *pix = iter->rawData();
     *pix = s;
 }
 
 inline bool checkAlphaDeviceFilledWithPixel(KisPaintDeviceSP dev, const QRect &rc, quint8 expected)
 {
     KisHLineIteratorSP it = dev->createHLineIteratorNG(rc.x(), rc.y(), rc.width());
 
     for (int y = rc.y(); y < rc.y() + rc.height(); y++) {
         for (int x = rc.x(); x < rc.x() + rc.width(); x++) {
 
             if(*((quint8*)it->rawData()) != expected) {
                 errKrita << "At point:" << x << y;
                 errKrita << "Expected pixel:" << expected;
                 errKrita << "Actual pixel:  " << *((quint8*)it->rawData());
                 return false;
             }
             it->nextPixel();
         }
         it->nextRow();
     }
     return true;
 }
 
 class TestNode : public DefaultNode
 {
     Q_OBJECT
 public:
     KisNodeSP clone() const override {
         return KisNodeSP(new TestNode(*this));
     }
 };
 
 class TestGraphListener : public KisNodeGraphListener
 {
 public:
 
     void aboutToAddANode(KisNode *parent, int index) override {
         KisNodeGraphListener::aboutToAddANode(parent, index);
         beforeInsertRow = true;
     }
 
     void nodeHasBeenAdded(KisNode *parent, int index) override {
         KisNodeGraphListener::nodeHasBeenAdded(parent, index);
         afterInsertRow = true;
     }
 
     void aboutToRemoveANode(KisNode *parent, int index) override {
         KisNodeGraphListener::aboutToRemoveANode(parent, index);
         beforeRemoveRow  = true;
     }
 
     void nodeHasBeenRemoved(KisNode *parent, int index) override {
         KisNodeGraphListener::nodeHasBeenRemoved(parent, index);
         afterRemoveRow = true;
     }
 
     void aboutToMoveNode(KisNode *parent, int oldIndex, int newIndex) override {
         KisNodeGraphListener::aboutToMoveNode(parent, oldIndex, newIndex);
         beforeMove = true;
     }
 
     void nodeHasBeenMoved(KisNode *parent, int oldIndex, int newIndex) override {
         KisNodeGraphListener::nodeHasBeenMoved(parent, oldIndex, newIndex);
         afterMove = true;
     }
 
     bool beforeInsertRow;
     bool afterInsertRow;
     bool beforeRemoveRow;
     bool afterRemoveRow;
     bool beforeMove;
     bool afterMove;
 
     void resetBools() {
         beforeRemoveRow = false;
         afterRemoveRow = false;
         beforeInsertRow = false;
         afterInsertRow = false;
         beforeMove = false;
         afterMove = false;
     }
 };
 
 }
 
 #include <QApplication>
 #include <kis_paint_layer.h>
 #include <kis_image.h>
 #include "kis_undo_stores.h"
 #include "kis_layer_utils.h"
 
 namespace TestUtil {
 
 struct MaskParent
 {
     MaskParent(const QRect &_imageRect = QRect(0,0,512,512))
         : imageRect(_imageRect) {
         const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
         undoStore = new KisSurrogateUndoStore();
         image = new KisImage(undoStore, imageRect.width(), imageRect.height(), cs, "test image");
         layer = KisPaintLayerSP(new KisPaintLayer(image, "paint1", OPACITY_OPAQUE_U8));
         image->addNode(KisNodeSP(layer.data()));
     }
 
     void waitForImageAndShapeLayers() {
         qApp->processEvents();
         image->waitForDone();
         KisLayerUtils::forceAllDelayedNodesUpdate(image->root());
         qApp->processEvents();
         image->waitForDone();
     }
 
     KisSurrogateUndoStore *undoStore;
     const QRect imageRect;
     KisImageSP image;
     KisPaintLayerSP layer;
 };
 
 }
 
 namespace TestUtil {
 
 class MeasureAvgPortion
 {
 public:
     MeasureAvgPortion(int period)
         : m_period(period),
         m_val(0),
         m_total(0),
         m_cycles(0)
     {
     }
 
     ~MeasureAvgPortion() {
         printValues(true);
     }
 
     void addVal(int x) {
         m_val += x;
     }
 
     void addTotal(int x) {
         m_total += x;
         m_cycles++;
         printValues();
     }
 
 private:
     void printValues(bool force = false) {
         if (m_cycles > m_period || force) {
             qDebug() << "Val / Total:" << qreal(m_val) / qreal(m_total);
             qDebug() << "Avg. Val:   " << qreal(m_val) / m_cycles;
             qDebug() << "Avg. Total: " << qreal(m_total) / m_cycles;
             qDebug() << ppVar(m_val) << ppVar(m_total) << ppVar(m_cycles);
 
             m_val = 0;
             m_total = 0;
             m_cycles = 0;
         }
     }
 
 private:
     int m_period;
     qint64 m_val;
     qint64 m_total;
     qint64 m_cycles;
 };
 
 struct MeasureDistributionStats {
     MeasureDistributionStats(int numBins, const QString &name = QString())
         : m_numBins(numBins),
           m_name(name)
     {
         reset();
     }
 
     void reset() {
         m_values.clear();
         m_values.resize(m_numBins);
     }
 
     void addValue(int value) {
         addValue(value, 1);
     }
 
     void addValue(int value, int increment) {
         KIS_SAFE_ASSERT_RECOVER_RETURN(value >= 0);
 
         if (value >= m_numBins) {
             m_values[m_numBins - 1] += increment;
         } else {
             m_values[value] += increment;
         }
     }
 
     void print() {
         qCritical() << "============= Stats ==============";
 
         if (!m_name.isEmpty()) {
             qCritical() << "Name:" << m_name;
         }
 
         int total = 0;
 
         for (int i = 0; i < m_numBins; i++) {
             total += m_values[i];
         }
 
         for (int i = 0; i < m_numBins; i++) {
             if (!m_values[i]) continue;
 
             const QString lastMarker = i == m_numBins - 1 ? "> " : "  ";
 
             const QString line =
                 QString("  %1%2: %3 (%4%)")
                     .arg(lastMarker)
                     .arg(i, 3)
                     .arg(m_values[i], 5)
                     .arg(qreal(m_values[i]) / total * 100.0, 7, 'g', 2);
 
             qCritical() << qPrintable(line);
         }
         qCritical() << "----                          ----";
         qCritical() << qPrintable(QString("Total: %1").arg(total));
         qCritical() << "==================================";
     }
 
 private:
     QVector<int> m_values;
     int m_numBins = 0;
     QString m_name;
 };
 
 QStringList getHierarchy(KisNodeSP root, const QString &prefix = "");
 bool checkHierarchy(KisNodeSP root, const QStringList &expected);
 
 }
 
 #endif