KisAnimCurvesModel Class Reference

#include <KisAnimCurvesModel.h>

Inheritance diagram for KisAnimCurvesModel:

Classes
struct	Private

Public Types
enum	ItemDataRole {   ScalarValueRole = KisTimeBasedItemModel::UserRole + 101 , InterpolationModeRole , TangentsModeRole , LeftTangentRole ,   RightTangentRole , CurveColorRole , CurveVisibleRole , PreviousKeyframeTime ,   NextKeyframeTime , ChannelIdentifier , ChannelLimits }
Public Types inherited from KisTimeBasedItemModel
enum	ItemDataRole {   ActiveFrameRole = Qt::UserRole + 101 , ScrubToRole , CloneOfActiveFrame , CloneCount ,   FrameExistsRole , SpecialKeyframeExists , FrameCachedRole , FrameEditableRole ,   FramesPerSecondRole , FrameHasContent , WithinClipRange , UserRole }

Signals
void	dataAdded (const QModelIndex &index)

Public Member Functions
KisAnimationCurve *	addCurve (KisScalarKeyframeChannel *channel)
bool	adjustKeyframes (const QModelIndexList &indexes, int timeOffset, qreal valueOffset)
void	beginCommand (const KUndo2MagicString &text)
QVariant	data (const QModelIndex &index, int role) const override
void	endCommand ()
bool	hasConnectionToCanvas () const
QVariant	headerData (int section, Qt::Orientation orientation, int role) const override
	KisAnimCurvesModel (QObject *parent)
void	removeCurve (KisAnimationCurve *curve)
int	rowCount (const QModelIndex &parent=QModelIndex()) const override
void	setCurveVisible (KisAnimationCurve *curve, bool visible)
bool	setData (const QModelIndex &index, const QVariant &value, int role) override
bool	setHeaderData (int section, Qt::Orientation orientation, const QVariant &value, int role) override
	~KisAnimCurvesModel () override
Public Member Functions inherited from KisTimeBasedItemModel
int	columnCount (const QModelIndex &parent=QModelIndex()) const override
int	currentTime () const
QVariant	data (const QModelIndex &index, int role) const override
KisDocument *	document () const
QVariant	headerData (int section, Qt::Orientation orientation, int role) const override
bool	isFrameCached (const int frame)
bool	isPlaybackActive () const
bool	isPlaybackPaused () const
bool	isScrubbing ()
	KisTimeBasedItemModel (QObject *parent)
bool	mirrorFrames (QModelIndexList indexes)
bool	removeFrames (const QModelIndexList &indexes)
bool	removeFramesAndOffset (QModelIndexList indicesToRemove)
void	scrubHorizontalHeaderUpdate (int activeHeader)
void	setAnimationPlayer (KisCanvasAnimationState *player)
bool	setData (const QModelIndex &index, const QVariant &value, int role) override
void	setDocument (class KisDocument *document)
void	setFrameCache (KisAnimationFrameCacheSP cache)
bool	setHeaderData (int section, Qt::Orientation orientation, const QVariant &value, int role) override
void	setImage (KisImageWSP image)
void	setLastVisibleFrame (int time)
void	setPlaybackRange (const KisTimeSpan &range)
void	setScrubState (bool active)
void	stopPlayback () const
	~KisTimeBasedItemModel () override

Protected Member Functions
KisKeyframeChannel *	channelByID (QModelIndex index, const QString &id) const override
QMap< QString, KisKeyframeChannel * >	channelsAt (QModelIndex index) const override
KisNodeSP	nodeAt (QModelIndex index) const override
Protected Member Functions inherited from KisTimeBasedItemModel
int	cloneCount (const QModelIndex &index) const
bool	cloneOfActiveFrame (const QModelIndex &index) const
KUndo2Command *	createOffsetFramesCommand (QModelIndexList srcIndexes, const QPoint &offset, bool copyFrames, bool moveEmptyFrames, KUndo2Command *parentCommand=0)
KisImageWSP	image () const

