KisTimeBasedItemModel Class Reference

#include <KisTimeBasedItemModel.h>

Inheritance diagram for KisTimeBasedItemModel:

Classes
struct	Private

Public Types
enum	ItemDataRole {   ActiveFrameRole = Qt::UserRole + 101 , ScrubToRole , CloneOfActiveFrame , CloneCount ,   FrameExistsRole , SpecialKeyframeExists , FrameCachedRole , FrameEditableRole ,   FramesPerSecondRole , FrameHasContent , WithinClipRange , UserRole }

Public Member Functions
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 Slots
void	slotCurrentTimeChanged (int time)

Protected Member Functions
virtual KisKeyframeChannel *	channelByID (QModelIndex index, const QString &id) const =0
virtual QMap< QString, KisKeyframeChannel * >	channelsAt (QModelIndex index) const =0
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
virtual KisNodeSP	nodeAt (QModelIndex index) const =0

Private Slots
void	slotCacheChanged ()
void	slotFramerateChanged ()
void	slotPlaybackFrameChanged ()
void	slotPlaybackRangeChanged ()
void	slotPlaybackStateChanged (PlaybackState state)

Private Attributes
const QScopedPointer< Private >	m_d

Detailed Description

Definition at line 22 of file KisTimeBasedItemModel.h.

Member Enumeration Documentation

ItemDataRole

enum KisTimeBasedItemModel::ItemDataRole

Enumerator
ActiveFrameRole
ScrubToRole
CloneOfActiveFrame
CloneCount
FrameExistsRole
SpecialKeyframeExists
FrameCachedRole
FrameEditableRole
FramesPerSecondRole
FrameHasContent
WithinClipRange
UserRole

Definition at line 63 of file KisTimeBasedItemModel.h.

    {
        ActiveFrameRole = Qt::UserRole + 101,
        ScrubToRole,
        CloneOfActiveFrame,
        CloneCount,
        FrameExistsRole,
        SpecialKeyframeExists,
        FrameCachedRole,
        FrameEditableRole,
        FramesPerSecondRole,
        FrameHasContent,
        WithinClipRange,
        UserRole
    };

Constructor & Destructor Documentation

KisTimeBasedItemModel()

KisTimeBasedItemModel::KisTimeBasedItemModel

(

QObject *

parent

)

Definition at line 93 of file KisTimeBasedItemModel.cpp.

    : QAbstractTableModel(parent)
    , m_d(new Private())
{
    KisConfig cfg(true);
 
    using namespace std::placeholders;
 
    std::function<void (int)> scrubHorizHeaderUpdateCallback(
        std::bind(&KisTimeBasedItemModel::scrubHorizontalHeaderUpdate, this, _1));
 
    m_d->scrubHeaderUpdateCompressor.reset(
        new KisSignalCompressorWithParam<int>(100, scrubHorizHeaderUpdateCallback, KisSignalCompressor::FIRST_ACTIVE));
}

References KisSignalCompressor::FIRST_ACTIVE, m_d, scrubHorizontalHeaderUpdate(), and void().

~KisTimeBasedItemModel()

KisTimeBasedItemModel::~KisTimeBasedItemModel ( )

override

Definition at line 108 of file KisTimeBasedItemModel.cpp.

{}

Member Function Documentation

channelByID()

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

protectedpure virtual

Implemented in KisAnimCurvesModel, and KisAnimTimelineFramesModel.

channelsAt()

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

protectedpure virtual

Implemented in KisAnimCurvesModel, and KisAnimTimelineFramesModel.

cloneCount()

int KisTimeBasedItemModel::cloneCount ( const QModelIndex & index ) const

protected

Definition at line 649 of file KisTimeBasedItemModel.cpp.

                                                                    {
    KisRasterKeyframeChannel *rasterChan = dynamic_cast<KisRasterKeyframeChannel*>(channelByID(index, KisKeyframeChannel::Raster.id()));
 
    if (!rasterChan) {
        return 0;
    }
    return rasterChan->clonesOf(index.column()).count();
}

References channelByID(), KisRasterKeyframeChannel::clonesOf(), and KisKeyframeChannel::Raster.

cloneOfActiveFrame()

bool KisTimeBasedItemModel::cloneOfActiveFrame ( const QModelIndex & index ) const

protected

