diff --git a/libs/image/kis_keyframe_channel.cpp b/libs/image/kis_keyframe_channel.cpp
index b8e4157aa6..4a85b6a2a4 100644
--- a/libs/image/kis_keyframe_channel.cpp
+++ b/libs/image/kis_keyframe_channel.cpp
@@ -1,964 +1,1045 @@
 /*
  *  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 "kis_keyframe_commands.h"
 #include "kis_animation_cycle.h"
 
 #include <QMap>
 
 const KoID KisKeyframeChannel::Content = KoID("content", ki18n("Content"));
 const KoID KisKeyframeChannel::Opacity = KoID("opacity", ki18n("Opacity"));
 const KoID KisKeyframeChannel::TransformArguments = KoID("transform_arguments", ki18n("Transform"));
 const KoID KisKeyframeChannel::TransformPositionX = KoID("transform_pos_x", ki18n("Position (X)"));
 const KoID KisKeyframeChannel::TransformPositionY = KoID("transform_pos_y", ki18n("Position (Y)"));
 const KoID KisKeyframeChannel::TransformScaleX = KoID("transform_scale_x", ki18n("Scale (X)"));
 const KoID KisKeyframeChannel::TransformScaleY = KoID("transform_scale_y", ki18n("Scale (Y)"));
 const KoID KisKeyframeChannel::TransformShearX = KoID("transform_shear_x", ki18n("Shear (X)"));
 const KoID KisKeyframeChannel::TransformShearY = KoID("transform_shear_y", ki18n("Shear (Y)"));
 const KoID KisKeyframeChannel::TransformRotationX = KoID("transform_rotation_x", ki18n("Rotation (X)"));
 const KoID KisKeyframeChannel::TransformRotationY = KoID("transform_rotation_y", ki18n("Rotation (Y)"));
 const KoID KisKeyframeChannel::TransformRotationZ = KoID("transform_rotation_z", ki18n("Rotation (Z)"));
 
+/**
+ * Finds the last item the in the map with a key less than the given one.
+ * Returns map.constEnd() if no such key exists.
+ */
+template<class T>
+typename QMap<int, T>::const_iterator findActive(const QMap<int, T> &map, int maximumKey)
+{
+    typename QMap<int, T>::const_iterator i = map.upperBound(maximumKey);
+    if (i == map.constBegin()) return map.constEnd();
+    return i - 1;
+}
+
+/**
+ * Finds the last item the in the map before the "active" item (see findActive) for the given key.
+ * Returns map.constEnd() if no such key exists.
+ */
+template<class T>
+typename QMap<int, T>::const_iterator findPrevious(const QMap<int, T> &map, int currentKey)
+{
+    typename QMap<int, T>::const_iterator active = findActive(map, currentKey);
+    if (active == map.constEnd()) return map.constEnd();
+
+    if (currentKey > active.key()) return active;
+
+    if (active == map.constBegin()) return map.constEnd();
+    return active - 1;
+}
+
+/**
+ * Finds the first item the in the map with a key greater than the given one.
+ * Returns map.constEnd() if no such key exists.
+ */
+template<class T>
+typename QMap<int, T>::const_iterator findNext(const QMap<int, T> &map, int currentKey)
+{
+    return map.upperBound(currentKey);
+}
+
 struct KisKeyframeChannel::Private
 {
     Private() {}
     Private(const Private &rhs, KisNodeWSP newParentNode) {
         node = newParentNode;
         id = rhs.id;
         defaultBounds = rhs.defaultBounds;
         haveBrokenFrameTimeBug = rhs.haveBrokenFrameTimeBug;
     }
 
     KeyframesMap keys;
     QMap<int, QSharedPointer<KisAnimationCycle>> cycles;
     QMap<int, QSharedPointer<KisRepeatFrame>> repeats;
     KisNodeWSP node;
     KoID id;
     KisDefaultBoundsBaseSP defaultBounds;
     bool haveBrokenFrameTimeBug = false;
 
     void add(KisKeyframeBaseSP item) {
         auto repeat = item.dynamicCast<KisRepeatFrame>();
         if (repeat) {
             repeat->cycle()->addRepeat(repeat);
             repeats.insert(repeat->time(), repeat);
         } else {
             auto keyframe = item.dynamicCast<KisKeyframe>();
             KIS_ASSERT_RECOVER_RETURN(keyframe);
             keys.insert(item->time(), keyframe);
         }
     }
 
     void remove(KisKeyframeBaseSP item) {
         auto repeat = item.dynamicCast<KisRepeatFrame>();
         if (repeat) {
             repeat->cycle()->removeRepeat(repeat);
             repeats.remove(repeat->time());
         } else {
             keys.remove(item->time());
         }
     }
 
-    void moveKeyframe(KisKeyframeSP keyframe, int newTime) {
+    void moveKeyframe(KisKeyframeBaseSP keyframe, int newTime) {
+        const QSharedPointer<KisAnimationCycle> cycle = cycles.value(keyframe->time());
+
         remove(keyframe);
         keyframe->setTime(newTime);
         add(keyframe);
+
+        if (cycle) {
+            KIS_SAFE_ASSERT_RECOVER_NOOP(newTime < cycle->lastSourceKeyframe()->time()); // TODO: make sure this is the case
+
+            cycles.remove(cycle->time());
+            cycle->setTime(newTime);
+            cycles.insert(newTime, cycle);
+        }
     }
 
     void addCycle(QSharedPointer<KisAnimationCycle> cycle) {
         cycles.insert(cycle->time(), cycle);
     }
 
     void removeCycle(QSharedPointer<KisAnimationCycle> cycle) {
         KIS_SAFE_ASSERT_RECOVER_NOOP(cycle->repeats().isEmpty());
         cycles.remove(cycle->time());
     }
 };
 
 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, KisNode *newParentNode)
     : m_d(new Private(*rhs.m_d, newParentNode))
 {
     KIS_ASSERT_RECOVER_NOOP(&rhs != this);
 
     Q_FOREACH(KisKeyframeSP keyframe, rhs.m_d->keys) {
         const KisKeyframeSP clone = keyframe->cloneFor(this);
             m_d->add(clone);
     }
 
     Q_FOREACH(const QSharedPointer<KisAnimationCycle> rhsCycle, rhs.m_d->cycles) {
         KisKeyframeSP firstFrame = keyframeAt(rhsCycle->firstSourceKeyframe()->time());
         KisKeyframeSP lastFrame = keyframeAt(rhsCycle->lastSourceKeyframe()->time());
 
         QSharedPointer<KisAnimationCycle> cycle = toQShared(new KisAnimationCycle(this, firstFrame, lastFrame));
         m_d->addCycle(cycle);
 
         Q_FOREACH(auto rhsRepeatWP, rhsCycle->repeats()) {
             const QSharedPointer<KisRepeatFrame> rhsRepeat = rhsRepeatWP.toStrongRef();
             if (rhsRepeat) {
                 m_d->add(toQShared(new KisRepeatFrame(this, rhsRepeat->time(), cycle)));
             }
         }
 
     }
 }
 
 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;
 }
 
 int KisKeyframeChannel::keyframeCount() const
 {
     return m_d->keys.count();
 }
 
 KisKeyframeChannel::KeyframesMap& KisKeyframeChannel::keys()
 {
     return m_d->keys;
 }
 
 const KisKeyframeChannel::KeyframesMap& KisKeyframeChannel::constKeys() const
 {
     return m_d->keys;
 }
 
 #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);
 }
 
 KisKeyframeSP KisKeyframeChannel::copyKeyframe(const KisKeyframeSP keyframe, int newTime, KUndo2Command *parentCommand)
 {
     LAZY_INITIALIZE_PARENT_COMMAND(parentCommand);
     return insertKeyframe(newTime, keyframe, parentCommand);
 }
 
