KisAnimUtils Namespace Reference

Classes
struct	FrameItem
struct	LessOperator

Typedefs
typedef QVector< FrameItem >	FrameItemList
typedef std::pair< FrameItem, FrameItem >	FrameMovePair
typedef QVector< FrameMovePair >	FrameMovePairList

Functions
KUndo2Command *	createCloneKeyframesCommand (const FrameMovePairList &srcDstPairs, KUndo2Command *parentCommand)
KUndo2Command *	createKeyframeCommand (KisImageSP image, KisNodeSP node, const QString &channelId, int time, bool copy, KUndo2Command *parentCommand)
void	createKeyframeLazy (KisImageSP image, KisNodeSP node, const QString &channelId, int time, bool copy)
KUndo2Command *	createMoveKeyframesCommand (const FrameItemList &srcFrames, const FrameItemList &dstFrames, bool copy, bool moveEmpty, KUndo2Command *parentCommand)
KUndo2Command *	createMoveKeyframesCommand (const FrameMovePairList &movePairs, bool copy, bool moveEmptyFrames, KUndo2Command *parentCommand=0)
	implements safe moves of the frames (even if there are cycling move dependencies)
void	makeClonesUnique (KisImageSP image, const FrameItemList &frames)
void	moveOneFrameItem (const FrameItem &src, const FrameItem &dst, bool copy, bool moveEmptyFrames, KUndo2Command *parentCommand)
QDebug	operator<< (QDebug dbg, const FrameItem &item)
uint	qHash (const FrameItem &item)
void	removeKeyframe (KisImageSP image, KisNodeSP node, const QString &channel, int time)
void	removeKeyframes (KisImageSP image, const FrameItemList &frames)
void	resetChannel (KisImageSP image, KisNodeSP node, const QString &channelID)
void	resetChannels (KisImageSP image, KisNodeSP node, const QList< QString > &channelIDs)
void	sortPointsForSafeMove (QModelIndexList *points, const QPoint &offset)
bool	supportsContentFrames (KisNodeSP node)
void	swapOneFrameItem (const FrameItem &src, const FrameItem &dst, KUndo2Command *parentCommand)

Variables
const QString	addOpacityKeyframeActionName
const QString	addTransformKeyframeActionName = i18n("Add transform keyframe")
const QString	dropFramesActionName = i18n("Drop Frames")
const QString	lazyFrameCreationActionName = i18n("Auto Frame Mode")
const QString	newLayerActionName = i18n("New Layer")
const QString	pinExistingLayerActionName = i18n("Pin Existing Layer")
const QString	removeLayerActionName = i18n("Remove Layer")
const QString	removeOpacityKeyframeActionName
const QString	removeTransformKeyframeActionName = i18n("Remove transform keyframe")

Typedef Documentation

FrameItemList

typedef QVector<FrameItem> KisAnimUtils::FrameItemList

Definition at line 45 of file KisAnimUtils.h.

FrameMovePair

typedef std::pair<FrameItem, FrameItem> KisAnimUtils::FrameMovePair

Definition at line 46 of file KisAnimUtils.h.

FrameMovePairList

typedef QVector<FrameMovePair> KisAnimUtils::FrameMovePairList

Definition at line 47 of file KisAnimUtils.h.

Function Documentation

createCloneKeyframesCommand()

KUndo2Command * KisAnimUtils::createCloneKeyframesCommand	(	const FrameMovePairList &	srcDstPairs,
		KUndo2Command *	parentCommand )

Definition at line 392 of file KisAnimUtils.cpp.

    {
        return new KisCommandUtils::LambdaCommand(
                kundo2_i18np("Clone Keyframe",
                             "Clone %1 Keyframes",
                             srcDstPairs.size()),
                parentCommand,
                [srcDstPairs, parentCommand]() -> KUndo2Command*
        {
            Q_UNUSED(parentCommand);
            QScopedPointer<KUndo2Command> cmd(new KUndo2Command());
 
            foreach (const FrameMovePair &move, srcDstPairs) {
                KisRasterKeyframeChannel *srcRasterChan = dynamic_cast<KisRasterKeyframeChannel*>(move.first.node->getKeyframeChannel(move.first.channel));
                KisRasterKeyframeChannel *dstRasterChan = dynamic_cast<KisRasterKeyframeChannel*>(move.second.node->getKeyframeChannel(move.second.channel));
 
                if (!srcRasterChan || !dstRasterChan) {
                    continue;
                }
 
                if (srcRasterChan == dstRasterChan) {
                    srcRasterChan->cloneKeyframe(move.first.time, move.second.time, cmd.data());
                } else {
                    KisKeyframeChannel::copyKeyframe(srcRasterChan, move.first.time, dstRasterChan, move.second.time, cmd.data());
                }
            }
 
            return cmd.take();
        });
    }