Definition at line 641 of file KisTimeBasedItemModel.cpp.

                                                                             {
    KisRasterKeyframeChannel *rasterChan = dynamic_cast<KisRasterKeyframeChannel*>(channelByID(index, KisKeyframeChannel::Raster.id()));
    if (!rasterChan) return false;
 
    const int activeKeyframeTime = rasterChan->activeKeyframeTime(m_d->activeFrameIndex);
    return rasterChan->areClones(activeKeyframeTime, index.column());
}

References KisKeyframeChannel::activeKeyframeTime(), KisRasterKeyframeChannel::areClones(), channelByID(), m_d, and KisKeyframeChannel::Raster.

columnCount()

int KisTimeBasedItemModel::columnCount ( const QModelIndex & parent = QModelIndex() ) const

override

Definition at line 213 of file KisTimeBasedItemModel.cpp.

{
    Q_UNUSED(parent);
    return m_d->numFramesOverride;
}

References m_d.

createOffsetFramesCommand()

KUndo2Command * KisTimeBasedItemModel::createOffsetFramesCommand ( QModelIndexList srcIndexes, const QPoint & offset, bool copyFrames, bool moveEmptyFrames, KUndo2Command * parentCommand = 0 )

protected

Definition at line 372 of file KisTimeBasedItemModel.cpp.

{
    if (srcIndexes.isEmpty()) return 0;
    if (offset.isNull()) return 0;
 
    KisAnimUtils::sortPointsForSafeMove(&srcIndexes, offset);
 
    KisAnimUtils::FrameItemList srcFrameItems;
    KisAnimUtils::FrameItemList dstFrameItems;
 
    Q_FOREACH (const QModelIndex &srcIndex, srcIndexes) {
        QModelIndex dstIndex = index(
                srcIndex.row() + offset.y(),
                srcIndex.column() + offset.x());
 
        KisNodeSP srcNode = nodeAt(srcIndex);
        KisNodeSP dstNode = nodeAt(dstIndex);
        if (!srcNode || !dstNode) return 0;
 
        Q_FOREACH(KisKeyframeChannel *channel, channelsAt(srcIndex)) {
            if (moveEmptyFrames || channel->keyframeAt(srcIndex.column())) {
                srcFrameItems << KisAnimUtils::FrameItem(srcNode, channel->id(), srcIndex.column());
                dstFrameItems << KisAnimUtils::FrameItem(dstNode, channel->id(), dstIndex.column());
            }
        }
    }
 
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(srcFrameItems.size() == dstFrameItems.size(), 0);
    if (srcFrameItems.isEmpty()) return 0;
 
    return
        KisAnimUtils::createMoveKeyframesCommand(srcFrameItems,
                                                      dstFrameItems,
                                                      copyFrames,
                                                      moveEmptyFrames,
                                                      parentCommand);
}