Private Slots
void	slotKeyframeAdded (const KisKeyframeChannel *channel, int time)
void	slotKeyframeChanged (const KisKeyframeChannel *channel, int time)

Private Attributes
const QScopedPointer< Private >	m_d

Additional Inherited Members
Protected Slots inherited from KisTimeBasedItemModel
void	slotCurrentTimeChanged (int time)

Detailed Description

Definition at line 33 of file KisAnimCurvesModel.h.

Member Enumeration Documentation

ItemDataRole

enum KisAnimCurvesModel::ItemDataRole

Enumerator
ScalarValueRole
InterpolationModeRole
TangentsModeRole
LeftTangentRole
RightTangentRole
CurveColorRole
CurveVisibleRole
PreviousKeyframeTime
NextKeyframeTime
ChannelIdentifier
ChannelLimits

Definition at line 61 of file KisAnimCurvesModel.h.

    {
        ScalarValueRole = KisTimeBasedItemModel::UserRole + 101,
        InterpolationModeRole,
        TangentsModeRole,
        LeftTangentRole,
        RightTangentRole,
        CurveColorRole,
        CurveVisibleRole,
        PreviousKeyframeTime,
        NextKeyframeTime,
        ChannelIdentifier,
        ChannelLimits
    };

Constructor & Destructor Documentation

KisAnimCurvesModel()

KisAnimCurvesModel::KisAnimCurvesModel

(

QObject *

parent

)

Definition at line 105 of file KisAnimCurvesModel.cpp.

    : KisTimeBasedItemModel(parent)
    , m_d(new Private())
{}

~KisAnimCurvesModel()

KisAnimCurvesModel::~KisAnimCurvesModel ( )

override

Definition at line 110 of file KisAnimCurvesModel.cpp.

{
    qDeleteAll(m_d->curves);
}

References m_d.

Member Function Documentation

addCurve()

KisAnimationCurve * KisAnimCurvesModel::addCurve

(

KisScalarKeyframeChannel *

channel

)

Definition at line 377 of file KisAnimCurvesModel.cpp.

{
    beginInsertRows(QModelIndex(), m_d->curves.size(), m_d->curves.size());
 
    KisAnimationCurve *curve = new KisAnimationCurve(channel, m_d->chooseNextColor());
    m_d->curves.append(curve);
 
    endInsertRows();
 
    connect(channel, &KisScalarKeyframeChannel::sigAddedKeyframe,
            this, &KisAnimCurvesModel::slotKeyframeChanged);
 
    connect(channel, &KisScalarKeyframeChannel::sigAddedKeyframe,
            this, &KisAnimCurvesModel::slotKeyframeAdded);
 
    connect(channel, &KisScalarKeyframeChannel::sigKeyframeHasBeenRemoved,
            this, [this](const KisKeyframeChannel* channel, int time) {
        this->slotKeyframeChanged(channel, time);
    });
 
    connect(channel, SIGNAL(sigKeyframeChanged(const KisKeyframeChannel*,int)),
            this, SLOT(slotKeyframeChanged(const KisKeyframeChannel*,int)));
 
    return curve;
}

References connect(), m_d, KisKeyframeChannel::sigAddedKeyframe(), KisKeyframeChannel::sigKeyframeHasBeenRemoved(), slotKeyframeAdded(), and slotKeyframeChanged().

adjustKeyframes()

bool KisAnimCurvesModel::adjustKeyframes	(	const QModelIndexList &	indexes,
		int	timeOffset,
		qreal	valueOffset )

Definition at line 311 of file KisAnimCurvesModel.cpp.