References createCloneKeyframesCommand(), and kundo2_i18np().

createKeyframeCommand()

KUndo2Command * KisAnimUtils::createKeyframeCommand	(	KisImageSP	image,
		KisNodeSP	node,
		const QString &	channelId,
		int	time,
		bool	copy,
		KUndo2Command *	parentCommand )

Scalar keyframes return the next value for positions before the first keyframe. That is a bit counterintuitive, but that is what we have.

Definition at line 36 of file KisAnimUtils.cpp.

                                                                                                                                                        {
        KUndo2Command *cmd = new KisCommandUtils::LambdaCommand(
            copy ? kundo2_i18n("Copy Keyframe") :
                   kundo2_i18n("Add Keyframe"),
            parentCommand,
 
            [image, node, channelId, time, copy] () mutable -> KUndo2Command* {
                bool success = false;
 
                QScopedPointer<KUndo2Command> cmd(new KUndo2Command());
 
                KisKeyframeChannel *channel = node->getKeyframeChannel(channelId);
                quint8 originalOpacity = node->opacity();
 
                // Try get channel...
                bool channelCreated = false;
                if (!channel) {
                    node->enableAnimation();
                    channel = node->getKeyframeChannel(channelId, true);
 
                    if (!channel) return nullptr;
 
                    channelCreated = true;
                }
 
                bool shouldPreserveCanvas = channelCreated && time == 0;
 
                if ((copy || shouldPreserveCanvas) && channel->activeKeyframeAt(time)) {
                    if (!channel->keyframeAt(time)) {
                        channel->copyKeyframe(channel->activeKeyframeTime(time), time, cmd.data());
                        success = true;
                    }
                } else {
                    bool clearExistingFrame = channel->keyframeAt(time) && !channelCreated;
                    if (clearExistingFrame && channelId == KisKeyframeChannel::Raster.id()) { // Overwrite existing keyframe with a new blank one...
                        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(image->animationInterface()->currentTime() == time, nullptr);
                        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(channelId == KisKeyframeChannel::Raster.id(), nullptr);
 
                        // Clear the frame...
                        KisPaintDeviceSP device = node->paintDevice();
                        if (device) {
                            const QRect dirtyRect = device->extent();
 
                            KisTransaction transaction(kundo2_i18n("Clear"), device, cmd.data());
                            device->clear();
                            (void) transaction.endAndTake(); // saved as 'parent'
 
                            node->setDirty(dirtyRect);
 
                            success = true;
                        }
                    } else { // Make a regular new blank keyframe...
                        KisKeyframeSP referenceKey = channel->activeKeyframeAt(time);
 
                        bool isScalar = (channelId != KisKeyframeChannel::Raster.id());
 
                        if (isScalar && !referenceKey) {
                            const QSet<int> allTimes = channel->allKeyframeTimes();
 
                            auto it = std::min_element(allTimes.begin(), allTimes.end());
                            if (it != allTimes.end()) {
                                referenceKey = channel->keyframeAt(*it);
                            }
                        }
 
                        if (isScalar && referenceKey) {
                            KisScalarKeyframeChannel* scalarChannel = static_cast<KisScalarKeyframeChannel*>(channel);
                            const qreal value = scalarChannel->valueAt(time); //Get interpolated value.
                            scalarChannel->addScalarKeyframe(time, value, cmd.data());
                        } else {
                            channel->addKeyframe(time, cmd.data());
                        }
 
                        // Use color label of previous key, if exists...
                        if (referenceKey && channel->keyframeAt(time)) {
                            channel->keyframeAt(time)->setColorLabel(referenceKey->colorLabel());
                        }
 
                        success = true;
                    }
                }
 
                // when a new opacity keyframe is created, the opacity is set to 0
                // this makes sure to use the opacity that was previously used
                // maybe there is a better way to do this
                node->setOpacity(originalOpacity);
 
                return success ? cmd.take() : nullptr;
        });
 
        return cmd;
    }