References channelsAt(), KisAnimUtils::createMoveKeyframesCommand(), KisKeyframeChannel::id(), KisKeyframeChannel::keyframeAt(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, nodeAt(), and KisAnimUtils::sortPointsForSafeMove().

currentTime()

int KisTimeBasedItemModel::currentTime

(

)

const

Definition at line 636 of file KisTimeBasedItemModel.cpp.

{
    return m_d->image->animationInterface()->currentUITime();
}

References m_d.

data()

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

override

Definition at line 219 of file KisTimeBasedItemModel.cpp.

{
    switch (role) {
        case ActiveFrameRole: {
            return index.column() == m_d->activeFrameIndex;
        }
        case CloneOfActiveFrame: {
            return cloneOfActiveFrame(index);
        }
        case CloneCount: {
            return cloneCount(index);
        }
        case WithinClipRange:
            return m_d->withinClipRange(index.column());
        }
 
    return QVariant();
}

References ActiveFrameRole, CloneCount, cloneCount(), CloneOfActiveFrame, cloneOfActiveFrame(), m_d, and WithinClipRange.

document()

KisDocument * KisTimeBasedItemModel::document

(

)

const

Definition at line 188 of file KisTimeBasedItemModel.cpp.

{
    return m_d->document;
}

References m_d.

headerData()

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

override

Definition at line 254 of file KisTimeBasedItemModel.cpp.

{
    if (orientation == Qt::Horizontal) {
        switch (role) {
        case ActiveFrameRole:
            return section == m_d->activeFrameIndex;
        case FrameCachedRole:
            return m_d->cachedFrames.size() > section ? m_d->cachedFrames[section] : false;
        case FramesPerSecondRole:
            return m_d->framesPerSecond();
        case WithinClipRange:
            return m_d->withinClipRange(section);
        }
    }
 
    return QVariant();
}

References ActiveFrameRole, FrameCachedRole, FramesPerSecondRole, m_d, and WithinClipRange.

image()

KisImageWSP KisTimeBasedItemModel::image ( ) const

protected

Definition at line 658 of file KisTimeBasedItemModel.cpp.

{
    return m_d->image;
}

References m_d.

isFrameCached()

bool KisTimeBasedItemModel::isFrameCached

(

const int

frame

)

Definition at line 154 of file KisTimeBasedItemModel.cpp.

{
    return m_d->framesCache && m_d->framesCache->frameStatus(frame) == KisAnimationFrameCache::Cached;
}

References KisAnimationFrameCache::Cached, and m_d.

isPlaybackActive()

bool KisTimeBasedItemModel::isPlaybackActive

(

)

const

Definition at line 622 of file KisTimeBasedItemModel.cpp.

{
    return m_d->animationPlayer && m_d->animationPlayer->playbackState() == PlaybackState::PLAYING;
}

References m_d, and PLAYING.

isPlaybackPaused()

bool KisTimeBasedItemModel::isPlaybackPaused

(

)

const

Definition at line 627 of file KisTimeBasedItemModel.cpp.

{
    return m_d->animationPlayer && m_d->animationPlayer->playbackState() == PlaybackState::PAUSED;
}

References m_d, and PAUSED.

isScrubbing()

bool KisTimeBasedItemModel::isScrubbing

(

)

Definition at line 554 of file KisTimeBasedItemModel.cpp.

{
    return m_d->scrubInProgress;
}

References m_d.

mirrorFrames()

bool KisTimeBasedItemModel::mirrorFrames

(

QModelIndexList

indexes

)

Definition at line 453 of file KisTimeBasedItemModel.cpp.

{
    QScopedPointer<KUndo2Command> parentCommand(new KUndo2Command(kundo2_i18n("Mirror Frames")));
 
    {
        KisImageBarrierLock locker(m_d->image);
 
        QMap<int, QModelIndexList> rowsList;
 
        Q_FOREACH (const QModelIndex &index, indexes) {
            rowsList[index.row()].append(index);
        }
 
 
        Q_FOREACH (int row, rowsList.keys()) {
            QModelIndexList &list = rowsList[row];
 
            KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!list.isEmpty(), false);
 
            std::sort(list.begin(), list.end(),
                [] (const QModelIndex &lhs, const QModelIndex &rhs) {
                    return lhs.column() < rhs.column();
                });
 
            auto srcIt = list.begin();
            auto dstIt = list.end();
 
            KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(srcIt != dstIt, false);
            --dstIt;
 
            QList<KisKeyframeChannel*> channels = channelsAt(*srcIt).values();
 
            while (srcIt < dstIt) {
                Q_FOREACH (KisKeyframeChannel *channel, channels) {
                    if (channel->keyframeAt(srcIt->column()) && channel->keyframeAt(dstIt->column())) {
 
                        channel->swapKeyframes(srcIt->column(),
                                               dstIt->column(),
                                               parentCommand.data());
                    }
                    else if (channel->keyframeAt(srcIt->column())) {
 
                        channel->insertKeyframe(dstIt->column(),
                                                channel->keyframeAt(srcIt->column()),
                                                parentCommand.data());
 
                        channel->removeKeyframe(srcIt->column(),
                                                parentCommand.data());
                    }
                    else if (channel->keyframeAt(dstIt->column())) {
 
                        channel->insertKeyframe(srcIt->column(),
                                                channel->keyframeAt(dstIt->column()),
                                                parentCommand.data());
 
                        channel->removeKeyframe(dstIt->column(),
                                                parentCommand.data());
                    }
                }
 
                srcIt++;
                dstIt--;
            }
        }
    }
 
    KisProcessingApplicator::runSingleCommandStroke(m_d->image,
                                                    parentCommand.take(),
                                                    KisStrokeJobData::BARRIER,
                                                    KisStrokeJobData::EXCLUSIVE);
    return true;
}