{
    QScopedPointer<KUndo2Command> command(
        new KUndo2Command(
            kundo2_i18np("Adjust Keyframe",
                         "Adjust %1 Keyframes",
                         indexes.size())));
 
    {
        KisImageBarrierLock lock(image());
 
        if (timeOffset != 0) {
            bool ok = createOffsetFramesCommand(indexes, QPoint(timeOffset, 0), false, false, command.data());
            if (!ok) return false;
        }
 
        using KisAnimUtils::FrameItem;
        using KisAnimUtils::FrameItemList;
        FrameItemList frameItems;
 
        Q_FOREACH(QModelIndex index, indexes) {
            KisScalarKeyframeChannel *channel = m_d->getCurveAt(index)->channel();
            KIS_ASSERT_RECOVER_RETURN_VALUE(channel, false);
 
            frameItems << FrameItem(channel->node(),
                                    channel->id(),
                                    index.column() + timeOffset);
        };
 
        new KisCommandUtils::LambdaCommand(
            command.data(),
            [frameItems, valueOffset] () -> KUndo2Command* {
 
                QScopedPointer<KUndo2Command> cmd(new KUndo2Command());
 
                bool result = false;
 
                Q_FOREACH (const FrameItem &item, frameItems) {
                    const int time = item.time;
                    KisNodeSP node = item.node;
 
                    KisKeyframeChannel *channel = node->getKeyframeChannel(item.channel);
 
                    if (!channel) continue;
 
                    KisScalarKeyframeSP scalarKeyframe = channel->keyframeAt(time).dynamicCast<KisScalarKeyframe>();
 
                    if (!scalarKeyframe) continue;
 
                    const qreal currentValue = scalarKeyframe->value();
                    //TODO Undo considerations.
                    scalarKeyframe->setValue(currentValue + valueOffset, cmd.data());
                    result = true;
                }
 
                return result ? new KisCommandUtils::SkipFirstRedoWrapper(cmd.take()) : 0;
        });
    }
 
    KisProcessingApplicator::runSingleCommandStroke(image(), command.take(),
                                                    KisStrokeJobData::BARRIER,
                                                    KisStrokeJobData::EXCLUSIVE);
 
    return true;
}

References KisTimeBasedItemModel::createOffsetFramesCommand(), KisKeyframeChannel::id(), KisTimeBasedItemModel::image(), KIS_ASSERT_RECOVER_RETURN_VALUE, kundo2_i18np(), m_d, and KisKeyframeChannel::node().

beginCommand()

void KisAnimCurvesModel::beginCommand

(

const KUndo2MagicString &

text

)

Begins a block of commands. The following calls to setData will be grouped to a single undo step. Note: MUST be followed by a call to endCommand().

Definition at line 296 of file KisAnimCurvesModel.cpp.

{
    KIS_ASSERT_RECOVER_RETURN(!m_d->undoCommand);
    m_d->undoCommand = new KUndo2Command(text);
}

References KIS_ASSERT_RECOVER_RETURN, and m_d.

channelByID()

KisKeyframeChannel * KisAnimCurvesModel::channelByID ( QModelIndex index, const QString & id ) const

overrideprotectedvirtual

Implements KisTimeBasedItemModel.

Definition at line 443 of file KisAnimCurvesModel.cpp.

{
    return nodeAt(index)->getKeyframeChannel(id);
}

References KisBaseNode::getKeyframeChannel(), and nodeAt().

channelsAt()

QMap< QString, KisKeyframeChannel * > KisAnimCurvesModel::channelsAt ( QModelIndex index ) const

overrideprotectedvirtual

Implements KisTimeBasedItemModel.

Definition at line 435 of file KisAnimCurvesModel.cpp.

{
    KisKeyframeChannel *channel = m_d->getCurveAt(index)->channel();
    QMap<QString, KisKeyframeChannel*> list;
    list[""] = channel;
    return list;
}

References m_d.

data()

QVariant KisAnimCurvesModel::data ( const QModelIndex & index, int role ) const

override

Definition at line 121 of file KisAnimCurvesModel.cpp.

