diff --git a/libs/image/kis_keyframe_channel.cpp b/libs/image/kis_keyframe_channel.cpp
index a8db73e50b..8a73001409 100644
--- a/libs/image/kis_keyframe_channel.cpp
+++ b/libs/image/kis_keyframe_channel.cpp
@@ -1,527 +1,532 @@
 /*
  *  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_keyframe_channel.h"
 #include "KoID.h"
 #include "kis_global.h"
 #include "kis_node.h"
 #include "kis_time_range.h"
 #include "kundo2command.h"
 
 #include <QMap>
 
 const KoID KisKeyframeChannel::Content = KoID("content", ki18n("Content"));
 const KoID KisKeyframeChannel::Opacity = KoID("opacity", ki18n("Opacity"));
 
 struct KisKeyframeChannel::Private
 {
     Private() {}
     Private(const Private &rhs, KisNodeWSP newParentNode) {
         keys = rhs.keys;
         node = newParentNode;
         id = rhs.id;
         defaultBounds = rhs.defaultBounds;
     }
 
     KeyframesMap keys;
     KisNodeWSP node;
     KoID id;
     KisDefaultBoundsBaseSP defaultBounds;
 };
 
 struct KisKeyframeChannel::InsertFrameCommand : public KUndo2Command
 {
     InsertFrameCommand(KisKeyframeChannel *channel, KisKeyframeSP keyframe, bool insert, KUndo2Command *parentCommand)
         : KUndo2Command(parentCommand),
           m_channel(channel),
           m_keyframe(keyframe),
           m_insert(insert)
     {
     }
 
     void redo() {
         doSwap(m_insert);
     }
 
     void undo() {
         doSwap(!m_insert);
     }
 
 private:
     void doSwap(bool insert) {
         if (insert) {
             m_channel->insertKeyframeLogical(m_keyframe);
         } else {
             m_channel->deleteKeyframeLogical(m_keyframe);
         }
     }
 
 private:
     KisKeyframeChannel *m_channel;
     KisKeyframeSP m_keyframe;
     bool m_insert;
 };
 
 struct KisKeyframeChannel::MoveFrameCommand : public KUndo2Command
 {
     MoveFrameCommand(KisKeyframeChannel *channel, KisKeyframeSP keyframe, int oldTime, int newTime, KUndo2Command *parentCommand)
         : KUndo2Command(parentCommand),
           m_channel(channel),
           m_keyframe(keyframe),
           m_oldTime(oldTime),
           m_newTime(newTime)
     {
     }
 
     void redo() {
         m_channel->moveKeyframeImpl(m_keyframe, m_newTime);
     }
 
     void undo() {
         m_channel->moveKeyframeImpl(m_keyframe, m_oldTime);
     }
 
 private:
     KisKeyframeChannel *m_channel;
     KisKeyframeSP m_keyframe;
     int m_oldTime;
     int m_newTime;
 };
 
 KisKeyframeChannel::KisKeyframeChannel(const KoID &id, KisDefaultBoundsBaseSP defaultBounds)
     : m_d(new Private)
 {
     m_d->id = id;
     m_d->node = 0;
     m_d->defaultBounds = defaultBounds;
 }
 
 KisKeyframeChannel::KisKeyframeChannel(const KisKeyframeChannel &rhs, KisNodeWSP newParentNode)
     : m_d(new Private(*rhs.m_d, newParentNode))
 {
     KIS_ASSERT_RECOVER_NOOP(&rhs != this);
 }
 
 KisKeyframeChannel::~KisKeyframeChannel()
 {}
 
 QString KisKeyframeChannel::id() const
 {
     return m_d->id.id();
 }
 
 QString KisKeyframeChannel::name() const
 {
     return m_d->id.name();
 }
 
 void KisKeyframeChannel::setNode(KisNodeWSP node)
 {
     m_d->node = node;
 }
 
 KisNodeWSP KisKeyframeChannel::node() const
 {
     return m_d->node;
 }
 
 #define LAZY_INITIALIZE_PARENT_COMMAND(cmd)       \
     QScopedPointer<KUndo2Command> __tempCommand;  \
     if (!parentCommand) {                         \
         __tempCommand.reset(new KUndo2Command()); \
         cmd = __tempCommand.data();               \
     }
 
 KisKeyframeSP KisKeyframeChannel::addKeyframe(int time, KUndo2Command *parentCommand)
 {
     LAZY_INITIALIZE_PARENT_COMMAND(parentCommand);
     return insertKeyframe(time, KisKeyframeSP(), parentCommand);
 }
 
 void KisKeyframeChannel::deleteKeyframeLogical(KisKeyframeSP keyframe)
 {
     QRect rect = affectedRect(keyframe);
     KisTimeRange range = affectedFrames(keyframe->time());
 
     emit sigKeyframeAboutToBeRemoved(keyframe.data());
     m_d->keys.remove(keyframe->time());
     emit sigKeyframeRemoved(keyframe.data());
 
     requestUpdate(range, rect);
 }
 
 
 bool KisKeyframeChannel::deleteKeyframeImpl(KisKeyframeSP keyframe, KUndo2Command *parentCommand, bool recreate)
 {
     LAZY_INITIALIZE_PARENT_COMMAND(parentCommand);
 
     Q_ASSERT(parentCommand);
 
     KUndo2Command *cmd = new InsertFrameCommand(this, keyframe, false, parentCommand);
     cmd->redo();
     destroyKeyframe(keyframe, parentCommand);
 
     if (recreate && keyframe->time() == 0) {
         addKeyframe(0, parentCommand);
     }
 
     return true;
 }
 
 bool KisKeyframeChannel::deleteKeyframe(KisKeyframeSP keyframe, KUndo2Command *parentCommand)
 {
     return deleteKeyframeImpl(keyframe, parentCommand, true);
 }
 
 void KisKeyframeChannel::moveKeyframeImpl(KisKeyframeSP keyframe, int newTime)
 {
     KIS_ASSERT_RECOVER_RETURN(keyframe);
     KIS_ASSERT_RECOVER_RETURN(!keyframeAt(newTime));
 
     KisTimeRange rangeSrc = affectedFrames(keyframe->time());
     QRect rectSrc = affectedRect(keyframe);
 
     emit sigKeyframeAboutToBeMoved(keyframe.data(), newTime);
 
     m_d->keys.remove(keyframe->time());
     int oldTime = keyframe->time();
     keyframe->setTime(newTime);
     m_d->keys.insert(newTime, keyframe);
 
     emit sigKeyframeMoved(keyframe.data(), oldTime);
 
     KisTimeRange rangeDst = affectedFrames(keyframe->time());
     QRect rectDst = affectedRect(keyframe);
 
     requestUpdate(rangeSrc, rectSrc);
     requestUpdate(rangeDst, rectDst);
 }
 
 bool KisKeyframeChannel::moveKeyframe(KisKeyframeSP keyframe, int newTime, KUndo2Command *parentCommand)
 {
     LAZY_INITIALIZE_PARENT_COMMAND(parentCommand);
 
     if (newTime == keyframe->time()) return false;
 
     KisKeyframeSP other = keyframeAt(newTime);
     if (other) {
         deleteKeyframeImpl(other, parentCommand, false);
     }
 
     const int srcTime = keyframe->time();
 
     KUndo2Command *cmd = new MoveFrameCommand(this, keyframe, srcTime, newTime, parentCommand);
     cmd->redo();
 
     if (srcTime == 0) {
         addKeyframe(srcTime, parentCommand);
     }
 
     return true;
 }
 
 KisKeyframeSP KisKeyframeChannel::copyKeyframe(const KisKeyframeSP keyframe, int newTime, KUndo2Command *parentCommand)
 {
     LAZY_INITIALIZE_PARENT_COMMAND(parentCommand);
     return insertKeyframe(newTime, keyframe, parentCommand);
 }
 
 KisKeyframeSP KisKeyframeChannel::keyframeAt(int time) const
 {
     KeyframesMap::const_iterator i = m_d->keys.constFind(time);
     if (i != m_d->keys.constEnd()) {
         return i.value();
     }
 
     return KisKeyframeSP();
 }
 
 KisKeyframeSP KisKeyframeChannel::activeKeyframeAt(int time) const
 {
     KeyframesMap::const_iterator i = activeKeyIterator(time);
     if (i != m_d->keys.constEnd()) {
         return i.value();
     }
 
     return KisKeyframeSP();
 }
 
 KisKeyframeSP KisKeyframeChannel::currentlyActiveKeyframe() const
 {
     return activeKeyframeAt(currentTime());
 }
 
 KisKeyframeSP KisKeyframeChannel::firstKeyframe() const
 {
     return keyframeAt(0);
 }
 
 KisKeyframeSP KisKeyframeChannel::nextKeyframe(KisKeyframeSP keyframe) const
 {
     KeyframesMap::const_iterator i = m_d->keys.constFind(keyframe->time());
     if (i == m_d->keys.constEnd()) return KisKeyframeSP(0);
 
     i++;
 
     if (i == m_d->keys.constEnd()) return KisKeyframeSP(0);
     return i.value();
 }
 
 KisKeyframeSP KisKeyframeChannel::previousKeyframe(KisKeyframeSP keyframe) const
 {
     KeyframesMap::const_iterator i = m_d->keys.constFind(keyframe->time());
     if (i == m_d->keys.constBegin() || i == m_d->keys.constEnd()) return KisKeyframeSP(0);
     i--;
 
     return i.value();
 }
 
 KisKeyframeSP KisKeyframeChannel::lastKeyframe() const
 {
     if (m_d->keys.isEmpty()) return KisKeyframeSP(0);
 
     return (m_d->keys.end()-1).value();
 }
 
 int KisKeyframeChannel::framesHash() const
 {
     KeyframesMap::const_iterator it = m_d->keys.constBegin();
     KeyframesMap::const_iterator end = m_d->keys.constEnd();
 
     int hash = 0;
 
     while (it != end) {
         hash += it.key();
         ++it;
     }
 
     return hash;
 }
 
 QSet<int> KisKeyframeChannel::allKeyframeIds() const
 {
     QSet<int> frames;
 
     KeyframesMap::const_iterator it = m_d->keys.constBegin();
     KeyframesMap::const_iterator end = m_d->keys.constEnd();
 
     while (it != end) {
         frames.insert(it.key());
         ++it;
     }
 
     return frames;
 }
 
 KisTimeRange KisKeyframeChannel::affectedFrames(int time) const
 {
     return identicalFrames(time);
 }
 
 KisTimeRange KisKeyframeChannel::identicalFrames(int time) const
 {
     if (m_d->keys.isEmpty()) return KisTimeRange::infinite(0);
 
     KeyframesMap::const_iterator active = activeKeyIterator(time);
     KeyframesMap::const_iterator next;
 
     int from;
 
     if (active == m_d->keys.constEnd()) {
         // No active keyframe, ie. time is before the first keyframe
         from = 0;
         next = m_d->keys.constBegin();
     } else {
         from = active.key();
         next = active + 1;
     }
 
     if (next == m_d->keys.constEnd()) {
         return KisTimeRange::infinite(from);
     } else {
         return KisTimeRange::fromTime(from, next.key() - 1);
     }
 }
 
 int KisKeyframeChannel::keyframeCount() const
 {
     return m_d->keys.count();
 }
 
 int KisKeyframeChannel::keyframeRowIndexOf(KisKeyframeSP keyframe) const
 {
     KeyframesMap::const_iterator it = m_d->keys.constBegin();
     KeyframesMap::const_iterator end = m_d->keys.constEnd();
 
     int row = 0;
 
     for (; it != end; ++it) {
         if (it.value().data() == keyframe) {
             return row;
         }
 
         row++;
     }
 
     return -1;
 }
 
 KisKeyframeSP KisKeyframeChannel::keyframeAtRow(int row) const
 {
     KeyframesMap::const_iterator it = m_d->keys.constBegin();
     KeyframesMap::const_iterator end = m_d->keys.constEnd();
 
     for (; it != end; ++it) {
         if (row <= 0) {
             return it.value();
         }
 
         row--;
     }
 
     return KisKeyframeSP();
 }
 
 int KisKeyframeChannel::keyframeInsertionRow(int time) const
 {
     KeyframesMap::const_iterator it = m_d->keys.constBegin();
     KeyframesMap::const_iterator end = m_d->keys.constEnd();
 
     int row = 0;
 
     for (; it != end; ++it) {
         if (it.value()->time() > time) {
             break;
         }
         row++;
     }
 
     return row;
 }
 
 QDomElement KisKeyframeChannel::toXML(QDomDocument doc, const QString &layerFilename)
 {
     QDomElement channelElement = doc.createElement("channel");
 
     channelElement.setAttribute("name", id());
 
     Q_FOREACH (KisKeyframeSP keyframe, m_d->keys.values()) {
         QDomElement keyframeElement = doc.createElement("keyframe");
         keyframeElement.setAttribute("time", keyframe->time());
 
         saveKeyframe(keyframe, keyframeElement, layerFilename);
 
         channelElement.appendChild(keyframeElement);
     }
 
     return channelElement;
 }
 
 void KisKeyframeChannel::loadXML(const QDomElement &channelNode)
 {
     for (QDomElement keyframeNode = channelNode.firstChildElement(); !keyframeNode.isNull(); keyframeNode = keyframeNode.nextSiblingElement()) {
         if (keyframeNode.nodeName().toUpper() != "KEYFRAME") continue;
 
         KisKeyframeSP keyframe = loadKeyframe(keyframeNode);
 
         m_d->keys.insert(keyframe->time(), keyframe);
     }
 }
 
 KisKeyframeChannel::KeyframesMap& KisKeyframeChannel::keys()
 {
     return m_d->keys;
 }
 
 const KisKeyframeChannel::KeyframesMap& KisKeyframeChannel::constKeys() const
 {
     return m_d->keys;
 }
 
 void KisKeyframeChannel::insertKeyframeLogical(KisKeyframeSP keyframe)
 {
     const int time = keyframe->time();
 
     emit sigKeyframeAboutToBeAdded(keyframe.data());
     m_d->keys.insert(time, keyframe);
     emit sigKeyframeAdded(keyframe.data());
 
     QRect rect = affectedRect(keyframe);
     KisTimeRange range = affectedFrames(time);
     requestUpdate(range, rect);
 }
 
 KisKeyframeSP KisKeyframeChannel::insertKeyframe(int time, const KisKeyframeSP copySrc, KUndo2Command *parentCommand)
 {
     KisKeyframeSP keyframe = keyframeAt(time);
     if (keyframe) {
         deleteKeyframeImpl(keyframe, parentCommand, false);
     }
 
     Q_ASSERT(parentCommand);
     keyframe = createKeyframe(time, copySrc, parentCommand);
 
     KUndo2Command *cmd = new InsertFrameCommand(this, keyframe, true, parentCommand);
     cmd->redo();
 
     return keyframe;
 }
 
 KisKeyframeSP KisKeyframeChannel::copyExternalKeyframe(KisKeyframeChannel *srcChannel, int srcTime, int dstTime, KUndo2Command *parentCommand)
 {
     if (srcChannel->id() != id()) {
         warnKrita << "Cannot copy frames from different ids:" << ppVar(srcChannel->id()) << ppVar(id());
         return KisKeyframeSP();
     }
 
     LAZY_INITIALIZE_PARENT_COMMAND(parentCommand);
 
     KisKeyframeSP dstFrame = keyframeAt(dstTime);
     if (dstFrame) {
         deleteKeyframeImpl(dstFrame, parentCommand, false);
     }
 
     KisKeyframeSP newKeyframe = createKeyframe(dstTime, KisKeyframeSP(), parentCommand);
     uploadExternalKeyframe(srcChannel, srcTime, newKeyframe);
 
     KUndo2Command *cmd = new InsertFrameCommand(this, newKeyframe, true, parentCommand);
     cmd->redo();
 
     return newKeyframe;
 }
 
 KisKeyframeChannel::KeyframesMap::const_iterator
 KisKeyframeChannel::activeKeyIterator(int time) const
 {
     KeyframesMap::const_iterator i = const_cast<const KeyframesMap*>(&m_d->keys)->upperBound(time);
 
     if (i == m_d->keys.constBegin()) return m_d->keys.constEnd();
     return --i;
 }
 
 void KisKeyframeChannel::requestUpdate(const KisTimeRange &range, const QRect &rect)
 {
     if (m_d->node) {
         m_d->node->invalidateFrames(range, rect);
+
+        int currentTime = m_d->defaultBounds->currentTime();
+        if (range.contains(currentTime)) {
+            m_d->node->setDirty(rect);
+        }
     }
 }
 
 int KisKeyframeChannel::currentTime() const
 {
     return m_d->defaultBounds->currentTime();
 }
diff --git a/libs/image/kis_raster_keyframe_channel.cpp b/libs/image/kis_raster_keyframe_channel.cpp
index 951dfb98cd..304336c896 100644
--- a/libs/image/kis_raster_keyframe_channel.cpp
+++ b/libs/image/kis_raster_keyframe_channel.cpp
@@ -1,293 +1,284 @@
 /*
  *  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_raster_keyframe_channel.h"
 #include "kis_node.h"
 #include "kis_dom_utils.h"
 
 #include "kis_global.h"
 #include "kis_paint_device.h"
 #include "kis_paint_device_frames_interface.h"
 #include "kis_time_range.h"
 #include "kundo2command.h"
 #include "kis_onion_skin_compositor.h"
 
 
 struct KisRasterKeyframeChannel::Private
 {
   Private(KisPaintDeviceWSP paintDevice, const QString filenameSuffix)
       : paintDevice(paintDevice),
         filenameSuffix(filenameSuffix),
         onionSkinsEnabled(false)
   {}
 
   KisPaintDeviceWSP paintDevice;
   QMap<int, QString> frameFilenames;
   QString filenameSuffix;
   bool onionSkinsEnabled;
 };
 
 KisRasterKeyframeChannel::KisRasterKeyframeChannel(const KoID &id, const KisPaintDeviceWSP paintDevice, KisDefaultBoundsBaseSP defaultBounds)
     : KisKeyframeChannel(id, defaultBounds),
       m_d(new Private(paintDevice, QString()))
 {
 }
 
 KisRasterKeyframeChannel::KisRasterKeyframeChannel(const KisRasterKeyframeChannel &rhs, const KisNodeWSP newParentNode, const KisPaintDeviceWSP newPaintDevice)
     : KisKeyframeChannel(rhs, newParentNode),
       m_d(new Private(newPaintDevice, rhs.m_d->filenameSuffix))
 {
     KIS_ASSERT_RECOVER_NOOP(&rhs != this);
 
     m_d->frameFilenames = rhs.m_d->frameFilenames;
     m_d->onionSkinsEnabled = rhs.m_d->onionSkinsEnabled;
 }
 
 KisRasterKeyframeChannel::~KisRasterKeyframeChannel()
 {
 }
 
 int KisRasterKeyframeChannel::frameIdAt(int time) const
 {
     KisKeyframeSP key = activeKeyframeAt(time);
     return key->value();
 }
 
 void KisRasterKeyframeChannel::fetchFrame(KisKeyframeSP keyframe, KisPaintDeviceSP targetDevice)
 {
     m_d->paintDevice->framesInterface()->fetchFrame(keyframe->value(), targetDevice);
 }
 
 void KisRasterKeyframeChannel::importFrame(int time, KisPaintDeviceSP sourceDevice, KUndo2Command *parentCommand)
 {
     KisKeyframeSP keyframe = addKeyframe(time, parentCommand);
 
     const int frameId = keyframe->value();
 
     m_d->paintDevice->framesInterface()->uploadFrame(frameId, sourceDevice);
 }
 
 QRect KisRasterKeyframeChannel::frameExtents(KisKeyframeSP keyframe)
 {
     return m_d->paintDevice->framesInterface()->frameBounds(keyframe->value());
 }
 
 QString KisRasterKeyframeChannel::frameFilename(int frameId) const
 {
     return m_d->frameFilenames.value(frameId, QString());
 }
 
 void KisRasterKeyframeChannel::setFilenameSuffix(const QString suffix)
 {
     m_d->filenameSuffix = suffix;
 }
 
 void KisRasterKeyframeChannel::setFrameFilename(int frameId, const QString &filename)
 {
     Q_ASSERT(!m_d->frameFilenames.contains(frameId));
     m_d->frameFilenames.insert(frameId, filename);
 }
 
 QString KisRasterKeyframeChannel::chooseFrameFilename(int frameId, const QString &layerFilename)
 {
     QString filename;
 
     int firstFrame = constKeys().begin().value()->value();
     if (frameId == firstFrame) {
         // Use legacy naming convention for first keyframe
         filename = layerFilename + m_d->filenameSuffix;
     } else {
         filename = layerFilename + m_d->filenameSuffix + ".f" + QString::number(frameId);
     }
 
     setFrameFilename(frameId, filename);
 
     return filename;
 }
 
 
 
 KisKeyframeSP KisRasterKeyframeChannel::createKeyframe(int time, const KisKeyframeSP copySrc, KUndo2Command *parentCommand)
 {
     int srcFrame = (copySrc != 0) ? copySrc->value() : 0;
 
     int frameId = m_d->paintDevice->framesInterface()->createFrame((copySrc != 0), srcFrame, QPoint(), parentCommand);
 
     KisKeyframeSP keyframe(new KisKeyframe(this, time, (quint32)frameId));
 
     return keyframe;
 }
 
 void KisRasterKeyframeChannel::destroyKeyframe(KisKeyframeSP key, KUndo2Command *parentCommand)
 {
     m_d->paintDevice->framesInterface()->deleteFrame(key->value(), parentCommand);
 }
 
 void KisRasterKeyframeChannel::uploadExternalKeyframe(KisKeyframeChannel *srcChannel, int srcTime, KisKeyframeSP dstFrame)
 {
     KisRasterKeyframeChannel *srcRasterChannel = dynamic_cast<KisRasterKeyframeChannel*>(srcChannel);
     KIS_ASSERT_RECOVER_RETURN(srcRasterChannel);
 
     const int srcId = srcRasterChannel->frameIdAt(srcTime);
     const int dstId = dstFrame->value();
 
     m_d->paintDevice->framesInterface()->
         uploadFrame(srcId,
                     dstId,
                     srcRasterChannel->m_d->paintDevice);
 }
 
 QRect KisRasterKeyframeChannel::affectedRect(KisKeyframeSP key)
 {
     KeyframesMap::iterator it = keys().find(key->time());
     QRect rect;
 
     // Calculate changed area as the union of the current and previous keyframe.
     // This makes sure there are no artifacts left over from the previous frame
     // where the new one doesn't cover the area.
 
     if (it == keys().begin()) {
         // Using the *next* keyframe at the start of the timeline avoids artifacts
         // when deleting or moving the first key
         it++;
     } else {
         it--;
     }
 
     if (it != keys().end()) {
         rect = m_d->paintDevice->framesInterface()->frameBounds(it.value()->value());
     }
 
     rect |= m_d->paintDevice->framesInterface()->frameBounds(key->value());
 
     if (m_d->onionSkinsEnabled) {
         const QRect dirtyOnionSkinsRect =
             KisOnionSkinCompositor::instance()->calculateFullExtent(m_d->paintDevice);
         rect |= dirtyOnionSkinsRect;
     }
 
     return rect;
 }
 
-void KisRasterKeyframeChannel::requestUpdate(const KisTimeRange &range, const QRect &rect)
-{
-    KisKeyframeChannel::requestUpdate(range, rect);
-
-    if (range.contains(m_d->paintDevice->defaultBounds()->currentTime())) {
-        m_d->paintDevice->setDirty(rect);
-    }
-}
-
 QDomElement KisRasterKeyframeChannel::toXML(QDomDocument doc, const QString &layerFilename)
 {
     m_d->frameFilenames.clear();
 
     return KisKeyframeChannel::toXML(doc, layerFilename);
 }
 
 void KisRasterKeyframeChannel::loadXML(const QDomElement &channelNode)
 {
     m_d->frameFilenames.clear();
 
     KisKeyframeChannel::loadXML(channelNode);
 }
 
 void KisRasterKeyframeChannel::saveKeyframe(KisKeyframeSP keyframe, QDomElement keyframeElement, const QString &layerFilename)
 {
     int frameId = keyframe->value();
 
     QString filename = frameFilename(frameId);
     if (filename.isEmpty()) {
         filename = chooseFrameFilename(frameId, layerFilename);
     }
     keyframeElement.setAttribute("frame", filename);
 
     QPoint offset = m_d->paintDevice->framesInterface()->frameOffset(frameId);
     KisDomUtils::saveValue(&keyframeElement, "offset", offset);
 }
 
 KisKeyframeSP KisRasterKeyframeChannel::loadKeyframe(const QDomElement &keyframeNode)
 {
     int time = keyframeNode.attribute("time").toUInt();
 
     QPoint offset;
     KisDomUtils::loadValue(keyframeNode, "offset", &offset);
     QString frameFilename = keyframeNode.attribute("frame");
 
     KisKeyframeSP keyframe;
 
     if (m_d->frameFilenames.isEmpty()) {
         // First keyframe loaded: use the existing frame
 
         Q_ASSERT(keyframeCount() == 1);
         keyframe = constKeys().begin().value();
 
         // Remove from keys. It will get reinserted with new time once we return
         keys().remove(keyframe->time());
 
         keyframe->setTime(time);
         m_d->paintDevice->move(offset);
     } else {
         KUndo2Command tempCommand;
         int frameId = m_d->paintDevice->framesInterface()->createFrame(false, 0, offset, &tempCommand);
 
         keyframe = toQShared(new KisKeyframe(this, time, frameId));
     }
 
     setFrameFilename(keyframe->value(), frameFilename);
 
     return keyframe;
 }
 
 bool KisRasterKeyframeChannel::hasScalarValue() const
 {
     return false;
 }
 
 qreal KisRasterKeyframeChannel::minScalarValue() const
 {
     return 0;
 }
 
 qreal KisRasterKeyframeChannel::maxScalarValue() const
 {
     return 0;
 }
 
 qreal KisRasterKeyframeChannel::scalarValue(const KisKeyframeSP keyframe) const
 {
     Q_UNUSED(keyframe);
 
     return 0;
 }
 
 void KisRasterKeyframeChannel::setScalarValue(KisKeyframeSP keyframe, qreal value, KUndo2Command *parentCommand)
 {
     Q_UNUSED(keyframe);
     Q_UNUSED(value);
     Q_UNUSED(parentCommand);
 }
 
 void KisRasterKeyframeChannel::setOnionSkinsEnabled(bool value)
 {
     m_d->onionSkinsEnabled = value;
 }
 
 bool KisRasterKeyframeChannel::onionSkinsEnabled() const
 {
     return m_d->onionSkinsEnabled;
 }
diff --git a/libs/image/kis_raster_keyframe_channel.h b/libs/image/kis_raster_keyframe_channel.h
index a983b5230c..f861254975 100644
--- a/libs/image/kis_raster_keyframe_channel.h
+++ b/libs/image/kis_raster_keyframe_channel.h
@@ -1,95 +1,94 @@
 /*
  *  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_RASTER_KEYFRAME_CHANNEL_H
 #define _KIS_RASTER_KEYFRAME_CHANNEL_H
 
 #include "kis_keyframe_channel.h"
 
 class KRITAIMAGE_EXPORT KisRasterKeyframeChannel : public KisKeyframeChannel
 {
     Q_OBJECT
 
 public:
     KisRasterKeyframeChannel(const KoID& id, const KisPaintDeviceWSP paintDevice, KisDefaultBoundsBaseSP defaultBounds);
     KisRasterKeyframeChannel(const KisRasterKeyframeChannel &rhs, const KisNodeWSP newParentNode, const KisPaintDeviceWSP newPaintDevice);
     ~KisRasterKeyframeChannel();
 
 public:
     /**
      * Return the ID of the active frame at a given time. The active frame is
      * defined by the keyframe at the given time or the last keyframe before it.
      * @param time
      * @return active frame id
      */
     int frameIdAt(int time) const;
 
     /**
      * Copy the active frame at given time to target device.
      * @param keyframe keyframe to copy from
      * @param targetDevice device to copy the frame to
      */
     void fetchFrame(KisKeyframeSP keyframe, KisPaintDeviceSP targetDevice);
 
     /**
      * Copy the content of the sourceDevice into a new keyframe at given time
      * @param time position of new keyframe
      * @param sourceDevice source for content
      */
     void importFrame(int time, KisPaintDeviceSP sourceDevice, KUndo2Command *parentCommand);
 
     QRect frameExtents(KisKeyframeSP keyframe);
 
     QString frameFilename(int frameId) const;
 
     /**
      * When choosing filenames for frames, this will be appended to the node filename
      */
     void setFilenameSuffix(const QString suffix);
 
     bool hasScalarValue() const;
     qreal minScalarValue() const;
     qreal maxScalarValue() const;
     qreal scalarValue(const KisKeyframeSP keyframe) const;
     void setScalarValue(KisKeyframeSP keyframe, qreal value, KUndo2Command *parentCommand);
 
     QDomElement toXML(QDomDocument doc, const QString &layerFilename);
     void loadXML(const QDomElement &channelNode);
 
     void setOnionSkinsEnabled(bool value);
     bool onionSkinsEnabled() const;
 
 protected:
     KisKeyframeSP createKeyframe(int time, const KisKeyframeSP copySrc, KUndo2Command *parentCommand);
     void destroyKeyframe(KisKeyframeSP key, KUndo2Command *parentCommand);
     void uploadExternalKeyframe(KisKeyframeChannel *srcChannel, int srcTime, KisKeyframeSP dstFrame);
 
     QRect affectedRect(KisKeyframeSP key);