References KisStrokeJobData::BARRIER, channelsAt(), KisStrokeJobData::EXCLUSIVE, KisKeyframeChannel::insertKeyframe(), KisKeyframeChannel::keyframeAt(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, kundo2_i18n(), m_d, KisKeyframeChannel::removeKeyframe(), KisProcessingApplicator::runSingleCommandStroke(), and KisKeyframeChannel::swapKeyframes().

nodeAt()

virtual KisNodeSP KisTimeBasedItemModel::nodeAt ( QModelIndex index ) const

protectedpure virtual

Implemented in KisAnimCurvesModel, and KisAnimTimelineFramesModel.

removeFrames()

bool KisTimeBasedItemModel::removeFrames

(

const QModelIndexList &

indexes

)

Definition at line 348 of file KisTimeBasedItemModel.cpp.

{
    KisAnimUtils::FrameItemList frameItems;
 
    {
        KisImageBarrierLock locker(m_d->image);
 
        Q_FOREACH (const QModelIndex &index, indexes) {
            int time = index.column();
            Q_FOREACH(KisKeyframeChannel *channel, channelsAt(index)) {
                if (channel->keyframeAt(time)) {
                    frameItems << KisAnimUtils::FrameItem(channel->node(), channel->id(), index.column());
                }
            }
        }
    }
 
    if (frameItems.isEmpty()) return false;
 
    KisAnimUtils::removeKeyframes(m_d->image, frameItems);
 
    return true;
}

References channelsAt(), KisKeyframeChannel::id(), KisKeyframeChannel::keyframeAt(), m_d, KisKeyframeChannel::node(), and KisAnimUtils::removeKeyframes().

removeFramesAndOffset()

bool KisTimeBasedItemModel::removeFramesAndOffset

(

QModelIndexList

indicesToRemove

)

Definition at line 414 of file KisTimeBasedItemModel.cpp.

{
    if (indicesToRemove.isEmpty()) return true;
 
    std::sort(indicesToRemove.begin(), indicesToRemove.end(),
              [] (const QModelIndex &lhs, const QModelIndex &rhs) {
                  return lhs.column() > rhs.column();
              });
 
    const int minColumn = indicesToRemove.last().column();
 
    KUndo2Command *parentCommand = new KUndo2Command(kundo2_i18np("Remove frame and shift", "Remove %1 frames and shift", indicesToRemove.size()));
 
    {
        KisImageBarrierLock locker(m_d->image);
 
        Q_FOREACH (const QModelIndex &index, indicesToRemove) {
            QModelIndexList indicesToOffset;
            for (int column = index.column() + 1; column < columnCount(); column++) {
                indicesToOffset << this->index(index.row(), column);
            }
            createOffsetFramesCommand(indicesToOffset, QPoint(-1, 0), false, true, parentCommand);
        }
 
        const int oldTime = m_d->image->animationInterface()->currentUITime();
        const int newTime = minColumn;
 
        new KisSwitchCurrentTimeCommand(m_d->image->animationInterface(),
                                        oldTime,
                                        newTime,
                                        parentCommand);
    }
 
    KisProcessingApplicator::runSingleCommandStroke(m_d->image, parentCommand,
                                                    KisStrokeJobData::BARRIER,
                                                    KisStrokeJobData::EXCLUSIVE);
    return true;
}

References KisStrokeJobData::BARRIER, columnCount(), createOffsetFramesCommand(), KisStrokeJobData::EXCLUSIVE, kundo2_i18np(), m_d, and KisProcessingApplicator::runSingleCommandStroke().

scrubHorizontalHeaderUpdate()

void KisTimeBasedItemModel::scrubHorizontalHeaderUpdate

(

int

activeHeader

)

Definition at line 341 of file KisTimeBasedItemModel.cpp.

{
    Q_EMIT headerDataChanged (Qt::Horizontal, m_d->scrubHeaderMin, m_d->scrubHeaderMax);
    m_d->scrubHeaderMin = activeColumn;
    m_d->scrubHeaderMax = activeColumn;
}

References m_d.

setAnimationPlayer()

void KisTimeBasedItemModel::setAnimationPlayer

(

KisCanvasAnimationState *

player

)

Definition at line 159 of file KisTimeBasedItemModel.cpp.

{
    if (m_d->animationPlayer == player) return;
 
    if (m_d->animationPlayer) {
        m_d->animationPlayer->disconnect(this);
    }
 
    m_d->animationPlayer = player;
 
    if (m_d->animationPlayer) {
        connect(m_d->animationPlayer, SIGNAL(sigPlaybackStateChanged(PlaybackState)), SLOT(slotPlaybackStateChanged(PlaybackState)));
        connect(m_d->animationPlayer, SIGNAL(sigFrameChanged()), SLOT(slotPlaybackFrameChanged()));
 
        const int frame = player ? player->displayProxy()->activeFrame() : m_d->image->animationInterface()->currentUITime();
        setHeaderData(frame, Qt::Horizontal, true, ActiveFrameRole);
 
        // only prioritize the cache, no seek operation to prevent audio from playing
        setHeaderData(frame, Qt::Horizontal, QVariant(int(SEEK_NONE)), ScrubToRole);
    }
}

References KisFrameDisplayProxy::activeFrame(), ActiveFrameRole, connect(), KisCanvasAnimationState::displayProxy(), m_d, ScrubToRole, SEEK_NONE, setHeaderData(), slotPlaybackFrameChanged(), and slotPlaybackStateChanged().

setData()

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

override

Definition at line 238 of file KisTimeBasedItemModel.cpp.

{
    if (!index.isValid()) return false;
 
    switch (role) {
        case ActiveFrameRole:
            setHeaderData(index.column(), Qt::Horizontal, value, role);
            break;
        case ScrubToRole:
            setHeaderData(index.column(), Qt::Horizontal, value, role);
            break;
    }
 
    return false;
}

References ActiveFrameRole, ScrubToRole, setHeaderData(), and value().

setDocument()

void KisTimeBasedItemModel::setDocument

(

class KisDocument *

document

)

Definition at line 181 of file KisTimeBasedItemModel.cpp.

{
    if (m_d->document == document) return;
 
    m_d->document = document;
}

References document(), and m_d.

setFrameCache()

void KisTimeBasedItemModel::setFrameCache

(

KisAnimationFrameCacheSP

cache

)

Definition at line 139 of file KisTimeBasedItemModel.cpp.

{
    if (KisAnimationFrameCacheSP(m_d->framesCache) == cache) return;
 
    if (m_d->framesCache) {
        m_d->framesCache->disconnect(this);
    }
 
    m_d->framesCache = cache;
 
    if (m_d->framesCache) {
        connect(m_d->framesCache, SIGNAL(changed()), SLOT(slotCacheChanged()));
    }
}

References connect(), m_d, and slotCacheChanged().

setHeaderData()

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

override

Optimization Hack Alert:

ideally, we should Q_EMIT all four signals, but... The point is this code is used in a tight loop during playback, so it should run as fast as possible. To tell the story short, commenting out these three lines makes playback run 15% faster ;)