{
    KisAnimationCurve *curve = m_d->getCurveAt(index);
 
    if (curve) {
        KisScalarKeyframeChannel *channel = curve->channel();
        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(channel, QVariant());
 
        const int time = index.column();
        KisScalarKeyframeSP keyframe = channel->keyframeAt(time).dynamicCast<KisScalarKeyframe>();
 
        switch (role) {
        case SpecialKeyframeExists:
            return !keyframe.isNull();
        case ScalarValueRole:
            return channel->valueAt(time);
        case LeftTangentRole: {
            if (keyframe.isNull())
                return QVariant();
 
            const int previousKeyTime = channel->previousKeyframeTime(time);
            KisScalarKeyframeSP previousKeyframe = channel->keyframeAt(previousKeyTime).dynamicCast<KisScalarKeyframe>();
 
            //Tangent null whenever there's no previous keyframe.
            if (!previousKeyframe)
                return QVariant();
 
            //Tangent should be null if previous keyframe not set to bezier.
            if (previousKeyframe->interpolationMode() != KisScalarKeyframe::Bezier)
                return QVariant();
 
            return keyframe->leftTangent();
        }
        case RightTangentRole: {
            if (keyframe.isNull())
                return QVariant();
 
            if (keyframe->interpolationMode() != KisScalarKeyframe::Bezier)
                return QVariant();
 
            return keyframe->rightTangent();
        }
        case InterpolationModeRole:
            return (keyframe.isNull()) ? QVariant() : keyframe->interpolationMode();
        case TangentsModeRole:
            return (keyframe.isNull()) ? QVariant() : keyframe->tangentsMode();
        case CurveColorRole:
            return curve->color();
        case CurveVisibleRole:
            return curve->visible();
        case PreviousKeyframeTime:
        {
            int activeKeyframeIndex = channel->activeKeyframeTime(time);
            if (!channel->keyframeAt(activeKeyframeIndex)) return QVariant();
            if (activeKeyframeIndex < time) {
                return activeKeyframeIndex;
            }
 
            int previousKeyframeIndex = channel->previousKeyframeTime(activeKeyframeIndex);
            if (!channel->keyframeAt(previousKeyframeIndex)) return QVariant();
            return previousKeyframeIndex;
        }
        case NextKeyframeTime:
        {
            int activeKeyframeIndex = channel->activeKeyframeTime(time);
            if (!channel->keyframeAt(activeKeyframeIndex)) {
                int firstKeyIndex = channel->firstKeyframeTime();
                if (firstKeyIndex != -1 && firstKeyIndex > time) {
                    return firstKeyIndex;
                }
                return QVariant();
            }
 
            int nextKeyframeIndex = channel->nextKeyframeTime(activeKeyframeIndex);
            if (!channel->keyframeAt(nextKeyframeIndex)) return QVariant();
            return nextKeyframeIndex;
        }
        case ChannelIdentifier:
            return channel->id();
        case ChannelLimits:
        {
            QSharedPointer<ScalarKeyframeLimits> limits = channel->limits();
 
            if (!limits)
                return QVariant();
 
            return QVariant::fromValue<ChannelLimitsMetatype>( ChannelLimitsMetatype(limits->lower, limits->upper) );
        }
        default:
            break;
        }
    }
 
    return KisTimeBasedItemModel::data(index, role);
}