-KisKeyframeSP KisKeyframeChannel::linkKeyframe(const KisKeyframeSP, int, KUndo2Command*) {
+KisKeyframeBaseSP KisKeyframeChannel::copyItem(const KisKeyframeBaseSP item, int newTime, KUndo2Command *parentCommand)
+{
+    LAZY_INITIALIZE_PARENT_COMMAND(parentCommand);
+    return insertKeyframe(newTime, item, parentCommand);
+}
+
+KisKeyframeSP KisKeyframeChannel::copyAsKeyframe(const KisKeyframeBaseSP item, int originalTime, int newTime, KUndo2Command *parentCommand)
+{
+    LAZY_INITIALIZE_PARENT_COMMAND(parentCommand);
+
+    KisKeyframeSP keyframe = item->getOriginalKeyframeFor(originalTime);
+    return insertKeyframe(newTime, keyframe, parentCommand);
+}
+
+KisKeyframeSP KisKeyframeChannel::linkKeyframe(const KisKeyframeBaseSP, int, KUndo2Command*) {
     return KisKeyframeSP();
 }
 
-KisKeyframeSP KisKeyframeChannel::insertKeyframe(int time, const KisKeyframeSP copySrc, KUndo2Command *parentCommand)
+KisKeyframeSP KisKeyframeChannel::insertKeyframe(int time, const KisKeyframeBaseSP copySrc, KUndo2Command *parentCommand)
 {
-    KisKeyframeSP keyframe = keyframeAt(time);
-    if (keyframe) {
-        deleteKeyframeImpl(keyframe, parentCommand, false);
+    KisKeyframeBaseSP oldItem = itemAt(time);
+    if (oldItem) {
+        deleteKeyframeImpl(oldItem, parentCommand, false);
     }
 
     Q_ASSERT(parentCommand);
-    keyframe = createKeyframe(time, copySrc, parentCommand);
+    KisKeyframeSP sourceKeyframe = copySrc ? copySrc->getOriginalKeyframeFor(copySrc->time()) : KisKeyframeSP();
+    KisKeyframeSP keyframe = createKeyframe(time, sourceKeyframe, parentCommand);
 
     KUndo2Command *cmd = new KisReplaceKeyframeCommand(this, keyframe->time(), keyframe, parentCommand);
     cmd->redo();
 
     return keyframe;
 }
 
-bool KisKeyframeChannel::deleteKeyframe(KisKeyframeSP keyframe, KUndo2Command *parentCommand)
+bool KisKeyframeChannel::deleteKeyframe(KisKeyframeBaseSP keyframe, KUndo2Command *parentCommand)
 {
     return deleteKeyframeImpl(keyframe, parentCommand, true);
 }
 
-bool KisKeyframeChannel::moveKeyframe(KisKeyframeSP keyframe, int newTime, KUndo2Command *parentCommand)
+bool KisKeyframeChannel::moveKeyframe(KisKeyframeBaseSP keyframe, int newTime, KUndo2Command *parentCommand)
 {
     LAZY_INITIALIZE_PARENT_COMMAND(parentCommand);
 
     if (newTime == keyframe->time()) return false;
 
-    KisKeyframeSP other = keyframeAt(newTime);
+    KisKeyframeBaseSP other = itemAt(newTime);
     if (other) {
         deleteKeyframeImpl(other, parentCommand, false);
     }
 
     const int srcTime = keyframe->time();
 
     KUndo2Command *cmd = new KisMoveFrameCommand(this, keyframe, srcTime, newTime, parentCommand);
     cmd->redo();
 
     if (srcTime == 0) {
         addKeyframe(srcTime, parentCommand);
     }
 
     return true;
 }
 
 bool KisKeyframeChannel::swapFrames(int lhsTime, int rhsTime, KUndo2Command *parentCommand)
 {
     LAZY_INITIALIZE_PARENT_COMMAND(parentCommand);
 
     if (lhsTime == rhsTime) return false;
 
-    KisKeyframeSP lhsFrame = keyframeAt(lhsTime);
-    KisKeyframeSP rhsFrame = keyframeAt(rhsTime);
+    KisKeyframeBaseSP lhsFrame = itemAt(lhsTime);
+    KisKeyframeBaseSP rhsFrame = itemAt(rhsTime);
 
     if (!lhsFrame && !rhsFrame) return false;
 
     if (lhsFrame && !rhsFrame) {
         moveKeyframe(lhsFrame, rhsTime, parentCommand);
     } else if (!lhsFrame && rhsFrame) {
         moveKeyframe(rhsFrame, lhsTime, parentCommand);
     } else {
         KUndo2Command *cmd = new KisSwapFramesCommand(this, lhsFrame, rhsFrame, parentCommand);
         cmd->redo();
     }
 
     return true;
 }
 
-bool KisKeyframeChannel::deleteKeyframeImpl(KisKeyframeSP keyframe, KUndo2Command *parentCommand, bool recreate)
+bool KisKeyframeChannel::deleteKeyframeImpl(KisKeyframeBaseSP item, KUndo2Command *parentCommand, bool recreate)
 {
     LAZY_INITIALIZE_PARENT_COMMAND(parentCommand);
 
     Q_ASSERT(parentCommand);
 
-    KUndo2Command *cmd = new KisReplaceKeyframeCommand(this, keyframe->time(), KisKeyframeSP(), parentCommand);
+    KUndo2Command *cmd = new KisReplaceKeyframeCommand(this, item->time(), KisKeyframeSP(), parentCommand);
     cmd->redo();
-    destroyKeyframe(keyframe, parentCommand);
 
-    if (recreate && keyframe->time() == 0) {
-        addKeyframe(0, parentCommand);
+    KisKeyframeSP keyframe = item.dynamicCast<KisKeyframe>();
+    if (keyframe) {
+        destroyKeyframe(keyframe, parentCommand);
+
+        if (recreate && keyframe->time() == 0) {
+            addKeyframe(0, parentCommand);
+        }
     }
 
     return true;
 }
 
-void KisKeyframeChannel::moveKeyframeImpl(KisKeyframeSP keyframe, int newTime)
+void KisKeyframeChannel::moveKeyframeImpl(KisKeyframeBaseSP keyframe, int newTime)
 {
     KIS_ASSERT_RECOVER_RETURN(keyframe);
-    KIS_ASSERT_RECOVER_RETURN(!keyframeAt(newTime));
+    KIS_ASSERT_RECOVER_RETURN(!itemAt(newTime));
 
     KisFrameSet rangeSrc = affectedFrames(keyframe->time());
     QRect rectSrc = keyframe->affectedRect();
 
     emit sigKeyframeAboutToBeMoved(keyframe, newTime);
 
     int oldTime = keyframe->time();
     m_d->moveKeyframe(keyframe, newTime);
     keyframe->setTime(newTime);
 
     emit sigKeyframeMoved(keyframe, oldTime);
 
     KisFrameSet rangeDst = affectedFrames(keyframe->time());
     QRect rectDst = keyframe->affectedRect();
 
     requestUpdate(rangeSrc, rectSrc);
     requestUpdate(rangeDst, rectDst);
 }
 
-void KisKeyframeChannel::swapKeyframesImpl(KisKeyframeSP lhsKeyframe, KisKeyframeSP rhsKeyframe)
+void KisKeyframeChannel::swapKeyframesImpl(KisKeyframeBaseSP lhsKeyframe, KisKeyframeBaseSP rhsKeyframe)
 {
     KIS_ASSERT_RECOVER_RETURN(lhsKeyframe);
     KIS_ASSERT_RECOVER_RETURN(rhsKeyframe);
 
     KisFrameSet rangeLhs = affectedFrames(lhsKeyframe->time());
     KisFrameSet rangeRhs = affectedFrames(rhsKeyframe->time());
 
     const QRect rectLhsSrc = lhsKeyframe->affectedRect();
     const QRect rectRhsSrc = rhsKeyframe->affectedRect();
 
     const int lhsTime = lhsKeyframe->time();
     const int rhsTime = rhsKeyframe->time();
 
     emit sigKeyframeAboutToBeMoved(lhsKeyframe, rhsTime);
     emit sigKeyframeAboutToBeMoved(rhsKeyframe, lhsTime);
 
     m_d->remove(lhsKeyframe);
     m_d->remove(rhsKeyframe);
 
     rhsKeyframe->setTime(lhsTime);
     lhsKeyframe->setTime(rhsTime);
 
     m_d->add(lhsKeyframe);
     m_d->add(rhsKeyframe);
 
     emit sigKeyframeMoved(lhsKeyframe, lhsTime);
     emit sigKeyframeMoved(rhsKeyframe, rhsTime);
 
     const QRect rectLhsDst = lhsKeyframe->affectedRect();
     const QRect rectRhsDst = rhsKeyframe->affectedRect();
 
     requestUpdate(rangeLhs, rectLhsSrc | rectRhsDst);
     requestUpdate(rangeRhs, rectRhsSrc | rectLhsDst);
 }
 
-KisKeyframeSP KisKeyframeChannel::replaceKeyframeAt(int time, KisKeyframeSP newKeyframe)
+KisKeyframeBaseSP KisKeyframeChannel::replaceKeyframeAt(int time, KisKeyframeBaseSP newKeyframe)
 {
     Q_ASSERT(newKeyframe.isNull() || time == newKeyframe->time());
 
-    KisKeyframeSP existingKeyframe = keyframeAt(time);
+    KisKeyframeBaseSP existingKeyframe = itemAt(time);
     if (!existingKeyframe.isNull()) {
         removeKeyframeLogical(existingKeyframe);
     }
 
     if (!newKeyframe.isNull()) {
         insertKeyframeLogical(newKeyframe);
     }
 
     return existingKeyframe;
 }
 
-void KisKeyframeChannel::insertKeyframeLogical(KisKeyframeSP keyframe)
+void KisKeyframeChannel::insertKeyframeLogical(KisKeyframeBaseSP keyframe)
 {
     const int time = keyframe->time();
 
     emit sigKeyframeAboutToBeAdded(keyframe);
     m_d->add(keyframe);
     emit sigKeyframeAdded(keyframe);
 
     QRect rect = keyframe->affectedRect();
     KisFrameSet range = affectedFrames(time);
     requestUpdate(range, rect);
 }
 
-void KisKeyframeChannel::removeKeyframeLogical(KisKeyframeSP keyframe)
+void KisKeyframeChannel::removeKeyframeLogical(KisKeyframeBaseSP keyframe)
 {
     QRect rect = keyframe->affectedRect();
     KisFrameSet range = affectedFrames(keyframe->time());
 
     emit sigKeyframeAboutToBeRemoved(keyframe);
     m_d->remove(keyframe);
     emit sigKeyframeRemoved(keyframe);
 
     requestUpdate(range, rect);
 }
 
 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();
+    return m_d->keys.value(time);
 }
 
 KisKeyframeSP KisKeyframeChannel::activeKeyframeAt(int time) const
 {
-    KeyframesMap::const_iterator i = activeKeyIterator(time);
+    KeyframesMap::const_iterator i = findActive(m_d->keys, time);
     if (i != m_d->keys.constEnd()) {
         return i.value();
     }
 
     return KisKeyframeSP();
 }
 
 KisKeyframeSP KisKeyframeChannel::visibleKeyframeAt(int time) const
 {
-    KisKeyframeSP keyframe = activeKeyframeAt(time);
-    const KisRepeatFrame *repeat = dynamic_cast<KisRepeatFrame*>(keyframe.data());
-
-    if (repeat) keyframe = repeat->getOriginalKeyframeFor(time);
-    return keyframe;
+    const QSharedPointer<KisRepeatFrame> repeat = activeRepeatAt(time);
+    return repeat ? repeat->getOriginalKeyframeFor(time) : activeKeyframeAt(time);
 }
 
 KisKeyframeSP KisKeyframeChannel::currentlyActiveKeyframe() const
 {
     return activeKeyframeAt(currentTime());
 }
 
 KisKeyframeSP KisKeyframeChannel::firstKeyframe() const
 {
     if (m_d->keys.isEmpty()) return KisKeyframeSP();
     return m_d->keys.first();
 }
 
 KisKeyframeSP KisKeyframeChannel::nextKeyframe(KisKeyframeSP keyframe) const
 {
     return nextKeyframe(*keyframe);
 }
 
-KisKeyframeSP KisKeyframeChannel::nextKeyframe(const KisKeyframe &keyframe) const
+KisKeyframeSP KisKeyframeChannel::nextKeyframe(const KisKeyframeBase &keyframe) const
 {
-    KeyframesMap::const_iterator i = m_d->keys.constFind(keyframe.time());
-    if (i == m_d->keys.constEnd()) return KisKeyframeSP(0);
-
-    i++;
-
+    KeyframesMap::const_iterator i = findNext(m_d->keys, keyframe.time());
     if (i == m_d->keys.constEnd()) return KisKeyframeSP(0);
     return i.value();
 }
 
 KisKeyframeSP KisKeyframeChannel::previousKeyframe(KisKeyframeSP keyframe) const
 {
     return previousKeyframe(*keyframe);
 }
 
-KisKeyframeSP KisKeyframeChannel::previousKeyframe(const KisKeyframe &keyframe) const
+KisKeyframeSP KisKeyframeChannel::previousKeyframe(const KisKeyframeBase &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--;
-
+    KeyframesMap::const_iterator i = findPrevious(m_d->keys, keyframe.time());
+    if (i == m_d->keys.constEnd()) return KisKeyframeSP(0);
     return i.value();
 }
 
 KisKeyframeSP KisKeyframeChannel::lastKeyframe() const
 {
     if (m_d->keys.isEmpty()) return KisKeyframeSP(0);
 
     return (m_d->keys.end()-1).value();
 }
 
-KisVisibleKeyframeIterator KisKeyframeChannel::visibleKeyframesFrom(int time) const
+KisKeyframeBaseSP KisKeyframeChannel::itemAt(int time) const
 {
-    return KisVisibleKeyframeIterator(visibleKeyframeAt(time));
+    const KisKeyframeSP keyframe = keyframeAt(time);
+    if (keyframe) return keyframe;
+
+    const QSharedPointer<KisRepeatFrame> repeat = activeRepeatAt(time);
+    if (repeat && time == repeat->time()) return repeat;
+
+    return KisKeyframeBaseSP();
 }
 
-KisTimeSpan KisKeyframeChannel::cycledRangeAt(int time) const
+KisKeyframeBaseSP KisKeyframeChannel::activeItemAt(int time) const
 {
-    QSharedPointer<KisAnimationCycle> cycle = cycleAt(time);
-    if (cycle.isNull()) return KisTimeSpan();
+    const KisKeyframeSP keyframe = activeKeyframeAt(time);
+    if (keyframe) return keyframe;
 
-    const KisKeyframeSP firstAfterCycle = nextKeyframe(cycle->lastSourceKeyframe());
+    return activeRepeatAt(time);
+}
 
-    int start = cycle->firstSourceKeyframe()->time();
+KisKeyframeBaseSP KisKeyframeChannel::nextItem(const KisKeyframeBase &item) const
+{
+    const KisKeyframeSP keyframe = nextKeyframe(item);
 
-    KisTimeSpan originalRange;
-    if (firstAfterCycle.isNull()) {
-        originalRange = KisTimeSpan(start, lastKeyframe()->time());
-    } else {
-        originalRange = KisTimeSpan(start, firstAfterCycle->time() - 1);
-    }
+    auto repeatIter = findNext(m_d->repeats, item.time());
+    const auto repeat = (repeatIter != m_d->repeats.constEnd()) ? repeatIter.value() : QSharedPointer<KisRepeatFrame>();
 
-    if (originalRange.contains(time)) {
-        return originalRange;
-    }
+    if (keyframe && (!repeat || repeat->time() > keyframe->time())) return keyframe;
+
+    return repeat;
+}
+
+KisKeyframeBaseSP KisKeyframeChannel::previousItem(const KisKeyframeBase &item) const
+{
+    const KisKeyframeSP keyframe = previousKeyframe(item);
+
+    auto repeatIter = findPrevious(m_d->repeats, item.time());
+    const auto repeat = (repeatIter != m_d->repeats.constEnd()) ? repeatIter.value() : QSharedPointer<KisRepeatFrame>();
+    if (keyframe && (!repeat || repeat->time() > keyframe->time())) return keyframe;
+
+    return repeat;
+}
+
+KisVisibleKeyframeIterator KisKeyframeChannel::visibleKeyframesFrom(int time) const
+{
+    return KisVisibleKeyframeIterator(visibleKeyframeAt(time));
+}
+
+KisTimeSpan KisKeyframeChannel::cycledRangeAt(int time) const
+{
+    QSharedPointer<KisRepeatFrame> repeat = activeRepeatAt(time);
+    if (repeat) return repeat->cycle()->originalRange();
+
+    QSharedPointer<KisAnimationCycle> cycle = cycleAt(time);
+    if (cycle) return cycle->originalRange();
 
     return KisTimeSpan();
 }
 
 QSharedPointer<KisAnimationCycle> KisKeyframeChannel::cycleAt(int time) const
 {
-    if (!m_d->cycles.isEmpty()) {
-        auto it = m_d->cycles.upperBound(time);
-        if (it != m_d->cycles.begin()) it--;
-            return it.value();
-    }
+    if (m_d->cycles.isEmpty()) return QSharedPointer<KisAnimationCycle>();
+
+    const auto it = findActive(m_d->cycles, time);
+    if (it == m_d->cycles.constEnd()) return QSharedPointer<KisAnimationCycle>();
+
+    const KisKeyframeBaseSP next = nextItem(*it.value()->lastSourceKeyframe());
+    if (next && next->time() <= time) return QSharedPointer<KisAnimationCycle>();
 
-    return QSharedPointer<KisAnimationCycle>();
+    return it.value();
 };
 
+QSharedPointer<KisRepeatFrame> KisKeyframeChannel::activeRepeatAt(int time) const
+{
+    const auto repeat = findActive(m_d->repeats, time);
+    if (repeat == m_d->repeats.constEnd()) return QSharedPointer<KisRepeatFrame>();
+
+    const KisKeyframeSP lastKeyframe = activeKeyframeAt(time);
+    if (lastKeyframe && lastKeyframe->time() > repeat.value()->time()) return QSharedPointer<KisRepeatFrame>();
+
+    return repeat.value();
+}
+
 void KisKeyframeChannel::activeKeyframeRange(int time, int *first, int *last) const
 {
     *first = *last = -1;
 
     const KisKeyframeSP currentKeyframe = activeKeyframeAt(time);
     if (currentKeyframe.isNull()) return;
 
     *first = currentKeyframe->time();
 
     const KisKeyframeSP next = nextKeyframe(currentKeyframe);
     if (!next.isNull()) {
         *last = next->time() - 1;
     }
 }
 
 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;
 }
 
 KisFrameSet KisKeyframeChannel::affectedFrames(int time) const
 {
     if (m_d->keys.isEmpty()) return KisFrameSet::infiniteFrom(0);
 
-    KeyframesMap::const_iterator active = activeKeyIterator(time);
+    KeyframesMap::const_iterator active = findActive(m_d->keys, 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;
     }
 
     KisFrameSet frames;
 
+    QSharedPointer<KisRepeatFrame> repeat = activeRepeatAt(time);
+
+    if (repeat) {
+        const KisKeyframeSP original = repeat->getOriginalKeyframeFor(time);
+        return affectedFrames(original->time());
+    }
+
     QSharedPointer<KisAnimationCycle> cycle = cycleAt(time);
-    if (!cycle.isNull()) {
+    if (cycle) {
         KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(active != m_d->keys.constEnd() && active.value(), KisFrameSet());
-
-        if (cycle->originalRange().contains(time)) {
-            frames = cycle->instancesWithin(active.value(), KisTimeSpan());
-        } else {
-            const KisRepeatFrame *repeat = dynamic_cast<KisRepeatFrame*>(active.value().data());
-            if (repeat) {
-                const KisKeyframeSP original = repeat->getOriginalKeyframeFor(time);
-                return affectedFrames(original->time());
-            }
-        }
+        frames = cycle->instancesWithin(active.value(), KisTimeSpan());
     }
 
     if (next == m_d->keys.constEnd()) {
         frames |= KisFrameSet::infiniteFrom(from);
     } else {
         frames |= KisFrameSet::between(from, next.key() - 1);
     }
 
     return frames;
 }
 
 KisFrameSet KisKeyframeChannel::identicalFrames(int time, const KisTimeSpan range) const
 {
-    KeyframesMap::const_iterator active = activeKeyIterator(time);
+    const QSharedPointer<KisRepeatFrame> repeat = activeRepeatAt(time);
+    if (repeat) {
+        const KisKeyframeSP original = repeat->getOriginalKeyframeFor(time);
+        return identicalFrames(original->time(), range);
+    }
 
-    QSharedPointer<KisAnimationCycle> cycle = cycleAt(time);
-    if (!cycle.isNull()) {
-        if (cycle->originalRange().contains(time)) {
-            return cycle->instancesWithin(active.value(), range);
-        } else {
-            const KisRepeatFrame *repeat = dynamic_cast<KisRepeatFrame*>(active.value().data());
-            if (repeat) {
-                const KisKeyframeSP original = repeat->getOriginalKeyframeFor(time);
-                return identicalFrames(original->time(), range);
-            }
-        }
+    KeyframesMap::const_iterator active = findActive(m_d->keys, time);
+
+    const QSharedPointer<KisAnimationCycle> cycle = cycleAt(time);
+    if (cycle) {
+        return cycle->instancesWithin(active.value(), range);
     }
 
     if (active != m_d->keys.constEnd() && (active+1) != m_d->keys.constEnd()) {
         if (active->data()->interpolationMode() != KisKeyframe::Constant) {
             return KisFrameSet::between(time, time);
         }
     }
 
     return affectedFrames(time);
 }
 
 bool KisKeyframeChannel::areFramesIdentical(int time1, int time2) const
 {
     const KisFrameSet identical = identicalFrames(time1, KisTimeSpan(time2, time2));
     return identical.contains(time2);
 }
 
 bool KisKeyframeChannel::isFrameAffectedBy(int targetFrame, int changedFrame) const
 {
     const KisFrameSet affected = affectedFrames(changedFrame);
     return affected.contains(targetFrame);
 }
 
 QDomElement KisKeyframeChannel::toXML(QDomDocument doc, const QString &layerFilename)
 {
     QDomElement channelElement = doc.createElement("channel");
 
     channelElement.setAttribute("name", id());
 
     Q_FOREACH (const QSharedPointer<KisAnimationCycle> cycle, m_d->cycles.values()) {
         QDomElement cycleElement = doc.createElement("cycle");
         cycleElement.setAttribute("firstKeyframe", cycle->firstSourceKeyframe()->time());
         cycleElement.setAttribute("lastKeyframe", cycle->lastSourceKeyframe()->time());
         channelElement.appendChild(cycleElement);
     }
 
     Q_FOREACH (KisKeyframeSP keyframe, m_d->keys.values()) {
         QDomElement keyframeElement = doc.createElement("keyframe");
         keyframeElement.setAttribute("time", keyframe->time());
         keyframeElement.setAttribute("color-label", keyframe->colorLabel());
 
         KisRepeatFrame *repeat = dynamic_cast<KisRepeatFrame*>(keyframe.data());
         if (repeat) {
             keyframeElement.setAttribute("type", "repeat");
 
             const int sourceTime = repeat->cycle()->firstSourceKeyframe()->time();
             keyframeElement.setAttribute("cycle", sourceTime);
         } else {
             saveKeyframe(keyframe, keyframeElement, layerFilename);
         }
 
         channelElement.appendChild(keyframeElement);
     }
 
     return channelElement;
 }
 
 void KisKeyframeChannel::loadXML(const QDomElement &channelNode)
 {
     QMap<int, QSharedPointer<KisAnimationCycle>> cyclesByFirstKeyframe;
     QMap<int, QSharedPointer<KisAnimationCycle>> cyclesByLastKeyframe;
 
     for (QDomElement childNode = channelNode.firstChildElement(); !childNode.isNull(); childNode = childNode.nextSiblingElement()) {
         const QString nodeName = childNode.nodeName().toUpper();
         if (nodeName == "CYCLE") {
             const int firstKeyframeTime = childNode.attribute("firstKeyframe", "-1").toInt();
             const int lastKeyframeTime = childNode.attribute("lastKeyframe", "-1").toInt();
 
             if (firstKeyframeTime >= 0 && lastKeyframeTime > firstKeyframeTime) {
                 QSharedPointer<KisAnimationCycle> cycle = toQShared(new KisAnimationCycle(this, KisKeyframeSP(), KisKeyframeSP()));
                 cyclesByFirstKeyframe.insert(firstKeyframeTime, cycle);
                 cyclesByLastKeyframe.insert(lastKeyframeTime, cycle);
             }
         }
     }
 
     for (QDomElement childNode = channelNode.firstChildElement(); !childNode.isNull(); childNode = childNode.nextSiblingElement()) {
         const QString nodeName = childNode.nodeName().toUpper();
         if (nodeName == "KEYFRAME") {
             const QString keyframeType = childNode.attribute("type", "").toUpper();
 
             KisKeyframeSP keyframe;
             if (keyframeType == "REPEAT") {
                 // FIXME
                 //keyframe = loadRepeatFrame(childNode, cyclesByFirstKeyframe);
             } else {
                 keyframe = loadKeyframe(childNode);
             }
 
             KIS_SAFE_ASSERT_RECOVER(keyframe) { continue; }
 
             if (childNode.hasAttribute("color-label")) {
                 keyframe->setColorLabel(childNode.attribute("color-label").toUInt());
             }
 
             m_d->add(keyframe);
 
             const int time = keyframe->time();
             if (cyclesByFirstKeyframe.contains(time)) {
                 //cyclesByFirstKeyframe[time]->setFirstKeyframe(keyframe);
                 addCycle(cyclesByFirstKeyframe[time]);
             }
             if (cyclesByLastKeyframe.contains(time)) {
                 //cyclesByLastKeyframe[time]->setLastKeyframe(keyframe);
             }
         }
     }
 }
 
 bool KisKeyframeChannel::swapExternalKeyframe(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 srcFrame = srcChannel->keyframeAt(srcTime);
     KisKeyframeSP dstFrame = keyframeAt(dstTime);
 
     if (!dstFrame && srcFrame) {
         copyExternalKeyframe(srcChannel, srcTime, dstTime, parentCommand);
         srcChannel->deleteKeyframe(srcFrame, parentCommand);
     } else if (dstFrame && !srcFrame) {
         srcChannel->copyExternalKeyframe(this, dstTime, srcTime, parentCommand);
         deleteKeyframe(dstFrame, parentCommand);
     } else if (dstFrame && srcFrame) {
         const int fakeFrameTime = -1;
 
         KisKeyframeSP newKeyframe = createKeyframe(fakeFrameTime, KisKeyframeSP(), parentCommand);
         uploadExternalKeyframe(srcChannel, srcTime, newKeyframe);
 
         srcChannel->copyExternalKeyframe(this, dstTime, srcTime, parentCommand);
 
         // do not recreate frame!
         deleteKeyframeImpl(dstFrame, parentCommand, false);
 
         newKeyframe->setTime(dstTime);
 
         KUndo2Command *cmd = new KisReplaceKeyframeCommand(this, newKeyframe->time(), newKeyframe, parentCommand);
         cmd->redo();
     }
 
     return true;
 }
 
 
 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 KisReplaceKeyframeCommand(this, newKeyframe->time(), newKeyframe, parentCommand);
     cmd->redo();
 
     return newKeyframe;
 }
 
-KUndo2Command * KisKeyframeChannel::createCycle(KisKeyframeSP firstKeyframe, KisKeyframeSP lastKeyframe, KUndo2Command *parentCommand)
+KisDefineCycleCommand * KisKeyframeChannel::createCycle(KisKeyframeSP firstKeyframe, KisKeyframeSP lastKeyframe, KUndo2Command *parentCommand)
 {
     const QSharedPointer<KisAnimationCycle> cycle = toQShared(new KisAnimationCycle(this, firstKeyframe, lastKeyframe));
     return new KisDefineCycleCommand(this, cycle, false, parentCommand);
 }
 
 void KisKeyframeChannel::addCycle(QSharedPointer<KisAnimationCycle> cycle)
 {
-    m_d->cycles.insert(cycle->firstSourceKeyframe()->time(), cycle);
+    m_d->addCycle(cycle);
 }
 
 KUndo2Command* KisKeyframeChannel::deleteCycle(QSharedPointer<KisAnimationCycle> cycle, KUndo2Command *parentCommand)
 {
-    Q_FOREACH(QWeakPointer<KisRepeatFrame> repeat, cycle->repeats()) {
-        auto repeatSP = repeat.toStrongRef();
-        // FIXME! deleteKeyframe(repeatSP, parentCommand);
+    KisDefineCycleCommand *defineCycleCommand = new KisDefineCycleCommand(this, cycle, true, parentCommand);
+
+    // Remove repeats of the cycle
+    Q_FOREACH(QWeakPointer<KisRepeatFrame> repeatWP, cycle->repeats()) {
+        auto repeat = repeatWP.toStrongRef();
+        if (repeat) {
+            deleteKeyframe(repeat);
+        }
     }
 
-    return new KisDefineCycleCommand(this, cycle, true, parentCommand);
+    return defineCycleCommand;
 }
 
 void KisKeyframeChannel::removeCycle(QSharedPointer<KisAnimationCycle> cycle)
 {
-    m_d->cycles.remove(cycle->firstSourceKeyframe()->time());
+    m_d->removeCycle(cycle);
 }
 
-KisKeyframeSP KisKeyframeChannel::addRepeat(int time, KisKeyframeSP source, KUndo2Command *parentCommand)
+QSharedPointer<KisRepeatFrame> KisKeyframeChannel::addRepeat(QSharedPointer<KisAnimationCycle> cycle, int time, KUndo2Command *parentCommand)
 {
-    return KisKeyframeSP();
-
-    /* FIXME
-    const QSharedPointer<KisAnimationCycle> cycle = m_d->cycles.value(source->time());
-    if (cycle.isNull()) return QSharedPointer<KisRepeatFrame>();
-
     const QSharedPointer<KisRepeatFrame> repeatFrame = toQShared(new KisRepeatFrame(this, time, cycle));
     KUndo2Command *cmd = new KisReplaceKeyframeCommand(this, time, repeatFrame, parentCommand);
     cmd->redo();
 
     return repeatFrame;
-    */
-}
-
-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 KisFrameSet &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);
         }
     }
 }
 
 void KisKeyframeChannel::workaroundBrokenFrameTimeBug(int *time)
 {
     /**
      * Between Krita 4.1 and 4.4 Krita had a bug which resulted in creating frames
      * with negative time stamp. The bug has been fixed, but there might be some files
      * still in the wild.
      *
      * TODO: remove this workaround in Krita 5.0, when no such file are left :)
      */
 
     if (*time < 0) {
         qWarning() << "WARNING: Loading a file with negative animation frames!";
         qWarning() << "         The file has been saved with a buggy version of Krita.";
         qWarning() << "         All the frames with negative ids will be dropped!";
         qWarning() << "         " << ppVar(this->id()) << ppVar(*time);
 
         m_d->haveBrokenFrameTimeBug = true;
         *time = 0;
     }
 
     if (m_d->haveBrokenFrameTimeBug) {
         while (keyframeAt(*time)) {
             (*time)++;
         }
     }
 }
 
 int KisKeyframeChannel::currentTime() const
 {
     return m_d->defaultBounds->currentTime();
 }
 
 qreal KisKeyframeChannel::minScalarValue() const
 {
     return 0;
 }
 
 qreal KisKeyframeChannel::maxScalarValue() const
 {
     return 0;
 }
 
 qreal KisKeyframeChannel::scalarValue(const KisKeyframeSP keyframe) const
 {
     Q_UNUSED(keyframe);
 
     return 0;
 }
 
 void KisKeyframeChannel::setScalarValue(KisKeyframeSP keyframe, qreal value, KUndo2Command *parentCommand)
 {
     Q_UNUSED(keyframe);
     Q_UNUSED(value);
     Q_UNUSED(parentCommand);
 }
 
 KisVisibleKeyframeIterator::KisVisibleKeyframeIterator() = default;
 
 KisVisibleKeyframeIterator::KisVisibleKeyframeIterator(KisKeyframeSP keyframe)
     : m_channel(keyframe->channel())
     , m_keyframe(keyframe)
     , m_time(keyframe->time())
 {}
 
 KisVisibleKeyframeIterator& KisVisibleKeyframeIterator::operator--()
 {
-    const KisRepeatFrame *repeat = dynamic_cast<KisRepeatFrame*>(m_keyframe.data());
+    const QSharedPointer<KisRepeatFrame> repeat = m_channel->activeRepeatAt(m_time);
 
     if (repeat) {
         const int time = repeat->previousVisibleFrame(m_time);
         if (time >= 0) {
             m_time = time;
             return *this;
         }
     }
 
     m_keyframe = m_channel->previousKeyframe(*m_keyframe);
     if (!m_keyframe) return invalidate();
 
     m_time = m_keyframe->time();
     return *this;
 }
 
 KisVisibleKeyframeIterator& KisVisibleKeyframeIterator::operator++()
 {
-    const KisRepeatFrame *repeat = dynamic_cast<KisRepeatFrame*>(m_keyframe.data());
+    const QSharedPointer<KisRepeatFrame> repeat = m_channel->activeRepeatAt(m_time);
 
     if (repeat) {
         const int time = repeat->nextVisibleFrame(m_time);
         if (time >= 0) {
             m_time = time;
             return *this;
         }
     }
 
     m_keyframe = m_channel->nextKeyframe(*m_keyframe);
     if (!m_keyframe) return invalidate();
 
     m_time = m_keyframe->time();
 
     return *this;
 };
 
 KisKeyframeSP KisVisibleKeyframeIterator::operator*() const
 {
     const KisRepeatFrame *repeat = dynamic_cast<KisRepeatFrame*>(m_keyframe.data());
 
     if (repeat) {
         return repeat->getOriginalKeyframeFor(m_time);
     }
 
     return m_keyframe;
 }
 
 KisKeyframeSP KisVisibleKeyframeIterator::operator->() const
 {
     return operator*();
 }
 
 bool KisVisibleKeyframeIterator::isValid() const
 {
     return m_channel && m_time >= 0;
 }
 
 KisVisibleKeyframeIterator& KisVisibleKeyframeIterator::invalidate()
 {
     m_channel = nullptr;
     m_keyframe = KisKeyframeSP();
     m_time = -1;
 
     return *this;
 }