Definition at line 272 of file KisTimeBasedItemModel.cpp.

{
    auto prioritizeCache = [this](int frame){
        if (m_d->image) {
            if(!isFrameCached(frame)) {
                KisPart::instance()->prioritizeFrameForCache(m_d->image, frame);
            }
        }
    };
 
 
    if (orientation == Qt::Horizontal) {
        switch (role) {
        case ActiveFrameRole:
            if (value.toBool() &&
                section != m_d->activeFrameIndex) {
 
                int prevFrame = m_d->activeFrameIndex;
                m_d->activeFrameIndex = section;
 
                if (m_d->scrubInProgress) {
                    Q_EMIT dataChanged(this->index(0, m_d->activeFrameIndex), this->index(rowCount() - 1, m_d->activeFrameIndex));
 
                    /*
                     * In order to try to correct rendering issues while preserving performance, we will
                     * defer updates just long enough that visual artifacts aren't majorly noticeable.
                     * By using a signal compressor, we're going to update the range of columns between
                     * min / max. That min max is reset every time the update occurs. This should fix
                     * rendering issues to a configurable framerate.
                     */
                    m_d->scrubHeaderMin = qMin(m_d->activeFrameIndex, m_d->scrubHeaderMin);
                    m_d->scrubHeaderMax = qMax(m_d->activeFrameIndex, m_d->scrubHeaderMax);
                    m_d->scrubHeaderUpdateCompressor->start(m_d->activeFrameIndex);
 
                    // vvvvvvvvvvvvvvvvvvvvv Read above comment.. This fixes all timeline rendering issues, but at what cost???
                    //Q_EMIT dataChanged(this->index(0, prevFrame), this->index(rowCount() - 1, prevFrame));
                    //Q_EMIT headerDataChanged (Qt::Horizontal, m_d->activeFrameIndex, m_d->activeFrameIndex);
                    //Q_EMIT headerDataChanged (Qt::Horizontal, prevFrame, prevFrame);
                } else {
                    Q_EMIT dataChanged(this->index(0, prevFrame), this->index(rowCount() - 1, prevFrame));
                    Q_EMIT dataChanged(this->index(0, m_d->activeFrameIndex), this->index(rowCount() - 1, m_d->activeFrameIndex));
                    Q_EMIT headerDataChanged (Qt::Horizontal, prevFrame, prevFrame);
                    Q_EMIT headerDataChanged (Qt::Horizontal, m_d->activeFrameIndex, m_d->activeFrameIndex);
                }
            }
            break;
        case ScrubToRole:
            SeekOptionFlags seekFlags = SeekOptionFlags(value.toInt());
            prioritizeCache(m_d->activeFrameIndex);
            if (!m_d->image->hasUpdatesRunning()) {
                KisPart::instance()->playbackEngine()->seek(m_d->activeFrameIndex, seekFlags);
            }
            break;
        }
    }
 
    return false;
}