References KisKeyframeChannel::activeKeyframeTime(), KisScalarKeyframe::Bezier, KisAnimationCurve::channel(), ChannelIdentifier, ChannelLimits, KisAnimationCurve::color(), CurveColorRole, CurveVisibleRole, KisTimeBasedItemModel::data(), KisKeyframeChannel::firstKeyframeTime(), KisKeyframeChannel::id(), InterpolationModeRole, KisKeyframeChannel::keyframeAt(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, LeftTangentRole, KisScalarKeyframeChannel::limits(), m_d, KisKeyframeChannel::nextKeyframeTime(), NextKeyframeTime, KisKeyframeChannel::previousKeyframeTime(), PreviousKeyframeTime, RightTangentRole, ScalarValueRole, KisTimeBasedItemModel::SpecialKeyframeExists, TangentsModeRole, KisScalarKeyframeChannel::valueAt(), and KisAnimationCurve::visible().

dataAdded

void KisAnimCurvesModel::dataAdded ( const QModelIndex & index )

signal

endCommand()

void KisAnimCurvesModel::endCommand

(

)

Definition at line 302 of file KisAnimCurvesModel.cpp.

{
    KIS_ASSERT_RECOVER_RETURN(m_d->undoCommand);
    image()->postExecutionUndoAdapter()->addCommand(toQShared(m_d->undoCommand));
 
    m_d->undoCommand = 0;
}

References KisPostExecutionUndoAdapter::addCommand(), KisTimeBasedItemModel::image(), KIS_ASSERT_RECOVER_RETURN, m_d, KisImage::postExecutionUndoAdapter(), and toQShared().

hasConnectionToCanvas()

bool KisAnimCurvesModel::hasConnectionToCanvas

(

)

const

headerData()

QVariant KisAnimCurvesModel::headerData ( int section, Qt::Orientation orientation, int role ) const

override

Definition at line 286 of file KisAnimCurvesModel.cpp.

{
    return KisTimeBasedItemModel::headerData(section, orientation, role);
}

References KisTimeBasedItemModel::headerData().

nodeAt()

KisNodeSP KisAnimCurvesModel::nodeAt ( QModelIndex index ) const

overrideprotectedvirtual

Implements KisTimeBasedItemModel.

Definition at line 426 of file KisAnimCurvesModel.cpp.

{
    KisAnimationCurve *curve = m_d->getCurveAt(index);
    if (curve && curve->channel() && curve->channel()->node()) {
        return KisNodeSP(curve->channel()->node());
    }
    return 0;
}

References KisAnimationCurve::channel(), m_d, and KisKeyframeChannel::node().

removeCurve()

void KisAnimCurvesModel::removeCurve

(

KisAnimationCurve *

curve

)

Definition at line 403 of file KisAnimCurvesModel.cpp.

{
    int index = m_d->curves.indexOf(curve);
    if (index < 0) return;
 
    curve->channel()->disconnect(this);
 
    beginRemoveRows(QModelIndex(), index, index);
 
    m_d->curves.removeAt(index);
    delete curve;
 
    endRemoveRows();
}

References KisAnimationCurve::channel(), and m_d.

rowCount()

int KisAnimCurvesModel::rowCount ( const QModelIndex & parent = QModelIndex() ) const

override

Definition at line 115 of file KisAnimCurvesModel.cpp.

{
    Q_UNUSED(parent);
    return m_d->curves.size();
}

References m_d.

setCurveVisible()

void KisAnimCurvesModel::setCurveVisible	(	KisAnimationCurve *	curve,
		bool	visible )

Definition at line 418 of file KisAnimCurvesModel.cpp.

{
    curve->setVisible(visible);
 
    int row = m_d->rowForCurve(curve);
    Q_EMIT dataChanged(index(row, 0), index(row, columnCount()));
}

References KisTimeBasedItemModel::columnCount(), m_d, and KisAnimationCurve::setVisible().

setData()

bool KisAnimCurvesModel::setData ( const QModelIndex & index, const QVariant & value, int role )

override

Definition at line 217 of file KisAnimCurvesModel.cpp.

{
    if (!index.isValid())
        return false;
 
    KisScalarKeyframeChannel *channel = m_d->getCurveAt(index)->channel();
    KUndo2Command *command = m_d->undoCommand;
 
    switch (role) {
    case ScalarValueRole:
    {
        if (channel->keyframeAt(index.column())) {
 
            if (!command) command = new KUndo2Command(kundo2_i18n("Adjust keyframe"));
            channel->keyframeAt<KisScalarKeyframe>(index.column())->setValue(value.toReal(), command);
        } else {
 
            if (!command) command = new KUndo2Command(kundo2_i18n("Insert keyframe"));
            channel->addScalarKeyframe(index.column(), value.toReal(), command);
        }
        dataChanged(index,index);
    }
        break;
    case LeftTangentRole:
    case RightTangentRole:
    {
        KisScalarKeyframeSP keyframe = channel->keyframeAt<KisScalarKeyframe>(index.column());
        if (!keyframe) return false;
 
        QPointF leftTangent = (role == LeftTangentRole ? value.toPointF() : keyframe->leftTangent());
        QPointF rightTangent = (role == RightTangentRole ? value.toPointF() : keyframe->rightTangent());
 
        if (!command) command = new KUndo2Command(kundo2_i18n("Adjust tangent"));
        keyframe->setInterpolationTangents(leftTangent, rightTangent, command);
        dataChanged(index, index);
    }
        break;
    case InterpolationModeRole:
    {
        KisScalarKeyframeSP key = channel->keyframeAt<KisScalarKeyframe>(index.column());
 
        if (!command) command = new KUndo2Command(kundo2_i18n("Set interpolation mode"));
        key->setInterpolationMode((KisScalarKeyframe::InterpolationMode)value.toInt(), command);
        dataChanged(index, index);
    }
        break;
    case TangentsModeRole:
    {
        KisScalarKeyframeSP keyframe = channel->keyframeAt<KisScalarKeyframe>(index.column());
        if (!keyframe) return false;
 
        KisScalarKeyframe::TangentsMode mode = (KisScalarKeyframe::TangentsMode)value.toInt();
 
        if (!command) command = new KUndo2Command(kundo2_i18n("Set interpolation mode"));
        keyframe->setTangentsMode( mode, command );
        dataChanged(index,index);
    }
        break;
    default:
        return KisTimeBasedItemModel::setData(index, value, role);
    }
 
    if (command && !m_d->undoCommand) {
        image()->postExecutionUndoAdapter()->addCommand(toQShared(command));
    }
 
    return true;
}

References KisPostExecutionUndoAdapter::addCommand(), KisScalarKeyframeChannel::addScalarKeyframe(), KisTimeBasedItemModel::image(), InterpolationModeRole, KisKeyframeChannel::keyframeAt(), kundo2_i18n(), LeftTangentRole, m_d, KisImage::postExecutionUndoAdapter(), RightTangentRole, ScalarValueRole, KisTimeBasedItemModel::setData(), TangentsModeRole, toQShared(), and value().

setHeaderData()

bool KisAnimCurvesModel::setHeaderData ( int section, Qt::Orientation orientation, const QVariant & value, int role )

override

Definition at line 291 of file KisAnimCurvesModel.cpp.

{
    return KisTimeBasedItemModel::setHeaderData(section, orientation, value, role);
}

References KisTimeBasedItemModel::setHeaderData(), and value().

slotKeyframeAdded

void KisAnimCurvesModel::slotKeyframeAdded ( const KisKeyframeChannel * channel, int time )

privateslot

Definition at line 455 of file KisAnimCurvesModel.cpp.

{
    Q_EMIT dataAdded(index(m_d->rowForChannel(channel), time));
}

References dataAdded(), and m_d.

slotKeyframeChanged

void KisAnimCurvesModel::slotKeyframeChanged ( const KisKeyframeChannel * channel, int time )

privateslot

Definition at line 448 of file KisAnimCurvesModel.cpp.

{
    int row = m_d->rowForChannel(channel);
    QModelIndex changedIndex = index(row, time);
    Q_EMIT dataChanged(changedIndex, changedIndex);
}

References m_d.

Member Data Documentation

m_d

const QScopedPointer<Private> KisAnimCurvesModel::m_d

private

Definition at line 90 of file KisAnimCurvesModel.h.

---

The documentation for this class was generated from the following files:

• plugins/dockers/animation/KisAnimCurvesModel.h
• plugins/dockers/animation/KisAnimCurvesModel.cpp