diff --git a/libs/image/kis_keyframe_channel.h b/libs/image/kis_keyframe_channel.h
index a143e93d1e..c8412c8cb3 100644
--- a/libs/image/kis_keyframe_channel.h
+++ b/libs/image/kis_keyframe_channel.h
@@ -1,220 +1,236 @@
 /*
  *  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_KEYFRAME_CHANNEL_H
 #define KIS_KEYFRAME_CHANNEL_H
 
 #include <QVariant>
 #include <QDomElement>
 #include <kundo2command.h>
 
 #include "kis_types.h"
 #include "KoID.h"
 #include "kritaimage_export.h"
 #include "kis_keyframe.h"
 #include "kis_default_bounds.h"
 
 class KisFrameSet;
 class KisTimeSpan;
 class KisAnimationCycle;
 class KisRepeatFrame;
 class KisVisibleKeyframeIterator;
+class KisDefineCycleCommand;
 
 class KRITAIMAGE_EXPORT KisKeyframeChannel : public QObject
 {
     Q_OBJECT
 
 public:
     // Standard Keyframe Ids
 
     static const KoID Content;
     static const KoID Opacity;
     static const KoID TransformArguments;
     static const KoID TransformPositionX;
     static const KoID TransformPositionY;
 
     static const KoID TransformScaleX;
     static const KoID TransformScaleY;
     static const KoID TransformShearX;
     static const KoID TransformShearY;
     static const KoID TransformRotationX;
     static const KoID TransformRotationY;
     static const KoID TransformRotationZ;
 public:
     KisKeyframeChannel(const KoID& id, KisDefaultBoundsBaseSP defaultBounds);
     KisKeyframeChannel(const KisKeyframeChannel &rhs, KisNode *newParentNode);
     ~KisKeyframeChannel() override;
 
     QString id() const;
     QString name() const;
 
     void setNode(KisNodeWSP node);
     KisNodeWSP node() const;
 
     KisKeyframeSP addKeyframe(int time, KUndo2Command *parentCommand = 0);
-    bool deleteKeyframe(KisKeyframeSP keyframe, KUndo2Command *parentCommand = 0);
-    bool moveKeyframe(KisKeyframeSP keyframe, int newTime, KUndo2Command *parentCommand = 0);
+    bool deleteKeyframe(KisKeyframeBaseSP keyframe, KUndo2Command *parentCommand = 0);
+    bool moveKeyframe(KisKeyframeBaseSP keyframe, int newTime, KUndo2Command *parentCommand = 0);
     bool swapFrames(int lhsTime, int rhsTime, KUndo2Command *parentCommand = 0);
+    KisKeyframeBaseSP copyItem(const KisKeyframeBaseSP item, int newTime, KUndo2Command *parentCommand = 0);
     KisKeyframeSP copyKeyframe(const KisKeyframeSP keyframe, int newTime, KUndo2Command *parentCommand = 0);
-    virtual KisKeyframeSP linkKeyframe(const KisKeyframeSP keyframe, int newTime, KUndo2Command *parentCommand = 0);
+    KisKeyframeSP copyAsKeyframe(const KisKeyframeBaseSP item, int originalTime, int newTime, KUndo2Command *parentCommand = 0);
+    virtual KisKeyframeSP linkKeyframe(const KisKeyframeBaseSP keyframe, int newTime, KUndo2Command *parentCommand = 0);
     KisKeyframeSP copyExternalKeyframe(KisKeyframeChannel *srcChannel, int srcTime, int dstTime, KUndo2Command *parentCommand = 0);
-    KUndo2Command * createCycle(KisKeyframeSP firstKeyframe, KisKeyframeSP lastKeyframe, KUndo2Command *parentCommand = 0);
+
+    KisDefineCycleCommand * createCycle(KisKeyframeSP firstKeyframe, KisKeyframeSP lastKeyframe, KUndo2Command *parentCommand = 0);
     KUndo2Command * deleteCycle(QSharedPointer<KisAnimationCycle> cycle, KUndo2Command *parentCommand = 0);
-    KisKeyframeSP addRepeat(int time, KisKeyframeSP source, KUndo2Command *parentCommand = 0);
+    QSharedPointer<KisRepeatFrame> addRepeat(QSharedPointer<KisAnimationCycle> cycle, int time, KUndo2Command *parentCommand);
 
     bool swapExternalKeyframe(KisKeyframeChannel *srcChannel, int srcTime, int dstTime, KUndo2Command *parentCommand = 0);
 
     KisKeyframeSP keyframeAt(int time) const;
     KisKeyframeSP activeKeyframeAt(int time) const;
     KisKeyframeSP visibleKeyframeAt(int time) const;
     KisKeyframeSP currentlyActiveKeyframe() const;
 
     KisKeyframeSP firstKeyframe() const;
     KisKeyframeSP nextKeyframe(KisKeyframeSP keyframe) const;
     KisKeyframeSP previousKeyframe(KisKeyframeSP keyframe) const;
-    KisKeyframeSP nextKeyframe(const KisKeyframe &keyframe) const;
-    KisKeyframeSP previousKeyframe(const KisKeyframe &keyframe) const;
+    KisKeyframeSP nextKeyframe(const KisKeyframeBase &keyframe) const;
+    KisKeyframeSP previousKeyframe(const KisKeyframeBase &keyframe) const;
     KisKeyframeSP lastKeyframe() const;
 
+    KisKeyframeBaseSP itemAt(int time) const;
+    KisKeyframeBaseSP activeItemAt(int time) const;
+    KisKeyframeBaseSP nextItem(const KisKeyframeBase &item) const;
+    KisKeyframeBaseSP previousItem(const KisKeyframeBase &item) const;
+
     KisVisibleKeyframeIterator visibleKeyframesFrom(int time) const;
 
     /**
      * Finds the original range of the cycle defined or repeated at the given time.
      * @arg time a time at any frame within the original cycle or any repeat of it.
      */
     KisTimeSpan cycledRangeAt(int time) const;
+
+    /**
+     * Finds the cycle defined at time, if any.
+     * @arg time a time within the original range of the cycle.
+     */
     QSharedPointer<KisAnimationCycle> cycleAt(int time) const;
 
+    /**
+     * Finds the repeat of a cycle at the time, if any.
+     */
+    QSharedPointer<KisRepeatFrame> activeRepeatAt(int time) const;
+
     /**
      * Finds the span of time of the keyframe active at given time.
      * If there is no active keyframe, first will be -1.
      * If the keyframe continues indefinitely, last will be -1.
      */
     void activeKeyframeRange(int time, int *first, int *last) const;
 
     /**
      * Calculates a pseudo-unique keyframes hash. The hash changes
      * every time any frame is added/removed/moved
      */
     int framesHash() const;
 
     QSet<int> allKeyframeIds() const;
     /**
      * Get the set of frames affected by any changes to the value
      * of the active keyframe at the given time.
      */
     virtual KisFrameSet affectedFrames(int time) const;
 
     /**
      * Get a set of frames for which the channel gives identical
      * results, compared to the given frame.
      *
      * Note: this set may be different than the set of affected frames
      * due to interpolation.
      */
     virtual KisFrameSet identicalFrames(int time, const KisTimeSpan range) const;
     virtual bool areFramesIdentical(int time1, int time2) const;
     virtual bool isFrameAffectedBy(int targetFrame, int changedFrame) const;
 
     int keyframeCount() const;
 
     virtual bool hasScalarValue() const = 0;
     virtual qreal minScalarValue() const;
     virtual qreal maxScalarValue() const;
     virtual qreal scalarValue(const KisKeyframeSP keyframe) const;
     virtual void setScalarValue(KisKeyframeSP keyframe, qreal value, KUndo2Command *parentCommand = 0);
 
     virtual QDomElement toXML(QDomDocument doc, const QString &layerFilename);
     virtual void loadXML(const QDomElement &channelNode);
 
     int currentTime() const;
 
 Q_SIGNALS:
-    void sigKeyframeAboutToBeAdded(KisKeyframeSP keyframe);
-    void sigKeyframeAdded(KisKeyframeSP keyframe);
-    void sigKeyframeAboutToBeRemoved(KisKeyframeSP keyframe);
-    void sigKeyframeRemoved(KisKeyframeSP keyframe);
-    void sigKeyframeAboutToBeMoved(KisKeyframeSP keyframe, int toTime);
-    void sigKeyframeMoved(KisKeyframeSP keyframe, int fromTime);
-    void sigKeyframeChanged(KisKeyframeSP keyframe);
+    void sigKeyframeAboutToBeAdded(KisKeyframeBaseSP keyframe);
+    void sigKeyframeAdded(KisKeyframeBaseSP keyframe);
+    void sigKeyframeAboutToBeRemoved(KisKeyframeBaseSP keyframe);
+    void sigKeyframeRemoved(KisKeyframeBaseSP keyframe);
+    void sigKeyframeAboutToBeMoved(KisKeyframeBaseSP keyframe, int toTime);
+    void sigKeyframeMoved(KisKeyframeBaseSP keyframe, int fromTime);
+    void sigKeyframeChanged(KisKeyframeBaseSP keyframe);
 
 protected:
     typedef QMap<int, KisKeyframeSP> KeyframesMap;
 
     KeyframesMap &keys();
     const KeyframesMap &constKeys() const;
-    KeyframesMap::const_iterator activeKeyIterator(int time) const;
 
     virtual KisKeyframeSP createKeyframe(int time, const KisKeyframeSP copySrc, KUndo2Command *parentCommand) = 0;
     virtual void destroyKeyframe(KisKeyframeSP key, KUndo2Command *parentCommand) = 0;
     virtual void uploadExternalKeyframe(KisKeyframeChannel *srcChannel, int srcTime, KisKeyframeSP dstFrame) = 0;
 
     virtual void requestUpdate(const KisFrameSet &range, const QRect &rect);
 
     virtual KisKeyframeSP loadKeyframe(const QDomElement &keyframeNode) = 0;
     virtual void saveKeyframe(KisKeyframeSP keyframe, QDomElement keyframeElement, const QString &layerFilename) = 0;
 
     void workaroundBrokenFrameTimeBug(int *time);
 
 private:
-    KisKeyframeSP replaceKeyframeAt(int time, KisKeyframeSP newKeyframe);
-    void insertKeyframeLogical(KisKeyframeSP keyframe);
-    void removeKeyframeLogical(KisKeyframeSP keyframe);
-    bool deleteKeyframeImpl(KisKeyframeSP keyframe, KUndo2Command *parentCommand, bool recreate);
-    void moveKeyframeImpl(KisKeyframeSP keyframe, int newTime);
-    void swapKeyframesImpl(KisKeyframeSP lhsKeyframe, KisKeyframeSP rhsKeyframe);
+    KisKeyframeBaseSP replaceKeyframeAt(int time, KisKeyframeBaseSP newKeyframe);
+    void insertKeyframeLogical(KisKeyframeBaseSP keyframe);
+    void removeKeyframeLogical(KisKeyframeBaseSP keyframe);
+    bool deleteKeyframeImpl(KisKeyframeBaseSP keyframe, KUndo2Command *parentCommand, bool recreate);
+    void moveKeyframeImpl(KisKeyframeBaseSP keyframe, int newTime);
+    void swapKeyframesImpl(KisKeyframeBaseSP lhsKeyframe, KisKeyframeBaseSP rhsKeyframe);
 
     void addCycle(QSharedPointer<KisAnimationCycle> cycle);
     void removeCycle(QSharedPointer<KisAnimationCycle> cycle);
 
-    KisKeyframeSP loadRepeatFrame(const QDomElement &keyframeNode, const QMap<int, QSharedPointer<KisAnimationCycle>> &cyclesByFirstKeyframe);
-
     friend class KisMoveFrameCommand;
     friend class KisReplaceKeyframeCommand;
     friend class KisSwapFramesCommand;
     friend class KisDefineCycleCommand;
 
 private:
-    KisKeyframeSP insertKeyframe(int time, const KisKeyframeSP copySrc, KUndo2Command *parentCommand);
+    KisKeyframeSP insertKeyframe(int time, const KisKeyframeBaseSP copySrc, KUndo2Command *parentCommand);
 
     struct Private;
     QScopedPointer<Private> m_d;
 };
 
 class KisVisibleKeyframeIterator
 {
 public:
     KisVisibleKeyframeIterator();
     explicit KisVisibleKeyframeIterator(KisKeyframeSP keyframe);
 
     KisVisibleKeyframeIterator& operator--();
     KisVisibleKeyframeIterator& operator++();
 
     bool isValid() const;
     KisKeyframeSP operator->() const;
     KisKeyframeSP operator*() const;
 
 private:
     KisVisibleKeyframeIterator &invalidate();
 
     KisKeyframeChannel *m_channel{nullptr};
     KisKeyframeSP m_keyframe;
     int m_time{-1};
 };
 
 #endif // KIS_KEYFRAME_CHANNEL_H
diff --git a/libs/image/kis_keyframe_commands.cpp b/libs/image/kis_keyframe_commands.cpp
index 809b04552b..526105e25a 100644
--- a/libs/image/kis_keyframe_commands.cpp
+++ b/libs/image/kis_keyframe_commands.cpp
@@ -1,80 +1,87 @@
 
 #include "kis_keyframe_commands.h"
 
-KisReplaceKeyframeCommand::KisReplaceKeyframeCommand(KisKeyframeChannel *channel, int time, KisKeyframeSP keyframe, KUndo2Command *parentCommand)
+#include <kis_pointer_utils.h>
+#include "kis_animation_cycle.h"
+
+KisReplaceKeyframeCommand::KisReplaceKeyframeCommand(KisKeyframeChannel *channel, int time, KisKeyframeBaseSP keyframe, KUndo2Command *parentCommand)
     : KUndo2Command(parentCommand),
       m_channel(channel),
       m_time(time),
       m_keyframe(keyframe),
       m_existingKeyframe(0)
 {
 }
 
 void KisReplaceKeyframeCommand::redo() {
     m_existingKeyframe = m_channel->replaceKeyframeAt(m_time, m_keyframe);
 }
 
 void KisReplaceKeyframeCommand::undo() {
     m_channel->replaceKeyframeAt(m_time, m_existingKeyframe);
 }
 
-
-KisMoveFrameCommand::KisMoveFrameCommand(KisKeyframeChannel *channel, KisKeyframeSP keyframe, int oldTime, int newTime, KUndo2Command *parentCommand)
+KisMoveFrameCommand::KisMoveFrameCommand(KisKeyframeChannel *channel, KisKeyframeBaseSP keyframe, int oldTime, int newTime, KUndo2Command *parentCommand)
     : KUndo2Command(parentCommand),
       m_channel(channel),
       m_keyframe(keyframe),
       m_oldTime(oldTime),
       m_newTime(newTime)
 {
 }
 
 void KisMoveFrameCommand::redo() {
     m_channel->moveKeyframeImpl(m_keyframe, m_newTime);
 }
 
 void KisMoveFrameCommand::undo() {
     m_channel->moveKeyframeImpl(m_keyframe, m_oldTime);
 }
 
-KisSwapFramesCommand::KisSwapFramesCommand(KisKeyframeChannel *channel, KisKeyframeSP lhsFrame, KisKeyframeSP rhsFrame, KUndo2Command *parentCommand)
+KisSwapFramesCommand::KisSwapFramesCommand(KisKeyframeChannel *channel, KisKeyframeBaseSP lhsFrame, KisKeyframeBaseSP rhsFrame, KUndo2Command *parentCommand)
     : KUndo2Command(parentCommand),
       m_channel(channel),
       m_lhsFrame(lhsFrame),
       m_rhsFrame(rhsFrame)
 {
 }
 
 void KisSwapFramesCommand::redo()
 {
     m_channel->swapKeyframesImpl(m_lhsFrame, m_rhsFrame);
 }
 
 void KisSwapFramesCommand::undo()
 {
     m_channel->swapKeyframesImpl(m_lhsFrame, m_rhsFrame);
 }
 
 KisDefineCycleCommand::KisDefineCycleCommand(KisKeyframeChannel *channel, QSharedPointer<KisAnimationCycle> cycle, bool undefine, KUndo2Command *parentCommand)
     : KUndo2Command(parentCommand)
     , m_channel(channel)
     , m_cycle(cycle)
     , m_undefine(undefine)
 {}
 
 void KisDefineCycleCommand::redo()
 {
     if (m_undefine) {
         m_channel->removeCycle(m_cycle);
     } else {
         m_channel->addCycle(m_cycle);
     }
 }
 
 void KisDefineCycleCommand::undo()
 {
     if (m_undefine) {
         m_channel->addCycle(m_cycle);
     } else {
         m_channel->removeCycle(m_cycle);
     }
 }