References ActiveFrameRole, KisPart::instance(), isFrameCached(), m_d, KisPart::playbackEngine, KisPart::prioritizeFrameForCache(), ScrubToRole, and value().

setImage()

void KisTimeBasedItemModel::setImage

(

KisImageWSP

image

)

Definition at line 111 of file KisTimeBasedItemModel.cpp.

{
    if (m_d->image == p_image ) {
        return;
    }
 
    beginResetModel();
 
    if (m_d->image) {
        //Disconnect old image..
        const KisImageAnimationInterface *ai = m_d->image->animationInterface();
        ai->disconnect(this);
    }
 
    m_d->image = p_image;
    m_d->numFramesOverride = m_d->effectiveNumFrames();
 
    if (m_d->image) {
        KisImageAnimationInterface *ai = m_d->image->animationInterface();
 
        connect(ai, SIGNAL(sigFramerateChanged()), this, SLOT(slotFramerateChanged()));
        connect(ai, SIGNAL(sigUiTimeChanged(int)), this, SLOT(slotCurrentTimeChanged(int)));
        connect(ai, SIGNAL(sigPlaybackRangeChanged()), this, SLOT(slotPlaybackRangeChanged()));
    }
 
    endResetModel();
}

References KisImage::animationInterface(), connect(), KisImageAnimationInterface::image(), m_d, slotCurrentTimeChanged(), slotFramerateChanged(), and slotPlaybackRangeChanged().

setLastVisibleFrame()

void KisTimeBasedItemModel::setLastVisibleFrame

(

int

time

)

Definition at line 193 of file KisTimeBasedItemModel.cpp.

{
    const int growThreshold = m_d->effectiveNumFrames() - 1;
    const int growValue = time + 8;
 
    const int shrinkThreshold = m_d->effectiveNumFrames() - 3;
    const int shrinkValue = qMax(m_d->baseNumFrames(), qMin(growValue, shrinkThreshold));
    const bool canShrink = m_d->baseNumFrames() < m_d->effectiveNumFrames();
 
    if (time >= growThreshold) {
        beginInsertColumns(QModelIndex(), m_d->effectiveNumFrames(), growValue - 1);
        m_d->numFramesOverride = growValue;
        endInsertColumns();
    } else if (time < shrinkThreshold && canShrink) {
        beginRemoveColumns(QModelIndex(), shrinkValue, m_d->effectiveNumFrames() - 1);
        m_d->numFramesOverride = shrinkValue;
        endRemoveColumns();
    }
}

References m_d.

setPlaybackRange()

void KisTimeBasedItemModel::setPlaybackRange

(

const KisTimeSpan &

range

)

Definition at line 614 of file KisTimeBasedItemModel.cpp.

{
    if (m_d->image.isNull()) return;
 
    KisImageAnimationInterface *i = m_d->image->animationInterface();
    i->setActivePlaybackRange(range);
}

References KisImage::animationInterface(), KisImageAnimationInterface::image(), m_d, and KisImageAnimationInterface::setActivePlaybackRange().

setScrubState()

void KisTimeBasedItemModel::setScrubState

(

bool

active

)

Definition at line 526 of file KisTimeBasedItemModel.cpp.