References KisKeyframeChannel::activeKeyframeAt(), KisKeyframeChannel::activeKeyframeTime(), KisKeyframeChannel::addKeyframe(), KisScalarKeyframeChannel::addScalarKeyframe(), KisKeyframeChannel::allKeyframeTimes(), KisImage::animationInterface(), KisPaintDevice::clear(), KisKeyframeChannel::copyKeyframe(), KisImageAnimationInterface::currentTime(), KisSharedPtr< T >::data(), KisBaseNode::enableAnimation(), KisTransaction::endAndTake(), KisPaintDevice::extent(), KisBaseNode::getKeyframeChannel(), KoID::id(), KisKeyframeChannel::keyframeAt(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, kundo2_i18n(), KisBaseNode::opacity(), KisBaseNode::paintDevice(), KisKeyframeChannel::Raster, KisNode::setDirty(), KisBaseNode::setOpacity(), value(), KisScalarKeyframeChannel::valueAt(), and void().

createKeyframeLazy()

void KisAnimUtils::createKeyframeLazy	(	KisImageSP	image,
		KisNodeSP	node,
		const QString &	channelId,
		int	time,
		bool	copy )

Definition at line 134 of file KisAnimUtils.cpp.

    {
        KUndo2Command *cmd = createKeyframeCommand(image, node, channelId, time, copy);
        KisProcessingApplicator::runSingleCommandStroke(image, cmd,
                                                        KisStrokeJobData::BARRIER,
                                                        KisStrokeJobData::EXCLUSIVE);
    }

References KisStrokeJobData::BARRIER, createKeyframeCommand(), KisStrokeJobData::EXCLUSIVE, and KisProcessingApplicator::runSingleCommandStroke().

createMoveKeyframesCommand() [1/2]

KUndo2Command * KisAnimUtils::createMoveKeyframesCommand	(	const FrameItemList &	srcFrames,
		const FrameItemList &	dstFrames,
		bool	copy,
		bool	moveEmpty,
		KUndo2Command *	parentCommand )

Definition at line 298 of file KisAnimUtils.cpp.

    {
        FrameMovePairList srcDstPairs;
        for (int i = 0; i < srcFrames.size(); i++) {
            srcDstPairs << std::make_pair(srcFrames[i], dstFrames[i]);
        }
        return createMoveKeyframesCommand(srcDstPairs, copy, moveEmpty, parentCommand);
    }

References createMoveKeyframesCommand().

createMoveKeyframesCommand() [2/2]

KRITAANIMATIONDOCKER_EXPORT KUndo2Command * KisAnimUtils::createMoveKeyframesCommand	(	const FrameMovePairList &	movePairs,
		bool	copy,
		bool	moveEmptyFrames,
		KUndo2Command *	parentCommand = 0 )

implements safe moves of the frames (even if there are cycling move dependencies)

Parameters

movePairs	the jobs for the moves
copy	shows if the frames should be copied or not
moveEmpty	allows an empty frame to replace a populated one
parentCommand	the command that should be a parent of the created command

Returns

a created undo command

Definition at line 311 of file KisAnimUtils.cpp.

    {
        KUndo2Command *cmd = new KisCommandUtils::LambdaCommand(
 
            !copy ?
                kundo2_i18np("Move Keyframe",
                             "Move %1 Keyframes",
                             srcDstPairs.size()) :
                kundo2_i18ncp("Copy one or several keyframes",
                             "Copy Keyframe",
                             "Copy %1 Keyframes",
                             srcDstPairs.size()),
 
            parentCommand,
 
            [srcDstPairs, copy, moveEmptyFrames] () -> KUndo2Command* {
                bool result = false;
 
                QScopedPointer<KUndo2Command> cmd(new KUndo2Command());
 
                using MoveChain = QList<FrameItem>;
                QHash<FrameItem, MoveChain> moveMap;
                Q_FOREACH (const FrameMovePair &pair, srcDstPairs) {
                    moveMap.insert(pair.first, {pair.second});
                }
 
                auto it = moveMap.begin();
                while (it != moveMap.end()) {
                    MoveChain &chain = it.value();
                    const FrameItem &previousFrame = chain.last();
 
                    auto tailIt = moveMap.find(previousFrame);
 
                    if (tailIt == it || tailIt == moveMap.end()) {
                        ++it;
                        continue;
                    }
 
                    chain.append(tailIt.value());
                    tailIt = moveMap.erase(tailIt);
                    // no incrementing! we are going to check the new tail now!
                }
 
                for (it = moveMap.begin(); it != moveMap.end(); ++it) {
                    MoveChain &chain = it.value();
                    chain.prepend(it.key());
                    KIS_SAFE_ASSERT_RECOVER(chain.size() > 1) { continue; }
 
                    bool isCycle = false;
                    if (chain.last() == chain.first()) {
                        isCycle = true;
                        chain.takeLast();
                    }
 
                    auto frameIt = chain.rbegin();
 
                    FrameItem dstItem = *frameIt++;
 
                    while (frameIt != chain.rend()) {
                        FrameItem srcItem = *frameIt++;
 
                        if (!isCycle) {
                            moveOneFrameItem(srcItem, dstItem, copy, moveEmptyFrames, cmd.data());
                        } else {
                            swapOneFrameItem(srcItem, dstItem, cmd.data());
                        }
 
                        dstItem = srcItem;
                        result = true;
                    }
                }
 
                return result ? cmd.take() : nullptr;
        });
 
        return cmd;
    }

References createMoveKeyframesCommand(), KIS_SAFE_ASSERT_RECOVER, kundo2_i18ncp(), kundo2_i18np(), moveOneFrameItem(), and swapOneFrameItem().

makeClonesUnique()

void KisAnimUtils::makeClonesUnique	(	KisImageSP	image,
		const FrameItemList &	frames )

Definition at line 424 of file KisAnimUtils.cpp.

    {
        KUndo2Command* cmd = new KisCommandUtils::LambdaCommand(
                    kundo2_i18n("Make clones Unique"),
                    [frames]() {
            QScopedPointer<KUndo2Command> cmd(new KUndo2Command());
 
            foreach (const FrameItem &frameItem, frames) {
                KisRasterKeyframeChannel *rasterChan = dynamic_cast<KisRasterKeyframeChannel*>(frameItem.node->getKeyframeChannel(frameItem.channel));
                if (!rasterChan) {
                    continue;
                }
 
                rasterChan->makeUnique(frameItem.time, cmd.data());
            }
 
            return cmd.take();
        });
 
        KisProcessingApplicator::runSingleCommandStroke(image, cmd,
                                                        KisStrokeJobData::BARRIER,
                                                        KisStrokeJobData::EXCLUSIVE);
    }

References KisStrokeJobData::BARRIER, KisAnimUtils::FrameItem::channel, KisStrokeJobData::EXCLUSIVE, KisBaseNode::getKeyframeChannel(), kundo2_i18n(), makeClonesUnique(), KisRasterKeyframeChannel::makeUnique(), KisAnimUtils::FrameItem::node, KisProcessingApplicator::runSingleCommandStroke(), and KisAnimUtils::FrameItem::time.

moveOneFrameItem()

void KisAnimUtils::moveOneFrameItem	(	const FrameItem &	src,
		const FrameItem &	dst,
		bool	copy,
		bool	moveEmptyFrames,
		KUndo2Command *	parentCommand )

Definition at line 258 of file KisAnimUtils.cpp.

    {
        const int srcTime = src.time;
        KisNodeSP srcNode = src.node;
        KisKeyframeChannel *srcChannel = srcNode->getKeyframeChannel(src.channel);
 
        const int dstTime = dst.time;
        KisNodeSP dstNode = dst.node;
        KisKeyframeChannel *dstChannel = dstNode->getKeyframeChannel(dst.channel, true);
 
        if (srcNode == dstNode) {
            if (!srcChannel) return; // TODO: add warning!
 
            if (srcChannel->keyframeAt(srcTime)) {
                if (copy) {
                    srcChannel->copyKeyframe(srcTime, dstTime, parentCommand);
                } else {
                    srcChannel->moveKeyframe(srcTime, dstTime, parentCommand);
                }
            } else {
                if (srcChannel->keyframeAt(dstTime) && moveEmptyFrames && !copy) {
                    //Destination is effectively replaced by an empty frame.
                    dstChannel->removeKeyframe(dstTime, parentCommand);
                }
            }
        } else {
            if (!srcChannel || !dstChannel) return; // TODO: add warning!
 
            KisKeyframeSP srcKeyframe = srcChannel->keyframeAt(srcTime);
 
            if (!srcKeyframe) return; // TODO: add warning!
 
            KisKeyframeChannel::copyKeyframe(srcChannel, srcTime, dstChannel, dstTime, parentCommand);
 
            if (!copy) {
                srcChannel->removeKeyframe(srcTime, parentCommand);
            }
        }
    }

References KisAnimUtils::FrameItem::channel, KisKeyframeChannel::copyKeyframe(), KisBaseNode::getKeyframeChannel(), KisKeyframeChannel::keyframeAt(), KisKeyframeChannel::moveKeyframe(), moveOneFrameItem(), KisAnimUtils::FrameItem::node, KisKeyframeChannel::removeKeyframe(), and KisAnimUtils::FrameItem::time.

operator<<()

KRITAANIMATIONDOCKER_EXPORT QDebug KisAnimUtils::operator<<	(	QDebug	dbg,
		const FrameItem &	item )

Definition at line 448 of file KisAnimUtils.cpp.

    {
        dbg.nospace() << "FrameItem(" << item.node->name() << ", " << item.channel << ", " << item.time << ")";
        return dbg.space();
    }

References KisAnimUtils::FrameItem::channel, KisBaseNode::name(), KisAnimUtils::FrameItem::node, and KisAnimUtils::FrameItem::time.

qHash()

uint KisAnimUtils::qHash ( const FrameItem & item )

inline

Definition at line 39 of file KisAnimUtils.h.

    {
        return ::qHash(item.node.data()) + ::qHash(item.channel) + ::qHash(item.time);
    }

References KisAnimUtils::FrameItem::channel, KisSharedPtr< T >::data(), KisAnimUtils::FrameItem::node, qHash(), and KisAnimUtils::FrameItem::time.

removeKeyframe()

void KisAnimUtils::removeKeyframe	(	KisImageSP	image,
		KisNodeSP	node,
		const QString &	channel,
		int	time )

Definition at line 180 of file KisAnimUtils.cpp.

                                                                                            {
        QVector<FrameItem> frames;
        frames << FrameItem(node, channel, time);
        removeKeyframes(image, frames);
    }

References removeKeyframe(), and removeKeyframes().

removeKeyframes()

void KisAnimUtils::removeKeyframes	(	KisImageSP	image,
		const FrameItemList &	frames )

Definition at line 142 of file KisAnimUtils.cpp.

                                                                        {
        KIS_SAFE_ASSERT_RECOVER_RETURN(!image->locked());
 
        KUndo2Command *cmd = new KisCommandUtils::LambdaCommand(
            kundo2_i18np("Remove Keyframe",
                         "Remove Keyframes",
                         frames.size()),
 
            [image, frames] () {
                bool result = false;
 
                QScopedPointer<KUndo2Command> cmd(new KUndo2Command());
 
                Q_FOREACH (const FrameItem &item, frames) {
                    const int time = item.time;
                    KisNodeSP node = item.node;
                    KisKeyframeChannel *channel = 0;
                    if (node) {
                        channel = node->getKeyframeChannel(item.channel);
                    }
                    if (!channel) continue;
 
                    KisKeyframeSP keyframe = channel->keyframeAt(time);
                    if (!keyframe) continue;
 
                    channel->removeKeyframe(time, cmd.data());
 
                    result = true;
                }
 
                return result ? cmd.take() : 0;
        });
 
        KisProcessingApplicator::runSingleCommandStroke(image, cmd,
                                                        KisStrokeJobData::BARRIER,
                                                        KisStrokeJobData::EXCLUSIVE);
    }

References KIS_SAFE_ASSERT_RECOVER_RETURN, kundo2_i18np(), and KisImage::locked().

resetChannel()

void KisAnimUtils::resetChannel	(	KisImageSP	image,
		KisNodeSP	node,
		const QString &	channelID )

Definition at line 202 of file KisAnimUtils.cpp.

                                                                                  {
        QList<QString> channels;
        channels << channelID;
        resetChannels(image, node, channels);
 
    }

References resetChannel(), and resetChannels().

resetChannels()

void KisAnimUtils::resetChannels	(	KisImageSP	image,
		KisNodeSP	node,
		const QList< QString > &	channelIDs )

Definition at line 186 of file KisAnimUtils.cpp.

                                                                                           {
        QVector<FrameItem> frames;
 
        Q_FOREACH( const QString& channelID, channelIDs) {
            KisKeyframeChannel* channel = node->getKeyframeChannel(channelID, false);
            if (!channel)
                continue;
 
            Q_FOREACH( const int& time, channel->allKeyframeTimes()) {
                frames << FrameItem(node, channelID, time);
            }
        }
 
        removeKeyframes(image, frames);
    }

References KisKeyframeChannel::allKeyframeTimes(), KisBaseNode::getKeyframeChannel(), removeKeyframes(), and resetChannels().

sortPointsForSafeMove()

void KisAnimUtils::sortPointsForSafeMove	(	QModelIndexList *	points,
		const QPoint &	offset )

Definition at line 227 of file KisAnimUtils.cpp.

    {
        std::sort(points->begin(), points->end(), LessOperator(offset));
    }

References sortPointsForSafeMove().

supportsContentFrames()

bool KisAnimUtils::supportsContentFrames

(

KisNodeSP

node

)

Definition at line 232 of file KisAnimUtils.cpp.

    {
        return node->inherits("KisPaintLayer") || node->inherits("KisFilterMask") || node->inherits("KisTransparencyMask") || node->inherits("KisSelectionBasedLayer");
    }

References supportsContentFrames().

swapOneFrameItem()

void KisAnimUtils::swapOneFrameItem	(	const FrameItem &	src,
		const FrameItem &	dst,
		KUndo2Command *	parentCommand )

Definition at line 237 of file KisAnimUtils.cpp.

    {
        const int srcTime = src.time;
        KisNodeSP srcNode = src.node;
        KisKeyframeChannel *srcChannel = srcNode->getKeyframeChannel(src.channel);
 
        const int dstTime = dst.time;
        KisNodeSP dstNode = dst.node;
        KisKeyframeChannel *dstChannel = dstNode->getKeyframeChannel(dst.channel, true);
 
        if (srcNode == dstNode) {
            if (!srcChannel) return; // TODO: add warning!
 
            srcChannel->swapKeyframes(srcTime, dstTime, parentCommand);
        } else {
            if (!srcChannel || !dstChannel) return; // TODO: add warning!
 
            KisKeyframeChannel::swapKeyframes(srcChannel, srcTime, dstChannel, dstTime, parentCommand);
        }
    }

References KisAnimUtils::FrameItem::channel, KisBaseNode::getKeyframeChannel(), KisAnimUtils::FrameItem::node, KisKeyframeChannel::swapKeyframes(), swapOneFrameItem(), and KisAnimUtils::FrameItem::time.

Variable Documentation

addOpacityKeyframeActionName

const QString KisAnimUtils::addOpacityKeyframeActionName

extern

addTransformKeyframeActionName

const QString KisAnimUtils::addTransformKeyframeActionName = i18n("Add transform keyframe")

Definition at line 33 of file KisAnimUtils.cpp.

dropFramesActionName

const QString KisAnimUtils::dropFramesActionName = i18n("Drop Frames")

Definition at line 27 of file KisAnimUtils.cpp.

lazyFrameCreationActionName

const QString KisAnimUtils::lazyFrameCreationActionName = i18n("Auto Frame Mode")

Definition at line 26 of file KisAnimUtils.cpp.

newLayerActionName

const QString KisAnimUtils::newLayerActionName = i18n("New Layer")

Definition at line 29 of file KisAnimUtils.cpp.

pinExistingLayerActionName

const QString KisAnimUtils::pinExistingLayerActionName = i18n("Pin Existing Layer")

Definition at line 30 of file KisAnimUtils.cpp.

removeLayerActionName

const QString KisAnimUtils::removeLayerActionName = i18n("Remove Layer")

Definition at line 31 of file KisAnimUtils.cpp.

removeOpacityKeyframeActionName

const QString KisAnimUtils::removeOpacityKeyframeActionName

extern

removeTransformKeyframeActionName

const QString KisAnimUtils::removeTransformKeyframeActionName = i18n("Remove transform keyframe")

Definition at line 34 of file KisAnimUtils.cpp.