+
+QSharedPointer<KisAnimationCycle> KisDefineCycleCommand::cycle() const
+{
+    return m_cycle;
+}
diff --git a/libs/image/kis_keyframe_commands.h b/libs/image/kis_keyframe_commands.h
index 72b5f49382..887f1d0a2b 100644
--- a/libs/image/kis_keyframe_commands.h
+++ b/libs/image/kis_keyframe_commands.h
@@ -1,85 +1,84 @@
 /*
  *  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_KEYFRAME_COMMANDS_H
 #define KIS_KEYFRAME_COMMANDS_H
 
 #include "kis_keyframe_channel.h"
 #include "kundo2command.h"
 #include "kritaimage_export.h"
 
 class KRITAIMAGE_EXPORT KisReplaceKeyframeCommand : public KUndo2Command
 {
 public:
-    KisReplaceKeyframeCommand(KisKeyframeChannel *channel, int time, KisKeyframeSP keyframe, KUndo2Command *parentCommand);
+    KisReplaceKeyframeCommand(KisKeyframeChannel *channel, int time, KisKeyframeBaseSP keyframe, KUndo2Command *parentCommand);
 
     void redo() override;
     void undo() override;
 
-private:
-    void doSwap(bool insert);
-
 private:
     KisKeyframeChannel *m_channel;
     int m_time;
-    KisKeyframeSP m_keyframe;
-    KisKeyframeSP m_existingKeyframe;
+    KisKeyframeBaseSP m_keyframe;
+    KisKeyframeBaseSP m_existingKeyframe;
 };
 
 class KRITAIMAGE_EXPORT KisMoveFrameCommand : public KUndo2Command
 {
 public:
-    KisMoveFrameCommand(KisKeyframeChannel *channel, KisKeyframeSP keyframe, int oldTime, int newTime, KUndo2Command *parentCommand);
+    KisMoveFrameCommand(KisKeyframeChannel *channel, KisKeyframeBaseSP keyframe, int oldTime, int newTime, KUndo2Command *parentCommand);
 
     void redo() override;
     void undo() override;
 
 private:
     KisKeyframeChannel *m_channel;
-    KisKeyframeSP m_keyframe;
+    KisKeyframeBaseSP m_keyframe;
     int m_oldTime;
     int m_newTime;
 };
 
 class KRITAIMAGE_EXPORT KisSwapFramesCommand : public KUndo2Command
 {
 public:
-    KisSwapFramesCommand(KisKeyframeChannel *channel, KisKeyframeSP lhsFrame, KisKeyframeSP rhsFrame, KUndo2Command *parentCommand);
+    KisSwapFramesCommand(KisKeyframeChannel *channel, KisKeyframeBaseSP lhsFrame, KisKeyframeBaseSP rhsFrame, KUndo2Command *parentCommand);
 
     void redo() override;
     void undo() override;
 
 private:
     KisKeyframeChannel *m_channel;
-    KisKeyframeSP m_lhsFrame;
-    KisKeyframeSP m_rhsFrame;
+    KisKeyframeBaseSP m_lhsFrame;
+    KisKeyframeBaseSP m_rhsFrame;
 };
 
 class KRITAIMAGE_EXPORT KisDefineCycleCommand : public KUndo2Command
 {
 public:
     KisDefineCycleCommand(KisKeyframeChannel *channel, QSharedPointer<KisAnimationCycle> cycle, bool undefine, KUndo2Command *parentCommand);
 
+    QSharedPointer<KisAnimationCycle> cycle() const;
+
     void redo() override;
     void undo() override;
 
 private:
     KisKeyframeChannel *m_channel;
     QSharedPointer<KisAnimationCycle> m_cycle;
     bool m_undefine;
 };
 
 #endif
diff --git a/libs/image/kis_raster_keyframe_channel.cpp b/libs/image/kis_raster_keyframe_channel.cpp
index 14e225759f..e6df3921d9 100644
--- a/libs/image/kis_raster_keyframe_channel.cpp
+++ b/libs/image/kis_raster_keyframe_channel.cpp
@@ -1,380 +1,378 @@
 /*
  *  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"
 #include "kis_keyframe_commands.h"
 
 struct KisRasterKeyframeChannel::Private
 {
     Private(KisPaintDeviceWSP paintDevice, const QString filenameSuffix)
             : paintDevice(paintDevice),
             filenameSuffix(filenameSuffix),
             onionSkinsEnabled(false)
     {}
 
     KisPaintDeviceWSP paintDevice;
     QMap<QString, int> framesByFilename;
     QMap<int, QString> frameFilenames;
     QMap<int, QVector<KisKeyframeSP>> frameInstances;
     QString filenameSuffix;
     bool onionSkinsEnabled;
 };
 
 class KisRasterKeyframe : public KisKeyframe
 {
 public:
     KisRasterKeyframe(KisRasterKeyframeChannel *channel, int time, int frameId)
         : KisKeyframe(channel, time)
         , frameId(frameId)
     {}
 
     KisRasterKeyframe(const KisRasterKeyframe *rhs, KisKeyframeChannel *channel)
         : KisKeyframe(rhs, channel)
         , frameId(rhs->frameId)
     {}
 
     int frameId;
 
     KisKeyframeSP cloneFor(KisKeyframeChannel *channel) const override
     {
         return toQShared(new KisRasterKeyframe(this, channel));
     }
 
     bool hasContent() const override {
         KisRasterKeyframeChannel *channel = dynamic_cast<KisRasterKeyframeChannel*>(this->channel());
         KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(channel, true);
 
         return channel->keyframeHasContent(this);
     }
 
     QRect affectedRect() const override
     {
         KisRasterKeyframeChannel *ch = dynamic_cast<KisRasterKeyframeChannel *>(channel());
         KisRasterKeyframeChannel::Private *ch_d = ch->m_d.data();
 
         // 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.
         KisKeyframeSP neighbor = ch->previousKeyframe(*this);
 
         // Using the *next* keyframe at the start of the timeline avoids artifacts
         // when deleting or moving the first key
         if (neighbor.isNull()) neighbor = ch->nextKeyframe(*this);
 
         QRect rect = ch_d->paintDevice->framesInterface()->frameBounds(frameId);
 
         if (!neighbor.isNull()) {
             // Note: querying through frameIdAt makes sure cycle repeats resolve to their original frames
             const int neighborFrameId = ch->frameIdAt(neighbor->time());
             rect |= ch_d->paintDevice->framesInterface()->frameBounds(neighborFrameId);
         }
 
         if (ch_d->onionSkinsEnabled) {
             const QRect dirtyOnionSkinsRect =
                     KisOnionSkinCompositor::instance()->calculateFullExtent(ch_d->paintDevice);
             rect |= dirtyOnionSkinsRect;
         }
 
         return rect;
     }
 
 };
 
 KisRasterKeyframeChannel::KisRasterKeyframeChannel(const KoID &id, const KisPaintDeviceWSP paintDevice, KisDefaultBoundsBaseSP defaultBounds)
     : KisKeyframeChannel(id, defaultBounds),
       m_d(new Private(paintDevice, QString()))
 {
 }
 
 KisRasterKeyframeChannel::KisRasterKeyframeChannel(const KisRasterKeyframeChannel &rhs, KisNode *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()
 {
 }
 
-KisKeyframeSP KisRasterKeyframeChannel::linkKeyframe(const KisKeyframeSP sourceKeyframe, int newTime, KUndo2Command *parentCommand)
+KisKeyframeSP KisRasterKeyframeChannel::linkKeyframe(const KisKeyframeBaseSP source, int newTime, KUndo2Command *parentCommand)
 {
+    KisKeyframeSP sourceKeyframe = source.dynamicCast<KisKeyframe>();
+    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(sourceKeyframe, KisKeyframeSP());
+
     const int frame = frameId(sourceKeyframe);
     KisKeyframeSP newKeyframe = toQShared(new KisRasterKeyframe(this, newTime, frame));
     m_d->frameInstances[frame].append(newKeyframe);
 
     KUndo2Command *cmd = new KisReplaceKeyframeCommand(this, newTime, newKeyframe, parentCommand);
     cmd->redo();
 
     return newKeyframe;
 }
 
 int KisRasterKeyframeChannel::frameId(KisKeyframeSP keyframe) const
 {
     return frameId(keyframe.data());
 }
 
 int KisRasterKeyframeChannel::frameId(const KisKeyframe *keyframe) const
 {
     const KisRasterKeyframe *key = dynamic_cast<const KisRasterKeyframe*>(keyframe);
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(key, -1);
     return key->frameId;
 }
 
 int KisRasterKeyframeChannel::frameIdAt(int time) const
 {
     KisKeyframeSP activeKey = visibleKeyframeAt(time);
     if (activeKey.isNull()) return -1;
     return frameId(activeKey);
 }
 
 void KisRasterKeyframeChannel::fetchFrame(KisKeyframeSP keyframe, KisPaintDeviceSP targetDevice)
 {
     m_d->paintDevice->framesInterface()->fetchFrame(frameId(keyframe), targetDevice);
 }
 
 void KisRasterKeyframeChannel::importFrame(int time, KisPaintDeviceSP sourceDevice, KUndo2Command *parentCommand)
 {
     KisKeyframeSP keyframe = addKeyframe(time, parentCommand);
 
     const int frame = frameId(keyframe);
 
     m_d->paintDevice->framesInterface()->uploadFrame(frame, sourceDevice);
 }
 
 QRect KisRasterKeyframeChannel::frameExtents(KisKeyframeSP keyframe)
 {
     return m_d->paintDevice->framesInterface()->frameBounds(frameId(keyframe));
 }
 
 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)
 {
     KIS_SAFE_ASSERT_RECOVER_NOOP(!m_d->frameFilenames.contains(frameId));
     m_d->frameFilenames.insert(frameId, filename);
     m_d->framesByFilename.insert(filename, frameId);
 }
 
 QString KisRasterKeyframeChannel::chooseFrameFilename(int frameId, const QString &layerFilename)
 {
     QString filename;
 
     if (m_d->frameFilenames.isEmpty()) {
         // 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)
 {
     KisRasterKeyframe *keyframe;
 
     const bool copy = !copySrc.isNull();
     const int srcFrameId = copy ? frameId(copySrc) : 0;
     const int frameId = m_d->paintDevice->framesInterface()->createFrame(copy, srcFrameId, QPoint(), parentCommand);
 
     if (!copy) {
         keyframe = new KisRasterKeyframe(this, time, frameId);
     } else {
         const KisRasterKeyframe *srcKeyframe = dynamic_cast<KisRasterKeyframe*>(copySrc.data());
         KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(srcKeyframe, KisKeyframeSP());
 
         keyframe = new KisRasterKeyframe(srcKeyframe, this);
         keyframe->setTime(time);
         keyframe->frameId = frameId;
     }
 
     KisKeyframeSP keyframeSP = toQShared(keyframe);
 
     m_d->frameInstances[keyframe->frameId].append(keyframeSP);
 
     return keyframeSP;
 }
 
 void KisRasterKeyframeChannel::destroyKeyframe(KisKeyframeSP keyframe, KUndo2Command *parentCommand)
 {
     int id = frameId(keyframe);
 
     QVector<KisKeyframeSP> &instances = m_d->frameInstances[id];
     instances.removeAll(keyframe);
 
     if (instances.isEmpty()) {
         m_d->frameInstances.remove(id);
         m_d->paintDevice->framesInterface()->deleteFrame(id, 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 = frameId(dstFrame);
 
     m_d->paintDevice->framesInterface()->
         uploadFrame(srcId,
                     dstId,
                     srcRasterChannel->m_d->paintDevice);
 }
 
 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 frame = frameId(keyframe);
 
     QString filename = frameFilename(frame);
     if (filename.isEmpty()) {
         filename = chooseFrameFilename(frame, layerFilename);
     }
     keyframeElement.setAttribute("frame", filename);
 
     QPoint offset = m_d->paintDevice->framesInterface()->frameOffset(frame);
     KisDomUtils::saveValue(&keyframeElement, "offset", offset);
 }
 
 KisKeyframeSP KisRasterKeyframeChannel::loadKeyframe(const QDomElement &keyframeNode)
 {
     int time = keyframeNode.attribute("time").toInt();
     workaroundBrokenFrameTimeBug(&time);
 
     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
 
         KIS_SAFE_ASSERT_RECOVER_NOOP(keyframeCount() == 1);
         keyframe = constKeys().begin().value();
         const int id = frameId(keyframe);
         setFrameFilename(id, frameFilename);
 
         // Remove from keys. It will get reinserted with new time once we return
         keys().remove(keyframe->time());
 
         keyframe->setTime(time);
         m_d->paintDevice->framesInterface()->setFrameOffset(id, offset);
     } else {
         int frameId = m_d->framesByFilename.value(frameFilename, -1);
 
         if (frameId == -1) {
             KUndo2Command tempCommand;
             frameId = m_d->paintDevice->framesInterface()->createFrame(false, 0, offset, &tempCommand);
             setFrameFilename(frameId, frameFilename);
         }
 
         keyframe = toQShared(new KisRasterKeyframe(this, time, frameId));
         m_d->frameInstances[frameId].append(keyframe);
     }
 
     return keyframe;
 }
 
 bool KisRasterKeyframeChannel::keyframeHasContent(const KisKeyframe *keyframe) const
 {
     return !m_d->paintDevice->framesInterface()->frameBounds(frameId(keyframe)).isEmpty();
 }
 
 bool KisRasterKeyframeChannel::hasScalarValue() const
 {
     return false;
 }
 
 KisFrameSet KisRasterKeyframeChannel::affectedFrames(int time) const
 {
     const int frameId = frameIdAt(time);
 
     if (frameId < 0) {
         // Not a raster frame (e.g. repeat of a cycle)
         return KisKeyframeChannel::affectedFrames(time);
     }
 
     KisFrameSet frames;
     Q_FOREACH(KisKeyframeSP keyframe, m_d->frameInstances[frameId]) {
         frames |= KisKeyframeChannel::affectedFrames(keyframe->time());
     }
     return frames;
 }
 
 KisFrameSet KisRasterKeyframeChannel::identicalFrames(int time, KisTimeSpan range) const
 {
     const int frameId = frameIdAt(time);
 
-    if (frameId < 0) {
-        // Not a raster frame (e.g. repeat of a cycle)
-        return KisKeyframeChannel::affectedFrames(time);
-    }
-
     KisFrameSet frames;
     Q_FOREACH(KisKeyframeSP keyframe, m_d->frameInstances[frameId]) {
         frames |= KisKeyframeChannel::identicalFrames(keyframe->time(), range);
     }
     return frames;
 }
 
 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 981b06621f..79374dbbc1 100644
--- a/libs/image/kis_raster_keyframe_channel.h
+++ b/libs/image/kis_raster_keyframe_channel.h
@@ -1,99 +1,99 @@
 /*
  *  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 KisTimeSpan;
 
 class KRITAIMAGE_EXPORT KisRasterKeyframeChannel : public KisKeyframeChannel
 {
     Q_OBJECT
 
 public:
     KisRasterKeyframeChannel(const KoID& id, const KisPaintDeviceWSP paintDevice, KisDefaultBoundsBaseSP defaultBounds);
     KisRasterKeyframeChannel(const KisRasterKeyframeChannel &rhs, KisNode *newParentNode, const KisPaintDeviceWSP newPaintDevice);
     ~KisRasterKeyframeChannel() override;
 
-    KisKeyframeSP linkKeyframe(const KisKeyframeSP keyframe, int newTime, KUndo2Command *parentCommand = 0) override;
+    KisKeyframeSP linkKeyframe(const KisKeyframeBaseSP keyframe, int newTime, KUndo2Command *parentCommand = 0) override;
 
 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 override;
     KisFrameSet affectedFrames(int time) const override;
     KisFrameSet identicalFrames(int time, KisTimeSpan range) const override;
 
     QDomElement toXML(QDomDocument doc, const QString &layerFilename) override;
     void loadXML(const QDomElement &channelNode) override;
 
     void setOnionSkinsEnabled(bool value);
     bool onionSkinsEnabled() const;
 
 protected:
     KisKeyframeSP createKeyframe(int time, const KisKeyframeSP copySrc, KUndo2Command *parentCommand) override;
     void destroyKeyframe(KisKeyframeSP keyframe, KUndo2Command *parentCommand) override;
     void uploadExternalKeyframe(KisKeyframeChannel *srcChannel, int srcTime, KisKeyframeSP dstFrame) override;
 
     void saveKeyframe(KisKeyframeSP keyframe, QDomElement keyframeElement, const QString &layerFilename) override;
     KisKeyframeSP loadKeyframe(const QDomElement &keyframeNode) override;
 
     friend class KisRasterKeyframe;
     bool keyframeHasContent(const KisKeyframe *keyframe) const;
 
 private:
     void setFrameFilename(int frameId, const QString &filename);
     QString chooseFrameFilename(int frameId, const QString &layerFilename);
     int frameId(KisKeyframeSP keyframe) const;
     int frameId(const KisKeyframe *keyframe) const;
 
     struct Private;
     QScopedPointer<Private> m_d;
 };
 
 #endif
diff --git a/libs/image/tests/kis_keyframing_test.cpp b/libs/image/tests/kis_keyframing_test.cpp
index a9ca4f80e3..108db90e98 100644
--- a/libs/image/tests/kis_keyframing_test.cpp
+++ b/libs/image/tests/kis_keyframing_test.cpp
@@ -1,581 +1,583 @@
 /*
  *  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_keyframing_test.h"
 #include <QTest>
 #include <qsignalspy.h>
 
 #include "kis_paint_device_frames_interface.h"
 #include "kis_keyframe_channel.h"
 #include "kis_scalar_keyframe_channel.h"
 #include "kis_raster_keyframe_channel.h"
 #include "kis_node.h"
 #include "kis_time_range.h"
+#include "kis_animation_cycle.h"
 #include "kundo2command.h"
-
+#include "kis_pointer_utils.h"
 
 #include <KoColorSpaceRegistry.h>
 
 #include "testing_timed_default_bounds.h"
 
 
 void KisKeyframingTest::initTestCase()
 {
     cs = KoColorSpaceRegistry::instance()->rgb8();
 
     red = new quint8[cs->pixelSize()];
     green = new quint8[cs->pixelSize()];
     blue = new quint8[cs->pixelSize()];
 
     cs->fromQColor(Qt::red, red);
     cs->fromQColor(Qt::green, green);
     cs->fromQColor(Qt::blue, blue);
 }
 
 void KisKeyframingTest::cleanupTestCase()
 {
     delete[] red;
     delete[] green;
     delete[] blue;
 }
 
 void KisKeyframingTest::testScalarChannel()
 {
     KisScalarKeyframeChannel *channel = new KisScalarKeyframeChannel(KoID(""), -17, 31, 0);
     KisKeyframeSP key;
     bool ok;
 
     QCOMPARE(channel->hasScalarValue(), true);
     QCOMPARE(channel->minScalarValue(), -17.0);
     QCOMPARE(channel->maxScalarValue(),  31.0);
 
     QVERIFY(channel->keyframeAt(0) == 0);
 
     // Adding new keyframe
 
     key = channel->addKeyframe(42);
     channel->setScalarValue(key, 7.0);
 
     key = channel->keyframeAt(42);
     QCOMPARE(channel->scalarValue(key), 7.0);
 
     // Copying a keyframe
 
     KisKeyframeSP key2 = channel->copyKeyframe(key, 13);
     QVERIFY(key2 != 0);
     QVERIFY(channel->keyframeAt(13) == key2);
     QCOMPARE(channel->scalarValue(key2), 7.0);
 
     // Adding a keyframe where one exists
 
     key2 = channel->addKeyframe(13);
     QVERIFY(key2 != key);
     QCOMPARE(channel->keyframeCount(), 2);
 
     // Moving keyframes
 
     ok = channel->moveKeyframe(key, 10);
     QCOMPARE(ok, true);
     QVERIFY(channel->keyframeAt(42) == 0);
 
     key = channel->keyframeAt(10);
     QCOMPARE(channel->scalarValue(key), 7.0);
 
     // Moving a keyframe where another one exists
     ok = channel->moveKeyframe(key, 13);
     QCOMPARE(ok, true);
     QVERIFY(channel->keyframeAt(13) != key2);
 
     // Deleting a keyframe
     channel->deleteKeyframe(key);
     QVERIFY(channel->keyframeAt(10) == 0);
     QCOMPARE(channel->keyframeCount(), 0);
 
     delete channel;
 }
 
 void KisKeyframingTest::testScalarChannelUndoRedo()
 {
     KisScalarKeyframeChannel *channel = new KisScalarKeyframeChannel(KoID(""), -17, 31, 0);
     KisKeyframeSP key;
 
     QCOMPARE(channel->hasScalarValue(), true);
     QCOMPARE(channel->minScalarValue(), -17.0);
     QCOMPARE(channel->maxScalarValue(),  31.0);
 
     QVERIFY(channel->keyframeAt(0) == 0);
 
     // Adding new keyframe
 
     KUndo2Command addCmd;
 
     key = channel->addKeyframe(42, &addCmd);
     channel->setScalarValue(key, 7.0, &addCmd);
 
     key = channel->keyframeAt(42);
     QCOMPARE(channel->scalarValue(key), 7.0);
 
     addCmd.undo();
 
     KisKeyframeSP newKey;
 
     newKey = channel->keyframeAt(42);
     QVERIFY(!newKey);
 
     addCmd.redo();
 
     newKey = channel->keyframeAt(42);
     QVERIFY(newKey);
 
     QCOMPARE(channel->scalarValue(key), 7.0);
     QCOMPARE(channel->scalarValue(newKey), 7.0);
 
     delete channel;
 }
 
 void KisKeyframingTest::testScalarInterpolation()
 {
     KisScalarKeyframeChannel *channel = new KisScalarKeyframeChannel(KoID(""), 0, 30, 0);
 
     KisKeyframeSP key1 = channel->addKeyframe(0);
     channel->setScalarValue(key1, 15);
 
     KisKeyframeSP key2 = channel->addKeyframe(10);
     channel->setScalarValue(key2, 30);
 
     // Constant
 
     key1->setInterpolationMode(KisKeyframe::Constant);
 
     QCOMPARE(channel->interpolatedValue(4), 15.0f);
 
     // Bezier
 
     key1->setInterpolationMode(KisKeyframe::Bezier);
     key1->setInterpolationTangents(QPointF(), QPointF(1,4));
     key2->setInterpolationTangents(QPointF(-4,2), QPointF());
 
     QVERIFY(qAbs(channel->interpolatedValue(4) - 24.9812f) < 0.1f);
 
     // Bezier, self-intersecting curve (auto-correct)
 
     channel->setScalarValue(key2, 15);
     key1->setInterpolationTangents(QPointF(), QPointF(13,10));
     key2->setInterpolationTangents(QPointF(-13,10), QPointF());
 
     QVERIFY(qAbs(channel->interpolatedValue(5) - 20.769f) < 0.1f);
 
     // Bezier, result outside allowed range (clamp)
 
     channel->setScalarValue(key2, 15);
     key1->setInterpolationTangents(QPointF(), QPointF(0, 50));
     key2->setInterpolationTangents(QPointF(0, 50), QPointF());
 
     QCOMPARE(channel->interpolatedValue(5), 30.0f);
 
     delete channel;
 }
 
 void KisKeyframingTest::testRasterChannel()
 {
     TestUtil::TestingTimedDefaultBounds *bounds = new TestUtil::TestingTimedDefaultBounds();
 
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
     dev->setDefaultBounds(bounds);
 
     KisRasterKeyframeChannel * channel = dev->createKeyframeChannel(KoID());
 
     QCOMPARE(channel->hasScalarValue(), false);
     QCOMPARE(channel->keyframeCount(), 1);
     QCOMPARE(dev->framesInterface()->frames().count(), 1);
     QCOMPARE(channel->frameIdAt(0), 0);
     QVERIFY(channel->keyframeAt(0) != 0);
 
     KisKeyframeSP key_0 = channel->keyframeAt(0);
 
     // New keyframe
 
     KisKeyframeSP key_10 = channel->addKeyframe(10);
     QCOMPARE(channel->keyframeCount(), 2);
     QCOMPARE(dev->framesInterface()->frames().count(), 2);
     QVERIFY(channel->frameIdAt(10) != 0);
 
     dev->fill(0, 0, 512, 512, red);
     QImage thumb1a = dev->createThumbnail(50, 50);
 
     bounds->testingSetTime(10);
 
     dev->fill(0, 0, 512, 512, green);
     QImage thumb2a = dev->createThumbnail(50, 50);
 
     bounds->testingSetTime(0);
     QImage thumb1b = dev->createThumbnail(50, 50);
 
     QVERIFY(thumb2a != thumb1a);
     QVERIFY(thumb1b == thumb1a);
 
     // Duplicate keyframe
 
     KisKeyframeSP key_20 = channel->copyKeyframe(key_0, 20);
     bounds->testingSetTime(20);
     QImage thumb3a = dev->createThumbnail(50, 50);
 
     QVERIFY(thumb3a == thumb1b);
 
     dev->fill(0, 0, 512, 512, blue);
     QImage thumb3b = dev->createThumbnail(50, 50);
 
     bounds->testingSetTime(0);
     QImage thumb1c = dev->createThumbnail(50, 50);
 
     QVERIFY(thumb3b != thumb3a);
     QVERIFY(thumb1c == thumb1b);
 
     // Delete keyrame
     QCOMPARE(channel->keyframeCount(), 3);
     QCOMPARE(dev->framesInterface()->frames().count(), 3);
 
     channel->deleteKeyframe(key_20);
     QCOMPARE(channel->keyframeCount(), 2);
     QCOMPARE(dev->framesInterface()->frames().count(), 2);
     QVERIFY(channel->keyframeAt(20) == 0);
 
     channel->deleteKeyframe(key_10);
     QCOMPARE(channel->keyframeCount(), 1);
     QCOMPARE(dev->framesInterface()->frames().count(), 1);
     QVERIFY(channel->keyframeAt(10) == 0);
 
     channel->deleteKeyframe(key_0);
     QCOMPARE(channel->keyframeCount(), 1);
     QCOMPARE(dev->framesInterface()->frames().count(), 1);
     QVERIFY(channel->keyframeAt(0) != 0);
 }
 
 void KisKeyframingTest::testChannelSignals()
 {
     KisScalarKeyframeChannel *channel = new KisScalarKeyframeChannel(KoID(""), -17, 31, 0);
-    KisKeyframeSP key;
-    KisKeyframeSP resKey;
+    KisKeyframeBaseSP key;
+    KisKeyframeBaseSP resKey;
 
-    qRegisterMetaType<KisKeyframeSP>("KisKeyframeSP");
-    QSignalSpy spyPreAdd(channel, SIGNAL(sigKeyframeAboutToBeAdded(KisKeyframeSP)));
-    QSignalSpy spyPostAdd(channel, SIGNAL(sigKeyframeAdded(KisKeyframeSP)));
+    qRegisterMetaType<KisKeyframeBaseSP>("KisKeyframeBaseSP");
+    QSignalSpy spyPreAdd(channel, SIGNAL(sigKeyframeAboutToBeAdded(KisKeyframeBaseSP)));
+    QSignalSpy spyPostAdd(channel, SIGNAL(sigKeyframeAdded(KisKeyframeBaseSP)));
 
-    QSignalSpy spyPreRemove(channel, SIGNAL(sigKeyframeAboutToBeRemoved(KisKeyframeSP)));
-    QSignalSpy spyPostRemove(channel, SIGNAL(sigKeyframeRemoved(KisKeyframeSP)));
+    QSignalSpy spyPreRemove(channel, SIGNAL(sigKeyframeAboutToBeRemoved(KisKeyframeBaseSP)));
+    QSignalSpy spyPostRemove(channel, SIGNAL(sigKeyframeRemoved(KisKeyframeBaseSP)));
 
-    QSignalSpy spyPreMove(channel, SIGNAL(sigKeyframeAboutToBeMoved(KisKeyframeSP,int)));
-    QSignalSpy spyPostMove(channel, SIGNAL(sigKeyframeMoved(KisKeyframeSP,int)));
+    QSignalSpy spyPreMove(channel, SIGNAL(sigKeyframeAboutToBeMoved(KisKeyframeBaseSP,int)));
+    QSignalSpy spyPostMove(channel, SIGNAL(sigKeyframeMoved(KisKeyframeBaseSP,int)));
 
     QVERIFY(spyPreAdd.isValid());
     QVERIFY(spyPostAdd.isValid());
     QVERIFY(spyPreRemove.isValid());
     QVERIFY(spyPostRemove.isValid());
     QVERIFY(spyPreMove.isValid());
     QVERIFY(spyPostMove.isValid());
 
     // Adding a keyframe
 
     QCOMPARE(spyPreAdd.count(), 0);
     QCOMPARE(spyPostAdd.count(), 0);
 
     key = channel->addKeyframe(10);
 
     QCOMPARE(spyPreAdd.count(), 1);
     QCOMPARE(spyPostAdd.count(), 1);
 
-    resKey = spyPreAdd.at(0).at(0).value<KisKeyframeSP>();
+    resKey = spyPreAdd.at(0).at(0).value<KisKeyframeBaseSP>();
     QVERIFY(resKey == key);
-    resKey = spyPostAdd.at(0).at(0).value<KisKeyframeSP>();
+    resKey = spyPostAdd.at(0).at(0).value<KisKeyframeBaseSP>();
     QVERIFY(resKey == key);
 
     // Moving a keyframe
 
     QCOMPARE(spyPreMove.count(), 0);
     QCOMPARE(spyPostMove.count(), 0);
     channel->moveKeyframe(key, 15);
     QCOMPARE(spyPreMove.count(), 1);
     QCOMPARE(spyPostMove.count(), 1);
 
-    resKey = spyPreMove.at(0).at(0).value<KisKeyframeSP>();
+    resKey = spyPreMove.at(0).at(0).value<KisKeyframeBaseSP>();
     QVERIFY(resKey == key);
     QCOMPARE(spyPreMove.at(0).at(1).toInt(), 15);
-    resKey = spyPostMove.at(0).at(0).value<KisKeyframeSP>();
+    resKey = spyPostMove.at(0).at(0).value<KisKeyframeBaseSP>();
     QVERIFY(resKey == key);
 
     // No-op move (no signals)
 
     channel->moveKeyframe(key, 15);
     QCOMPARE(spyPreMove.count(), 1);
     QCOMPARE(spyPostMove.count(), 1);
 
     // Deleting a keyframe
 
     QCOMPARE(spyPreRemove.count(), 0);
     QCOMPARE(spyPostRemove.count(), 0);
     channel->deleteKeyframe(key);
     QCOMPARE(spyPreRemove.count(), 1);
     QCOMPARE(spyPostRemove.count(), 1);
 
     delete channel;
 }
 
 void KisKeyframingTest::testRasterFrameFetching()
 {
     TestUtil::TestingTimedDefaultBounds *bounds = new TestUtil::TestingTimedDefaultBounds();
 
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
     KisPaintDeviceSP devTarget = new KisPaintDevice(cs);
     dev->setDefaultBounds(bounds);
 
     KisRasterKeyframeChannel * channel = dev->createKeyframeChannel(KoID());
 
     channel->addKeyframe(0);
     channel->addKeyframe(10);
     channel->addKeyframe(50);
 
     bounds->testingSetTime(0);
     dev->fill(0, 0, 512, 512, red);
     QImage frame1 = dev->createThumbnail(50, 50);
 
     bounds->testingSetTime(10);
     dev->fill(0, 256, 512, 512, green);
     QImage frame2 = dev->createThumbnail(50, 50);
 
     bounds->testingSetTime(50);
     dev->fill(0, 0, 256, 512, blue);
     QImage frame3 = dev->createThumbnail(50, 50);
 
     bounds->testingSetTime(10);
 
     KisKeyframeSP keyframe = channel->activeKeyframeAt(0);
     channel->fetchFrame(keyframe, devTarget);
     QImage fetched1 = devTarget->createThumbnail(50, 50);
 
     keyframe = channel->activeKeyframeAt(10);
     channel->fetchFrame(keyframe, devTarget);
     QImage fetched2 = devTarget->createThumbnail(50, 50);
 
     keyframe = channel->activeKeyframeAt(50);
     channel->fetchFrame(keyframe, devTarget);
     QImage fetched3 = devTarget->createThumbnail(50, 50);
 
     QVERIFY(fetched1 == frame1);
     QVERIFY(fetched2 == frame2);
     QVERIFY(fetched3 == frame3);
 }
 
 void KisKeyframingTest::testDeleteFirstRasterChannel()
 {
     // Test Plan:
     // 
     // delete
     // undo delete
     // move
     // undo move
 
     TestUtil::TestingTimedDefaultBounds *bounds = new TestUtil::TestingTimedDefaultBounds();
 
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
     dev->setDefaultBounds(bounds);
 
     KisRasterKeyframeChannel * channel = dev->createKeyframeChannel(KoID());
 
     QCOMPARE(channel->hasScalarValue(), false);
     QCOMPARE(channel->keyframeCount(), 1);
     QCOMPARE(dev->framesInterface()->frames().count(), 1);
     QCOMPARE(channel->frameIdAt(0), 0);
     QVERIFY(channel->keyframeAt(0) != 0);
 
     KisKeyframeSP key_0 = channel->keyframeAt(0);
 
     {
         KUndo2Command cmd;
         bool deleteResult = channel->deleteKeyframe(key_0, &cmd);
         QVERIFY(deleteResult);
         QCOMPARE(dev->framesInterface()->frames().count(), 1);
         QVERIFY(channel->frameIdAt(0) != 0);
         QVERIFY(channel->keyframeAt(0));
         QVERIFY(channel->keyframeAt(0) != key_0);
 
         cmd.undo();
 
         QCOMPARE(dev->framesInterface()->frames().count(), 1);
         QVERIFY(channel->frameIdAt(0) == 0);
         QVERIFY(channel->keyframeAt(0));
         QVERIFY(channel->keyframeAt(0) == key_0);
     }
 
     {
         KUndo2Command cmd;
         bool moveResult = channel->moveKeyframe(key_0, 1, &cmd);
         QVERIFY(moveResult);
         QCOMPARE(dev->framesInterface()->frames().count(), 2);
         QVERIFY(channel->frameIdAt(0) != 0);
         QVERIFY(channel->frameIdAt(1) == 0);
         QVERIFY(channel->keyframeAt(0));
         QVERIFY(channel->keyframeAt(1));
         QVERIFY(channel->keyframeAt(0) != key_0);
         QVERIFY(channel->keyframeAt(1) == key_0);
 
         cmd.undo();
 
         QCOMPARE(dev->framesInterface()->frames().count(), 1);
         QVERIFY(channel->frameIdAt(0) == 0);
         QVERIFY(channel->keyframeAt(0));
         QVERIFY(channel->keyframeAt(0) == key_0);
     }
 }
 
 void KisKeyframingTest::testAffectedFrames()
 {
     KisScalarKeyframeChannel *channel = new KisScalarKeyframeChannel(KoID(""), -17, 31, 0);
     KisFrameSet frames;
 
     channel->addKeyframe(10);
     channel->addKeyframe(20);
     channel->addKeyframe(30);
 
     // At a keyframe
     frames = channel->affectedFrames(20);
     QCOMPARE(frames, KisFrameSet::between(20, 29));
 
     // Between frames
     frames = channel->affectedFrames(25);
     QCOMPARE(frames, KisFrameSet::between(20, 29));
 
     // Before first frame
     frames = channel->affectedFrames(5);
     QCOMPARE(frames, KisFrameSet::between(0, 9));
 
     // After last frame
     frames = channel->affectedFrames(35);
     QCOMPARE(frames, KisFrameSet::infiniteFrom(30));
 
     // Linked keyframes
 
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
     KisRasterKeyframeChannel * rasterChannel = dev->createKeyframeChannel(KoID());
 
     auto key0 = rasterChannel->addKeyframe(0);
     auto key5 = rasterChannel->addKeyframe(5);
     auto key10 = rasterChannel->linkKeyframe(key0, 10, nullptr);
 
     QCOMPARE(rasterChannel->affectedFrames(5), KisFrameSet::between(5,9));
     KisFrameSet result = rasterChannel->affectedFrames(1);
     QCOMPARE(result, KisFrameSet::between(0, 4) | KisFrameSet::infiniteFrom(10));
     result = rasterChannel->affectedFrames(15);
     QCOMPARE(result, KisFrameSet::between(0, 4) | KisFrameSet::infiniteFrom(10));
 }
 
 void KisKeyframingTest::testMovingFrames()
 {
     TestUtil::TestingTimedDefaultBounds *bounds = new TestUtil::TestingTimedDefaultBounds();
 
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
     dev->setDefaultBounds(bounds);
 
     KisRasterKeyframeChannel * srcChannel = dev->createKeyframeChannel(KoID());
 
     srcChannel->addKeyframe(0);
     srcChannel->addKeyframe(10);
     srcChannel->addKeyframe(50);
 
     KisPaintDeviceSP dev2 = new KisPaintDevice(*dev, KritaUtils::CopyAllFrames);
     KisRasterKeyframeChannel * dstChannel = dev->keyframeChannel();
 
 
     for (int i = 0; i < 1000; i++) {
 
         const int srcTime = 50 + i;
         const int dstTime = 60 + i;
         const int src2Time = 51 + i;
 
         {
             KUndo2Command parentCommand;
             KisKeyframeSP srcKeyframe = srcChannel->keyframeAt(srcTime);
             KIS_ASSERT(srcKeyframe);
             dstChannel->copyExternalKeyframe(srcChannel, srcTime, dstTime, &parentCommand);
             srcChannel->deleteKeyframe(srcKeyframe, &parentCommand);
         }
 
         for (int j = qMax(0, i-15); j < i+5; ++j) {
             bounds->testingSetTime(j);
             QRect rc1 = dev->extent();
             QRect rc2 = dev2->extent();
             Q_UNUSED(rc1);
             Q_UNUSED(rc2);
         }
 
         {
             KUndo2Command parentCommand;
             KisKeyframeSP dstKeyframe = dstChannel->keyframeAt(dstTime);
             KIS_ASSERT(dstKeyframe);
             srcChannel->copyExternalKeyframe(dstChannel, dstTime, src2Time, &parentCommand);
             dstChannel->deleteKeyframe(dstKeyframe, &parentCommand);
         }
     }
 }
 
 void KisKeyframingTest::testCycles()
 {
     TestUtil::TestingTimedDefaultBounds *bounds = new TestUtil::TestingTimedDefaultBounds();
 
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
     dev->setDefaultBounds(bounds);
     KisRasterKeyframeChannel *channel = dev->createKeyframeChannel(KoID());
 
     KisKeyframeSP frame10 = channel->addKeyframe(10);
     channel->addKeyframe(12);
     KisKeyframeSP frame16 = channel->addKeyframe(16);
     channel->addKeyframe(20);
 
     auto cmd = channel->createCycle(frame10, frame16);
     cmd->redo();
 
     // Cycled range can be queried from by any frame within it
     QCOMPARE(channel->cycledRangeAt(9), KisTimeSpan());
     QCOMPARE(channel->cycledRangeAt(20), KisTimeSpan());
     QCOMPARE(channel->cycledRangeAt(10), KisTimeSpan(10, 19));
     QCOMPARE(channel->cycledRangeAt(19), KisTimeSpan(10, 19));
 
-    channel->addRepeat(30, frame10);
+    QSharedPointer<KisRepeatFrame> repeatFrame = toQShared(new KisRepeatFrame(channel, 30, channel->cycleAt(10)));
+    KisReplaceKeyframeCommand(channel, 30, repeatFrame, nullptr).redo();
 
     // Repeats also resolve to the original cycled range
     QCOMPARE(channel->cycledRangeAt(29), KisTimeSpan());
     QCOMPARE(channel->cycledRangeAt(30), KisTimeSpan(10, 19));
     QCOMPARE(channel->cycledRangeAt(50), KisTimeSpan(10, 19));
     QCOMPARE(channel->cycledRangeAt(100), KisTimeSpan(10, 19));
 
     // Affected frames contain original frames and repeats
     QCOMPARE(channel->affectedFrames(15), KisFrameSet::between(12, 15) | KisFrameSet::infiniteFrom(32));
     QCOMPARE(channel->affectedFrames(50), KisFrameSet::between(10, 11) | KisFrameSet::infiniteFrom(30));
 
     // All repeats within the queried range are reported as identical. Original is always included.
     QCOMPARE(channel->identicalFrames(50, KisTimeSpan(40, 60)), KisFrameSet({{10, 11}, {40, 41}, {50, 51}, {60, 60}}));
 
     // Repeat ends at the next keyframe
     channel->addKeyframe(42);
     QCOMPARE(channel->cycledRangeAt(41), KisTimeSpan(10, 19));
     QCOMPARE(channel->cycledRangeAt(42), KisTimeSpan());
 
     // Finitely many repeats are all included separately as affected
     QCOMPARE(channel->affectedFrames(40), KisFrameSet({{10, 11}, {30, 31}, {40, 41}}));
 }
 
 QTEST_MAIN(KisKeyframingTest)
diff --git a/plugins/dockers/animation/kis_animation_curves_model.cpp b/plugins/dockers/animation/kis_animation_curves_model.cpp
index dadf8afc34..9bda1d9cb1 100644
--- a/plugins/dockers/animation/kis_animation_curves_model.cpp
+++ b/plugins/dockers/animation/kis_animation_curves_model.cpp
@@ -1,412 +1,412 @@
 /*
  *  Copyright (c) 2016 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_curves_model.h"
 
 #include <QAbstractItemModel>
 
 #include "kis_global.h"
 #include "kis_image.h"
 #include "kis_node.h"
 #include "kis_keyframe_channel.h"
 #include "kis_scalar_keyframe_channel.h"
 #include "kis_post_execution_undo_adapter.h"
 #include "kis_animation_utils.h"
 #include "kis_processing_applicator.h"
 #include "kis_command_utils.h"
 #include "KisImageBarrierLockerWithFeedback.h"
 
 struct KisAnimationCurve::Private
 {
     Private(KisScalarKeyframeChannel *channel, QColor color)
         : channel(channel)
         , color(color)
         , visible(true)
     {}
 
     KisScalarKeyframeChannel *channel;
     QColor color;
     bool visible;
 };
 
 KisAnimationCurve::KisAnimationCurve(KisScalarKeyframeChannel *channel, QColor color)
     : m_d(new Private(channel, color))
 {}
 
 KisScalarKeyframeChannel *KisAnimationCurve::channel() const
 {
     return m_d->channel;
 }
 
 QColor KisAnimationCurve::color() const
 {
     return m_d->color;
 }
 
 void KisAnimationCurve::setVisible(bool visible)
 {
     m_d->visible = visible;
 }
 
 bool KisAnimationCurve::visible() const
 {
     return m_d->visible;
 }
 
 struct KisAnimationCurvesModel::Private
 {
     QList<KisAnimationCurve*> curves;
     int nextColorHue;
     KUndo2Command *undoCommand;
 
     Private()
         : nextColorHue(0)
         , undoCommand(0)
     {}
 
     KisAnimationCurve *getCurveAt(const QModelIndex& index) {
 
         if (!index.isValid()) return 0;
 
         int row = index.row();
 
         if (row < 0 || row >= curves.size()) {
             return 0;
         }
 
         return curves.at(row);
     }
 
     int rowForCurve(KisAnimationCurve *curve) {
         return curves.indexOf(curve);
     }
 
     int rowForChannel(KisKeyframeChannel *channel) {
         for (int row = 0; row < curves.count(); row++) {
             if (curves.at(row)->channel() == channel) return row;
         }
 
         return -1;
     }
 
     QColor chooseNextColor() {
         if (curves.isEmpty()) nextColorHue = 0;
 
         QColor color = QColor::fromHsv(nextColorHue, 255, 255);
         nextColorHue += 94; // Value chosen experimentally for providing distinct colors
         nextColorHue = nextColorHue & 0xff;
         return color;
     }
 };
 
 KisAnimationCurvesModel::KisAnimationCurvesModel(QObject *parent)
     : KisTimeBasedItemModel(parent)
     , m_d(new Private())
 {}
 
 KisAnimationCurvesModel::~KisAnimationCurvesModel()
 {
     qDeleteAll(m_d->curves);
 }
 
 int KisAnimationCurvesModel::rowCount(const QModelIndex &parent) const
 {
     Q_UNUSED(parent);
     return m_d->curves.size();
 }
 
 QVariant KisAnimationCurvesModel::data(const QModelIndex &index, int role) const
 {
     KisAnimationCurve *curve = m_d->getCurveAt(index);
 
     if (curve) {
         KisScalarKeyframeChannel *channel = curve->channel();
 
         int time = index.column();
         KisKeyframeSP keyframe = channel->keyframeAt(time);
 
         switch (role) {
         case SpecialKeyframeExists:
             return !keyframe.isNull();
         case ScalarValueRole:
             return channel->interpolatedValue(time);
         case LeftTangentRole:
             return (keyframe.isNull()) ? QVariant() : keyframe->leftTangent();
         case RightTangentRole:
             return (keyframe.isNull()) ? QVariant() : keyframe->rightTangent();
         case InterpolationModeRole:
             return (keyframe.isNull()) ? QVariant() : keyframe->interpolationMode();
         case TangentsModeRole:
             return (keyframe.isNull()) ? QVariant() : keyframe->tangentsMode();
         case CurveColorRole:
             return curve->color();
         case CurveVisibleRole:
             return curve->visible();
         case PreviousKeyframeTime:
         {
             KisKeyframeSP active = channel->activeKeyframeAt(time);
             if (active.isNull()) return QVariant();
             if (active->time() < time) {
                 return active->time();
             }
             KisKeyframeSP previous = channel->previousKeyframe(active);
             if (previous.isNull()) return QVariant();
             return previous->time();
         }
         case NextKeyframeTime:
         {
             KisKeyframeSP active = channel->activeKeyframeAt(time);
             if (active.isNull()) {
                 KisKeyframeSP first = channel->firstKeyframe();
                 if (!first.isNull() && first->time() > time) {
                     return first->time();
                 }
                 return QVariant();
             }
             KisKeyframeSP next = channel->nextKeyframe(active);
             if (next.isNull()) return QVariant();
             return next->time();
         }
         default:
             break;
         }
     }
 
     return KisTimeBasedItemModel::data(index, role);
 }
 
 bool KisAnimationCurvesModel::setData(const QModelIndex &index, const QVariant &value, int role)
 {
     if (!index.isValid()) return false;
     KisScalarKeyframeChannel *channel = m_d->getCurveAt(index)->channel();
     KUndo2Command *command = m_d->undoCommand;
 
     switch (role) {
     case ScalarValueRole:
     {
         KisKeyframeSP keyframe = channel->keyframeAt(index.column());
         if (keyframe) {
             if (!command) command = new KUndo2Command(kundo2_i18n("Adjust keyframe"));
             channel->setScalarValue(keyframe, value.toReal(), command);
         } else {
             if (!command) command = new KUndo2Command(kundo2_i18n("Insert keyframe"));
             auto *addKeyframeCommand = new KisScalarKeyframeChannel::AddKeyframeCommand(
                 channel, index.column(), value.toReal(), command);
             addKeyframeCommand->redo();
         }
     }
         break;
     case LeftTangentRole:
     case RightTangentRole:
     {
         KisKeyframeSP keyframe = channel->keyframeAt(index.column());
         if (!keyframe) return false;
 
         QPointF leftTangent = (role == LeftTangentRole ? value.toPointF() : keyframe->leftTangent());
         QPointF rightTangent = (role == RightTangentRole ? value.toPointF() : keyframe->rightTangent());
 
         if (!command) command = new KUndo2Command(kundo2_i18n("Adjust tangent"));
         channel->setInterpolationTangents(keyframe, keyframe->tangentsMode(), leftTangent, rightTangent, command);
     }
         break;
     case InterpolationModeRole:
     {
         KisKeyframeSP keyframe = channel->keyframeAt(index.column());
         if (!keyframe) return false;
 
         if (!command) command = new KUndo2Command(kundo2_i18n("Set interpolation mode"));
         channel->setInterpolationMode(keyframe, (KisKeyframe::InterpolationMode)value.toInt(), command);
     }
         break;
     case TangentsModeRole:
     {
         KisKeyframeSP keyframe = channel->keyframeAt(index.column());
         if (!keyframe) return false;
 
         KisKeyframe::InterpolationTangentsMode mode = (KisKeyframe::InterpolationTangentsMode)value.toInt();
         QPointF leftTangent = keyframe->leftTangent();
         QPointF rightTangent = keyframe->rightTangent();
 
         if (!command) command = new KUndo2Command(kundo2_i18n("Set interpolation mode"));
         channel->setInterpolationTangents(keyframe, mode, leftTangent, rightTangent, command);
     }
         break;
     default:
         return KisTimeBasedItemModel::setData(index, value, role);
     }
 
     if (command && !m_d->undoCommand) {
         image()->postExecutionUndoAdapter()->addCommand(toQShared(command));
     }
 
     return true;
 }
 
 QVariant KisAnimationCurvesModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
     // TODO
     return KisTimeBasedItemModel::headerData(section, orientation, role);
 }
 
 void KisAnimationCurvesModel::beginCommand(const KUndo2MagicString &text)
 {
     KIS_ASSERT_RECOVER_RETURN(!m_d->undoCommand);
     m_d->undoCommand = new KUndo2Command(text);
 }
 
 void KisAnimationCurvesModel::endCommand()
 {
     KIS_ASSERT_RECOVER_RETURN(m_d->undoCommand);
     image()->postExecutionUndoAdapter()->addCommand(toQShared(m_d->undoCommand));
 
     m_d->undoCommand = 0;
 }
 
 
 bool KisAnimationCurvesModel::adjustKeyframes(const QModelIndexList &indexes, int timeOffset, qreal valueOffset)
 {
     QScopedPointer<KUndo2Command> command(
         new KUndo2Command(
             kundo2_i18np("Adjust Keyframe",
                          "Adjust %1 Keyframes",
                          indexes.size())));
 
     {
         KisImageBarrierLockerWithFeedback locker(image());
 
         if (timeOffset != 0) {
             bool ok = createOffsetFramesCommand(indexes, QPoint(timeOffset, 0), false, false, command.data());
             if (!ok) return false;
         }
 
         using KisAnimationUtils::FrameItem;
         using KisAnimationUtils::FrameItemList;
         FrameItemList frameItems;
 
         Q_FOREACH(QModelIndex index, indexes) {
             KisScalarKeyframeChannel *channel = m_d->getCurveAt(index)->channel();
             KIS_ASSERT_RECOVER_RETURN_VALUE(channel, false);
 
             frameItems << FrameItem(channel->node(),
                                     channel->id(),
                                     index.column() + timeOffset);
         };
 
         new KisCommandUtils::LambdaCommand(
             command.data(),
             [frameItems, valueOffset] () -> KUndo2Command* {
 
                 QScopedPointer<KUndo2Command> cmd(new KUndo2Command());
 
                 bool result = false;
 
                 Q_FOREACH (const FrameItem &item, frameItems) {
                     const int time = item.time;
                     KisNodeSP node = item.node;
 
                     KisKeyframeChannel *channel = node->getKeyframeChannel(item.channel);
 
                     if (!channel) continue;
 
                     KisKeyframeSP keyframe = channel->keyframeAt(time);
                     if (!keyframe) continue;
 
                     const qreal currentValue = channel->scalarValue(keyframe);
                     channel->setScalarValue(keyframe, currentValue + valueOffset, cmd.data());
                     result = true;
                 }
 
                 return result ? new KisCommandUtils::SkipFirstRedoWrapper(cmd.take()) : 0;
         });
     }
 
     KisProcessingApplicator::runSingleCommandStroke(image(), command.take(), KisStrokeJobData::BARRIER);
 
     return true;
 }
 
 KisAnimationCurve *KisAnimationCurvesModel::addCurve(KisScalarKeyframeChannel *channel)
 {
     beginInsertRows(QModelIndex(), m_d->curves.size(), m_d->curves.size());
 
     KisAnimationCurve *curve = new KisAnimationCurve(channel, m_d->chooseNextColor());
     m_d->curves.append(curve);
 
     endInsertRows();
 
     connect(channel, &KisScalarKeyframeChannel::sigKeyframeAdded,
             this, &KisAnimationCurvesModel::slotKeyframeChanged);
 
     connect(channel, &KisScalarKeyframeChannel::sigKeyframeMoved,
             this, &KisAnimationCurvesModel::slotKeyframeChanged);
 
     connect(channel, &KisScalarKeyframeChannel::sigKeyframeRemoved,
             this, &KisAnimationCurvesModel::slotKeyframeChanged);
 
     connect(channel, &KisScalarKeyframeChannel::sigKeyframeChanged,
             this, &KisAnimationCurvesModel::slotKeyframeChanged);
 
     return curve;
 }
 
 void KisAnimationCurvesModel::removeCurve(KisAnimationCurve *curve)
 {
     int index = m_d->curves.indexOf(curve);
     if (index < 0) return;
 
     curve->channel()->disconnect(this);
 
     beginRemoveRows(QModelIndex(), index, index);
 
     m_d->curves.removeAt(index);
     delete curve;
 
     endRemoveRows();
 }
 
 void KisAnimationCurvesModel::setCurveVisible(KisAnimationCurve *curve, bool visible)
 {
     curve->setVisible(visible);
 
     int row = m_d->rowForCurve(curve);
     emit dataChanged(index(row, 0), index(row, columnCount()));
 }
 
 KisNodeSP KisAnimationCurvesModel::nodeAt(QModelIndex index) const
 {
     KisAnimationCurve *curve = m_d->getCurveAt(index);
     if (curve && curve->channel() && curve->channel()->node()) {
         return KisNodeSP(curve->channel()->node());
     }
     return 0;
 }
 
 QMap<QString, KisKeyframeChannel *> KisAnimationCurvesModel::channelsAt(QModelIndex index) const
 {
     KisKeyframeChannel *channel = m_d->getCurveAt(index)->channel();
     QMap<QString, KisKeyframeChannel*> list;
     list[""] = channel;
     return list;
 }
 
-void KisAnimationCurvesModel::slotKeyframeChanged(KisKeyframeSP keyframe)
+void KisAnimationCurvesModel::slotKeyframeChanged(KisKeyframeBaseSP keyframe)
 {
     int row = m_d->rowForChannel(keyframe->channel());
     QModelIndex changedIndex = index(row, keyframe->time());
     emit dataChanged(changedIndex, changedIndex);
 }
diff --git a/plugins/dockers/animation/kis_animation_curves_model.h b/plugins/dockers/animation/kis_animation_curves_model.h
index f09ee02f20..d3ca22a9c3 100644
--- a/plugins/dockers/animation/kis_animation_curves_model.h
+++ b/plugins/dockers/animation/kis_animation_curves_model.h
@@ -1,98 +1,98 @@
 /*
  *  Copyright (c) 2016 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_CURVES_MODEL_H
 #define _KIS_ANIMATION_CURVES_MODEL_H
 
 #include <QScopedPointer>
 #include <QIcon>
 #include <QAbstractItemModel>
 
 #include "kis_time_based_item_model.h"
 #include "kis_types.h"
 #include "kundo2command.h"
 
 class KisScalarKeyframeChannel;
 
 class KisAnimationCurve {
 public:
     KisAnimationCurve(KisScalarKeyframeChannel *channel, QColor color);
     KisScalarKeyframeChannel *channel() const;
     QColor color() const;
 
     void setVisible(bool visible);
     bool visible() const;
 
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 };
 
 class KisAnimationCurvesModel : public KisTimeBasedItemModel
 {
     Q_OBJECT
 public:
     KisAnimationCurvesModel(QObject *parent);
     ~KisAnimationCurvesModel() override;
 
     bool hasConnectionToCanvas() const;
 
     KisAnimationCurve *addCurve(KisScalarKeyframeChannel *channel);
     void removeCurve(KisAnimationCurve *curve);
     void setCurveVisible(KisAnimationCurve *curve, bool visible);
 
     int rowCount(const QModelIndex &parent = QModelIndex()) const override;
     QVariant data(const QModelIndex &index, int role) const override;
     bool setData(const QModelIndex &index, const QVariant &value, int role) override;
     QVariant headerData(int section, Qt::Orientation orientation, int role) const override;
 
     /**
      * Begins a block of commands. The following calls to setData will be grouped to a single undo step.
      * Note: MUST be followed by a call to endCommand().
      */
     void beginCommand(const KUndo2MagicString &text);
     void endCommand();
 
     bool adjustKeyframes(const QModelIndexList &indexes, int timeOffset, qreal valueOffset);
 
     enum ItemDataRole
     {
         ScalarValueRole = KisTimeBasedItemModel::UserRole + 101,
         InterpolationModeRole,
         TangentsModeRole,
         LeftTangentRole,
         RightTangentRole,
         CurveColorRole,
         CurveVisibleRole,
         PreviousKeyframeTime,
         NextKeyframeTime
     };
 
 protected:
     KisNodeSP nodeAt(QModelIndex index) const override;
     QMap<QString, KisKeyframeChannel *> channelsAt(QModelIndex index) const override;
 
 private Q_SLOTS:
-    void slotKeyframeChanged(KisKeyframeSP keyframe);
+    void slotKeyframeChanged(KisKeyframeBaseSP keyframe);
 
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 };
 
 #endif
diff --git a/plugins/dockers/animation/kis_animation_utils.cpp b/plugins/dockers/animation/kis_animation_utils.cpp
index 9957235d29..d0f3f8ccfa 100644
--- a/plugins/dockers/animation/kis_animation_utils.cpp
+++ b/plugins/dockers/animation/kis_animation_utils.cpp
@@ -1,351 +1,351 @@
 /*
  *  Copyright (c) 2015 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_animation_utils.h"
 
 #include "kundo2command.h"
 #include "kis_algebra_2d.h"
 #include "kis_image.h"
 #include "kis_node.h"
 #include "kis_keyframe_channel.h"
 #include "kis_post_execution_undo_adapter.h"
 #include "kis_global.h"
 #include "kis_tool_utils.h"
 #include "kis_image_animation_interface.h"
 #include "kis_command_utils.h"
 #include "kis_processing_applicator.h"
 #include "kis_transaction.h"
 
 
 namespace KisAnimationUtils {
     const QString addFrameActionName = i18n("New Frame");
     const QString duplicateFrameActionName = i18n("Copy Frame");
     const QString removeFrameActionName = i18n("Remove Frame");
     const QString removeFramesActionName = i18n("Remove Frames");
     const QString lazyFrameCreationActionName = i18n("Auto Frame Mode");
     const QString dropFramesActionName = i18n("Drop Frames");
     const QString showLayerActionName = i18n("Show in Timeline");
 
     const QString newLayerActionName = i18n("New Layer");
     const QString addExistingLayerActionName = i18n("Add Existing Layer");
     const QString removeLayerActionName = i18n("Remove Layer");
 
     const QString addOpacityKeyframeActionName = i18n("Add opacity keyframe");
     const QString addTransformKeyframeActionName = i18n("Add transform keyframe");
     const QString removeOpacityKeyframeActionName = i18n("Remove opacity keyframe");
     const QString removeTransformKeyframeActionName = i18n("Remove transform keyframe");
 
     KUndo2Command* createKeyframeCommand(KisImageSP image, KisNodeSP node, const QString &channelId, int time, bool copy, KUndo2Command *parentCommand) {
         KUndo2Command *cmd = new KisCommandUtils::LambdaCommand(
             copy ? kundo2_i18n("Copy Keyframe") :
                    kundo2_i18n("Add Keyframe"),
             parentCommand,
 
             [image, node, channelId, time, copy] () mutable -> KUndo2Command* {
                 bool result = false;
 
                 QScopedPointer<KUndo2Command> cmd(new KUndo2Command());
 
                 KisKeyframeChannel *channel = node->getKeyframeChannel(channelId);
                 bool createdChannel = false;
 
                 if (!channel) {
                     node->enableAnimation();
                     channel = node->getKeyframeChannel(channelId, true);
                     if (!channel) return nullptr;
 
                     createdChannel = true;
                 }
 
                 if (copy) {
-                    if (!channel->keyframeAt(time)) {
-                        KisKeyframeSP srcFrame = channel->activeKeyframeAt(time);
-                        channel->copyKeyframe(srcFrame, time, cmd.data());
+                    if (!channel->itemAt(time)) {
+                        KisKeyframeBaseSP srcFrame = channel->activeItemAt(time);
+                        channel->copyItem(srcFrame, time, cmd.data());
                         result = true;
                     }
                 } else {
                     if (channel->keyframeAt(time) && !createdChannel) {
                         if (image->animationInterface()->currentTime() == time && channelId == KisKeyframeChannel::Content.id()) {
 
                             //shortcut: clearing the image instead
                             KisPaintDeviceSP device = node->paintDevice();
                             if (device) {
                                 KisTransaction transaction(kundo2_i18n("Clear"), device, cmd.data());
                                 device->clear();
                                 (void) transaction.endAndTake(); // saved as 'parent'
                                 result = true;
                             }
                         }
                     } else {
                         channel->addKeyframe(time, cmd.data());
                         result = true;
                     }
                 }
 
                 return result ? new KisCommandUtils::SkipFirstRedoWrapper(cmd.take()) : nullptr;
         });
 
         return cmd;
     }
 
     void createKeyframeLazy(KisImageSP image, KisNodeSP node, const QString &channelId, int time, bool copy) {
         KUndo2Command *cmd = createKeyframeCommand(image, node, channelId, time, copy);
         KisProcessingApplicator::runSingleCommandStroke(image, cmd, KisStrokeJobData::BARRIER);
     }
 
     void removeKeyframes(KisImageSP image, const FrameItemList &frames) {
         KIS_SAFE_ASSERT_RECOVER_RETURN(!image->locked());
 
         KUndo2Command *cmd = new KisCommandUtils::LambdaCommand(
             kundo2_i18np("Remove Keyframe",
                          "Remove Keyframes",
                          frames.size()),
 
             [image, frames] () {
                 bool result = false;
 
                 QScopedPointer<KUndo2Command> cmd(new KUndo2Command());
 
                 Q_FOREACH (const FrameItem &item, frames) {
                     const int time = item.time;
                     KisNodeSP node = item.node;
                     KisKeyframeChannel *channel = 0;
                     if (node) {
                         channel = node->getKeyframeChannel(item.channel);
                     }
                     if (!channel) continue;
 
                     KisKeyframeSP keyframe = channel->keyframeAt(time);
                     if (!keyframe) continue;
 
                     channel->deleteKeyframe(keyframe, cmd.data());
 
                     result = true;
                 }
 
                 return result ? new KisCommandUtils::SkipFirstRedoWrapper(cmd.take()) : 0;
         });
 
         KisProcessingApplicator::runSingleCommandStroke(image, cmd, KisStrokeJobData::BARRIER);
     }
 
     void removeKeyframe(KisImageSP image, KisNodeSP node, const QString &channel, int time) {
         QVector<FrameItem> frames;
         frames << FrameItem(node, channel, time);
         removeKeyframes(image, frames);
     }
 
 
     struct LessOperator {
         LessOperator(const QPoint &offset)
             : m_columnCoeff(-KisAlgebra2D::signPZ(offset.x())),
               m_rowCoeff(-1000000 * KisAlgebra2D::signZZ(offset.y()))
         {
         }
 
         bool operator()(const QModelIndex &lhs, const QModelIndex &rhs) {
             return
                 m_columnCoeff * lhs.column() + m_rowCoeff * lhs.row() <
                 m_columnCoeff * rhs.column() + m_rowCoeff * rhs.row();
         }
 
     private:
         int m_columnCoeff;
         int m_rowCoeff;
     };
 
     void sortPointsForSafeMove(QModelIndexList *points, const QPoint &offset)
     {
         std::sort(points->begin(), points->end(), LessOperator(offset));
     }
 
     bool supportsContentFrames(KisNodeSP node)
     {
         return node->inherits("KisPaintLayer") || node->inherits("KisFilterMask") || node->inherits("KisTransparencyMask") || node->inherits("KisSelectionBasedLayer");
     }
 
     void swapOneFrameItem(const FrameItem &src, const FrameItem &dst, KUndo2Command *parentCommand)
     {
         const int srcTime = src.time;
         KisNodeSP srcNode = src.node;
         KisKeyframeChannel *srcChannel = srcNode->getKeyframeChannel(src.channel);
 
         const int dstTime = dst.time;
         KisNodeSP dstNode = dst.node;
         KisKeyframeChannel *dstChannel = dstNode->getKeyframeChannel(dst.channel, true);
 
         if (srcNode == dstNode) {
             if (!srcChannel) return; // TODO: add warning!
 
             srcChannel->swapFrames(srcTime, dstTime, parentCommand);
         } else {
             if (!srcChannel || !dstChannel) return; // TODO: add warning!
 
             dstChannel->swapExternalKeyframe(srcChannel, srcTime, dstTime, parentCommand);
         }
     }
 
     void moveOneFrameItem(const FrameItem &src, const FrameItem &dst, KeyframeAction action, bool moveEmptyFrames, KUndo2Command *parentCommand)
     {
         const int srcTime = src.time;
         KisNodeSP srcNode = src.node;
         KisKeyframeChannel *srcChannel = srcNode->getKeyframeChannel(src.channel);
 
         const int dstTime = dst.time;
         KisNodeSP dstNode = dst.node;
         KisKeyframeChannel *dstChannel = dstNode->getKeyframeChannel(dst.channel, true);
 
         if (srcNode == dstNode) {
             if (!srcChannel) return; // TODO: add warning!
 
             KisKeyframeSP srcKeyframe = srcChannel->keyframeAt(srcTime);
             KisKeyframeSP dstKeyFrame = srcChannel->keyframeAt(dstTime);
             if (srcKeyframe) {
                 if (action == CopyKeyframes) {
                     srcChannel->copyKeyframe(srcKeyframe, dstTime, parentCommand);
                 } else if (action == LinkKeyframes) {
                     srcChannel->linkKeyframe(srcKeyframe, dstTime, parentCommand);
                 } else {
                     srcChannel->moveKeyframe(srcKeyframe, dstTime, parentCommand);
                 }
             } else {
                 if (dstKeyFrame && moveEmptyFrames && action != CopyKeyframes) {
                     //Destination is effectively replaced by an empty frame.
                     dstChannel->deleteKeyframe(dstKeyFrame, parentCommand);
                 }
             }
         } else {
             if (!srcChannel || !dstChannel) return; // TODO: add warning!
 
             KisKeyframeSP srcKeyframe = srcChannel->keyframeAt(srcTime);
 
             if (!srcKeyframe) return; // TODO: add warning!
 
             dstChannel->copyExternalKeyframe(srcChannel, srcTime, dstTime, parentCommand);
 
             if (action == MoveKeyframes) {
                 srcChannel->deleteKeyframe(srcKeyframe, parentCommand);
             }
         }
     }
 
     KUndo2Command* createMoveKeyframesCommand(const FrameItemList &srcFrames,
                                               const FrameItemList &dstFrames,
                                               bool copy,
                                               bool moveEmpty,
                                               KUndo2Command *parentCommand)
     {
         FrameMovePairList srcDstPairs;
         for (int i = 0; i < srcFrames.size(); i++) {
             srcDstPairs << std::make_pair(srcFrames[i], dstFrames[i]);
         }
         return createMoveKeyframesCommand(srcDstPairs, copy ? CopyKeyframes : MoveKeyframes, moveEmpty, parentCommand);
     }
 
     KUndo2Command* createMoveKeyframesCommand(const FrameMovePairList &srcDstPairs,
                                               KeyframeAction action,
                                               bool moveEmptyFrames,
                                               KUndo2Command *parentCommand)
     {
         KUndo2Command *cmd = new KisCommandUtils::LambdaCommand(
 
                 (action == CopyKeyframes) ?
                 kundo2_i18np("Copy Keyframe",
                              "Copy %1 Keyframes",
                              srcDstPairs.size()) :
                 (action == LinkKeyframes) ?
                 kundo2_i18np("Link Keyframe",
                              "Link %1 Keyframes",
                              srcDstPairs.size()) :
                 kundo2_i18np("Move Keyframe",
                              "Move %1 Keyframes",
                               srcDstPairs.size()),
 
             parentCommand,
 
             [srcDstPairs, action, moveEmptyFrames] () -> KUndo2Command* {
                 bool result = false;
 
                 QScopedPointer<KUndo2Command> cmd(new KUndo2Command());
 
                 using MoveChain = QList<FrameItem>;
                 QHash<FrameItem, MoveChain> moveMap;
                 Q_FOREACH (const FrameMovePair &pair, srcDstPairs) {
                     moveMap.insert(pair.first, {pair.second});
                 }
 
                 auto it = moveMap.begin();
                 while (it != moveMap.end()) {
                     MoveChain &chain = it.value();
                     const FrameItem &previousFrame = chain.last();
 
                     auto tailIt = moveMap.find(previousFrame);
 
                     if (tailIt == it || tailIt == moveMap.end()) {
                         ++it;
                         continue;
                     }
 
                     chain.append(tailIt.value());
                     tailIt = moveMap.erase(tailIt);
                     // no incrementing! we are going to check the new tail now!
                 }
 
                 for (it = moveMap.begin(); it != moveMap.end(); ++it) {
                     MoveChain &chain = it.value();
                     chain.prepend(it.key());
                     KIS_SAFE_ASSERT_RECOVER(chain.size() > 1) { continue; }
 
                     bool isCycle = false;
                     if (chain.last() == chain.first()) {
                         isCycle = true;
                         chain.takeLast();
                     }
 
                     auto frameIt = chain.rbegin();
 
                     FrameItem dstItem = *frameIt++;
 
                     while (frameIt != chain.rend()) {
                         FrameItem srcItem = *frameIt++;
 
                         if (!isCycle) {
                             moveOneFrameItem(srcItem, dstItem, action, moveEmptyFrames, cmd.data());
                         } else {
                             swapOneFrameItem(srcItem, dstItem, cmd.data());
                         }
 
                         dstItem = srcItem;
                         result = true;
                     }
                 }
 
                 return result ? new KisCommandUtils::SkipFirstRedoWrapper(cmd.take()) : 0;
         });
 
         return cmd;
     }
 
     QDebug operator<<(QDebug dbg, const FrameItem &item)
     {
         dbg.nospace() << "FrameItem(" << item.node->name() << ", " << item.channel << ", " << item.time << ")";
         return dbg.space();
     }
 
 }
 
diff --git a/plugins/dockers/animation/timeline_frames_model.cpp b/plugins/dockers/animation/timeline_frames_model.cpp
index bb465ead71..5f69c09da8 100644
--- a/plugins/dockers/animation/timeline_frames_model.cpp
+++ b/plugins/dockers/animation/timeline_frames_model.cpp
@@ -1,1120 +1,1119 @@
 /*
  *  Copyright (c) 2015 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 "timeline_frames_model.h"
 #include <QFont>
 #include <QSize>
 #include <QColor>
 #include <QMimeData>
 #include <QPointer>
 #include <KoResourceModel.h>
 
 #include "kis_layer.h"
 #include "kis_config.h"
 
 #include "kis_global.h"
 #include "kis_debug.h"
 #include "kis_image.h"
 #include "kis_image_animation_interface.h"
 #include "kis_undo_adapter.h"
 #include "kis_node_dummies_graph.h"
 #include "kis_dummies_facade_base.h"
 #include "kis_signal_compressor.h"
 #include "kis_signal_compressor_with_param.h"
 #include "kis_keyframe_channel.h"
+#include "kis_keyframe_commands.h"
 #include "kundo2command.h"
 #include "kis_post_execution_undo_adapter.h"
 #include <commands/kis_node_property_list_command.h>
 #include <commands_new/kis_switch_current_time_command.h>
 
 #include "kis_animation_utils.h"
 #include "timeline_color_scheme.h"
 #include "kis_node_model.h"
 #include "kis_projection_leaf.h"
 #include "kis_time_range.h"
 #include "kis_animation_cycle.h"
 
 #include "kis_node_view_color_scheme.h"
 #include "krita_utils.h"
 #include <QApplication>
 #include "kis_processing_applicator.h"
 #include <KisImageBarrierLockerWithFeedback.h>
 #include "kis_node_uuid_info.h"
 
 
 struct TimelineFramesModel::Private
 {
     Private()
         : activeLayerIndex(0),
           dummiesFacade(0),
           needFinishInsertRows(false),
           needFinishRemoveRows(false),
           updateTimer(200, KisSignalCompressor::FIRST_INACTIVE),
           parentOfRemovedNode(0)
     {}
 
     int activeLayerIndex;
 
     QPointer<KisDummiesFacadeBase> dummiesFacade;
     KisImageWSP image;
     bool needFinishInsertRows;
     bool needFinishRemoveRows;
 
     QList<KisNodeDummy*> updateQueue;
     KisSignalCompressor updateTimer;
 
     KisNodeDummy* parentOfRemovedNode;
     QScopedPointer<TimelineNodeListKeeper> converter;
 
     QScopedPointer<NodeManipulationInterface> nodeInterface;
 
     QPersistentModelIndex lastClickedIndex;
 
     QVariant layerName(int row) const {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return QVariant();
         return dummy->node()->name();
     }
 
     bool layerEditable(int row) const {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return true;
         return dummy->node()->visible() && !dummy->node()->userLocked();
     }
 
     bool frameExists(int row, int column) const {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return false;
 
         KisKeyframeChannel *primaryChannel = dummy->node()->getKeyframeChannel(KisKeyframeChannel::Content.id());
         return (primaryChannel && primaryChannel->keyframeAt(column));
     }
 
     bool frameHasContent(int row, int column) {
 
         KisNodeDummy *dummy = converter->dummyFromRow(row);
 
         KisKeyframeChannel *primaryChannel = dummy->node()->getKeyframeChannel(KisKeyframeChannel::Content.id());
         if (!primaryChannel) return false;
 
         // first check if we are a key frame
         KisKeyframeSP frame = primaryChannel->activeKeyframeAt(column);
         if (!frame) return false;
 
         return frame->hasContent();
     }
 
     bool specialKeyframeExists(int row, int column) {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return false;
         Q_FOREACH(KisKeyframeChannel *channel, dummy->node()->keyframeChannels()) {
             if (channel->id() != KisKeyframeChannel::Content.id() && channel->keyframeAt(column)) {
                 return true;
             }
         }
         return false;
     }
 
     bool isIdenticalWith(int row, int column, int frame) {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return false;
         Q_FOREACH(KisKeyframeChannel *channel, dummy->node()->keyframeChannels()) {
             if (channel->areFramesIdentical(column, frame)) {
                 return true;
             }
         }
         return false;
     }
 
     int frameColorLabel(int row, int column) {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return -1;
 
         KisKeyframeChannel *primaryChannel = dummy->node()->getKeyframeChannel(KisKeyframeChannel::Content.id());
         if (!primaryChannel) return -1;
 
         KisKeyframeSP frame = primaryChannel->activeKeyframeAt(column);
         if (!frame) return -1;
 
         return frame->colorLabel();
     }
 
     void setFrameColorLabel(int row, int column, int color) {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return;
 
         KisKeyframeChannel *primaryChannel = dummy->node()->getKeyframeChannel(KisKeyframeChannel::Content.id());
         if (!primaryChannel) return;
 
         KisKeyframeSP frame = primaryChannel->keyframeAt(column);
         if (!frame) return;
 
         frame->setColorLabel(color);
     }
 
     int layerColorLabel(int row) const {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return -1;
         return dummy->node()->colorLabelIndex();
     }
 
     CycleMode frameCycleMode(int row, int time) const{
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return NoCycle;
 
         KisKeyframeChannel *primaryChannel = dummy->node()->getKeyframeChannel(KisKeyframeChannel::Content.id());
         if (!primaryChannel) return NoCycle;
 
         KisTimeSpan cycle = primaryChannel->cycledRangeAt(time);
         KisKeyframeSP keyframe = primaryChannel->activeKeyframeAt(time);
         KisRepeatFrame *repeatFrame = dynamic_cast<KisRepeatFrame*>(keyframe.data());
 
         if (repeatFrame){
             const int originalTime = repeatFrame->getOriginalTimeFor(time);
             if (cycle.start() == originalTime) return BeginsRepeat;
             if (cycle.end() == originalTime) return EndsRepeat;
             return ContinuesRepeat;
         } else if (cycle.contains(time)) {
             if (cycle.start() == time) return BeginsCycle;
             if (cycle.end() == time) return EndsCycle;
             return ContinuesCycle;
         }
 
         return NoCycle;
     };
 
     QVariant layerProperties(int row) const {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return QVariant();
 
         PropertyList props = dummy->node()->sectionModelProperties();
         return QVariant::fromValue(props);
     }
 
     bool setLayerProperties(int row, PropertyList props) {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return false;
 
         KisNodePropertyListCommand::setNodePropertiesNoUndo(dummy->node(), image, props);
         return true;
     }
 
     bool addKeyframe(int row, int column, bool copy) {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return false;
 
         KisNodeSP node = dummy->node();
         if (!KisAnimationUtils::supportsContentFrames(node)) return false;
 
         KisAnimationUtils::createKeyframeLazy(image, node, KisKeyframeChannel::Content.id(), column, copy);
         return true;
     }
 
     bool addNewLayer(int row) {
         Q_UNUSED(row);
 
         if (nodeInterface) {
             KisLayerSP layer = nodeInterface->addPaintLayer();
             layer->setUseInTimeline(true);
         }
 
         return true;
     }
 
     bool removeLayer(int row) {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return false;
 
         if (nodeInterface) {
             nodeInterface->removeNode(dummy->node());
         }
 
         return true;
     }
 };
 
 TimelineFramesModel::TimelineFramesModel(QObject *parent)
     : ModelWithExternalNotifications(parent),
       m_d(new Private)
 {
     connect(&m_d->updateTimer, SIGNAL(timeout()), SLOT(processUpdateQueue()));
 }
 
 TimelineFramesModel::~TimelineFramesModel()
 {
 }
 
 bool TimelineFramesModel::hasConnectionToCanvas() const
 {
     return m_d->dummiesFacade;
 }
 
 void TimelineFramesModel::setNodeManipulationInterface(NodeManipulationInterface *iface)
 {
     m_d->nodeInterface.reset(iface);
 }
 
 KisNodeSP TimelineFramesModel::nodeAt(QModelIndex index) const
 {
     /**
      * The dummy might not exist because the user could (quickly) change
      * active layer and the list of the nodes in m_d->converter will change.
      */
     KisNodeDummy *dummy = m_d->converter->dummyFromRow(index.row());
     return dummy ? dummy->node() : 0;
 }
 
 QMap<QString, KisKeyframeChannel*> TimelineFramesModel::channelsAt(QModelIndex index) const
 {
     KisNodeDummy *srcDummy = m_d->converter->dummyFromRow(index.row());
     return srcDummy->node()->keyframeChannels();
 }
 
 void TimelineFramesModel::setDummiesFacade(KisDummiesFacadeBase *dummiesFacade, KisImageSP image)
 {
     KisDummiesFacadeBase *oldDummiesFacade = m_d->dummiesFacade;
 
     if (m_d->dummiesFacade && m_d->image) {
         m_d->image->animationInterface()->disconnect(this);
         m_d->image->disconnect(this);
         m_d->dummiesFacade->disconnect(this);
     }
 
     m_d->image = image;
     KisTimeBasedItemModel::setImage(image);
 
     m_d->dummiesFacade = dummiesFacade;
     m_d->converter.reset();
 
     if (m_d->dummiesFacade) {
         m_d->converter.reset(new TimelineNodeListKeeper(this, m_d->dummiesFacade));
         connect(m_d->dummiesFacade, SIGNAL(sigDummyChanged(KisNodeDummy*)),
                 SLOT(slotDummyChanged(KisNodeDummy*)));
         connect(m_d->image->animationInterface(),
                 SIGNAL(sigFullClipRangeChanged()), SIGNAL(sigInfiniteTimelineUpdateNeeded()));
         connect(m_d->image->animationInterface(),
                 SIGNAL(sigAudioChannelChanged()), SIGNAL(sigAudioChannelChanged()));
         connect(m_d->image->animationInterface(),
                 SIGNAL(sigAudioVolumeChanged()), SIGNAL(sigAudioChannelChanged()));
         connect(m_d->image, SIGNAL(sigImageModified()), SLOT(slotImageContentChanged()));
     }
 
     if (m_d->dummiesFacade != oldDummiesFacade) {
         beginResetModel();
         endResetModel();
     }
 
     if (m_d->dummiesFacade) {
         emit sigInfiniteTimelineUpdateNeeded();
         emit sigAudioChannelChanged();
     }
 }
 
 void TimelineFramesModel::slotDummyChanged(KisNodeDummy *dummy)
 {
     if (!m_d->updateQueue.contains(dummy)) {
         m_d->updateQueue.append(dummy);
     }
     m_d->updateTimer.start();
 }
 
 void TimelineFramesModel::slotImageContentChanged()
 {
     if (m_d->activeLayerIndex < 0) return;
 
     KisNodeDummy *dummy = m_d->converter->dummyFromRow(m_d->activeLayerIndex);
     if (!dummy) return;
 
     slotDummyChanged(dummy);
 }
 
 void TimelineFramesModel::processUpdateQueue()
 {
     Q_FOREACH (KisNodeDummy *dummy, m_d->updateQueue) {
         int row = m_d->converter->rowForDummy(dummy);
 
         if (row >= 0) {
             emit headerDataChanged (Qt::Vertical, row, row);
             emit dataChanged(this->index(row, 0), this->index(row, columnCount() - 1));
         }
     }
     m_d->updateQueue.clear();
 }
 
 void TimelineFramesModel::slotCurrentNodeChanged(KisNodeSP node)
 {
     if (!node) {
         m_d->activeLayerIndex = -1;
         return;
     }
 
     KisNodeDummy *dummy = m_d->dummiesFacade->dummyForNode(node);
     if (!dummy) {
         // It's perfectly normal that dummyForNode returns 0; that happens
         // when views get activated while Krita is closing down.
         return;
     }
 
     m_d->converter->updateActiveDummy(dummy);
 
     const int row = m_d->converter->rowForDummy(dummy);
     if (row < 0) {
         qWarning() << "WARNING: TimelineFramesModel::slotCurrentNodeChanged: node not found!";
     }
 
     if (row >= 0 && m_d->activeLayerIndex != row) {
         setData(index(row, 0), true, ActiveLayerRole);
     }
 }
 
 int TimelineFramesModel::rowCount(const QModelIndex &parent) const
 {
     Q_UNUSED(parent);
     if(!m_d->dummiesFacade) return 0;
 
     return m_d->converter->rowCount();
 }
 
 QVariant TimelineFramesModel::data(const QModelIndex &index, int role) const
 {
     if(!m_d->dummiesFacade) return QVariant();
 
     switch (role) {
     case ActiveLayerRole: {
         return index.row() == m_d->activeLayerIndex;
     }
     case FrameEditableRole: {
         return m_d->layerEditable(index.row());
     }
     case FrameHasContent: {
         return m_d->frameHasContent(index.row(), index.column());
     }
     case FrameExistsRole: {
         return m_d->frameExists(index.row(), index.column());
     }
     case SpecialKeyframeExists: {
         return m_d->specialKeyframeExists(index.row(), index.column());
     }
     case IdenticalWithActive: {
         return m_d->isIdenticalWith(index.row(), index.column(), activeFrameIndex());
     }
     case FrameColorLabelIndexRole: {
         int label = m_d->frameColorLabel(index.row(), index.column());
         return label > 0 ? label : QVariant();
     }
     case FrameCycleMode: {
         return m_d->frameCycleMode(index.row(), index.column());
     }
     case Qt::DisplayRole: {
         return m_d->layerName(index.row());
     }
     case Qt::TextAlignmentRole: {
         return QVariant(Qt::AlignHCenter | Qt::AlignVCenter);
     }
     case KoResourceModel::LargeThumbnailRole: {
         KisNodeDummy *dummy = m_d->converter->dummyFromRow(index.row());
         if (!dummy) {
             return  QVariant();
         }
         const int maxSize = 200;
 
         QSize size = dummy->node()->extent().size();
         size.scale(maxSize, maxSize, Qt::KeepAspectRatio);
         if (size.width() == 0 || size.height() == 0) {
             // No thumbnail can be shown if there isn't width or height...
             return QVariant();
         }
         QImage image(dummy->node()->createThumbnailForFrame(size.width(), size.height(), index.column()));
         return image;
     }
     }
 
     return ModelWithExternalNotifications::data(index, role);
 }
 
 bool TimelineFramesModel::setData(const QModelIndex &index, const QVariant &value, int role)
 {
     if (!index.isValid() || !m_d->dummiesFacade) return false;
 
     switch (role) {
     case ActiveLayerRole: {
         if (value.toBool() &&
             index.row() != m_d->activeLayerIndex) {
 
             int prevLayer = m_d->activeLayerIndex;
             m_d->activeLayerIndex = index.row();
 
             emit dataChanged(this->index(prevLayer, 0), this->index(prevLayer, columnCount() - 1));
             emit dataChanged(this->index(m_d->activeLayerIndex, 0), this->index(m_d->activeLayerIndex, columnCount() - 1));
 
             emit headerDataChanged(Qt::Vertical, prevLayer, prevLayer);
             emit headerDataChanged(Qt::Vertical, m_d->activeLayerIndex, m_d->activeLayerIndex);
 
             KisNodeDummy *dummy = m_d->converter->dummyFromRow(m_d->activeLayerIndex);
             KIS_ASSERT_RECOVER(dummy) { return true; }
 
             emit requestCurrentNodeChanged(dummy->node());
             emit sigEnsureRowVisible(m_d->activeLayerIndex);
         }
         break;
     }
     case FrameColorLabelIndexRole: {
         m_d->setFrameColorLabel(index.row(), index.column(), value.toInt());
     }
         break;
     }
 
     return ModelWithExternalNotifications::setData(index, value, role);
 }
 
 QVariant TimelineFramesModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
     if(!m_d->dummiesFacade) return QVariant();
 
     if (orientation == Qt::Vertical) {
         switch (role) {
         case ActiveLayerRole:
             return section == m_d->activeLayerIndex;
         case Qt::DisplayRole: {
             QVariant value = headerData(section, orientation, Qt::ToolTipRole);
             if (!value.isValid()) return value;
 
             QString name = value.toString();
             const int maxNameSize = 13;
 
             if (name.size() > maxNameSize) {
                 name = QString("%1...").arg(name.left(maxNameSize));
             }
 
             return name;
         }
         case Qt::TextColorRole: {
             // WARNING: this role doesn't work for header views! Use
             //          bold font to show isolated mode instead!
             return QVariant();
         }
         case Qt::FontRole: {
             KisNodeDummy *dummy = m_d->converter->dummyFromRow(section);
             if (!dummy) return QVariant();
             KisNodeSP node = dummy->node();
 
             QFont baseFont;
             if (node->projectionLeaf()->isDroppedMask()) {
                 baseFont.setStrikeOut(true);
             } else if (m_d->image && m_d->image->isolatedModeRoot() &&
                        KisNodeModel::belongsToIsolatedGroup(m_d->image, node, m_d->dummiesFacade)) {
                 baseFont.setBold(true);
             }
             return baseFont;
         }
         case Qt::ToolTipRole: {
             return m_d->layerName(section);
         }
         case TimelinePropertiesRole: {
             return QVariant::fromValue(m_d->layerProperties(section));
         }
         case OtherLayersRole: {
             TimelineNodeListKeeper::OtherLayersList list =
                 m_d->converter->otherLayersList();
 
             return QVariant::fromValue(list);
         }
         case LayerUsedInTimelineRole: {
             KisNodeDummy *dummy = m_d->converter->dummyFromRow(section);
             if (!dummy) return QVariant();
             return dummy->node()->useInTimeline();
         }
         case Qt::BackgroundRole: {
             int label = m_d->layerColorLabel(section);
             if (label > 0) {
                 KisNodeViewColorScheme scm;
                 QColor color = scm.colorLabel(label);
                 QPalette pal = qApp->palette();
                 color = KritaUtils::blendColors(color, pal.color(QPalette::Button), 0.3);
                 return QBrush(color);
             } else {
                 return QVariant();
             }
         }
         }
     }
 
     return ModelWithExternalNotifications::headerData(section, orientation, role);
 }
 
 bool TimelineFramesModel::setHeaderData(int section, Qt::Orientation orientation, const QVariant &value, int role)
 {
     if (!m_d->dummiesFacade) return false;
 
     if (orientation == Qt::Vertical) {
         switch (role) {
         case ActiveLayerRole: {
             setData(index(section, 0), value, role);
             break;
         }
         case TimelinePropertiesRole: {
             TimelineFramesModel::PropertyList props = value.value<TimelineFramesModel::PropertyList>();
 
             int result = m_d->setLayerProperties(section, props);
             emit headerDataChanged (Qt::Vertical, section, section);
             return result;
         }
         case LayerUsedInTimelineRole: {
             KisNodeDummy *dummy = m_d->converter->dummyFromRow(section);
             if (!dummy) return false;
             dummy->node()->setUseInTimeline(value.toBool());
             return true;
         }
         }
     }
 
     return ModelWithExternalNotifications::setHeaderData(section, orientation, value, role);
 }
 
 Qt::DropActions TimelineFramesModel::supportedDragActions() const
 {
     return Qt::MoveAction | Qt::CopyAction | Qt::LinkAction;
 }
 
 Qt::DropActions TimelineFramesModel::supportedDropActions() const
 {
     return Qt::MoveAction | Qt::CopyAction | Qt::LinkAction;
 }
 
 QStringList TimelineFramesModel::mimeTypes() const
 {
     QStringList types;
     types << QLatin1String("application/x-krita-frame");
     return types;
 }
 
 void TimelineFramesModel::setLastClickedIndex(const QModelIndex &index)
 {
     m_d->lastClickedIndex = index;
 }
 
 QMimeData* TimelineFramesModel::mimeData(const QModelIndexList &indexes) const
 {
     return mimeDataExtended(indexes, m_d->lastClickedIndex, UndefinedPolicy);
 }
 
 QMimeData *TimelineFramesModel::mimeDataExtended(const QModelIndexList &indexes,
                                                  const QModelIndex &baseIndex,
                                                  TimelineFramesModel::MimeCopyPolicy copyPolicy) const
 {
     QMimeData *data = new QMimeData();
 
     QByteArray encoded;
     QDataStream stream(&encoded, QIODevice::WriteOnly);
 
     const int baseRow = baseIndex.row();
     const int baseColumn = baseIndex.column();
 
     stream << indexes.size();
     stream << baseRow << baseColumn;
 
     Q_FOREACH (const QModelIndex &index, indexes) {
         KisNodeSP node = nodeAt(index);
         KIS_SAFE_ASSERT_RECOVER(node) { continue; }
 
         stream << index.row() - baseRow << index.column() - baseColumn;
 
         const QByteArray uuidData = node->uuid().toRfc4122();
         stream << int(uuidData.size());
         stream.writeRawData(uuidData.data(), uuidData.size());
     }
 
     stream << int(copyPolicy);
     data->setData("application/x-krita-frame", encoded);
 
     return data;
 }
 
 inline void decodeBaseIndex(QByteArray *encoded, int *row, int *col)
 {
     int size_UNUSED = 0;
 
     QDataStream stream(encoded, QIODevice::ReadOnly);
     stream >> size_UNUSED >> *row >> *col;
 }
 
 bool TimelineFramesModel::canDropFrameData(const QMimeData */*data*/, const QModelIndex &index)
 {
     if (!index.isValid()) return false;
 
     /**
      * Now we support D&D around any layer, so just return 'true' all
      * the time.
      */
     return true;
 }
 
 bool TimelineFramesModel::dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent)
 {
     Q_UNUSED(row);
     Q_UNUSED(column);
 
     return dropMimeDataExtended(data, action, parent);
 }
 
 bool TimelineFramesModel::dropMimeDataExtended(const QMimeData *data, Qt::DropAction action, const QModelIndex &parent, bool *dataMoved)
 {
     bool result = false;
 
     if ((action != Qt::MoveAction && action != Qt::CopyAction && action != Qt::LinkAction) ||
         !parent.isValid()) return result;
 
     QByteArray encoded = data->data("application/x-krita-frame");
     QDataStream stream(&encoded, QIODevice::ReadOnly);
 
     int size, baseRow, baseColumn;
     stream >> size >> baseRow >> baseColumn;
 
     const QPoint offset(parent.column() - baseColumn, parent.row() - baseRow);
 
     KisAnimationUtils::FrameMovePairList frameMoves;
 
     for (int i = 0; i < size; i++) {
         int relRow, relColumn;
         stream >> relRow >> relColumn;
 
         const int srcRow = baseRow + relRow;
         const int srcColumn = baseColumn + relColumn;
 
         int uuidLen = 0;
         stream >> uuidLen;
         QByteArray uuidData(uuidLen, '\0');
         stream.readRawData(uuidData.data(), uuidLen);
         QUuid nodeUuid = QUuid::fromRfc4122(uuidData);
 
         KisNodeSP srcNode;
 
         if (!nodeUuid.isNull()) {
             KisNodeUuidInfo nodeInfo(nodeUuid);
             srcNode = nodeInfo.findNode(m_d->image->root());
         } else {
             QModelIndex index = this->index(srcRow, srcColumn);
             srcNode = nodeAt(index);
         }
 
         KIS_SAFE_ASSERT_RECOVER(srcNode) { continue; }
 
         const QModelIndex dstIndex = this->index(srcRow + offset.y(), srcColumn + offset.x());
         if (!dstIndex.isValid()) continue;
 
         KisNodeSP dstNode = nodeAt(dstIndex);
         KIS_SAFE_ASSERT_RECOVER(dstNode) { continue; }
 
         Q_FOREACH (KisKeyframeChannel *channel, srcNode->keyframeChannels().values()) {
             KisAnimationUtils::FrameItem srcItem(srcNode, channel->id(), srcColumn);
             KisAnimationUtils::FrameItem dstItem(dstNode, channel->id(), dstIndex.column());
             frameMoves << std::make_pair(srcItem, dstItem);
         }
     }
 
     MimeCopyPolicy copyPolicy = UndefinedPolicy;
 
     if (!stream.atEnd()) {
         int value = 0;
         stream >> value;
         copyPolicy = MimeCopyPolicy(value);
     }
 
     const bool copyFrames =
         copyPolicy == UndefinedPolicy ?
         action == Qt::CopyAction :
         copyPolicy == CopyFramesPolicy;
 
     if (dataMoved) {
         *dataMoved = !copyFrames;
     }
 
     KUndo2Command *cmd = 0;
 
     KisAnimationUtils::KeyframeAction frameAction;
     if (action == Qt::LinkAction) {
         frameAction = KisAnimationUtils::LinkKeyframes;
     } else {
         frameAction = copyFrames ? KisAnimationUtils::CopyKeyframes : KisAnimationUtils::MoveKeyframes;
     }
 
     if (!frameMoves.isEmpty()) {
         KisImageBarrierLockerWithFeedback locker(m_d->image);
         cmd = KisAnimationUtils::createMoveKeyframesCommand(frameMoves, frameAction, false, 0);
     }
 
     if (cmd) {
         KisProcessingApplicator::runSingleCommandStroke(m_d->image, cmd, KisStrokeJobData::BARRIER);
     }
 
     return cmd;
 }
 
 Qt::ItemFlags TimelineFramesModel::flags(const QModelIndex &index) const
 {
     Qt::ItemFlags flags = ModelWithExternalNotifications::flags(index);
     if (!index.isValid()) return flags;
 
     if (m_d->frameExists(index.row(), index.column()) || m_d->specialKeyframeExists(index.row(), index.column())) {
         if (data(index, FrameEditableRole).toBool()) {
             flags |= Qt::ItemIsDragEnabled;
         }
     }
 
     /**
      * Basically we should forbid overrides only if we D&D a single frame
      * and allow it when we D&D multiple frames. But we cannot distinguish
      * it here... So allow all the time.
      */
     flags |= Qt::ItemIsDropEnabled;
 
     return flags;
 }
 
 bool TimelineFramesModel::insertRows(int row, int count, const QModelIndex &parent)
 {
     Q_UNUSED(parent);
 
     KIS_ASSERT_RECOVER(count == 1) { return false; }
 
     if (row < 0 || row > rowCount()) return false;
 
     bool result = m_d->addNewLayer(row);
     return result;
 }
 
 bool TimelineFramesModel::removeRows(int row, int count, const QModelIndex &parent)
 {
     Q_UNUSED(parent);
     KIS_ASSERT_RECOVER(count == 1) { return false; }
 
     if (row < 0 || row >= rowCount()) return false;
 
     bool result = m_d->removeLayer(row);
     return result;
 }
 
 bool TimelineFramesModel::insertOtherLayer(int index, int dstRow)
 {
     Q_UNUSED(dstRow);
 
     TimelineNodeListKeeper::OtherLayersList list =
         m_d->converter->otherLayersList();
 
     if (index < 0 || index >= list.size()) return false;
 
     list[index].dummy->node()->setUseInTimeline(true);
     dstRow = m_d->converter->rowForDummy(list[index].dummy);
     setData(this->index(dstRow, 0), true, ActiveLayerRole);
 
     return true;
 }
 
 int TimelineFramesModel::activeLayerRow() const
 {
     return m_d->activeLayerIndex;
 }
 
 bool TimelineFramesModel::createFrame(const QModelIndex &dstIndex)
 {
     if (!dstIndex.isValid()) return false;
 
     return m_d->addKeyframe(dstIndex.row(), dstIndex.column(), false);
 }
 
 bool TimelineFramesModel::copyFrame(const QModelIndex &dstIndex)
 {
     if (!dstIndex.isValid()) return false;
 
     return m_d->addKeyframe(dstIndex.row(), dstIndex.column(), true);
 }
 
 bool TimelineFramesModel::insertFrames(int dstColumn, const QList<int> &dstRows, int count, int timing)
 {
     if (dstRows.isEmpty() || count <= 0) return true;
     timing = qMax(timing, 1);
 
     KUndo2Command *parentCommand = new KUndo2Command(kundo2_i18np("Insert frame", "Insert %1 frames", count));
 
     {
         KisImageBarrierLockerWithFeedback locker(m_d->image);
 
         QModelIndexList indexes;
 
         Q_FOREACH (int row, dstRows) {
             for (int column = dstColumn; column < columnCount(); column++) {
                 indexes << index(row, column);
             }
         }
 
         setLastVisibleFrame(columnCount() + (count * timing) - 1);
 
         createOffsetFramesCommand(indexes, QPoint((count * timing), 0), false, false, parentCommand);
 
         Q_FOREACH (int row, dstRows) {
             KisNodeDummy *dummy = m_d->converter->dummyFromRow(row);
             if (!dummy) continue;
 
             KisNodeSP node = dummy->node();
             if (!KisAnimationUtils::supportsContentFrames(node)) continue;
 
             for (int column = dstColumn; column < dstColumn + (count * timing); column += timing) {
                 KisAnimationUtils::createKeyframeCommand(m_d->image, node, KisKeyframeChannel::Content.id(), column, false, parentCommand);
             }
         }
 
         const int oldTime = m_d->image->animationInterface()->currentUITime();
         const int newTime = dstColumn > oldTime ? dstColumn : dstColumn + (count * timing) - 1;
 
         new KisSwitchCurrentTimeCommand(m_d->image->animationInterface(),
                                         oldTime,
                                         newTime, parentCommand);
     }
 
     KisProcessingApplicator::runSingleCommandStroke(m_d->image, parentCommand, KisStrokeJobData::BARRIER);
 
     return true;
 }
 
 bool TimelineFramesModel::insertHoldFrames(QModelIndexList selectedIndexes, int count)
 {
     if (selectedIndexes.isEmpty() || count == 0) return true;
 
     QScopedPointer<KUndo2Command> parentCommand(new KUndo2Command(kundo2_i18np("Insert frame", "Insert %1 frames", count)));
 
     {
         KisImageBarrierLockerWithFeedback locker(m_d->image);
 
         QSet<KisKeyframeSP> uniqueKeyframesInSelection;
 
         int minSelectedTime = std::numeric_limits<int>::max();
 
         Q_FOREACH (const QModelIndex &index, selectedIndexes) {
             KisNodeSP node = nodeAt(index);
             KIS_SAFE_ASSERT_RECOVER(node) { continue; }
 
             KisKeyframeChannel *channel = node->getKeyframeChannel(KisKeyframeChannel::Content.id());
             if (!channel) continue;
 
             minSelectedTime = qMin(minSelectedTime, index.column());
             KisKeyframeSP keyFrame = channel->activeKeyframeAt(index.column());
 
             if (keyFrame) {
                 uniqueKeyframesInSelection.insert(keyFrame);
             }
         }
 
         QList<KisKeyframeSP> keyframesToMove;
 
         for (auto it = uniqueKeyframesInSelection.begin(); it != uniqueKeyframesInSelection.end(); ++it) {
             KisKeyframeSP keyframe = *it;
 
             KisKeyframeChannel *channel = keyframe->channel();
             KisKeyframeSP nextKeyframe = channel->nextKeyframe(keyframe);
 
             if (nextKeyframe) {
                 keyframesToMove << nextKeyframe;
             }
         }
 
         std::sort(keyframesToMove.begin(), keyframesToMove.end(),
             [] (KisKeyframeSP lhs, KisKeyframeSP rhs) {
                 return lhs->time() > rhs->time();
             });
 
         if (keyframesToMove.isEmpty()) return true;
 
         const int maxColumn = columnCount();
 
         if (count > 0) {
             setLastVisibleFrame(columnCount() + count);
         }
 
         Q_FOREACH (KisKeyframeSP keyframe, keyframesToMove) {
             int plannedFrameMove = count;
 
             if (count < 0) {
                 KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(keyframe->time() > 0, false);
 
                 KisKeyframeSP prevFrame = keyframe->channel()->previousKeyframe(keyframe);
                 KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(prevFrame, false);
 
                 plannedFrameMove = qMax(count, prevFrame->time() - keyframe->time() + 1);
 
                 minSelectedTime = qMin(minSelectedTime, prevFrame->time());
             }
 
             KisNodeDummy *dummy = m_d->dummiesFacade->dummyForNode(keyframe->channel()->node());
             KIS_SAFE_ASSERT_RECOVER(dummy) { continue; }
 
             const int row = m_d->converter->rowForDummy(dummy);
             KIS_SAFE_ASSERT_RECOVER(row >= 0) { continue; }
 
             QModelIndexList indexes;
             for (int column = keyframe->time(); column < maxColumn; column++) {
                 indexes << index(row, column);
             }
 
             createOffsetFramesCommand(indexes,
                                       QPoint(plannedFrameMove, 0),
                                       false, true, parentCommand.data());
         }
 
         const int oldTime = m_d->image->animationInterface()->currentUITime();
         const int newTime = minSelectedTime;
 
         new KisSwitchCurrentTimeCommand(m_d->image->animationInterface(),
                                         oldTime,
                                         newTime, parentCommand.data());
     }
 
 
     KisProcessingApplicator::runSingleCommandStroke(m_d->image, parentCommand.take(), KisStrokeJobData::BARRIER);
     return true;
 }
 
 bool TimelineFramesModel::defineCycles(int timeFrom, int timeTo, QSet<int> rows)
 {
     KUndo2Command *parentCommand = new KUndo2Command(kundo2_i18np("Create animation cycle", "Create animation cycles", rows.size()));
 
     Q_FOREACH(const int row, rows) {
         KisNodeDummy *dummy = m_d->converter->dummyFromRow(row);
         if (dummy) {
             KisKeyframeChannel *contentChannel = dummy->node()->getKeyframeChannel(KisKeyframeChannel::Content.id());
             if (contentChannel) {
                 KisKeyframeSP firstKeyframe = contentChannel->activeKeyframeAt(timeFrom);
                 KisKeyframeSP lastKeyframe = contentChannel->activeKeyframeAt(timeTo);
 
                 if (!firstKeyframe.isNull() && !lastKeyframe.isNull()) {
-                    contentChannel->createCycle(firstKeyframe, lastKeyframe, parentCommand);
+                    KisDefineCycleCommand *createCycle = contentChannel->createCycle(firstKeyframe, lastKeyframe, parentCommand);
 
                     if (contentChannel->keyframeAt(timeTo + 1).isNull()) {
-                        contentChannel->addRepeat(timeTo + 1, firstKeyframe, parentCommand);
+                        contentChannel->addRepeat(createCycle->cycle(), timeTo + 1, parentCommand);
                     }
                 }
             }
         }
     }
 
     KisProcessingApplicator::runSingleCommandStroke(m_d->image, parentCommand, KisStrokeJobData::BARRIER);
 
     return true;
 }
 
 bool TimelineFramesModel::deleteCycles(int timeFrom, int timeTo, QSet<int> rows)
 {
     QVector<QSharedPointer<KisAnimationCycle>> cycles;
 
     Q_FOREACH(const int row, rows) {
         KisNodeDummy *dummy = m_d->converter->dummyFromRow(row);
         if (!dummy) continue;
 
         KisKeyframeChannel *contentChannel = dummy->node()->getKeyframeChannel(KisKeyframeChannel::Content.id());
         if (!contentChannel) continue;
 
         for (int time = timeFrom; time <= timeTo; time++) {
             auto cycle = contentChannel->cycleAt(time);
             if (!cycle.isNull()) {
                 KisTimeSpan cycleRange = cycle->originalRange();
 
                 if (cycleRange.contains(time)) {
                     cycles.append(cycle);
                     time = cycleRange.end();
                 }
             }
         }
     }
 
     KUndo2Command *parentCommand = new KUndo2Command(kundo2_i18np("Delete animation cycle", "Delete animation cycles", cycles.size()));
 
     Q_FOREACH(QSharedPointer<KisAnimationCycle> cycle, cycles) {
         KisKeyframeChannel *channel = cycle->firstSourceKeyframe()->channel();
         channel->deleteCycle(cycle, parentCommand);
     }
 
     KisProcessingApplicator::runSingleCommandStroke(m_d->image, parentCommand, KisStrokeJobData::BARRIER);
 
     return true;
 }
 
 void TimelineFramesModel::addRepeatAt(QModelIndex location)
 {
     const int time = location.row();
 
     KisNodeDummy *dummy = m_d->converter->dummyFromRow(time);
     if (dummy) {
         KisKeyframeChannel *contentChannel = dummy->node()->getKeyframeChannel(KisKeyframeChannel::Content.id());
         if (contentChannel) {
             for (int t = location.column(); t >= 0; t--) {
-                const KisTimeSpan cycled = contentChannel->cycledRangeAt(t);
-                if (!cycled.isEmpty()) {
+                const QSharedPointer<KisAnimationCycle> cycle = contentChannel->cycleAt(t);
+                if (cycle) {
                     KUndo2Command *parentCommand = new KUndo2Command(kundo2_i18n("Add animation repeat"));
-
-                    KisKeyframeSP sourceKeyframe = contentChannel->activeKeyframeAt(cycled.start());
-                    contentChannel->addRepeat(location.column(), sourceKeyframe, parentCommand);
+                    contentChannel->addRepeat(cycle, location.column(), parentCommand);
                     KisProcessingApplicator::runSingleCommandStroke(m_d->image, parentCommand, KisStrokeJobData::BARRIER);
 
                     return;
                 }
             }
         }
     }
 }
 
 QString TimelineFramesModel::audioChannelFileName() const
 {
     return m_d->image ? m_d->image->animationInterface()->audioChannelFileName() : QString();
 }
 
 void TimelineFramesModel::setAudioChannelFileName(const QString &fileName)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->image);
     m_d->image->animationInterface()->setAudioChannelFileName(fileName);
 }
 
 bool TimelineFramesModel::isAudioMuted() const
 {
     return m_d->image ? m_d->image->animationInterface()->isAudioMuted() : false;
 }
 
 void TimelineFramesModel::setAudioMuted(bool value)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->image);
     m_d->image->animationInterface()->setAudioMuted(value);
 }
 
 qreal TimelineFramesModel::audioVolume() const
 {
     return m_d->image ? m_d->image->animationInterface()->audioVolume() : 0.5;
 }
 
 void TimelineFramesModel::setAudioVolume(qreal value)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->image);
     m_d->image->animationInterface()->setAudioVolume(value);
 }
 
 void TimelineFramesModel::setFullClipRangeStart(int column)
 {
     m_d->image->animationInterface()->setFullClipRangeStartTime(column);
 }
 
 void TimelineFramesModel::setFullClipRangeEnd(int column)
 {
     m_d->image->animationInterface()->setFullClipRangeEndTime(column);
 }