{
    if (!m_d->animationPlayer) {
        return;
    }
 
    if (m_d->scrubInProgress != p_state) {
        m_d->scrubInProgress = p_state;
 
        if (m_d->scrubInProgress == true) {
            m_d->scrubStartFrame = m_d->activeFrameIndex;
 
            if (m_d->animationPlayer->playbackState() == PLAYING) {
                m_d->shouldReturnToPlay = true;
                m_d->animationPlayer->setPlaybackState(PAUSED);
            }
 
        } else {
            if (m_d->shouldReturnToPlay) {
                m_d->animationPlayer->setPlaybackState(PLAYING);
            }
 
            m_d->scrubStartFrame = -1;
            m_d->shouldReturnToPlay = false;
        }
    }
}

References m_d, PAUSED, and PLAYING.

slotCacheChanged

void KisTimeBasedItemModel::slotCacheChanged ( )

privateslot

Definition at line 587 of file KisTimeBasedItemModel.cpp.

{
    const int numFrames = columnCount();
    m_d->cachedFrames.resize(numFrames);
 
    for (int i = 0; i < numFrames; i++) {
        m_d->cachedFrames[i] =
            m_d->framesCache->frameStatus(i) == KisAnimationFrameCache::Cached;
    }
 
    Q_EMIT headerDataChanged(Qt::Horizontal, 0, numFrames);
}

References KisAnimationFrameCache::Cached, columnCount(), and m_d.

slotCurrentTimeChanged

void KisTimeBasedItemModel::slotCurrentTimeChanged ( int time )

protectedslot

Definition at line 560 of file KisTimeBasedItemModel.cpp.

{
    if (time != m_d->activeFrameIndex) {
        setHeaderData(time, Qt::Horizontal, true, ActiveFrameRole);
    }
}

References ActiveFrameRole, m_d, and setHeaderData().

slotFramerateChanged

void KisTimeBasedItemModel::slotFramerateChanged ( )

privateslot

Definition at line 567 of file KisTimeBasedItemModel.cpp.

{
    Q_EMIT headerDataChanged(Qt::Horizontal, 0, columnCount() - 1);
}

References columnCount().

slotPlaybackFrameChanged

void KisTimeBasedItemModel::slotPlaybackFrameChanged ( )

privateslot

Definition at line 601 of file KisTimeBasedItemModel.cpp.

{
    if (m_d->animationPlayer->playbackState() != PlaybackState::PLAYING) return;
    setHeaderData(m_d->animationPlayer->displayProxy()->activeFrame(), Qt::Horizontal, true, ActiveFrameRole);
}

References ActiveFrameRole, m_d, PLAYING, and setHeaderData().

slotPlaybackRangeChanged

void KisTimeBasedItemModel::slotPlaybackRangeChanged ( )

privateslot

Definition at line 572 of file KisTimeBasedItemModel.cpp.

{
    if (m_d->image && m_d->image->animationInterface() ) {
        const KisImageAnimationInterface* const interface = m_d->image->animationInterface();
        const int lastFrame = interface->activePlaybackRange().end();
        if (lastFrame > m_d->numFramesOverride) {
            beginInsertColumns(QModelIndex(), m_d->numFramesOverride, interface->activePlaybackRange().end());
            m_d->numFramesOverride = interface->activePlaybackRange().end();
            endInsertColumns();
        }
 
        dataChanged(index(0,0), index(rowCount(), columnCount()));
    }
}

References columnCount(), image(), and m_d.

slotPlaybackStateChanged

void KisTimeBasedItemModel::slotPlaybackStateChanged ( PlaybackState state )

privateslot

Definition at line 607 of file KisTimeBasedItemModel.cpp.

{
    if (p_state == PlaybackState::STOPPED) {
        setHeaderData(m_d->image->animationInterface()->currentUITime(), Qt::Horizontal, true, ActiveFrameRole);
    }
}

References ActiveFrameRole, m_d, setHeaderData(), and STOPPED.

stopPlayback()

void KisTimeBasedItemModel::stopPlayback

(

)

const

Definition at line 632 of file KisTimeBasedItemModel.cpp.

                                               {
    KisPart::instance()->playbackEngine()->stop();
}

References KisPart::instance(), and KisPart::playbackEngine.

Member Data Documentation

m_d

const QScopedPointer<Private> KisTimeBasedItemModel::m_d

private

Definition at line 104 of file KisTimeBasedItemModel.h.

---

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

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