diff --git a/libs/image/kis_animation_cycle.cpp b/libs/image/kis_animation_cycle.cpp index 1ddaf9b18c..bfe32e0117 100644 --- a/libs/image/kis_animation_cycle.cpp +++ b/libs/image/kis_animation_cycle.cpp @@ -1,233 +1,201 @@ /* * Copyright (c) 2018 Jouni Pentikäinen * * 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_cycle.h" #include #include "kis_time_range.h" #include "kis_keyframe_channel.h" -KisAnimationCycle::KisAnimationCycle(KisKeyframeChannel *channel, KisKeyframeSP firstKeyframe, KisKeyframeSP lastKeyframe) - : KisKeyframeBase(channel, firstKeyframe->time()) - , m_firstSourceKeyframe(firstKeyframe) - , m_lastSourceKeyframe(lastKeyframe) +KisAnimationCycle::KisAnimationCycle(KisKeyframeChannel *channel, KisTimeSpan sourceRange) + : KisKeyframeBase(channel, sourceRange.start()) + , m_range(sourceRange) {} -KisAnimationCycle::KisAnimationCycle(const KisAnimationCycle &cycle, KisKeyframeSP firstKeyframe, KisKeyframeSP lastKeyframe) - : KisKeyframeBase(cycle.channel(), firstKeyframe->time()) - , m_firstSourceKeyframe(firstKeyframe) - , m_lastSourceKeyframe(lastKeyframe) - , m_repeats(cycle.m_repeats) +KisAnimationCycle::KisAnimationCycle(const KisAnimationCycle &cycle, KisTimeSpan newRange) + : KisKeyframeBase(cycle.channel(), newRange.start()) + , m_range(newRange) {} -KisKeyframeSP KisAnimationCycle::firstSourceKeyframe() const -{ - return m_firstSourceKeyframe; -} - -KisKeyframeSP KisAnimationCycle::lastSourceKeyframe() const -{ - return m_lastSourceKeyframe; -} - KisTimeSpan KisAnimationCycle::originalRange() const { - const KisKeyframeBaseSP firstAfterCycle = m_lastSourceKeyframe->channel()->nextItem(*m_lastSourceKeyframe); - - KisTimeSpan range; - if (firstAfterCycle.isNull()) { - // TODO: semantics of repeat definition without a terminating keyframe? - range = KisTimeSpan(m_firstSourceKeyframe->time(), m_lastSourceKeyframe->time()); - } else { - range = KisTimeSpan(m_firstSourceKeyframe->time(), firstAfterCycle->time() - 1); - } - return range; + return m_range; } int KisAnimationCycle::duration() const { return originalRange().duration(); } void KisAnimationCycle::addRepeat(QSharedPointer repeat) { if (m_repeats.contains(repeat)) return; m_repeats.append(repeat); } void KisAnimationCycle::removeRepeat(QSharedPointer repeat) { m_repeats.removeAll(repeat); } const QVector>& KisAnimationCycle::repeats() const { return m_repeats; } KisFrameSet KisAnimationCycle::instancesWithin(KisKeyframeSP original, KisTimeSpan range) const { KisFrameSet frames; const int originalTime = original->time(); const KisKeyframeBaseSP next = original->channel()->nextItem(*original); const int frameDuration = (next.isNull()) ? -1 : next->time() - originalTime; const int interval = duration(); int infiniteFrom = frameDuration == -1 ? originalTime : -1; QVector spans; Q_FOREACH(const QWeakPointer repeatFrame, m_repeats) { auto repeat = repeatFrame.toStrongRef(); if (!repeat) continue; const int endTime = repeat->end(); if (range.isEmpty()) { if (endTime != -1) { range = KisTimeSpan(0, endTime - 1); } else { infiniteFrom = repeat->firstInstanceOf(originalTime); continue; } } KisTimeSpan repeatRange = (endTime != -1) ? range & KisTimeSpan(repeat->time(), endTime) : range.truncateRight(repeat->time()); int firstInstance = repeat->firstInstanceOf(originalTime); if (firstInstance == -1) continue; if (firstInstance < repeatRange.start()) { firstInstance += interval * ((range.start() - firstInstance) / interval); } for (int repeatTime = firstInstance; repeatTime <= repeatRange.end(); repeatTime += interval) { bool endsWithinRange = frameDuration != -1 && repeatTime + frameDuration - 1 <= repeatRange.end(); const int repeatEndTime = endsWithinRange ? (repeatTime + frameDuration - 1) : repeatRange.end(); spans.append(KisTimeSpan(repeatTime, repeatEndTime)); } } frames |= KisFrameSet(spans); if (infiniteFrom != -1) { frames |= KisFrameSet::infiniteFrom(infiniteFrom); } else { frames |= KisFrameSet::between(originalTime, originalTime + frameDuration - 1); } return frames; } QRect KisAnimationCycle::affectedRect() const { QRect rect; - KisKeyframeSP keyframe = m_firstSourceKeyframe; - do { + for (auto keyframe : channel()->itemsWithin(m_range)) { rect |= keyframe->affectedRect(); - keyframe = channel()->nextKeyframe(keyframe); - } while (keyframe && keyframe != m_lastSourceKeyframe); + } return rect; } KisKeyframeSP KisAnimationCycle::getOriginalKeyframeFor(int time) const { return channel()->activeKeyframeAt(time); } KisRepeatFrame::KisRepeatFrame(KisKeyframeChannel *channel, int time, QSharedPointer cycle) : KisKeyframeBase(channel, time) , m_cycle(cycle) {} QSharedPointer KisRepeatFrame::cycle() const { return m_cycle; } QRect KisRepeatFrame::affectedRect() const { - KisKeyframeSP keyframe = m_cycle->firstSourceKeyframe(); - - QRect rect; - while (!keyframe.isNull() && keyframe->time() <= m_cycle->lastSourceKeyframe()->time()) { - rect |= keyframe->affectedRect(); - keyframe = channel()->nextKeyframe(keyframe); - } - - return rect; + return m_cycle->affectedRect(); } int KisRepeatFrame::getOriginalTimeFor(int time) const { KisTimeSpan originalRange = m_cycle->originalRange(); int timeWithinCycle = (time - this->time()) % originalRange.duration(); - return m_cycle->firstSourceKeyframe()->time() + timeWithinCycle; + return originalRange.start() + timeWithinCycle; } KisKeyframeSP KisRepeatFrame::getOriginalKeyframeFor(int time) const { return channel()->activeKeyframeAt(getOriginalTimeFor(time)); } int KisRepeatFrame::firstInstanceOf(int originalTime) const { KisTimeSpan originalRange = m_cycle->originalRange(); const int timeWithinCycle = originalTime - originalRange.start(); const int first = this->time() + timeWithinCycle; const KisKeyframeSP next = channel()->nextKeyframe(time()); if (next && next->time() < first) return -1; return first; } int KisRepeatFrame::previousVisibleFrame(int time) const { if (time <= this->time()) return -1; const int earlierOriginalTime = getOriginalTimeFor(time - 1); int originalStart, originalEnd; channel()->activeKeyframeRange(earlierOriginalTime, &originalStart, &originalEnd); if (originalEnd == -1) return -1; const int durationOfOriginalKeyframe = originalEnd + 1 - originalStart; return time - durationOfOriginalKeyframe; } int KisRepeatFrame::nextVisibleFrame(int time) const { const int originalTime = getOriginalTimeFor(time); int originalStart, originalEnd; channel()->activeKeyframeRange(originalTime, &originalStart, &originalEnd); if (originalEnd == -1) return -1; const int durationOfOriginalKeyframe = originalEnd + 1 - originalStart; const int nextFrameTime = time + durationOfOriginalKeyframe; const int endTime = end(); return (endTime == -1 || nextFrameTime < endTime) ? nextFrameTime : -1; } int KisRepeatFrame::end() const { const KisKeyframeBaseSP next = channel()->nextItem(*this); return next ? next->time() - 1 : -1; } diff --git a/libs/image/kis_animation_cycle.h b/libs/image/kis_animation_cycle.h index d4e490e978..fff2f308f2 100644 --- a/libs/image/kis_animation_cycle.h +++ b/libs/image/kis_animation_cycle.h @@ -1,93 +1,94 @@ /* * Copyright (c) 2018 Jouni Pentikäinen * * 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_CYCLE_H #define KIS_ANIMATION_CYCLE_H #include "kis_keyframe.h" +#include "kis_time_range.h" class KisTimeSpan; class KisFrameSet; class KisRepeatFrame; class KRITAIMAGE_EXPORT KisAnimationCycle : public KisKeyframeBase { public: - KisAnimationCycle(KisKeyframeChannel *channel, KisKeyframeSP firstKeyframe, KisKeyframeSP lastKeyframe); + KisAnimationCycle(KisKeyframeChannel *channel, KisTimeSpan sourceRange); + KisAnimationCycle(const KisAnimationCycle &cycle, KisTimeSpan newRange); - KisAnimationCycle(const KisAnimationCycle &cycle, KisKeyframeSP firstKeyframe, KisKeyframeSP lastKeyframe); - - KisKeyframeSP firstSourceKeyframe() const; - KisKeyframeSP lastSourceKeyframe() const; + /** + * The full source range repeated by the cycle. + */ KisTimeSpan originalRange() const; int duration() const; void addRepeat(QSharedPointer repeat); void removeRepeat(QSharedPointer repeat); const QVector>& repeats() const; QRect affectedRect() const override; KisKeyframeSP getOriginalKeyframeFor(int time) const override; KisFrameSet instancesWithin(KisKeyframeSP original, KisTimeSpan range) const; private: friend class KisKeyframeChannel; - KisKeyframeSP m_firstSourceKeyframe, m_lastSourceKeyframe; + KisTimeSpan m_range; QVector> m_repeats; }; class KRITAIMAGE_EXPORT KisRepeatFrame : public KisKeyframeBase { public: KisRepeatFrame(KisKeyframeChannel *channel, int time, QSharedPointer cycle); QSharedPointer cycle() const; QRect affectedRect() const override; int getOriginalTimeFor(int time) const; KisKeyframeSP getOriginalKeyframeFor(int time) const override; /// Returns the earliest time the original frame appears in this repeat, or -1 if it never does. int firstInstanceOf(int originalTime) const; /** Returns the time at which the previous frame within the repeat appears, * or -1 if time is at the first repeated frame. * NB: time should be at the start of a repeated frame */ int previousVisibleFrame(int time) const; /** Returns the time at which the next frame within the repeat appears, * or -1 if time is at the last repeated frame. * NB: time should be at the start of a repeated frame */ int nextVisibleFrame(int time) const; /** * Finds the time of the next keyframe if any. * Returns -1 if the cycle continues indefinitely. */ int end() const; private: QSharedPointer m_cycle; }; #endif diff --git a/libs/image/kis_keyframe_channel.cpp b/libs/image/kis_keyframe_channel.cpp index fb81f87c9a..63c6a64f49 100644 --- a/libs/image/kis_keyframe_channel.cpp +++ b/libs/image/kis_keyframe_channel.cpp @@ -1,1156 +1,1138 @@ /* * Copyright (c) 2015 Jouni Pentikäinen * * 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 "KisCollectionUtils.h" #include "kis_time_range.h" #include "kundo2command.h" #include "kis_keyframe_commands.h" #include "kis_animation_cycle.h" #include 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 typename QMap::const_iterator findActive(const QMap &map, int maximumKey) { typename QMap::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 typename QMap::const_iterator findPrevious(const QMap &map, int currentKey) { typename QMap::const_iterator active = lastBeforeOrAt(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 typename QMap::const_iterator findNext(const QMap &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> cycles; QMap> repeats; KisNodeWSP node; KoID id; KisDefaultBoundsBaseSP defaultBounds; bool haveBrokenFrameTimeBug = false; void add(KisKeyframeBaseSP item) { auto repeat = item.dynamicCast(); if (repeat) { repeat->cycle()->addRepeat(repeat); repeats.insert(repeat->time(), repeat); } else { auto keyframe = item.dynamicCast(); KIS_ASSERT_RECOVER_RETURN(keyframe); keys.insert(item->time(), keyframe); } } void remove(KisKeyframeBaseSP item) { auto repeat = item.dynamicCast(); if (repeat) { repeat->cycle()->removeRepeat(repeat); repeats.remove(repeat->time()); } else { keys.remove(item->time()); } } void moveKeyframe(KisKeyframeBaseSP keyframe, int newTime) { const QSharedPointer 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 + KIS_SAFE_ASSERT_RECOVER_NOOP(newTime < cycle->originalRange().end()); // TODO: make sure this is the case cycles.remove(cycle->time()); cycle->setTime(newTime); cycles.insert(newTime, cycle); } } void addCycle(QSharedPointer cycle) { cycles.insert(cycle->time(), cycle); Q_FOREACH(QWeakPointer repeatWP, cycle->repeats()) { KisKeyframeBaseSP repeat = repeatWP.toStrongRef(); if (repeat) add(repeat); } } void removeCycle(QSharedPointer 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 rhsCycle, rhs.m_d->cycles) { - KisKeyframeSP firstFrame = keyframeAt(rhsCycle->firstSourceKeyframe()->time()); - KisKeyframeSP lastFrame = keyframeAt(rhsCycle->lastSourceKeyframe()->time()); - - QSharedPointer cycle = toQShared(new KisAnimationCycle(this, firstFrame, lastFrame)); + QSharedPointer cycle = toQShared(new KisAnimationCycle(this, rhsCycle->originalRange())); m_d->addCycle(cycle); Q_FOREACH(auto rhsRepeatWP, rhsCycle->repeats()) { const QSharedPointer 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 __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); } 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 KisKeyframeBaseSP copySrc, KUndo2Command *parentCommand) { KisKeyframeBaseSP oldItem = itemAt(time); if (oldItem) { deleteKeyframeImpl(oldItem, parentCommand, false); } Q_ASSERT(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(KisKeyframeBaseSP keyframe, KUndo2Command *parentCommand) { return deleteKeyframeImpl(keyframe, parentCommand, true); } bool KisKeyframeChannel::moveKeyframe(KisKeyframeBaseSP keyframe, int newTime, KUndo2Command *parentCommand) { LAZY_INITIALIZE_PARENT_COMMAND(parentCommand); if (newTime == keyframe->time()) return false; - 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; 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(KisKeyframeBaseSP item, KUndo2Command *parentCommand, bool recreate) { LAZY_INITIALIZE_PARENT_COMMAND(parentCommand); Q_ASSERT(parentCommand); KUndo2Command *cmd = new KisReplaceKeyframeCommand(this, item->time(), KisKeyframeSP(), parentCommand); cmd->redo(); KisKeyframeSP keyframe = item.dynamicCast(); if (keyframe) { destroyKeyframe(keyframe, parentCommand); if (recreate && keyframe->time() == 0) { addKeyframe(0, parentCommand); } } return true; } void KisKeyframeChannel::moveKeyframeImpl(KisKeyframeBaseSP keyframe, int newTime) { KIS_ASSERT_RECOVER_RETURN(keyframe); 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(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); } KisKeyframeBaseSP KisKeyframeChannel::replaceKeyframeAt(int time, KisKeyframeBaseSP newKeyframe) { Q_ASSERT(newKeyframe.isNull() || time == newKeyframe->time()); KisKeyframeBaseSP existingKeyframe = itemAt(time); if (!existingKeyframe.isNull()) { removeKeyframeLogical(existingKeyframe); } if (!newKeyframe.isNull()) { insertKeyframeLogical(newKeyframe); } return existingKeyframe; } 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(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 { return m_d->keys.value(time); } KisKeyframeSP KisKeyframeChannel::activeKeyframeAt(int time) const { KeyframesMap::const_iterator i = KisCollectionUtils::lastBeforeOrAt(m_d->keys, time); if (i != m_d->keys.constEnd()) { return i.value(); } return KisKeyframeSP(); } KisKeyframeSP KisKeyframeChannel::visibleKeyframeAt(int time) const { const QSharedPointer 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->time()); } KisKeyframeSP KisKeyframeChannel::nextKeyframe(int time) const { KeyframesMap::const_iterator i = KisCollectionUtils::firstAfter(m_d->keys, time); if (i == m_d->keys.constEnd()) return KisKeyframeSP(0); return i.value(); } KisKeyframeSP KisKeyframeChannel::previousKeyframe(KisKeyframeSP keyframe) const { return previousKeyframe(keyframe->time()); } KisKeyframeSP KisKeyframeChannel::previousKeyframe(int time) const { KeyframesMap::const_iterator i = KisCollectionUtils::lastBefore(m_d->keys, 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(); } KisKeyframeBaseSP KisKeyframeChannel::itemAt(int time) const { const KisKeyframeSP keyframe = keyframeAt(time); if (keyframe) return keyframe; const QSharedPointer repeat = activeRepeatAt(time); if (repeat && time == repeat->time()) return repeat; return KisKeyframeBaseSP(); } KisKeyframeBaseSP KisKeyframeChannel::activeItemAt(int time) const { const KisKeyframeSP keyframe = activeKeyframeAt(time); if (keyframe) return keyframe; return activeRepeatAt(time); } KisKeyframeBaseSP KisKeyframeChannel::nextItem(const KisKeyframeBase &item) const { const KisKeyframeSP keyframe = nextKeyframe(item.time()); auto repeatIter = KisCollectionUtils::firstAfter(m_d->repeats, item.time()); const auto repeat = (repeatIter != m_d->repeats.constEnd()) ? repeatIter.value() : QSharedPointer(); if (keyframe && (!repeat || repeat->time() > keyframe->time())) return keyframe; return repeat; } KisKeyframeBaseSP KisKeyframeChannel::previousItem(const KisKeyframeBase &item) const { const KisKeyframeSP keyframe = previousKeyframe(item.time()); auto repeatIter = KisCollectionUtils::lastBefore(m_d->repeats, item.time()); const auto repeat = (repeatIter != m_d->repeats.constEnd()) ? repeatIter.value() : QSharedPointer(); if (keyframe && (!repeat || repeat->time() > keyframe->time())) return keyframe; return repeat; } KisRangedKeyframeIterator KisKeyframeChannel::itemsWithin(KisTimeSpan range) const { return KisRangedKeyframeIterator(this, range); } KisVisibleKeyframeIterator KisKeyframeChannel::visibleKeyframesFrom(int time) const { return KisVisibleKeyframeIterator(visibleKeyframeAt(time)); } QList> KisKeyframeChannel::cycles() const { return m_d->cycles.values(); } KisTimeSpan KisKeyframeChannel::cycledRangeAt(int time) const { QSharedPointer repeat = activeRepeatAt(time); if (repeat) return repeat->cycle()->originalRange(); QSharedPointer cycle = cycleAt(time); if (cycle) return cycle->originalRange(); return KisTimeSpan(); } QSharedPointer KisKeyframeChannel::cycleAt(int time) const { if (m_d->cycles.isEmpty()) return QSharedPointer(); const auto it = KisCollectionUtils::lastBeforeOrAt(m_d->cycles, time); if (it == m_d->cycles.constEnd()) return QSharedPointer(); - const KisKeyframeBaseSP next = nextItem(*it.value()->lastSourceKeyframe()); - if (next && next->time() <= time) return QSharedPointer(); - + if (!it.value()->originalRange().contains(time)) return nullptr; return it.value(); }; QSharedPointer KisKeyframeChannel::activeRepeatAt(int time) const { const auto repeat = KisCollectionUtils::lastBeforeOrAt(m_d->repeats, time); if (repeat == m_d->repeats.constEnd()) return QSharedPointer(); const KisKeyframeSP lastKeyframe = activeKeyframeAt(time); if (lastKeyframe && lastKeyframe->time() > repeat.value()->time()) return QSharedPointer(); 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 KisKeyframeChannel::allKeyframeIds() const { QSet 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 = KisCollectionUtils::lastBeforeOrAt(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 repeat = activeRepeatAt(time); if (repeat) { const KisKeyframeSP original = repeat->getOriginalKeyframeFor(time); return affectedFrames(original->time()); } QSharedPointer cycle = cycleAt(time); if (cycle) { KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(active != m_d->keys.constEnd() && active.value(), KisFrameSet()); 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 { const QSharedPointer repeat = activeRepeatAt(time); if (repeat) { const KisKeyframeSP original = repeat->getOriginalKeyframeFor(time); return identicalFrames(original->time(), range); } KeyframesMap::const_iterator active = KisCollectionUtils::lastBeforeOrAt(m_d->keys, time); const QSharedPointer 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 (KisKeyframeSP keyframe, m_d->keys.values()) { QDomElement keyframeElement = doc.createElement("keyframe"); keyframeElement.setAttribute("time", keyframe->time()); keyframeElement.setAttribute("color-label", keyframe->colorLabel()); saveKeyframe(keyframe, keyframeElement, layerFilename); channelElement.appendChild(keyframeElement); } Q_FOREACH (const QSharedPointer cycle, m_d->cycles.values()) { QDomElement cycleElement = doc.createElement("cycle"); - cycleElement.setAttribute("firstKeyframe", cycle->firstSourceKeyframe()->time()); - cycleElement.setAttribute("lastKeyframe", cycle->lastSourceKeyframe()->time()); + cycleElement.setAttribute("start", cycle->originalRange().start()); + cycleElement.setAttribute("end", cycle->originalRange().end()); Q_FOREACH (auto repeatWP, cycle->repeats()) { const QSharedPointer repeat = repeatWP.toStrongRef(); if (!repeat) continue; QDomElement repeatElement = doc.createElement("repeat"); repeatElement.setAttribute("time", repeat->time()); cycleElement.appendChild(repeatElement); } channelElement.appendChild(cycleElement); } return channelElement; } void KisKeyframeChannel::loadXML(const QDomElement &channelNode) { 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; 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); } } for (QDomElement childNode = channelNode.firstChildElement(); !childNode.isNull(); childNode = childNode.nextSiblingElement()) { if (childNode.nodeName().toUpper() == "CYCLE") { QSharedPointer cycle = loadCycle(childNode); if (cycle) { m_d->addCycle(cycle); } } } } QSharedPointer KisKeyframeChannel::loadCycle(const QDomElement &cycleElement) { - const int firstKeyframeTime = cycleElement.attribute("firstKeyframe", "-1").toInt(); - const int lastKeyframeTime = cycleElement.attribute("lastKeyframe", "-1").toInt(); - - if (firstKeyframeTime < 0 || lastKeyframeTime <= firstKeyframeTime) { - qWarning() << "Invalid cycle range: " << firstKeyframeTime << "to" << lastKeyframeTime; - return nullptr; - } - - const KisKeyframeSP firstKeyframe = keyframeAt(firstKeyframeTime); - const KisKeyframeSP lastKeyframe = keyframeAt(lastKeyframeTime); + const int startTime = cycleElement.attribute("start", "-1").toInt(); + const int endTime = cycleElement.attribute("end", "-1").toInt(); - if (!firstKeyframe || !lastKeyframe) { - qWarning() << "Could not find defining keyframes for cycle " << firstKeyframeTime << "to" << lastKeyframeTime; + if (startTime < 0 || endTime <= startTime) { + qWarning() << "Invalid cycle range: " << startTime << "to" << endTime; return nullptr; } - QSharedPointer cycle = toQShared(new KisAnimationCycle(this, firstKeyframe, lastKeyframe)); + QSharedPointer cycle = toQShared(new KisAnimationCycle(this, KisTimeSpan(startTime, endTime))); for (QDomElement grandChildNode = cycleElement.firstChildElement(); !grandChildNode.isNull(); grandChildNode = grandChildNode.nextSiblingElement()) { if (grandChildNode.nodeName().toUpper() == "REPEAT") { const int time = grandChildNode.attribute("time").toInt(); const QSharedPointer repeat = toQShared(new KisRepeatFrame(this, time, cycle)); m_d->add(repeat); } } return cycle; } 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; } -KisDefineCycleCommand * KisKeyframeChannel::createCycle(KisKeyframeSP firstKeyframe, KisKeyframeSP lastKeyframe, KUndo2Command *parentCommand) +KisDefineCycleCommand * KisKeyframeChannel::createCycle(KisTimeSpan range, KUndo2Command *parentCommand) { - const QSharedPointer cycle = toQShared(new KisAnimationCycle(this, firstKeyframe, lastKeyframe)); + const QSharedPointer cycle = toQShared(new KisAnimationCycle(this, range)); return new KisDefineCycleCommand(nullptr, cycle, parentCommand); } void KisKeyframeChannel::addCycle(QSharedPointer cycle) { m_d->addCycle(cycle); } KUndo2Command* KisKeyframeChannel::deleteCycle(QSharedPointer cycle, KUndo2Command *parentCommand) { KisDefineCycleCommand *defineCycleCommand = new KisDefineCycleCommand(cycle, nullptr, parentCommand); // Remove repeats of the cycle Q_FOREACH(QWeakPointer repeatWP, cycle->repeats()) { auto repeat = repeatWP.toStrongRef(); if (repeat) { deleteKeyframe(repeat); } } return defineCycleCommand; } void KisKeyframeChannel::removeCycle(QSharedPointer cycle) { m_d->removeCycle(cycle); } QSharedPointer KisKeyframeChannel::addRepeat(QSharedPointer cycle, int time, KUndo2Command *parentCommand) { const QSharedPointer repeatFrame = toQShared(new KisRepeatFrame(this, time, cycle)); KUndo2Command *cmd = new KisReplaceKeyframeCommand(this, time, repeatFrame, parentCommand); cmd->redo(); return repeatFrame; } 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); } KisKeyframeBaseSP firstKeyframeInRange(const KisKeyframeChannel *channel, KisTimeSpan range) { KisKeyframeBaseSP active = channel->activeItemAt(range.start()); if (active) { if (range.contains(active->time())) return active; if (active->time() < range.start()) { const KisKeyframeBaseSP next = channel->nextItem(*active); if (next && range.contains(next->time())) return next; } } return KisKeyframeBaseSP(); } KisRangedKeyframeIterator::KisRangedKeyframeIterator() {} KisRangedKeyframeIterator::KisRangedKeyframeIterator(const KisKeyframeChannel *channel, KisKeyframeBaseSP keyframe, KisTimeSpan range) : m_channel(channel) , m_keyframe(keyframe) , m_range(range) {} KisRangedKeyframeIterator::KisRangedKeyframeIterator(const KisKeyframeChannel *channel, KisTimeSpan range) : KisRangedKeyframeIterator(channel, firstKeyframeInRange(channel, range), range) {} KisRangedKeyframeIterator& KisRangedKeyframeIterator::operator++() { if (!m_keyframe) return *this; m_keyframe = m_channel->nextItem(*m_keyframe); if (!m_keyframe || !m_range.contains(m_keyframe->time())) { m_keyframe = nullptr; } return *this; } KisRangedKeyframeIterator& KisRangedKeyframeIterator::operator--() { if (!m_keyframe) { // One-past-end state: return to last keyframe in range const KisKeyframeBaseSP last = m_channel->activeItemAt(m_range.end()); if (m_range.contains(last->time())) m_keyframe = last; } else { const KisKeyframeBaseSP previousKeyframe = m_channel->previousItem(*m_keyframe); if (previousKeyframe && m_range.contains(previousKeyframe->time())) { m_keyframe = previousKeyframe; } } return *this; } KisKeyframeBaseSP KisRangedKeyframeIterator::operator*() const { return m_keyframe; } KisKeyframeBaseSP KisRangedKeyframeIterator::operator->() const { return m_keyframe; } KisRangedKeyframeIterator KisRangedKeyframeIterator::begin() const { return KisRangedKeyframeIterator(m_channel, m_range); } KisRangedKeyframeIterator KisRangedKeyframeIterator::end() const { return KisRangedKeyframeIterator(m_channel, nullptr, m_range); } bool KisRangedKeyframeIterator::isValid() const { return m_keyframe != nullptr; } bool KisRangedKeyframeIterator::operator==(const KisRangedKeyframeIterator &rhs) const { return m_keyframe == rhs.m_keyframe && m_range == rhs.m_range; } bool KisRangedKeyframeIterator::operator!=(const KisRangedKeyframeIterator &rhs) const { return !(rhs == *this); } KisVisibleKeyframeIterator::KisVisibleKeyframeIterator() = default; KisVisibleKeyframeIterator::KisVisibleKeyframeIterator(KisKeyframeSP keyframe) : m_channel(keyframe->channel()) , m_keyframe(keyframe) , m_time(keyframe->time()) {} KisVisibleKeyframeIterator& KisVisibleKeyframeIterator::operator--() { const QSharedPointer 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->time()); if (!m_keyframe) return invalidate(); m_time = m_keyframe->time(); return *this; } KisVisibleKeyframeIterator& KisVisibleKeyframeIterator::operator++() { const QSharedPointer 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->time()); if (!m_keyframe) return invalidate(); m_time = m_keyframe->time(); return *this; }; KisKeyframeSP KisVisibleKeyframeIterator::operator*() const { const KisRepeatFrame *repeat = dynamic_cast(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 238079e770..5aa3b5732b 100644 --- a/libs/image/kis_keyframe_channel.h +++ b/libs/image/kis_keyframe_channel.h @@ -1,272 +1,272 @@ /* * Copyright (c) 2015 Jouni Pentikäinen * * 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 #include #include #include "kis_types.h" #include "KoID.h" #include "kritaimage_export.h" #include "kis_keyframe.h" #include "kis_default_bounds.h" #include "kis_time_range.h" class KisFrameSet; class KisTimeSpan; class KisAnimationCycle; class KisRepeatFrame; class KisRangedKeyframeIterator; 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(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 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); - KisDefineCycleCommand * createCycle(KisKeyframeSP firstKeyframe, KisKeyframeSP lastKeyframe, KUndo2Command *parentCommand = 0); + KisDefineCycleCommand * createCycle(KisTimeSpan range, KUndo2Command *parentCommand = 0); KUndo2Command * deleteCycle(QSharedPointer cycle, KUndo2Command *parentCommand = 0); QSharedPointer addRepeat(QSharedPointer 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(int time) const; KisKeyframeSP previousKeyframe(int time) 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; KisRangedKeyframeIterator itemsWithin(KisTimeSpan range) const; KisVisibleKeyframeIterator visibleKeyframesFrom(int time) const; QList> cycles() 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 cycleAt(int time) const; /** * Finds the repeat of a cycle at the time, if any. */ QSharedPointer 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 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(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 KeyframesMap; KeyframesMap &keys(); const KeyframesMap &constKeys() 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: 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 cycle); void removeCycle(QSharedPointer cycle); friend class KisMoveKeyframesCommand; friend class KisMoveFrameCommand; friend class KisReplaceKeyframeCommand; friend class KisSwapFramesCommand; friend class KisDefineCycleCommand; friend class KisRangedKeyframeIterator; private: KisKeyframeSP insertKeyframe(int time, const KisKeyframeBaseSP copySrc, KUndo2Command *parentCommand); QSharedPointer loadCycle(const QDomElement &cycleElement); struct Private; QScopedPointer m_d; }; class KisRangedKeyframeIterator { public: KisRangedKeyframeIterator(); KisRangedKeyframeIterator(const KisKeyframeChannel *channel, KisTimeSpan range); KisRangedKeyframeIterator& operator--(); KisRangedKeyframeIterator& operator++(); KisKeyframeBaseSP operator->() const; KisKeyframeBaseSP operator*() const; bool operator==(const KisRangedKeyframeIterator &rhs) const; bool operator!=(const KisRangedKeyframeIterator &rhs) const; KisRangedKeyframeIterator begin() const; KisRangedKeyframeIterator end() const; bool isValid() const; private: KisRangedKeyframeIterator(const KisKeyframeChannel *channel, KisKeyframeBaseSP keyframe, KisTimeSpan range); const KisKeyframeChannel *m_channel{nullptr}; KisKeyframeBaseSP m_keyframe; KisTimeSpan m_range; }; 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 169c959314..dbf5a6888a 100644 --- a/libs/image/kis_keyframe_commands.cpp +++ b/libs/image/kis_keyframe_commands.cpp @@ -1,390 +1,391 @@ #include "kis_keyframe_commands.h" #include #include #include "kis_time_range.h" #include "kis_animation_cycle.h" using CycleSP = QSharedPointer; using KeyframeMove = KisKeyframeCommands::KeyframeMove; KisKeyframeCommands::KeyframeMove::KeyframeMove(KisKeyframeBaseSP keyframe, int newTime) : keyframe(keyframe) , oldTime(keyframe->time()) , newTime(newTime) {} class KisMoveKeyframesCommand : public KUndo2Command { public: KisMoveKeyframesCommand(QVector moves, KUndo2Command *parentCommand) : KUndo2Command(parentCommand) , m_moves(moves) {} void redo() override { Q_FOREACH(const KeyframeMove &move, m_moves) { move.keyframe->channel()->moveKeyframeImpl(move.keyframe, move.newTime); } } void undo() override { Q_FOREACH(const KeyframeMove &move, m_moves) { move.keyframe->channel()->moveKeyframeImpl(move.keyframe, move.oldTime); } } private: QVector m_moves; }; struct KeyframeMapping { KisKeyframeChannel *channel; QMap destinations; QMap sources; KeyframeMapping(KisKeyframeChannel *channel, const QVector &moves) : channel(channel) { const int count = moves.count(); for (int i = 0; i < count; i++) { const int time = moves[i].newTime; const KisKeyframeBaseSP key = moves[i].keyframe; if (key->channel() == channel) { destinations[key] = time; sources[time] = key; } } } bool isEmpty() const { return destinations.isEmpty(); } int destination(const KisKeyframeSP &keyframe) const { const int oldTime = keyframe->time(); const int newTime = destinations.value(keyframe, -1); if (newTime == -1 && !sources.value(oldTime, KisKeyframeBaseSP())) { return oldTime; } return newTime; } KisKeyframeSP firstTrueKeyframeAfter(int destinationTime) const { KisKeyframeSP unmovedKeyframe; { int time = destinationTime; KisKeyframeSP key; do { key = channel->nextKeyframe(time); time = key ? key->time() : -1; } while(destinations.contains(key)); unmovedKeyframe = key; } KisKeyframeSP movedKeyframe; int movedTime; { auto sourceIt = KisCollectionUtils::firstAfter(sources, destinationTime); // Skip non-keyframes (e.g. repeat frames) while (sourceIt != sources.cend() && !sourceIt.value().dynamicCast()) { sourceIt++; } movedTime = (sourceIt != sources.cend()) ? sourceIt.key() : -1; } if (movedKeyframe && unmovedKeyframe) { return (movedTime < unmovedKeyframe->time()) ? movedKeyframe : unmovedKeyframe; } else { return movedKeyframe ? movedKeyframe : unmovedKeyframe; } } }; bool areValidMoveSources(const KisKeyframeChannel *channel, QVector moves) { Q_FOREACH(const KeyframeMove &move, moves) { if (move.keyframe->channel() != channel) return false; } std::sort(moves.begin(), moves.end(), [](const KeyframeMove &lhs, const KeyframeMove &rhs){ return lhs.oldTime < rhs.oldTime; } ); for (int i = 1; i < moves.size(); i++) { if (moves[i - 1].keyframe == moves[i].keyframe) return false; } return true; } CycleSP cycleAfterMove(const CycleSP &cycle, const KeyframeMapping &movedKeyframes) { const KisKeyframeChannel *channel = cycle->channel(); - KisTimeSpan newRange; int firstDestination = -1, lastDestination = -1; + KisKeyframeSP oldLastKeyframe; KisKeyframeSP newFirstKeyframe, newLastKeyframe; - KisKeyframeSP key = cycle->firstSourceKeyframe(); - while (!key.isNull() && key->time() <= cycle->lastSourceKeyframe()->time()) { - const int destination = movedKeyframes.destinations.value(key, -1); - const int newTime = (destination >=0) ? destination : key->time(); + const KisTimeSpan &oldRange = cycle->originalRange(); + for (KisKeyframeBaseSP key : channel->itemsWithin(oldRange)) { + KisKeyframeSP keyframe = key.dynamicCast(); + KIS_SAFE_ASSERT_RECOVER(keyframe) { continue; } - const KisKeyframeBaseSP overwritingKey = (destination >= 0) - ? nullptr - : movedKeyframes.sources.value(key->time(), nullptr); + const int newTime = movedKeyframes.destination(keyframe); - if (!overwritingKey) { + if (newTime >= 0) { if (!newFirstKeyframe || newTime < firstDestination) { firstDestination = newTime; - newFirstKeyframe = key; + newFirstKeyframe = keyframe; } if (!newLastKeyframe || newTime > lastDestination) { lastDestination = newTime; - newLastKeyframe = key; + newLastKeyframe = keyframe; } } - key = channel->nextKeyframe(key->time()); + oldLastKeyframe = keyframe; } if (!newLastKeyframe) return CycleSP(); - if (newFirstKeyframe == cycle->firstSourceKeyframe() && newLastKeyframe == cycle->lastSourceKeyframe()) { + const int newEnd = lastDestination; // FIXME + + const KisTimeSpan &newRange = KisTimeSpan(firstDestination, newEnd); + if (newRange == oldRange) { return cycle; } - return toQShared(new KisAnimationCycle(*cycle, newFirstKeyframe, newLastKeyframe)); + return toQShared(new KisAnimationCycle(*cycle, newRange)); } QVector resolveCycleOverlaps(QVector &cycles, const KeyframeMapping &movedKeyframes) { - std::sort(cycles.begin(), cycles.end(), [&movedKeyframes](const CycleSP &lhs, const CycleSP &rhs) { - const int lhsTime = movedKeyframes.destination(lhs->firstSourceKeyframe()); - const int rhsTime = movedKeyframes.destination(rhs->firstSourceKeyframe()); - return lhsTime < rhsTime; + if (cycles.isEmpty()) return cycles; + + std::sort(cycles.begin(), cycles.end(), [](const CycleSP &lhs, const CycleSP &rhs) { + return lhs->originalRange().start() < rhs->originalRange().start(); }); CycleSP lhs = cycles[0]; for (int i = 1; i < cycles.size(); i++) { const CycleSP &rhs = cycles[i]; - const int lhsEnd = movedKeyframes.destination(lhs->lastSourceKeyframe()); - const int rhsStart = movedKeyframes.destination(rhs->firstSourceKeyframe()); + const int lhsEnd = lhs->originalRange().end(); + const int rhsStart = rhs->originalRange().start(); if (rhsStart < lhsEnd) { - const int rhsEnd = movedKeyframes.destination(rhs->lastSourceKeyframe()); + const int rhsEnd = rhs->originalRange().end(); if (rhsEnd < lhsEnd) { // Rhs cycle is entirely inside lhs one: drop it cycles[i] = CycleSP(); continue; } else { // TODO: logic for picking the cycle to truncate? - KisKeyframeSP truncatedStart = movedKeyframes.firstTrueKeyframeAfter(lhsEnd); - cycles[i] = toQShared(new KisAnimationCycle(*rhs, truncatedStart, rhs->lastSourceKeyframe())); + const int truncatedStart = movedKeyframes.firstTrueKeyframeAfter(lhsEnd)->time(); + cycles[i] = toQShared(new KisAnimationCycle(*rhs, {truncatedStart, rhsEnd})); } } lhs = cycles[i]; } return cycles; } QVector cyclesAfterMoves(const KeyframeMapping &movedKeyframes) { const KisKeyframeChannel *channel = movedKeyframes.destinations.begin().key()->channel(); QVector cycles; Q_FOREACH(const CycleSP cycle, channel->cycles()) { const CycleSP newCycle = cycleAfterMove(cycle, movedKeyframes); if (newCycle) { cycles << newCycle; } } return resolveCycleOverlaps(cycles, movedKeyframes); } bool validateRepeats(const QVector &cycles, const KeyframeMapping &movedKeyframes) { Q_FOREACH(const CycleSP &cycle, cycles) { if (!cycle) continue; - const int cycleStart = movedKeyframes.destination(cycle->firstSourceKeyframe()); - const int cycleEnd = movedKeyframes.destination(cycle->lastSourceKeyframe()); + const int cycleStart = cycle->originalRange().start(); + const int cycleEnd = cycle->originalRange().end(); // If any repeat frame would land within the cycle, refuse the operation. auto keyIt = KisCollectionUtils::firstAfter(movedKeyframes.sources, cycleStart); while (keyIt != movedKeyframes.sources.cend() && keyIt.key() < cycleEnd) { const QSharedPointer repeat = keyIt.value().dynamicCast(); if (repeat) return false; keyIt++; } } return true; } void updateCycles(const KisKeyframeChannel *channel, QVector cyclesAfter, KUndo2Command *parentCommand) { const QList &cyclesBefore = channel->cycles(); // Remove out-of-date definitions Q_FOREACH(const CycleSP &cycle, cyclesBefore) { if (!cyclesAfter.contains(cycle)) { new KisDefineCycleCommand(cycle, nullptr, parentCommand); } } // Add new cycle definitions Q_FOREACH(const CycleSP &cycle, cyclesAfter) { if (!cyclesBefore.contains(cycle)) { new KisDefineCycleCommand(nullptr, cycle, parentCommand); } } } void deleteOverwrittenKeys(KeyframeMapping moves, KUndo2Command *parentCommand) { QVector deletedKeys; for (auto it = moves.destinations.cbegin(); it != moves.destinations.cend(); ++it) { const KisKeyframeBaseSP &keyframe = it.key(); const int newTime = it.value(); const KisKeyframeBaseSP &originalKey = keyframe->channel()->itemAt(newTime); if (originalKey) { const bool isOverwritten = !moves.destinations.contains(originalKey); if (isOverwritten) { deletedKeys.append(originalKey); } } } Q_FOREACH(KisKeyframeBaseSP keyframe, deletedKeys) { new KisReplaceKeyframeCommand(keyframe->channel(), keyframe->time(), KisKeyframeBaseSP(), parentCommand); } } KUndo2CommandSP KisKeyframeCommands::tryMoveKeyframes(KisKeyframeChannel *channel, QVector moves, KUndo2Command *parentCommand) { KUndo2Command *command = new KUndo2Command(parentCommand); if (!areValidMoveSources(channel, moves)) return nullptr; const KeyframeMapping movedKeyframes(channel, moves); if (movedKeyframes.isEmpty()) return nullptr; const QVector cycles = cyclesAfterMoves(movedKeyframes); if (!validateRepeats(cycles, movedKeyframes)) return nullptr; deleteOverwrittenKeys(movedKeyframes, command); new KisMoveKeyframesCommand(moves, command); updateCycles(channel, cycles, command); return toQShared(command); } 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, 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, 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(CycleSP oldCycle, CycleSP newCycle, KUndo2Command *parentCommand) : KUndo2Command(parentCommand) , m_channel(oldCycle ? oldCycle->channel() : newCycle->channel()) , m_oldCycle(oldCycle) , m_newCycle(newCycle) {} void KisDefineCycleCommand::redo() { if (m_oldCycle) { m_channel->removeCycle(m_oldCycle); } if (m_newCycle) { m_channel->addCycle(m_newCycle); } } void KisDefineCycleCommand::undo() { if (m_newCycle) { m_channel->removeCycle(m_newCycle); } if (m_oldCycle) { m_channel->addCycle(m_oldCycle); } } QSharedPointer KisDefineCycleCommand::cycle() const { return m_newCycle; } diff --git a/libs/image/tests/kis_keyframing_test.cpp b/libs/image/tests/kis_keyframing_test.cpp index 9e9765ebae..21a9a6e3a1 100644 --- a/libs/image/tests/kis_keyframing_test.cpp +++ b/libs/image/tests/kis_keyframing_test.cpp @@ -1,583 +1,583 @@ /* * Copyright (c) 2015 Jouni Pentikäinen * * 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 #include #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 #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->copyAsKeyframe(key, 2, 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->copyAsKeyframe(key_0, 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); KisKeyframeBaseSP key; KisKeyframeBaseSP resKey; qRegisterMetaType("KisKeyframeBaseSP"); QSignalSpy spyPreAdd(channel, SIGNAL(sigKeyframeAboutToBeAdded(KisKeyframeBaseSP))); QSignalSpy spyPostAdd(channel, SIGNAL(sigKeyframeAdded(KisKeyframeBaseSP))); QSignalSpy spyPreRemove(channel, SIGNAL(sigKeyframeAboutToBeRemoved(KisKeyframeBaseSP))); QSignalSpy spyPostRemove(channel, SIGNAL(sigKeyframeRemoved(KisKeyframeBaseSP))); 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(); QVERIFY(resKey == key); resKey = spyPostAdd.at(0).at(0).value(); 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(); QVERIFY(resKey == key); QCOMPARE(spyPreMove.at(0).at(1).toInt(), 15); resKey = spyPostMove.at(0).at(0).value(); 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); + auto cmd = channel->createCycle({10, 19}); 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)); QSharedPointer 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/timeline_frames_model.cpp b/plugins/dockers/animation/timeline_frames_model.cpp index 3690d3bcee..1dfa358472 100644 --- a/plugins/dockers/animation/timeline_frames_model.cpp +++ b/plugins/dockers/animation/timeline_frames_model.cpp @@ -1,1114 +1,1105 @@ /* * Copyright (c) 2015 Dmitry Kazakov * * 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 #include #include #include #include #include #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 #include #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 #include "kis_processing_applicator.h" #include #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 dummiesFacade; KisImageWSP image; bool needFinishInsertRows; bool needFinishRemoveRows; QList updateQueue; KisSignalCompressor updateTimer; KisNodeDummy* parentOfRemovedNode; QScopedPointer converter; QScopedPointer 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 { KisKeyframeChannel *primaryChannel = getChannel(row, KisKeyframeChannel::Content.id()); return (primaryChannel && primaryChannel->itemAt(column)); } bool frameHasContent(int row, int column) { KisKeyframeChannel *primaryChannel = getChannel(row, KisKeyframeChannel::Content.id()); if (!primaryChannel) return false; // first check if we are a key frame KisKeyframeBaseSP frame = primaryChannel->activeItemAt(column); if (!frame) return false; const KisKeyframe *keyframe = dynamic_cast(frame.data()); return keyframe && keyframe->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) { KisKeyframeChannel *primaryChannel = getChannel(row, KisKeyframeChannel::Content.id()); if (!primaryChannel) return -1; KisKeyframeSP frame = primaryChannel->visibleKeyframeAt(column); if (!frame) return -1; return frame->colorLabel(); } void setFrameColorLabel(int row, int column, int color) { KisKeyframeChannel *primaryChannel = getChannel(row, KisKeyframeChannel::Content.id()); if (!primaryChannel) return; KisKeyframeSP frame = primaryChannel->visibleKeyframeAt(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{ KisKeyframeChannel *primaryChannel = getChannel(row, KisKeyframeChannel::Content.id()); if (!primaryChannel) return NoCycle; const QSharedPointer cycle = primaryChannel->cycleAt(time); const QSharedPointer repeat = primaryChannel->activeRepeatAt(time); if (repeat) { const KisTimeSpan range = repeat->cycle()->originalRange(); const int originalTime = repeat->getOriginalTimeFor(time); if (originalTime == range.start()) return BeginsRepeat; if (originalTime == range.end()) return EndsRepeat; return ContinuesRepeat; } else if (cycle) { const KisTimeSpan range = cycle->originalRange(); if (time == range.start()) return BeginsCycle; if (time == range.end()) 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; } KisKeyframeChannel *getChannel(int row, const QString &channelId) const { KisNodeDummy *dummy = converter->dummyFromRow(row); if (!dummy) return nullptr; return dummy->node()->getKeyframeChannel(channelId); } }; 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 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(); 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 &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 parentCommand(new KUndo2Command(kundo2_i18np("Insert frame", "Insert %1 frames", count))); { KisImageBarrierLockerWithFeedback locker(m_d->image); QSet uniqueKeyframesInSelection; int minSelectedTime = std::numeric_limits::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()); KisKeyframeBaseSP keyFrame = channel->activeItemAt(index.column()); if (keyFrame) { uniqueKeyframesInSelection.insert(keyFrame); } } QList keyframesToMove; for (auto it = uniqueKeyframesInSelection.begin(); it != uniqueKeyframesInSelection.end(); ++it) { KisKeyframeBaseSP keyframe = *it; KisKeyframeChannel *channel = keyframe->channel(); KisKeyframeBaseSP nextKeyframe = channel->nextItem(*keyframe); if (nextKeyframe) { keyframesToMove << nextKeyframe; } } std::sort(keyframesToMove.begin(), keyframesToMove.end(), [] (KisKeyframeBaseSP lhs, KisKeyframeBaseSP rhs) { return lhs->time() > rhs->time(); }); if (keyframesToMove.isEmpty()) return true; const int maxColumn = columnCount(); if (count > 0) { setLastVisibleFrame(columnCount() + count); } Q_FOREACH (KisKeyframeBaseSP keyframe, keyframesToMove) { int plannedFrameMove = count; if (count < 0) { KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(keyframe->time() > 0, false); KisKeyframeBaseSP prevFrame = keyframe->channel()->previousItem(*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 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()) { - KisDefineCycleCommand *createCycle = contentChannel->createCycle(firstKeyframe, lastKeyframe, parentCommand); - - if (contentChannel->itemAt(timeTo + 1).isNull()) { - contentChannel->addRepeat(createCycle->cycle(), timeTo + 1, parentCommand); - } - } + contentChannel->createCycle({timeFrom, timeTo}, parentCommand); } } } KisProcessingApplicator::runSingleCommandStroke(m_d->image, parentCommand, KisStrokeJobData::BARRIER); return true; } bool TimelineFramesModel::deleteCycles(int timeFrom, int timeTo, QSet rows) { QVector> 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 cycle, cycles) { - KisKeyframeChannel *channel = cycle->firstSourceKeyframe()->channel(); + KisKeyframeChannel *channel = cycle->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 QSharedPointer cycle = contentChannel->cycleAt(t); if (cycle) { KUndo2Command *parentCommand = new KUndo2Command(kundo2_i18n("Add animation repeat")); 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); }