-    void requestUpdate(const KisTimeRange &range, const QRect &rect);
 
     void saveKeyframe(KisKeyframeSP keyframe, QDomElement keyframeElement, const QString &layerFilename);
     KisKeyframeSP loadKeyframe(const QDomElement &keyframeNode);
 
 private:
     void setFrameFilename(int frameId, const QString &filename);
     QString chooseFrameFilename(int frameId, const QString &layerFilename);
 
     struct Private;
     QScopedPointer<Private> m_d;
 };
 
 #endif
diff --git a/libs/image/kis_scalar_keyframe_channel.cpp b/libs/image/kis_scalar_keyframe_channel.cpp
index 48292972c9..4984589f55 100644
--- a/libs/image/kis_scalar_keyframe_channel.cpp
+++ b/libs/image/kis_scalar_keyframe_channel.cpp
@@ -1,215 +1,220 @@
 /*
  *  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_scalar_keyframe_channel.h"
 #include "kis_node.h"
 #include "kundo2command.h"
 #include "kis_time_range.h"
 
 #include "kis_global.h"
 
 
 struct KisScalarKeyframeChannel::Private
 {
 public:
     Private(qreal min, qreal max)
         : minValue(min), maxValue(max), firstFreeIndex(0)
     {}
 
     qreal minValue;
     qreal maxValue;
     QMap<int, qreal> values;
     int firstFreeIndex;
 
     struct InsertValueCommand;
     struct SetValueCommand;
 };
 
 KisScalarKeyframeChannel::KisScalarKeyframeChannel(const KoID &id, qreal minValue, qreal maxValue, KisDefaultBoundsBaseSP defaultBounds)
     : KisKeyframeChannel(id, defaultBounds),
       m_d(new Private(minValue, maxValue))
 {
 }
 
 KisScalarKeyframeChannel::~KisScalarKeyframeChannel()
 {}
 
 bool KisScalarKeyframeChannel::hasScalarValue() const
 {
     return true;
 }
 
 qreal KisScalarKeyframeChannel::minScalarValue() const
 {
     return m_d->minValue;
 }
 
 qreal KisScalarKeyframeChannel::maxScalarValue() const
 {
     return m_d->maxValue;
 }
 
 qreal KisScalarKeyframeChannel::scalarValue(const KisKeyframeSP keyframe) const
 {
     return m_d->values[keyframe->value()];
 }
 
 struct KisScalarKeyframeChannel::Private::SetValueCommand : public KUndo2Command
 {
     SetValueCommand(KisScalarKeyframeChannel *channel, KisKeyframeSP keyframe, qreal oldValue, qreal newValue, KUndo2Command *parentCommand)
         : KUndo2Command(parentCommand),
           m_channel(channel),
           m_keyframe(keyframe),
           m_oldValue(oldValue),
           m_newValue(newValue)
     {
     }
 
     void redo() {
         m_channel->setScalarValueImpl(m_keyframe, m_newValue);
     }
 
     void undo() {
         m_channel->setScalarValueImpl(m_keyframe, m_oldValue);
     }
 
 private:
     KisScalarKeyframeChannel *m_channel;
     KisKeyframeSP m_keyframe;
     qreal m_oldValue;
     qreal m_newValue;
 };
 
 void KisScalarKeyframeChannel::setScalarValueImpl(KisKeyframeSP keyframe, qreal value)
 {
     int index = keyframe->value();
     m_d->values[index] = value;
 
     QRect rect = affectedRect(keyframe);
     KisTimeRange range = affectedFrames(keyframe->time());
 
     requestUpdate(range, rect);
 }
 
 void KisScalarKeyframeChannel::setScalarValue(KisKeyframeSP keyframe, qreal value, KUndo2Command *parentCommand)
 {
     QScopedPointer<KUndo2Command> tempCommand;
     if (!parentCommand) {
         tempCommand.reset(new KUndo2Command());
         parentCommand = tempCommand.data();
     }
 
     int index = keyframe->value();
     KUndo2Command *cmd = new Private::SetValueCommand(this, keyframe, m_d->values[index], value, parentCommand);
     cmd->redo();
 }
 
 struct KisScalarKeyframeChannel::Private::InsertValueCommand : public KUndo2Command
 {
     InsertValueCommand(KisScalarKeyframeChannel::Private *d, int index, qreal value, bool insert, KUndo2Command *parentCommand)
         : KUndo2Command(parentCommand),
           m_d(d),
           m_index(index),
           m_value(value),
           m_insert(insert)
     {
     }
 
     void redo() {
         doSwap(m_insert);
     }
 
     void undo() {
         doSwap(!m_insert);
     }
 
 private:
     void doSwap(bool insert) {
         if (insert) {
             m_d->values[m_index] = m_value;
         } else {
             m_d->values.remove(m_index);
         }
     }
 
 private:
     KisScalarKeyframeChannel::Private *m_d;
     int m_index;
     qreal m_value;
     bool m_insert;
 };
 
 KisKeyframeSP KisScalarKeyframeChannel::createKeyframe(int time, const KisKeyframeSP copySrc, KUndo2Command *parentCommand)
 {
     qreal value = (copySrc.isNull() ? 0 : scalarValue(copySrc));
     int index = m_d->firstFreeIndex++;
 
     KUndo2Command *cmd = new Private::InsertValueCommand(m_d.data(), index, value, true, parentCommand);
     cmd->redo();
 
     return toQShared(new KisKeyframe(this, time, index));
 }
 
 void KisScalarKeyframeChannel::destroyKeyframe(KisKeyframeSP key, KUndo2Command *parentCommand)
 {
     int index = key->value();
 
     KIS_ASSERT_RECOVER_RETURN(m_d->values.contains(index));
 
     KUndo2Command *cmd = new Private::InsertValueCommand(m_d.data(), index, m_d->values[index], false, parentCommand);
     cmd->redo();
 }
 
 void KisScalarKeyframeChannel::uploadExternalKeyframe(KisKeyframeChannel *srcChannel, int srcTime, KisKeyframeSP dstFrame)
 {
     KisScalarKeyframeChannel *srcScalarChannel = dynamic_cast<KisScalarKeyframeChannel*>(srcChannel);
     KIS_ASSERT_RECOVER_RETURN(srcScalarChannel);
 
     KisKeyframeSP srcFrame = srcScalarChannel->keyframeAt(srcTime);
     KIS_ASSERT_RECOVER_RETURN(srcFrame);
 
     const qreal newValue = scalarValue(srcFrame);
 
     const int dstId = dstFrame->value();
     KIS_ASSERT_RECOVER_RETURN(m_d->values.contains(dstId));
     m_d->values[dstId] = newValue;
 }
 
 QRect KisScalarKeyframeChannel::affectedRect(KisKeyframeSP key)
 {
     Q_UNUSED(key);
-    return QRect();
+
+    if (node()) {
+        return node()->extent();
+    } else {
+        return QRect();
+    }
 }
 
 void KisScalarKeyframeChannel::saveKeyframe(KisKeyframeSP keyframe, QDomElement keyframeElement, const QString &layerFilename)
 {
     Q_UNUSED(layerFilename);
     keyframeElement.setAttribute("value", m_d->values[keyframe->value()]);
 }
 
 KisKeyframeSP KisScalarKeyframeChannel::loadKeyframe(const QDomElement &keyframeNode)
 {
     int time = keyframeNode.toElement().attribute("time").toUInt();
     QVariant value = keyframeNode.toElement().attribute("value");
 
     KUndo2Command tempParentCommand;
     KisKeyframeSP keyframe = createKeyframe(time, KisKeyframeSP(), &tempParentCommand);
     setScalarValue(keyframe, value.toReal());
 
     return keyframe;
 }