StoryboardModel Class Reference

The main storyboard model. This class manages a StoryboardItemList which is a list of StoryboardItem objects. It provides the interface to manipulate and access the data. More...

#include <StoryboardModel.h>

Inheritance diagram for StoryboardModel:

Classes
class	KeyframeReorderLock

Public Types
enum	AdditionalRoles { TotalSceneDurationInFrames = Qt::UserRole + 1 , TotalSceneDurationInSeconds = Qt::UserRole + 2 }

Public Slots
void	slotSetActiveNode (KisNodeSP)

Signals
void	sigStoryboardItemListChanged ()
	This signal is emitted whenever m_items is changed. it is used to keep the StoryboardItemList in KisDocument in sync with m_items.

Public Member Functions
QModelIndexList	affectedIndexes (KisTimeSpan range) const
	Returns a list of index of items that have frame in between argument range.
bool	changeSceneHoldLength (int oldDuration, QModelIndex itemIndex)
	moves all keyframes in all layers after the frame of the parent of durationIndex Keyframes are moved to the left or right based on the difference (newDuration-oldDuration)
int	columnCount (const QModelIndex &parent=QModelIndex()) const override
void	createBlankKeyframes (const QModelIndex &index, KUndo2Command *cmd=nullptr)
void	createDuplicateKeyframes (const QModelIndex &index, KUndo2Command *cmd=nullptr)
QVariant	data (const QModelIndex &index, int role=Qt::DisplayRole) const override
bool	dropMimeData (const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent) override
Qt::ItemFlags	flags (const QModelIndex &index) const override
StoryboardComment	getComment (int row) const
StoryboardItemList	getData ()
int	getFramesPerSecond () const
QModelIndex	index (int row, int column, const QModelIndex &parent=QModelIndex()) const override
QModelIndex	indexFromFrame (int frame, bool framePerfect=true) const
	Returns the index of the item corresponding the frame, if there is an item with that frame.
void	insertChildRows (int position, KUndo2Command *cmd=nullptr)
	must be called after a first level index is inserted. Adds child nodes to the first level indices
void	insertChildRows (int position, StoryboardItemSP item)
	Adds child nodes from the item provided.
bool	insertItem (QModelIndex index, bool after)
	inserts item after or before index based on after parameter
bool	insertRows (int position, int rows, const QModelIndex &index=QModelIndex()) override
bool	isFrozen () const
bool	isLocked () const
QModelIndex	lastIndexBeforeFrame (int frame) const
	Returns the index of the item with largest frame smaller than argument frame.
int	lastKeyframeGlobal () const
int	lastKeyframeWithin (QModelIndex index)
	Gets the last keyframe that exists within an index's duration. Used to prevent duration from overwriting keyframes that exist internal to an existing scene.
QMimeData *	mimeData (const QModelIndexList &indexes) const override
QStringList	mimeTypes () const override
bool	moveRows (const QModelIndex &sourceParent, int sourceRow, int count, const QModelIndex &destinationParent, int destinationChild) override
int	nextKeyframeGlobal (int keyframeTime) const
	the next time at which there is a keyframe in any layer after keyframeTime
QModelIndex	parent (const QModelIndex &index) const override
void	pushUndoCommand (KUndo2Command *command)
bool	removeItem (QModelIndex index, KUndo2Command *command=nullptr)
	removes item, deletes keyframes within and shifts keyframe after the scene to fill in the gap
bool	removeRows (int position, int rows, const QModelIndex &index=QModelIndex()) override
void	reorderKeyframes ()
	reorders all keyframes to reflect storyboard docker's arrangement. typically used after drag and drop to keep storyboard timing accurate to timeline timing.
void	resetData (StoryboardItemList list)
	resets m_items to list
int	rowCount (const QModelIndex &parent=QModelIndex()) const override
void	setCommentModel (StoryboardCommentModel *commentModel)
	Sets the commentModel in StoryboardModel and creates connections to keep the local copy of comments in sync with the commentModel's.
bool	setCommentScrollData (const QModelIndex &index, const QVariant &value)
	Sets the scrollValue of the CommentBox object.
bool	setData (const QModelIndex &index, const QVariant &value, int role=Qt::EditRole) override
void	setFreeze (bool)
void	setImage (KisImageWSP image)
void	setLocked (bool)
bool	setThumbnailPixmapData (const QModelIndex &parentIndex, const KisPaintDeviceSP &dev)
	Sets the Pixmap data.
void	setView (StoryboardView *view)
void	shiftKeyframes (KisTimeSpan affected, int offset, KUndo2Command *cmd=nullptr)
void	slotUpdateThumbnailsForItems (QModelIndexList indices)
	StoryboardModel (QObject *parent)
Qt::DropActions	supportedDragActions () const override
Qt::DropActions	supportedDropActions () const override
int	totalCommentCount ()
	Get total number of comments.
bool	updateDurationData (const QModelIndex &parentIndex)
	updates the duration data of item at parentIndex to the number of frame to the next keyframe in any layer.
int	visibleCommentCount () const
	Used in StoryboardDelegate and StoryboardView to get size of one storyboard item.
int	visibleCommentsUpto (QModelIndex index) const
	Used in StoryboardView to design the layout of storyboard item.
void	visualizeScene (const QModelIndex &index, bool useUndo=true)
	~StoryboardModel () override

Private Slots
void	slotCommentDataChanged ()
void	slotCommentRowInserted (const QModelIndex, int, int)
void	slotCommentRowMoved (const QModelIndex &sourceParent, int sourceRow, int count, const QModelIndex &destinationParent, int destinationChild)
void	slotCommentRowRemoved (const QModelIndex, int, int)
void	slotCurrentFrameChanged (int frameId)
	called when currentUiTime changes
void	slotFramerateChanged ()
void	slotFrameRenderCancelled (int frame)
	called KisStoryboardThumbnailRenderScheduler when frame render is cancelled.
void	slotFrameRenderCompleted (int frame, KisPaintDeviceSP dev)
	called KisStoryboardThumbnailRenderScheduler when frame render is complete
void	slotKeyframeAdded (const KisKeyframeChannel *channel, int time)
void	slotKeyframeRemoved (const KisKeyframeChannel *channel, int time)
void	slotNodeRemoved (KisNodeSP node)
void	slotUpdateThumbnailForFrame (int frame, bool delay=true)
	calls regeneration of frame in the background i.e. in another thread.
void	slotUpdateThumbnails ()
	calls regeneration of the currentUiTime() and all frames in affectedIndexes(KisTimeSpan)

Private Member Functions
bool	isValidBoard (const QModelIndex &index) const
bool	moveRowsImpl (const QModelIndex &sourceParent, int sourceRow, int count, const QModelIndex &destinationParent, int destinationChild, KUndo2Command *parentCMD=nullptr)

Private Attributes
KisNodeWSP	m_activeNode
QVector< StoryboardComment >	m_commentList
StoryboardCommentModel *	m_commentModel {0}
bool	m_freezeKeyframePositions {false}
KisImageWSP	m_image
KisIdleWatcher	m_imageIdleWatcher
StoryboardItemList	m_items
int	m_lastScene {0}
bool	m_lockBoards {false}
KisStoryboardThumbnailRenderScheduler *	m_renderScheduler {0}
KisSignalCompressor	m_renderSchedulingCompressor
bool	m_reorderingKeyframes {false}
StoryboardView *	m_view {0}

Friends
class	KisMoveStoryboardCommand

Detailed Description

The main storyboard model. This class manages a StoryboardItemList which is a list of StoryboardItem objects. It provides the interface to manipulate and access the data.

Definition at line 32 of file StoryboardModel.h.

Member Enumeration Documentation

AdditionalRoles

enum StoryboardModel::AdditionalRoles

Enumerator
TotalSceneDurationInFrames
TotalSceneDurationInSeconds

Definition at line 37 of file StoryboardModel.h.

                         {
        TotalSceneDurationInFrames = Qt::UserRole + 1,
        TotalSceneDurationInSeconds = Qt::UserRole + 2,
    };

Constructor & Destructor Documentation

StoryboardModel()

StoryboardModel::StoryboardModel

(

QObject *

parent

)

Definition at line 30 of file StoryboardModel.cpp.

        : QAbstractItemModel(parent)
        , m_freezeKeyframePositions(false)
        , m_lockBoards(false)
        , m_reorderingKeyframes(false)
        , m_imageIdleWatcher(10)
        , m_renderScheduler(new KisStoryboardThumbnailRenderScheduler(this))
        , m_renderSchedulingCompressor(1000,KisSignalCompressor::FIRST_ACTIVE)
{
    connect(m_renderScheduler, SIGNAL(sigFrameCompleted(int, KisPaintDeviceSP)), this, SLOT(slotFrameRenderCompleted(int, KisPaintDeviceSP)));
    connect(m_renderScheduler, SIGNAL(sigFrameCancelled(int)), this, SLOT(slotFrameRenderCancelled(int)));
    connect(&m_renderSchedulingCompressor, SIGNAL(timeout()), this, SLOT(slotUpdateThumbnails()));
    connect(&m_imageIdleWatcher, SIGNAL(startedIdleMode()), m_renderScheduler, SLOT(slotStartFrameRendering()));
}

References connect(), m_imageIdleWatcher, m_renderScheduler, m_renderSchedulingCompressor, slotFrameRenderCancelled(), slotFrameRenderCompleted(), and slotUpdateThumbnails().

~StoryboardModel()

StoryboardModel::~StoryboardModel ( )

override

Definition at line 45 of file StoryboardModel.cpp.

{
    delete m_renderScheduler;
}

References m_renderScheduler.

Member Function Documentation

affectedIndexes()

QModelIndexList StoryboardModel::affectedIndexes

(

KisTimeSpan

range

)

const

Returns a list of index of items that have frame in between argument range.

Parameters

range

The range of frames

Returns

The list of index corresponding to the range.

Definition at line 667 of file StoryboardModel.cpp.

{
    QModelIndex firstIndex = index(0,0);
 
    if (!firstIndex.isValid())
        return QModelIndexList();
 
    if ( range.start() > index(StoryboardItem::FrameNumber, 0, firstIndex).data().toInt()) {
        firstIndex = indexFromFrame(range.start(), false);
    }
 
    QModelIndex lastIndex = index(rowCount() - 1, 0);
 
    if (!range.isInfinite() && range.isValid()) {
        lastIndex = indexFromFrame(range.end(), false);
    }
 
    QItemSelectionRange indexRange(firstIndex, lastIndex);
    return indexRange.indexes();
}

References data(), KisTimeSpan::end(), StoryboardItem::FrameNumber, index(), indexFromFrame(), KisTimeSpan::isInfinite(), KisTimeSpan::isValid(), rowCount(), and KisTimeSpan::start().

changeSceneHoldLength()

bool StoryboardModel::changeSceneHoldLength	(	int	oldDuration,
		QModelIndex	itemIndex )

moves all keyframes in all layers after the frame of the parent of durationIndex Keyframes are moved to the left or right based on the difference (newDuration-oldDuration)

Parameters

oldDuration	The old duration in frames assigned to item
itemIndex	The storyboard item index.

Returns

True if keyframes were moved, otherwise False

Definition at line 854 of file StoryboardModel.cpp.

{
    if (!itemIndex.isValid()) {
        return false;
    }
 
    const int origSceneFrameLength = data(itemIndex, TotalSceneDurationInFrames).toInt();
    const int lastFrameOfScene = lastKeyframeWithin(itemIndex);
 
    int durationChange = newDuration - origSceneFrameLength;
    if (durationChange == 0) {
        return false;
    }
 
    if (origSceneFrameLength != 0) {
        shiftKeyframes(KisTimeSpan::infinite(lastFrameOfScene + 1), durationChange);
    }
 
    return true;
}

References data(), KisTimeSpan::infinite(), lastKeyframeWithin(), shiftKeyframes(), and TotalSceneDurationInFrames.

columnCount()

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

override

Definition at line 107 of file StoryboardModel.cpp.

{
   if (!parent.isValid()) {
       return 1;
   }
   //1st level nodes have 1 column
   if (!parent.parent().isValid()) {
       return 1;
   }
   //end level nodes have no child
   return 0;
}

References parent().

createBlankKeyframes()

void StoryboardModel::createBlankKeyframes	(	const QModelIndex &	index,
		KUndo2Command *	cmd = nullptr )

Definition at line 1321 of file StoryboardModel.cpp.

{
    if (!m_freezeKeyframePositions && m_image) {
        const int targetFrame = index(StoryboardItem::FrameNumber, 0, pIndex).data().toInt();
 
        KisLayerUtils::recursiveApplyNodes(m_image->root(), [targetFrame, cmd](KisNodeSP node){
            if (node->supportsKeyframeChannel(KisKeyframeChannel::Raster.id())
             && node->isEditable(true)) {
 
                KisKeyframeChannel* chan = node->getKeyframeChannel(KisKeyframeChannel::Raster.id(), true);
                chan->addKeyframe(targetFrame, cmd);
            }
        });
    }
}

References StoryboardItem::FrameNumber, index(), m_freezeKeyframePositions, m_image, KisLayerUtils::recursiveApplyNodes(), and KisNodeFacade::root.

createDuplicateKeyframes()

void StoryboardModel::createDuplicateKeyframes	(	const QModelIndex &	index,
		KUndo2Command *	cmd = nullptr )

Definition at line 1304 of file StoryboardModel.cpp.

{
    if (!m_freezeKeyframePositions && m_image) {
        const int targetFrame = index(StoryboardItem::FrameNumber, 0, pIndex).data().toInt();
 
        KisLayerUtils::recursiveApplyNodes(m_image->root(), [targetFrame, cmd](KisNodeSP node){
            if (node->supportsKeyframeChannel(KisKeyframeChannel::Raster.id())
             && node->isEditable(true)) {
 
                KisKeyframeChannel* chan = node->getKeyframeChannel(KisKeyframeChannel::Raster.id(), true);
                const int activeFrameTime = chan->activeKeyframeTime(targetFrame);
                chan->copyKeyframe(activeFrameTime, targetFrame, cmd);
            }
        });
    }
}

References StoryboardItem::FrameNumber, index(), m_freezeKeyframePositions, m_image, KisLayerUtils::recursiveApplyNodes(), and KisNodeFacade::root.

data()

QVariant StoryboardModel::data ( const QModelIndex & index, int role = Qt::DisplayRole ) const

override

Definition at line 120 of file StoryboardModel.cpp.

{
    if (!index.isValid()) {
        return QVariant();
    }
 
    //return data only for the storyboardChild i.e. 2nd level nodes
    if (isValidBoard(index)) {
        if (role == TotalSceneDurationInFrames) {
            int duration = this->index(StoryboardItem::DurationFrame, 0, index).data().toInt()
                + this->index(StoryboardItem::DurationSecond, 0, index).data().toInt() * getFramesPerSecond();
            return duration;
        }
        else if (role == TotalSceneDurationInSeconds) {
            qreal duration = this->index(StoryboardItem::DurationSecond, 0, index).data().toInt()
                + this->index(StoryboardItem::DurationFrame, 0, index).data().toInt()
                / getFramesPerSecond();
            return duration;
        }
        return QVariant();
    }
 
    if (role == Qt::DisplayRole || role == Qt::EditRole || role == Qt::UserRole) {
        QSharedPointer<StoryboardChild> child = m_items.at(index.parent().row())->child(index.row());
        if (index.row() == StoryboardItem::FrameNumber) {
            ThumbnailData thumbnailData = qvariant_cast<ThumbnailData>(child->data());
            if (role == Qt::UserRole) {
                return thumbnailData.pixmap;
            }
            else {
                return thumbnailData.frameNum;
            }
        }
        else if (index.row() >= StoryboardItem::Comments) {
            CommentBox commentBox = qvariant_cast<CommentBox>(child->data());
            if (role == Qt::UserRole) {         //scroll bar position
                return commentBox.scrollValue;
            }
            else {
                return commentBox.content;
            }
        }
        return child->data();
    }
    return QVariant();
}

References StoryboardItem::Comments, CommentBox::content, StoryboardItem::DurationFrame, StoryboardItem::DurationSecond, ThumbnailData::frameNum, StoryboardItem::FrameNumber, getFramesPerSecond(), index(), isValidBoard(), m_items, ThumbnailData::pixmap, CommentBox::scrollValue, TotalSceneDurationInFrames, and TotalSceneDurationInSeconds.

dropMimeData()

bool StoryboardModel::dropMimeData ( const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & parent )

override

Definition at line 468 of file StoryboardModel.cpp.

{
    Q_UNUSED(column);
    if (action == Qt::IgnoreAction) {
        return false;
    }
 
    if (action == Qt::MoveAction && data->hasFormat("application/x-krita-storyboard")) {
        QByteArray bytes = data->data("application/x-krita-storyboard");
        QDataStream stream(&bytes, QIODevice::ReadOnly);
 
        if (parent.isValid()) {
            return false;
        }
 
        if (isLocked()) {
            return false;
        }
 
        int sourceRow;
        QModelIndexList moveRowIndexes;
        while (!stream.atEnd()) {
            stream >> sourceRow;
            QModelIndex index = this->index(sourceRow, 0);
            moveRowIndexes.append(index);
        }
 
        moveRows(QModelIndex(), moveRowIndexes.at(0).row(), moveRowIndexes.count(), parent, row);
        //returning true deletes the source row
        return false;
    }
    return false;
}

References data(), index(), isLocked(), moveRows(), and parent().

flags()

Qt::ItemFlags StoryboardModel::flags ( const QModelIndex & index ) const

override

Definition at line 320 of file StoryboardModel.cpp.

{
    if(!index.isValid()) {
        return Qt::ItemIsDropEnabled;
    }
 
    //1st level nodes
    if (isValidBoard(index)) {
        return Qt::ItemIsDragEnabled | Qt::ItemIsSelectable | Qt::ItemIsEnabled;
    }
 
    //2nd level nodes
    return Qt::ItemIsSelectable | Qt::ItemIsEditable | Qt::ItemIsEnabled | Qt::ItemNeverHasChildren;
}

References index(), and isValidBoard().

getComment()

StoryboardComment StoryboardModel::getComment

(

int

row

)

const

Parameters

row	The row of the comment.

Returns

The Comment object at row in comment's list.

Note

The Comment object contains the name of the comment. Not to be confused with CommentBox.

See also

Comment

Definition at line 556 of file StoryboardModel.cpp.

{
    return m_commentList.at(row);
}

References m_commentList.

getData()

StoryboardItemList StoryboardModel::getData

(

)

Returns

The list of StoryboardItem* stored in the model.

Definition at line 1030 of file StoryboardModel.cpp.

{
    return m_items;
}

References m_items.

getFramesPerSecond()

int StoryboardModel::getFramesPerSecond

(

)

const

Definition at line 581 of file StoryboardModel.cpp.

{
    return m_image.isValid() ? m_image->animationInterface()->framerate() : 24;
}

References KisImage::animationInterface(), KisImageAnimationInterface::framerate(), KisWeakSharedPtr< T >::isValid(), and m_image.

index()

QModelIndex StoryboardModel::index ( int row, int column, const QModelIndex & parent = QModelIndex() ) const

override

Definition at line 50 of file StoryboardModel.cpp.

{
    if (!hasIndex(row, column, parent)) {
        return QModelIndex();
    }
    if (row < 0 || row >= rowCount(parent)) {
        return QModelIndex();
    }
    if (column != 0) {
        return QModelIndex();
    }
    
    if (isValidBoard(parent)) {
        StoryboardItemSP parentItem = m_items.at(parent.row());
        QSharedPointer<StoryboardChild> childItem = parentItem->child(row);
 
        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(childItem, QModelIndex());
        return createIndex(row, column, childItem.data());
    } else {
        return createIndex(row, column, m_items.at(row).data());
    }
}

References isValidBoard(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, m_items, parent(), and rowCount().

indexFromFrame()

QModelIndex StoryboardModel::indexFromFrame	(	int	frame,
		bool	framePerfect = true ) const

Returns the index of the item corresponding the frame, if there is an item with that frame.

Parameters

frame	The frame whose index is needed.
framePerfect	Whether query will return a valid scene even when a scene contains the frame, not just if it starts on said frame. Default == true

Returns

The index corresponding to frame, if exists.

Definition at line 637 of file StoryboardModel.cpp.

{
    int end = rowCount(), begin = 0;
    while (end >= begin) {
        const int row = begin + (end - begin) / 2;
        const int nextRow = row + 1;
        QModelIndex parentIndex = index(row, 0);
        QModelIndex frameNumIndex = index(StoryboardItem::FrameNumber, 0, parentIndex);
        QModelIndex nextParentIndex = index(nextRow, 0);
        QModelIndex nextFrameNumIndex = index(StoryboardItem::FrameNumber, 0, nextParentIndex);
 
        if (framePerfect && frame == frameNumIndex.data().toInt()) {
            return parentIndex;
        } else if (frame >= frameNumIndex.data().toInt() && (!nextParentIndex.isValid() || frame < nextFrameNumIndex.data().toInt())) {
            return parentIndex;
        } else if (frame < frameNumIndex.data().toInt()) {
            end = row - 1;
        } else if (frame > frameNumIndex.data().toInt()) {
            begin = row + 1;
        }
    }
 
    return QModelIndex();
}

References StoryboardItem::FrameNumber, index(), and rowCount().

insertChildRows() [1/2]

void StoryboardModel::insertChildRows	(	int	position,
		KUndo2Command *	cmd = nullptr )

must be called after a first level index is inserted. Adds child nodes to the first level indices

Parameters

position

Index of the first level node.

Definition at line 1245 of file StoryboardModel.cpp.

{
    if (position + 1 < rowCount()) {
        const int frame = index(StoryboardItem::FrameNumber, 0, index(position + 1, 0)).data().toInt();
        shiftKeyframes(KisTimeSpan::infinite(frame), 1);
    }
 
    for (int row = position + 1; row < rowCount(); ++row) {
        const int frame = index(StoryboardItem::FrameNumber, 0, index(row, 0)).data().toInt();
        setData(index(StoryboardItem::FrameNumber, 0, index(row, 0)), frame + 1);
    }
 
    QModelIndex parentIndex = index(position, 0);
    insertRows(0, 4 + m_commentList.count(), parentIndex);
 
    m_lastScene++;
    QString sceneName = i18nc("default name for storyboard item", "scene ") + QString::number(m_lastScene);
    setData(index(StoryboardItem::ItemName, 0, parentIndex), sceneName);
 
    const bool firstEntry = rowCount() == 1;
 
    if (position == 0) {
        setData(index(StoryboardItem::FrameNumber, 0, index(position, 0)), 0);
        setData(index(StoryboardItem::DurationFrame, 0, index(position, 0)), lastKeyframeGlobal() - 0 + 1);
    } else {
        const int targetFrame = index(StoryboardItem::FrameNumber, 0, index(position - 1,0)).data().toInt()
                                + data(index(position - 1, 0), TotalSceneDurationInFrames).toInt();
 
        setData(index(StoryboardItem::FrameNumber, 0, index(position, 0)), targetFrame);
        setData(index(StoryboardItem::DurationFrame, 0, parentIndex), 1);
        setData(index(StoryboardItem::DurationSecond, 0, parentIndex), 0);
    }
 
    if (firstEntry) {
        createDuplicateKeyframes(index(position, 0), cmd);
    } else {
        createBlankKeyframes(index(position, 0), cmd);
    }
 
    const int frameToSwitch = index(StoryboardItem::FrameNumber, 0, index(position, 0)).data().toInt();
    if (m_image) {
        KisSwitchCurrentTimeCommand* switchFrameCmd = new KisSwitchCurrentTimeCommand(m_image->animationInterface(), m_image->animationInterface()->currentTime(), frameToSwitch, cmd);
        switchFrameCmd->redo();
    }
}

References KisImage::animationInterface(), createBlankKeyframes(), createDuplicateKeyframes(), KisImageAnimationInterface::currentTime(), data(), StoryboardItem::DurationFrame, StoryboardItem::DurationSecond, StoryboardItem::FrameNumber, index(), KisTimeSpan::infinite(), insertRows(), StoryboardItem::ItemName, lastKeyframeGlobal(), m_commentList, m_image, m_lastScene, KisSwitchCurrentTimeCommand::redo(), rowCount(), setData(), shiftKeyframes(), and TotalSceneDurationInFrames.

insertChildRows() [2/2]

void StoryboardModel::insertChildRows	(	int	position,
		StoryboardItemSP	item )

Adds child nodes from the item provided.

Parameters

position

Index of the first level node.

Definition at line 1415 of file StoryboardModel.cpp.

{
    QModelIndex parentIndex = index(position, 0);
    insertRows(0, 4 + m_commentList.count(), parentIndex);
 
    setFreeze(true);
    for (int i = 0; i < item->childCount(); i++) {   
        QVariant data = item->child(i)->data();
        setData(index(i, 0, index(position, 0)), data);
    }
    setFreeze(false);
    slotUpdateThumbnails();
    m_renderScheduler->slotStartFrameRendering();
}

References data(), index(), insertRows(), m_commentList, m_renderScheduler, setData(), setFreeze(), KisStoryboardThumbnailRenderScheduler::slotStartFrameRendering(), and slotUpdateThumbnails().

insertItem()

bool StoryboardModel::insertItem	(	QModelIndex	index,
		bool	after )

inserts item after or before index based on after parameter

Parameters

index	The index at which right click was clicked or the plus button belonged to.
after	If True item is added after index, otherwise before

Returns

True if item was inserted, otherwise false

Definition at line 926 of file StoryboardModel.cpp.

{
    //index is the index at which context menu was created, or the + button belongs to
    //after is whether we want the item before or after index
 
    //disable for vector layers
    if (!m_activeNode->paintDevice()) {
        return false;
    }
 
    int desiredIndex;
    if (!index.isValid()) {
        desiredIndex = rowCount();
    } else {
        desiredIndex = after ? index.row() + 1 : index.row();    
    }
 
    insertRow(desiredIndex);
    KisAddStoryboardCommand *command = new KisAddStoryboardCommand(desiredIndex, m_items.at(desiredIndex), this);
    insertChildRows(desiredIndex, command);
    const int currentTime = m_image->animationInterface()->currentTime();
    const int desiredTime = this->index(StoryboardItem::FrameNumber, 0, this->index(desiredIndex, 0)).data().toInt();
 
    if (m_image && currentTime != desiredTime) {
        KisSwitchCurrentTimeCommand *switchTimeCmd = new KisSwitchCurrentTimeCommand(m_image->animationInterface(),
                                                                                     currentTime,
                                                                                     desiredTime,
                                                                                     command);
        switchTimeCmd->redo();
    } else {
        m_view->setCurrentItem(currentTime);
    }
 
    pushUndoCommand(command);
 
    // Let's start rendering after adding new storyboard items.
    slotUpdateThumbnails();
    m_renderScheduler->slotStartFrameRendering();
 
    return true;
}

References KisImage::animationInterface(), KisImageAnimationInterface::currentTime(), StoryboardItem::FrameNumber, index(), insertChildRows(), m_activeNode, m_image, m_items, m_renderScheduler, m_view, KisBaseNode::paintDevice(), pushUndoCommand(), KisSwitchCurrentTimeCommand::redo(), rowCount(), StoryboardView::setCurrentItem(), KisStoryboardThumbnailRenderScheduler::slotStartFrameRendering(), and slotUpdateThumbnails().

insertRows()

bool StoryboardModel::insertRows ( int position, int rows, const QModelIndex & index = QModelIndex() )

override

Definition at line 335 of file StoryboardModel.cpp.

{
    if (!parent.isValid()) {
        if (position < 0 || position > m_items.count()) {
            return false;
        }
 
        if (isLocked()) {
            return false;
        }
 
        beginInsertRows(QModelIndex(), position, position+rows-1);
        for (int row = 0; row < rows; ++row) {
            StoryboardItemSP newItem = toQShared(new StoryboardItem());
            m_items.insert(position + row, newItem);
        }
        endInsertRows();
        emit(sigStoryboardItemListChanged());
        return true;
    }
    else if (!parent.parent().isValid()) {              //insert 2nd level nodes
        StoryboardItemSP item = m_items.at(parent.row());
 
        if (position < 0 || position > item->childCount()) {
            return false;
        }
        beginInsertRows(parent, position, position+rows-1);
        for (int row = 0; row < rows; ++row) {
            item->insertChild(position, QVariant());
        }
        endInsertRows();
        emit(sigStoryboardItemListChanged());
        return true;
    }
    //we can't insert to 2nd level nodes as they are leaf nodes
    return false;
}

References isLocked(), m_items, parent(), sigStoryboardItemListChanged(), and toQShared().

isFrozen()

bool StoryboardModel::isFrozen

(

)

const

Definition at line 566 of file StoryboardModel.cpp.

{
    return m_freezeKeyframePositions;
}

References m_freezeKeyframePositions.

isLocked()

bool StoryboardModel::isLocked

(

)

const

Definition at line 576 of file StoryboardModel.cpp.

{
    return m_lockBoards;
}

References m_lockBoards.

isValidBoard()

bool StoryboardModel::isValidBoard ( const QModelIndex & index ) const

inlineprivate

Definition at line 275 of file StoryboardModel.h.

{return index.isValid() && !index.parent().isValid();}

lastIndexBeforeFrame()

QModelIndex StoryboardModel::lastIndexBeforeFrame

(

int

frame

)

const

Returns the index of the item with largest frame smaller than argument frame.

Parameters

frame

Returns

The index with largest frame less than argument frame.

Definition at line 662 of file StoryboardModel.cpp.

{
    return indexFromFrame(frame, false);
}

References indexFromFrame().

lastKeyframeGlobal()

int StoryboardModel::lastKeyframeGlobal

(

)

const

Definition at line 717 of file StoryboardModel.cpp.

{
    if (!m_image)
        return 0;
 
    KisNodeSP node = m_image->rootLayer();
    int lastKeyframeTime = 0;
    if (node) {
    KisLayerUtils::recursiveApplyNodes (node, [&lastKeyframeTime] (KisNodeSP node)
    {
        if (node->isAnimated() && node->supportsKeyframeChannel(KisKeyframeChannel::Raster.id())) {
            KisKeyframeChannel* channel = node->getKeyframeChannel(KisKeyframeChannel::Raster.id(), false);
 
            if (!channel) {
                return;
            }
 
            lastKeyframeTime = qMax(channel->lastKeyframeTime(), lastKeyframeTime);
        }
    });
    }
 
    return lastKeyframeTime;
}

References KoID::id(), KisBaseNode::isAnimated(), m_image, KisKeyframeChannel::Raster, KisLayerUtils::recursiveApplyNodes(), KisImage::rootLayer(), and KisBaseNode::supportsKeyframeChannel().

lastKeyframeWithin()

int StoryboardModel::lastKeyframeWithin

(

QModelIndex

index

)

Gets the last keyframe that exists within an index's duration. Used to prevent duration from overwriting keyframes that exist internal to an existing scene.

Definition at line 742 of file StoryboardModel.cpp.

{
    KIS_ASSERT(sceneIndex.isValid());
    const int sceneFrame = index(StoryboardItem::FrameNumber, 0, sceneIndex).data().toInt();
 
    if (!m_image)
        return sceneFrame;
    
    QModelIndex nextScene = index(sceneIndex.row() + 1, 0);
    int nextSceneFrame;
    if (nextScene.isValid()) {
        nextSceneFrame = data(index(StoryboardItem::FrameNumber, 0, nextScene)).toInt();
    }
    else {
        nextSceneFrame = sceneFrame + data(sceneIndex, TotalSceneDurationInFrames).toInt();
    }
 
    int lastFrameOfScene = sceneFrame;
    for (int frame = sceneFrame; frame < nextSceneFrame; frame = nextKeyframeGlobal(frame)) {
        lastFrameOfScene = frame;
    }
 
    return lastFrameOfScene;
}

References data(), StoryboardItem::FrameNumber, index(), KIS_ASSERT, m_image, nextKeyframeGlobal(), and TotalSceneDurationInFrames.

mimeData()

QMimeData * StoryboardModel::mimeData ( const QModelIndexList & indexes ) const

override

Definition at line 449 of file StoryboardModel.cpp.

{
    QMimeData *mimeData = new QMimeData();
    QByteArray encodeData;
 
    QDataStream stream(&encodeData, QIODevice::WriteOnly);
 
    //take the row number of the index where drag started
    foreach (QModelIndex index, indexes) {
        if (index.isValid()) {
            int row = index.row();
            stream << row;
        }
    }
 
    mimeData->setData("application/x-krita-storyboard", encodeData); //default mimetype
    return mimeData;
}

References encodeData(), index(), and mimeData().

mimeTypes()

QStringList StoryboardModel::mimeTypes ( ) const

override

Definition at line 442 of file StoryboardModel.cpp.

{
    QStringList types;
    types << QLatin1String("application/x-krita-storyboard");
    return types;
}

moveRows()

bool StoryboardModel::moveRows ( const QModelIndex & sourceParent, int sourceRow, int count, const QModelIndex & destinationParent, int destinationChild )

override

Definition at line 421 of file StoryboardModel.cpp.

{
    KisMoveStoryboardCommand *command = new KisMoveStoryboardCommand(sourceRow, count, destinationChild, this);
 
    if (moveRowsImpl(sourceParent, sourceRow, count, destinationParent, destinationChild, command)) {
        if (!sourceParent.isValid()) {
            const int sceneIndex = sourceRow < destinationChild ? destinationChild - 1 : destinationChild;
            new KisVisualizeStoryboardCommand(m_image->animationInterface()->currentTime(),
                                              sceneIndex,
                                              this,
                                              m_image,
                                              command);
        }
 
        KisProcessingApplicator::runSingleCommandStroke(m_image, command, KisStrokeJobData::BARRIER, KisStrokeJobData::EXCLUSIVE);
        return true;
    }
 
    return false;
}

References KisImage::animationInterface(), KisStrokeJobData::BARRIER, KisImageAnimationInterface::currentTime(), KisStrokeJobData::EXCLUSIVE, KisMoveStoryboardCommand, m_image, moveRowsImpl(), and KisProcessingApplicator::runSingleCommandStroke().

moveRowsImpl()

bool StoryboardModel::moveRowsImpl ( const QModelIndex & sourceParent, int sourceRow, int count, const QModelIndex & destinationParent, int destinationChild, KUndo2Command * parentCMD = nullptr )

private

Definition at line 1337 of file StoryboardModel.cpp.

{
    if (sourceParent != destinationParent) {
        return false;
    }
    if (destinationChild == sourceRow || destinationChild == sourceRow + 1) {
        return false;
    }
 
    if (isLocked()) {
        return false;
    }
 
    //We want to test-run an action when nullptrs are present.
    bool dryrun = (parentCMD != nullptr);
 
    if (destinationChild > sourceRow + count - 1) {
        //we adjust for the upward shift, see qt doc for why this is needed
        beginMoveRows(sourceParent, sourceRow, sourceRow + count - 1, destinationParent, destinationChild + count - 1);
        destinationChild = destinationChild - count;
    }
    else {
        beginMoveRows(sourceParent, sourceRow, sourceRow + count - 1, destinationParent, destinationChild);
    }
    //for moves within the 1st level nodes for comment nodes
    if (sourceParent == destinationParent && sourceParent.isValid() && !sourceParent.parent().isValid()) {
        const QModelIndex parent = sourceParent;
        for (int row = 0; row < count; row++) {
            if (sourceRow < StoryboardItem::Comments || sourceRow >= rowCount(parent)) {
                return false;
            }
            if (destinationChild + row < StoryboardItem::Comments || destinationChild + row >= rowCount(parent)) {
                return false;
            }
 
            StoryboardItemSP item = m_items.at(parent.row());
 
            if (!dryrun) {
                item->moveChild(sourceRow, destinationChild + row);
            }
        }
        endMoveRows();
 
        if (!dryrun) {
            reorderKeyframes();
            Q_EMIT sigStoryboardItemListChanged();
        }
 
        return true;
    }
    else if (!sourceParent.isValid()) {                  //for moves of 1st level nodes
        for (int row = 0; row < count; row++) {
            if (sourceRow < 0 || sourceRow >= rowCount()) {
                return false;
            }
            if (destinationChild + row < 0 || destinationChild + row >= rowCount()) {
                return false;
            }
 
            if (!dryrun) {
                m_items.move(sourceRow, destinationChild + row);
            }
        }
        endMoveRows();
 
        if (!dryrun) {
            reorderKeyframes();
            Q_EMIT sigStoryboardItemListChanged();
        }
 
        return true;
    }
    else {
        return false;
    }
}

References isLocked(), m_items, parent(), reorderKeyframes(), rowCount(), and sigStoryboardItemListChanged().

nextKeyframeGlobal()

int StoryboardModel::nextKeyframeGlobal

(

int

keyframeTime

)

const

the next time at which there is a keyframe in any layer after keyframeTime

Parameters

keyframeTime

The time after which keyframe is wanted.

Returns

The time of the next keyframe in any layer.

Definition at line 688 of file StoryboardModel.cpp.

{
    KisNodeSP node = m_image->rootLayer();
    int nextKeyframeTime = INT_MAX;
    if (node) {
    KisLayerUtils::recursiveApplyNodes (node, [keyframeTime, &nextKeyframeTime] (KisNodeSP node)
    {
        if (node->isAnimated() && node->supportsKeyframeChannel(KisKeyframeChannel::Raster.id())) {
            KisKeyframeChannel* channel = node->getKeyframeChannel(KisKeyframeChannel::Raster.id(), false);
 
            if (!channel) {
                return;
            }
 
            int nextKeyframeTimeQuery = channel->nextKeyframeTime(keyframeTime);
            if (channel->keyframeAt(nextKeyframeTimeQuery)) {
                if (nextKeyframeTime == INT_MAX) {
                    nextKeyframeTime = nextKeyframeTimeQuery;
                } else {
                    nextKeyframeTime = qMin(nextKeyframeTime, nextKeyframeTimeQuery);
                }
            }
        }
    });
    }
 
    return nextKeyframeTime;
}

References KoID::id(), KisBaseNode::isAnimated(), m_image, KisKeyframeChannel::Raster, KisLayerUtils::recursiveApplyNodes(), KisImage::rootLayer(), and KisBaseNode::supportsKeyframeChannel().

parent()

QModelIndex StoryboardModel::parent ( const QModelIndex & index ) const

override

Definition at line 73 of file StoryboardModel.cpp.

{
    if (!index.isValid()) {
        return QModelIndex();
    }
 
    //no parent for 1st level node
    StoryboardItem *childItemFirstLevel = static_cast<StoryboardItem*>(index.internalPointer());
 
    Q_FOREACH( StoryboardItemSP item, m_items) {
        if (item.data() == childItemFirstLevel) {
            return QModelIndex();
        }
    }
 
    //return parent only for 2nd level nodes
    StoryboardChild *childItem = static_cast<StoryboardChild*>(index.internalPointer());
    QSharedPointer<StoryboardItem> parentItem = childItem->parent();
    int indexOfParent = m_items.indexOf(parentItem);
    return createIndex(indexOfParent, 0, parentItem.data());
}

References index(), m_items, and StoryboardChild::parent().

pushUndoCommand()

void StoryboardModel::pushUndoCommand

(

KUndo2Command *

command

)

Definition at line 1035 of file StoryboardModel.cpp.

{
    m_image->postExecutionUndoAdapter()->addCommand(toQShared(command));
}

References KisPostExecutionUndoAdapter::addCommand(), m_image, KisImage::postExecutionUndoAdapter(), and toQShared().

removeItem()

bool StoryboardModel::removeItem	(	QModelIndex	index,
		KUndo2Command *	command = nullptr )

removes item, deletes keyframes within and shifts keyframe after the scene to fill in the gap

Parameters

index

The index of the item to be removed

Returns

true if item was removed

Definition at line 968 of file StoryboardModel.cpp.

 {
    const int row = index.row();
    const int durationDeletedScene = data(index, TotalSceneDurationInFrames).toInt();
 
    //remove all keyframes within the scene with command as parent
    KisNodeSP node = m_image->rootLayer();
    const int firstFrameOfScene = data(this->index(StoryboardItem::FrameNumber, 0, index)).toInt();
    const int timeOfNextScene = firstFrameOfScene + durationDeletedScene;
    if (command) {
        if (node) {
            KisLayerUtils::recursiveApplyNodes (node, [firstFrameOfScene, timeOfNextScene, command] (KisNodeSP node){
                if (node->isAnimated() && node->isEditable(true)) {
                    Q_FOREACH(KisKeyframeChannel* keyframeChannel, node->keyframeChannels()) {
                        int timeIter = keyframeChannel->keyframeAt(firstFrameOfScene)
                                                                    ? firstFrameOfScene
                                                                    : keyframeChannel->nextKeyframeTime(firstFrameOfScene);
 
                        while (keyframeChannel->keyframeAt(timeIter) && timeIter < timeOfNextScene) {
                            keyframeChannel->removeKeyframe(timeIter, command);
                            timeIter = keyframeChannel->nextKeyframeTime(timeIter);
                        }
                    }
                }
            });
        }
        shiftKeyframes(KisTimeSpan::infinite(timeOfNextScene), -durationDeletedScene, command);
 
        //If we're viewing the scene we're about the remove, let's jump back to the last valid scene.
        if (row > 0 && row <= rowCount()) {
            QModelIndex currentSceneFN = this->index(StoryboardItem::FrameNumber, 0, this->index(row, 0));
            if (m_image && m_image->animationInterface()->currentTime() == currentSceneFN.data().toInt()) {
                KisSwitchCurrentTimeCommand* switchTimeCmd = new KisSwitchCurrentTimeCommand(m_image->animationInterface(),
                                                                                             currentSceneFN.data().toInt(),
                                                                                             this->index(StoryboardItem::FrameNumber, 0, this->index(row-1, 0)).data().toInt(),
                                                                                             command);
                switchTimeCmd->redo();
            }
        }
    }
 
    removeRows(row, 1);
    for (int i = row; i < rowCount(); i++) {
        QModelIndex frameNumIndex = this->index(StoryboardItem::FrameNumber, 0, this->index(i, 0));
        setData(frameNumIndex, data(frameNumIndex).toInt() - durationDeletedScene);
    }
 
    //do we also need to make the 'change frame' command a child??
    // Render after removing
    slotUpdateThumbnails();
    m_renderScheduler->slotStartFrameRendering();
 
    return true;
}

References KisImage::animationInterface(), KisImageAnimationInterface::currentTime(), data(), StoryboardItem::FrameNumber, index(), KisTimeSpan::infinite(), KisBaseNode::isAnimated(), KisBaseNode::isEditable(), m_image, KisLayerUtils::recursiveApplyNodes(), KisSwitchCurrentTimeCommand::redo(), KisImage::rootLayer(), rowCount(), shiftKeyframes(), and TotalSceneDurationInFrames.

removeRows()

bool StoryboardModel::removeRows ( int position, int rows, const QModelIndex & index = QModelIndex() )

override

Definition at line 373 of file StoryboardModel.cpp.

{
    if (rows <= 0) {
        return false;
    }
    //remove 1st level nodes
    if (!parent.isValid()) {
 
        if (position < 0 || position >= m_items.count()) {
            return false;
        }
 
        if (isLocked()) {
            return false;
        }
 
        beginRemoveRows(QModelIndex(), position, position+rows-1);
 
        for (int row = position + rows - 1; row >= position; row--) {
            m_items.removeAt(row);
            if (m_items.count() == 0) {
                break;
            }
        }
        endRemoveRows();
        emit(sigStoryboardItemListChanged());
        return true;
    }
    else if (!parent.parent().isValid()) {                     //remove 2nd level nodes
        StoryboardItemSP item = m_items.at(parent.row());
 
        if (position < 0 || position >= item->childCount()) {
            return false;
        }
        if (m_items.contains(item)) {
            beginRemoveRows(parent, position, position+rows-1);
            for (int row = 0; row < rows; ++row) {
                item->removeChild(position);
            }
            endRemoveRows();
            emit(sigStoryboardItemListChanged());
            return true;
        }
    }
    //2nd level node has no child
    return false;
}

References isLocked(), m_items, parent(), and sigStoryboardItemListChanged().

reorderKeyframes()

void StoryboardModel::reorderKeyframes

(

)

reorders all keyframes to reflect storyboard docker's arrangement. typically used after drag and drop to keep storyboard timing accurate to timeline timing.

Definition at line 767 of file StoryboardModel.cpp.

{
    //Get the earliest frame number in the storyboard list
    int earliestFrame = INT_MAX;
 
    if (!m_image) {
        return;
    }
 
    typedef int AssociateFrameOffset;
 
    QMultiHash<QModelIndex, AssociateFrameOffset> frameAssociates;
 
    for (int i = 0; i < rowCount(); i++) {
        QModelIndex sceneIndex = index(i, 0);
        int sceneFrame = index(StoryboardItem::FrameNumber, 0, sceneIndex).data().toInt();
        earliestFrame = sceneFrame < earliestFrame ? sceneFrame : earliestFrame;
 
        const int lastFrameOfScene = index(StoryboardItem::FrameNumber, 0, sceneIndex).data().toInt()
                                     + data(sceneIndex, TotalSceneDurationInFrames).toInt();
 
        for( int i = sceneFrame; i < lastFrameOfScene; i++) {
            frameAssociates.insert(sceneIndex, i - sceneFrame);
        }
    }
 
    if (earliestFrame == INT_MAX) {
        return;
    }
 
    //We want to temporarily lock responding to keyframe removal / addition.
    //Will unlock when scope exits.
    QScopedPointer<KeyframeReorderLock> lock(new KeyframeReorderLock(this));
 
    //Let's cancel all frame rendering for the time being.
    m_renderScheduler->cancelAllFrameRendering();
 
    KisNodeSP root = m_image->root();
    if (root && !m_freezeKeyframePositions) {
        KisLayerUtils::recursiveApplyNodes(root, [this, earliestFrame, frameAssociates](KisNodeSP node) {
            if (!node->isAnimated() || !node->paintDevice())
                return;
 
            KisRasterKeyframeChannel* rasterChan = node->paintDevice()->keyframeChannel();
 
            if (!rasterChan)
                return;
 
            // Gather all original keyframes and their associated time values.
            QHash<int, KisKeyframeSP> originalKeyframes;
            Q_FOREACH( const int& time, rasterChan->allKeyframeTimes()) {
                if (time >= earliestFrame && rasterChan->keyframeAt(time)) {
                    originalKeyframes.insert(time, rasterChan->keyframeAt(time));
                    rasterChan->removeKeyframe(time);
                }
            }
 
            //Now lets re-sort the raster channels...
            int intendedSceneFrameTime = earliestFrame;
            for (int i = 0; i < rowCount(); i++) {
                QModelIndex sceneIndex = index(i, 0);
                const int srcFrame = index(StoryboardItem::FrameNumber, 0, sceneIndex).data().toInt();
                Q_FOREACH( const int& associateFrameOffset, frameAssociates.values(sceneIndex) ) {
                    if (!originalKeyframes.contains(srcFrame + associateFrameOffset))
                        continue;
 
                    rasterChan->insertKeyframe(intendedSceneFrameTime + associateFrameOffset,
                                               originalKeyframes.value(srcFrame + associateFrameOffset));
                }
 
                intendedSceneFrameTime += data(sceneIndex, TotalSceneDurationInFrames).toInt();
            }
        });
    }
 
    //Lastly, let's update all of the frame values.
    int intendedFrameValue = earliestFrame;
    for (int i = 0; i < rowCount(); i++) {
        QModelIndex sceneIndex = index(i, 0);
        setData(index(StoryboardItem::FrameNumber, 0, sceneIndex), intendedFrameValue);
        slotUpdateThumbnailForFrame(intendedFrameValue);
        intendedFrameValue += data(sceneIndex, TotalSceneDurationInFrames).toInt();
    }
 
    m_renderScheduler->slotStartFrameRendering();
}

References KisKeyframeChannel::allKeyframeTimes(), KisStoryboardThumbnailRenderScheduler::cancelAllFrameRendering(), data(), StoryboardItem::FrameNumber, index(), KisRasterKeyframeChannel::insertKeyframe(), KisBaseNode::isAnimated(), KisKeyframeChannel::keyframeAt(), KisPaintDevice::keyframeChannel(), m_freezeKeyframePositions, m_image, m_renderScheduler, KisBaseNode::paintDevice(), KisLayerUtils::recursiveApplyNodes(), KisRasterKeyframeChannel::removeKeyframe(), KisNodeFacade::root, rowCount(), setData(), KisStoryboardThumbnailRenderScheduler::slotStartFrameRendering(), slotUpdateThumbnailForFrame(), and TotalSceneDurationInFrames.

resetData()

void StoryboardModel::resetData

(

StoryboardItemList

list

)

resets m_items to list

Parameters

list	The new list of StoryboardItem*

Definition at line 1023 of file StoryboardModel.cpp.

{
    beginResetModel();
    m_items = list;
    endResetModel();
}

References m_items.

rowCount()

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

override

Definition at line 95 of file StoryboardModel.cpp.

{
    if (!parent.isValid()) {
        return m_items.count();
    }
    else if (!parent.parent().isValid()) {
        QSharedPointer<StoryboardItem> parentItem = m_items.at(parent.row());
        return parentItem->childCount();
    }
    return 0;   //2nd level nodes have no child
}

References m_items, and parent().

setCommentModel()

void StoryboardModel::setCommentModel

(

StoryboardCommentModel *

commentModel

)

Sets the commentModel in StoryboardModel and creates connections to keep the local copy of comments in sync with the commentModel's.

See also

slotCommentDataChanged();

slotCommentRowInserted(QModelIndex,int,int)

slotCommentRowRemoved(QModelIndex,int,int)

slotCommentRowMoved();

Definition at line 543 of file StoryboardModel.cpp.

{
    m_commentModel = commentModel;
    connect(m_commentModel, SIGNAL(dataChanged(const QModelIndex ,const QModelIndex)),
                this, SLOT(slotCommentDataChanged()));
    connect(m_commentModel, SIGNAL(rowsRemoved(const QModelIndex ,int, int)),
                this, SLOT(slotCommentRowRemoved(const QModelIndex ,int, int)));
    connect(m_commentModel, SIGNAL(rowsInserted(const QModelIndex, int, int)),
                this, SLOT(slotCommentRowInserted(const QModelIndex, int, int)));
    connect(m_commentModel, SIGNAL(rowsMoved(const QModelIndex, int, int, const QModelIndex, int)),
                this, SLOT(slotCommentRowMoved(const QModelIndex, int, int, const QModelIndex, int)));
}

References connect(), m_commentModel, slotCommentDataChanged(), slotCommentRowInserted(), slotCommentRowMoved(), and slotCommentRowRemoved().

setCommentScrollData()

bool StoryboardModel::setCommentScrollData	(	const QModelIndex &	index,
		const QVariant &	value )

Sets the scrollValue of the CommentBox object.

Parameters

index	The index of the CommentBox object whose scrollValue is changed
value	The new scrollValue

Returns

True if data was set

See also

CommentBox

Definition at line 258 of file StoryboardModel.cpp.

{
    QSharedPointer<StoryboardChild> child = m_items.at(index.parent().row())->child(index.row());
    if (child) {
        CommentBox commentBox = qvariant_cast<CommentBox>(child->data());
        commentBox.scrollValue = value.toInt();
        child->setData(QVariant::fromValue<CommentBox>(commentBox));
        emit(sigStoryboardItemListChanged());
        return true;
    }
    return false;
}

References index(), m_items, CommentBox::scrollValue, sigStoryboardItemListChanged(), and value().

setData()

bool StoryboardModel::setData ( const QModelIndex & index, const QVariant & value, int role = Qt::EditRole )

override

Definition at line 167 of file StoryboardModel.cpp.

{
    if (index.isValid() && !isLocked() && (role == Qt::EditRole || role == Qt::DisplayRole)) {
        if (isValidBoard(index)) {
            return false;
        }
 
        QSharedPointer<StoryboardChild> child = m_items.at(index.parent().row())->child(index.row());
        if (child) {
            if (index.row() == StoryboardItem::FrameNumber && !value.canConvert<ThumbnailData>()) {
                if (value.toInt() < 0) {
                    return false;
                }
                ThumbnailData thumbnailData = qvariant_cast<ThumbnailData>(child->data());
                thumbnailData.frameNum = value.toInt();
                child->setData(QVariant::fromValue<ThumbnailData>(thumbnailData));
            }
            else if (index.row() == StoryboardItem::DurationSecond ||
                     index.row() == StoryboardItem::DurationFrame) {
 
                QModelIndex frameIndex = index.row() == StoryboardItem::DurationFrame ? index : siblingAtRow(index, StoryboardItem::DurationFrame);
                QModelIndex secondIndex = index.row() == StoryboardItem::DurationSecond ? index : siblingAtRow(index, StoryboardItem::DurationSecond);
                const int sceneStartFrame = siblingAtRow(index, StoryboardItem::FrameNumber).data().toInt();
 
                const int secondCount = index.row() == StoryboardItem::DurationSecond ? value.toInt() : secondIndex.data().toInt();
                const int frameCount = index.row() == StoryboardItem::DurationFrame ? value.toInt() : frameIndex.data().toInt();
 
                // Do not allow desired scene length to be shorter than keyframes within
                // the given scene. This prevents overwriting data that exists internal
                // to a scene.
                const int sceneDesiredDuration = frameCount + secondCount * getFramesPerSecond();
                const int implicitSceneDuration = qMax(
                                                  qMax( sceneDesiredDuration, lastKeyframeWithin(index.parent()) - sceneStartFrame + 1 ),
                                                  1 );
 
                if (value.toInt() < 0 && secondIndex.data().toInt() == 0) {
                    return false;
                }
                if (implicitSceneDuration == data(index.parent(), TotalSceneDurationInFrames).toInt()) {
                    return false;
                }
                const int fps = m_image.isValid() ? m_image->animationInterface()->framerate() : 24;
 
                QModelIndex lastScene = index.parent();
                QModelIndex nextScene = this->index(lastScene.row() + 1, 0);
                changeSceneHoldLength(implicitSceneDuration, index.parent());
                while (nextScene.isValid()) {
                    const int lastSceneStartFrame = this->index(StoryboardItem::FrameNumber, 0, lastScene).data().toInt();
                    const int lastSceneDuration = lastScene == index.parent() ? implicitSceneDuration
                                                                              : data(lastScene, TotalSceneDurationInFrames).toInt();
                    setData( this->index(StoryboardItem::FrameNumber, 0, nextScene), lastSceneStartFrame + lastSceneDuration);
                    lastScene = nextScene;
                    nextScene = this->index(lastScene.row() + 1, 0);
                }
 
                StoryboardItemSP scene = m_items.at(index.parent().row());
                QSharedPointer<StoryboardChild> durationSeconds = scene->child(secondIndex.row());
                QSharedPointer<StoryboardChild> durationFrames = scene->child(frameIndex.row());
                durationSeconds->setData(QVariant::fromValue<int>(implicitSceneDuration / fps));
                durationFrames->setData(QVariant::fromValue<int>(implicitSceneDuration % fps));
 
                // Account for new durations with auto-adjust playback range option.
                if (m_image.isValid()) {
                    KisConfig cfg(true);
                    QModelIndex lastScene = this->index(rowCount() - 1, 0);
                    if (cfg.adaptivePlaybackRange()) {
                        int frameNum = this->index(StoryboardItem::FrameNumber, 0, lastScene).data().toInt();
                        int totalDuration = data(lastScene, TotalSceneDurationInFrames).toInt();
                        KisTimeSpan playbackRange = m_image->animationInterface()->documentPlaybackRange();
                        playbackRange.include(frameNum+totalDuration);
                        m_image->animationInterface()->setDocumentRange(playbackRange);
                    }
                }
 
            }
            else if (index.row() >= StoryboardItem::Comments && !value.canConvert<CommentBox>()) {
                CommentBox commentBox = qvariant_cast<CommentBox>(child->data());
                commentBox.content = value.toString();
                child->setData(QVariant::fromValue<CommentBox>(commentBox));
            }
            else {
                child->setData(value);
            }
            Q_EMIT dataChanged(index, index);
            emit(sigStoryboardItemListChanged());
            return true;
        }
    }
    return false;
}

References KisConfig::adaptivePlaybackRange(), KisImage::animationInterface(), changeSceneHoldLength(), StoryboardItem::Comments, CommentBox::content, data(), KisImageAnimationInterface::documentPlaybackRange(), StoryboardItem::DurationFrame, StoryboardItem::DurationSecond, ThumbnailData::frameNum, StoryboardItem::FrameNumber, KisImageAnimationInterface::framerate(), getFramesPerSecond(), KisTimeSpan::include(), index(), isLocked(), KisWeakSharedPtr< T >::isValid(), isValidBoard(), lastKeyframeWithin(), m_image, m_items, rowCount(), setData(), KisImageAnimationInterface::setDocumentRange(), siblingAtRow(), sigStoryboardItemListChanged(), TotalSceneDurationInFrames, and value().

setFreeze()

void StoryboardModel::setFreeze

(

bool

value

)

Definition at line 561 of file StoryboardModel.cpp.

{
    m_freezeKeyframePositions = value;
}

References m_freezeKeyframePositions, and value().

setImage()

void StoryboardModel::setImage

(

KisImageWSP

image

)

Definition at line 591 of file StoryboardModel.cpp.

{
    if (m_image) {
        m_image->disconnect(this);
        m_image->animationInterface()->disconnect(this);
    }
    m_image = image;
    m_renderScheduler->setImage(m_image);
    m_imageIdleWatcher.setTrackedImage(m_image);
 
    if (!image) {
        return;
    }
 
    //setting image to a different image stops rendering of all frames previously scheduled.
    //resetData() must be called before setImage(KisImageWSP) so that we can schedule rendering for the items in the new KisDocument
    foreach (StoryboardItemSP item, m_items) {
        int frame = qvariant_cast<ThumbnailData>(item->child(StoryboardItem::FrameNumber)->data()).frameNum.toInt();
        m_renderScheduler->scheduleFrameForRegeneration(frame, true);
    }
    m_lastScene = m_items.size();
 
    m_imageIdleWatcher.forceImageModified();
 
    connect(m_image, SIGNAL(sigImageUpdated(const QRect &)), &m_renderSchedulingCompressor, SLOT(start()));
 
    connect(m_image, SIGNAL(sigRemoveNodeAsync(KisNodeSP)), this, SLOT(slotNodeRemoved(KisNodeSP)));
 
    //for add, remove and move
    connect(m_image->animationInterface(), SIGNAL(sigKeyframeAdded(const KisKeyframeChannel*,int)),
            this, SLOT(slotKeyframeAdded(const KisKeyframeChannel*,int)), Qt::UniqueConnection);
    connect(m_image->animationInterface(), SIGNAL(sigKeyframeRemoved(const KisKeyframeChannel*,int)),
            this, SLOT(slotKeyframeRemoved(const KisKeyframeChannel*,int)), Qt::UniqueConnection);
 
    connect(m_image->animationInterface(), SIGNAL(sigFramerateChanged()), this, SLOT(slotFramerateChanged()), Qt::UniqueConnection);
 
    //for selection sync with timeline
    slotCurrentFrameChanged(m_image->animationInterface()->currentUITime());
    connect(m_image->animationInterface(), SIGNAL(sigUiTimeChanged(int)), this, SLOT(slotCurrentFrameChanged(int)), Qt::UniqueConnection);
}

References KisImage::animationInterface(), connect(), KisImageAnimationInterface::currentUITime(), KisIdleWatcher::forceImageModified(), StoryboardItem::FrameNumber, m_image, m_imageIdleWatcher, m_items, m_lastScene, m_renderScheduler, m_renderSchedulingCompressor, KisStoryboardThumbnailRenderScheduler::scheduleFrameForRegeneration(), KisStoryboardThumbnailRenderScheduler::setImage(), KisIdleWatcher::setTrackedImage(), slotCurrentFrameChanged(), slotFramerateChanged(), slotKeyframeAdded(), slotKeyframeRemoved(), and slotNodeRemoved().

setLocked()

void StoryboardModel::setLocked

(

bool

value

)

Definition at line 571 of file StoryboardModel.cpp.

{
    m_lockBoards = value;
}

References m_lockBoards, and value().

setThumbnailPixmapData()

bool StoryboardModel::setThumbnailPixmapData	(	const QModelIndex &	parentIndex,
		const KisPaintDeviceSP &	dev )

Sets the Pixmap data.

Parameters

parentIndex	The index of item whose thumbnail changed.
dev	Projection of the new pixmap.

Returns

True if data was set

See also

ThumbnailData

Definition at line 271 of file StoryboardModel.cpp.

{
    QModelIndex index = this->index(0, 0, parentIndex);
    QRect thumbnailRect = m_view->visualRect(parentIndex);
    float scale = qMin(thumbnailRect.height() / (float)m_image->height(), (float)thumbnailRect.width() / m_image->width());
 
    QImage image = dev->convertToQImage(KoColorSpaceRegistry::instance()->rgb8()->profile(), m_image->bounds());
    QPixmap pxmap = QPixmap::fromImage(image);
    pxmap = pxmap.scaled((1.5)*scale*m_image->size(), Qt::KeepAspectRatio, Qt::SmoothTransformation);
 
    if (isValidBoard(index))
        return false;
 
    QSharedPointer<StoryboardChild> child = m_items.at(index.parent().row())->child(index.row());
    if (child) {
        ThumbnailData thumbnailData = qvariant_cast<ThumbnailData>(child->data());
        thumbnailData.pixmap = pxmap;
        child->setData(QVariant::fromValue<ThumbnailData>(thumbnailData));
        Q_EMIT dataChanged(index, index);
        return true;
    }
    return false;
}

References KisImage::bounds(), KisPaintDevice::convertToQImage(), KisImage::height(), index(), KoColorSpaceRegistry::instance(), isValidBoard(), m_image, m_items, m_view, ThumbnailData::pixmap, KisImage::size(), StoryboardView::visualRect(), and KisImage::width().

setView()

void StoryboardModel::setView

(

StoryboardView *

view

)

Definition at line 586 of file StoryboardModel.cpp.

{
    m_view = view;
}

References m_view.

shiftKeyframes()

void StoryboardModel::shiftKeyframes	(	KisTimeSpan	affected,
		int	offset,
		KUndo2Command *	cmd = nullptr )

Definition at line 875 of file StoryboardModel.cpp.

                                                                                         {
    if (!m_image)
        return;
 
    KisNodeSP node = m_image->rootLayer();
 
    if (offset == 0)
        return;
 
    //We want to temporarily lock respondance to keyframe removal / addition.
    //Will unlock when scope exits.
    QScopedPointer<KeyframeReorderLock> lock(new KeyframeReorderLock(this));
 
    if (node && !m_freezeKeyframePositions) {
        KisLayerUtils::recursiveApplyNodes (node, [affected, offset, cmd] (KisNodeSP node) {
                const int startFrame = affected.start();
                if (node->isAnimated()) {
                    Q_FOREACH(KisKeyframeChannel* keyframeChannel, node->keyframeChannels()) {
                        if (keyframeChannel) {
                            if (offset > 0) {
                                int timeIter = affected.isInfinite() ?
                                                        keyframeChannel->lastKeyframeTime()
                                                      : keyframeChannel->activeKeyframeTime(affected.end());
 
                                KisKeyframeSP iterEnd = keyframeChannel->keyframeAt(keyframeChannel->previousKeyframeTime(startFrame));
 
                                while (keyframeChannel->keyframeAt(timeIter) &&
                                       keyframeChannel->keyframeAt(timeIter) != iterEnd) {
                                    keyframeChannel->moveKeyframe(timeIter, timeIter + offset, cmd);
                                    timeIter = keyframeChannel->previousKeyframeTime(timeIter);
                                }
 
                            } else {
                                int timeIter = keyframeChannel->keyframeAt(startFrame) ? startFrame : keyframeChannel->nextKeyframeTime(startFrame);
 
                                KisKeyframeSP iterEnd = affected.isInfinite() ?
                                                            nullptr
                                                          : keyframeChannel->keyframeAt(keyframeChannel->nextKeyframeTime(affected.end()));
 
                                while (keyframeChannel->keyframeAt(timeIter) != iterEnd) {
                                    keyframeChannel->moveKeyframe(timeIter, timeIter + offset, cmd);
                                    timeIter = keyframeChannel->nextKeyframeTime(timeIter);
                                }
                            }
                        }
                    }
                }
            });
    }
}

References KisBaseNode::isAnimated(), m_freezeKeyframePositions, m_image, KisLayerUtils::recursiveApplyNodes(), KisImage::rootLayer(), and KisTimeSpan::start().

sigStoryboardItemListChanged

void StoryboardModel::sigStoryboardItemListChanged ( )

signal

This signal is emitted whenever m_items is changed. it is used to keep the StoryboardItemList in KisDocument in sync with m_items.

slotCommentDataChanged

void StoryboardModel::slotCommentDataChanged ( )

privateslot

Definition at line 1204 of file StoryboardModel.cpp.

{
    m_commentList = m_commentModel->m_commentList;
    emit(layoutChanged());
}

References StoryboardCommentModel::m_commentList, m_commentList, and m_commentModel.

slotCommentRowInserted

void StoryboardModel::slotCommentRowInserted ( const QModelIndex parent, int first, int last )

privateslot

Definition at line 1210 of file StoryboardModel.cpp.

{
    Q_UNUSED(parent);
    int numItems = rowCount();
    for(int row = 0; row < numItems; row++) {
        QModelIndex parentIndex = index(row, 0);
        insertRows(4 + first, last - first + 1, parentIndex);       //four indices are already there
    }
    slotCommentDataChanged();
}

References index(), insertRows(), parent(), rowCount(), and slotCommentDataChanged().

slotCommentRowMoved

void StoryboardModel::slotCommentRowMoved ( const QModelIndex & sourceParent, int sourceRow, int count, const QModelIndex & destinationParent, int destinationChild )

privateslot

Definition at line 1232 of file StoryboardModel.cpp.

{
    Q_UNUSED(sourceParent);
    Q_UNUSED(destinationParent);
    int numItems = rowCount();
    for(int row = 0; row < numItems; row++) {
        QModelIndex parentIndex = index(row, 0);
        moveRowsImpl(parentIndex, start + 4, end - start + 1, parentIndex, destinationRow + 4);
    }
    slotCommentDataChanged();
}

References index(), moveRowsImpl(), rowCount(), and slotCommentDataChanged().

slotCommentRowRemoved

void StoryboardModel::slotCommentRowRemoved ( const QModelIndex parent, int first, int last )

privateslot

Definition at line 1221 of file StoryboardModel.cpp.

{
    Q_UNUSED(parent);
    int numItems = rowCount();
    for(int row = 0; row < numItems; row++) {
        QModelIndex parentIndex = index(row, 0);
        removeRows(4 + first, last - first + 1, parentIndex);
    }
    slotCommentDataChanged();
}

References index(), parent(), removeRows(), rowCount(), and slotCommentDataChanged().

slotCurrentFrameChanged

void StoryboardModel::slotCurrentFrameChanged ( int frameId )

privateslot

called when currentUiTime changes

See also

KisImageAnimationInterface::sigUiTimeChanged(int)

Definition at line 1040 of file StoryboardModel.cpp.

{
    m_view->setCurrentItem(frameId);
}

References m_view, and StoryboardView::setCurrentItem().

slotFramerateChanged

void StoryboardModel::slotFramerateChanged ( )

privateslot

Definition at line 1097 of file StoryboardModel.cpp.

{
    QModelIndex sceneIndex = index(0,0);
    QModelIndex nextScene = index(1,0);
    if (nextScene.isValid()) {
 
        while (sceneIndex.isValid() && nextScene.isValid()) {
            StoryboardItemSP item = m_items.at(sceneIndex.row());
            const int nextSceneFrame = index(StoryboardItem::FrameNumber, 0, nextScene).data().toInt();
            const int sceneFrame = index(StoryboardItem::FrameNumber, 0, sceneIndex).data().toInt();
            const int duration = nextSceneFrame - sceneFrame;
            const int durationFrames = duration % getFramesPerSecond();
            const int durationSeconds = duration / getFramesPerSecond();
 
            item->child(StoryboardItem::DurationFrame)->setData(QVariant::fromValue<int>(durationFrames));
            item->child(StoryboardItem::DurationSecond)->setData(QVariant::fromValue<int>(durationSeconds));
 
            sceneIndex = nextScene;
            nextScene = index(sceneIndex.row() + 1, sceneIndex.column());
        }
 
        Q_EMIT dataChanged(index(0,0), sceneIndex);
    } else if (sceneIndex.isValid()) {
 
        StoryboardItemSP item = m_items.at(sceneIndex.row());
        const int lastKeyframe = lastKeyframeGlobal();
        const int sceneFrame = index(StoryboardItem::FrameNumber, 0, sceneIndex).data().toInt();
        const int duration = lastKeyframe + 1 - sceneFrame;
 
        const int durationFrames = duration % getFramesPerSecond();
        const int durationSeconds = duration / getFramesPerSecond();
 
        item->child(StoryboardItem::DurationFrame)->setData(QVariant::fromValue<int>(durationFrames));
        item->child(StoryboardItem::DurationSecond)->setData(QVariant::fromValue<int>(durationSeconds));
 
        Q_EMIT dataChanged(sceneIndex, sceneIndex);
    }
}

References StoryboardItem::DurationFrame, StoryboardItem::DurationSecond, StoryboardItem::FrameNumber, getFramesPerSecond(), index(), lastKeyframeGlobal(), and m_items.

slotFrameRenderCancelled

void StoryboardModel::slotFrameRenderCancelled ( int frame )

privateslot

called KisStoryboardThumbnailRenderScheduler when frame render is cancelled.

Definition at line 1199 of file StoryboardModel.cpp.

{
    Q_UNUSED(frame);
}

slotFrameRenderCompleted

void StoryboardModel::slotFrameRenderCompleted ( int frame, KisPaintDeviceSP dev )

privateslot

called KisStoryboardThumbnailRenderScheduler when frame render is complete

Parameters

frame	The frame whose regeneration was requested
dev	The projection of the frame

Definition at line 1191 of file StoryboardModel.cpp.

{
    QModelIndex index = indexFromFrame(frame);
    if (index.isValid()) {
        setThumbnailPixmapData(index, dev);
    }
}

References index(), indexFromFrame(), and setThumbnailPixmapData().

slotKeyframeAdded

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

privateslot

Definition at line 1045 of file StoryboardModel.cpp.

{
    if (m_reorderingKeyframes)
        return;
 
    const QModelIndex lastScene = lastIndexBeforeFrame(time);
    const QModelIndex nextScene = index( lastScene.row() + 1, 0);
    const bool extendsLastScene = lastScene.isValid() && !nextScene.isValid();
 
    //Capture new keyframes after last scene and extend duration to include the new key.
    if (extendsLastScene) {
        const int sceneStartFrame = index(StoryboardItem::FrameNumber, 0, lastScene).data().toInt();
        const int desiredDuration = time - sceneStartFrame + 1;
        const int actualDuration = data(lastScene, TotalSceneDurationInFrames).toInt();
        const int duration = qMax(actualDuration, desiredDuration);
        KIS_ASSERT(duration > 0);
        const QSharedPointer<StoryboardChild> frameElement = m_items.at(lastScene.row())->child(StoryboardItem::DurationFrame);
        const QSharedPointer<StoryboardChild> secondElement = m_items.at(lastScene.row())->child(StoryboardItem::DurationSecond);
        frameElement->setData(QVariant::fromValue<int>(duration % getFramesPerSecond()));
        secondElement->setData(QVariant::fromValue<int>(duration / getFramesPerSecond()));
 
        Q_EMIT dataChanged(lastScene, lastScene);
    }
 
    QModelIndexList affected = affectedIndexes(KisTimeSpan::fromTimeToTime(time, channel->nextKeyframeTime(time)));
    slotUpdateThumbnailsForItems(affected);
}

References affectedIndexes(), data(), StoryboardItem::DurationFrame, StoryboardItem::DurationSecond, StoryboardItem::FrameNumber, KisTimeSpan::fromTimeToTime(), getFramesPerSecond(), index(), KIS_ASSERT, lastIndexBeforeFrame(), m_items, m_reorderingKeyframes, KisKeyframeChannel::nextKeyframeTime(), slotUpdateThumbnailsForItems(), and TotalSceneDurationInFrames.

slotKeyframeRemoved

void StoryboardModel::slotKeyframeRemoved ( const KisKeyframeChannel * channel, int time )

privateslot

Definition at line 1073 of file StoryboardModel.cpp.

{
    if (m_reorderingKeyframes)
        return;
 
    QModelIndexList affected = affectedIndexes(KisTimeSpan::fromTimeToTime(channel->activeKeyframeTime(time), channel->nextKeyframeTime(time)));
    slotUpdateThumbnailsForItems(affected);
}

References KisKeyframeChannel::activeKeyframeTime(), affectedIndexes(), KisTimeSpan::fromTimeToTime(), m_reorderingKeyframes, KisKeyframeChannel::nextKeyframeTime(), and slotUpdateThumbnailsForItems().

slotNodeRemoved

void StoryboardModel::slotNodeRemoved ( KisNodeSP node )

privateslot

Definition at line 1082 of file StoryboardModel.cpp.

{ 
    if (node->isAnimated() && node->paintDevice() && node->paintDevice()->keyframeChannel()) {
        KisKeyframeChannel *channel = node->paintDevice()->keyframeChannel();
        int keyframeTime = channel->firstKeyframeTime();
        while (channel->keyframeAt(keyframeTime)) {
            //sigKeyframeRemoved is not emitted when parent node is deleted so calling explicitly
            slotKeyframeRemoved(channel, keyframeTime);
            keyframeTime = channel->nextKeyframeTime(keyframeTime);
        }
    }
 
    slotUpdateThumbnails();
}

References KisKeyframeChannel::firstKeyframeTime(), KisBaseNode::isAnimated(), KisKeyframeChannel::keyframeAt(), KisPaintDevice::keyframeChannel(), KisKeyframeChannel::nextKeyframeTime(), KisBaseNode::paintDevice(), slotKeyframeRemoved(), and slotUpdateThumbnails().

slotSetActiveNode

void StoryboardModel::slotSetActiveNode ( KisNodeSP node )

slot

Definition at line 632 of file StoryboardModel.cpp.

{
    m_activeNode = node;
}

References m_activeNode.

slotUpdateThumbnailForFrame

void StoryboardModel::slotUpdateThumbnailForFrame ( int frame, bool delay = true )

privateslot

calls regeneration of frame in the background i.e. in another thread.

Parameters

frame	The frame to be regenerated.
delay	Update thumbnail with delay if true

Definition at line 1136 of file StoryboardModel.cpp.

{
    Q_UNUSED(delay);
    if (!m_image) {
        return;
    }
 
    QModelIndex index = indexFromFrame(frame);
    bool affected = true;
    if (index.isValid() && !isLocked()) {
        m_renderScheduler->scheduleFrameForRegeneration(frame, affected);
        m_renderScheduler->slotStartFrameRendering();
    }
}

References index(), indexFromFrame(), isLocked(), m_image, m_renderScheduler, KisStoryboardThumbnailRenderScheduler::scheduleFrameForRegeneration(), and KisStoryboardThumbnailRenderScheduler::slotStartFrameRendering().

slotUpdateThumbnails

void StoryboardModel::slotUpdateThumbnails ( )

privateslot

calls regeneration of the currentUiTime() and all frames in affectedIndexes(KisTimeSpan)

Definition at line 1168 of file StoryboardModel.cpp.

{
    if (!m_image || isLocked()) {
        return;
    }
 
    int currentTime = m_image->animationInterface()->currentUITime();
    slotUpdateThumbnailForFrame(currentTime);
 
    KisTimeSpan affectedRange;
    if (m_activeNode) {
        affectedRange = KisTimeSpan::calculateAffectedFramesRecursive(m_activeNode, currentTime);
        QModelIndexList dirtyIndexes = affectedIndexes(affectedRange);
        foreach(QModelIndex index, dirtyIndexes) {
            int frame = this->index(StoryboardItem::FrameNumber, 0, index).data().toInt();
            slotUpdateThumbnailForFrame(frame);
        }
    }
    else {
        return;
    }
}

References affectedIndexes(), KisImage::animationInterface(), KisTimeSpan::calculateAffectedFramesRecursive(), KisImageAnimationInterface::currentUITime(), StoryboardItem::FrameNumber, index(), isLocked(), m_activeNode, m_image, and slotUpdateThumbnailForFrame().

slotUpdateThumbnailsForItems()

void StoryboardModel::slotUpdateThumbnailsForItems

(

QModelIndexList

indices

)

Definition at line 1151 of file StoryboardModel.cpp.

                                                                          {
    if (isLocked())
        return;
 
    Q_FOREACH( const QModelIndex& storyboardItemIndex, indices ) {
        if (!storyboardItemIndex.isValid())
            continue;
 
        //If this isn't a storyboard item (root) we will continue
        if (storyboardItemIndex.parent().isValid())
            continue;
 
        const int frame = index(StoryboardItem::FrameNumber, 0, storyboardItemIndex).data().toInt();
        slotUpdateThumbnailForFrame(frame, false);        
    }
}

References StoryboardItem::FrameNumber, index(), isLocked(), and slotUpdateThumbnailForFrame().

supportedDragActions()

Qt::DropActions StoryboardModel::supportedDragActions ( ) const

override

Definition at line 508 of file StoryboardModel.cpp.

{
    return Qt::CopyAction | Qt::MoveAction;
}

supportedDropActions()

Qt::DropActions StoryboardModel::supportedDropActions ( ) const

override

Definition at line 503 of file StoryboardModel.cpp.

{
    return Qt::CopyAction | Qt::MoveAction;
}

totalCommentCount()

int StoryboardModel::totalCommentCount

(

)

Get total number of comments.

Returns

Number of total comments.

Definition at line 524 of file StoryboardModel.cpp.

{
    return m_commentList.count();
}

References m_commentList.

updateDurationData()

bool StoryboardModel::updateDurationData

(

const QModelIndex &

parentIndex

)

updates the duration data of item at parentIndex to the number of frame to the next keyframe in any layer.

Parameters

parentIndex

The index whose duration is to be updated.

Returns

True if data was set

Note

If there are no keyframes after this index's frame duration is set to 0s 0f

Definition at line 295 of file StoryboardModel.cpp.

{
    if (!parentIndex.isValid()) {
        return false;
    }
 
    QModelIndex currentScene = parentIndex;
    QModelIndex nextScene = index(currentScene.row() + 1, 0);
    if (nextScene.isValid()) {
        const int currentSceneFrame = index(StoryboardItem::FrameNumber, 0, currentScene).data().toInt();
        const int nextSceneFrame = index(StoryboardItem::FrameNumber, 0, nextScene).data().toInt();
        const int sceneDuration = nextSceneFrame - currentSceneFrame;
        const int fps = getFramesPerSecond();
 
        if (index(StoryboardItem::DurationSecond, 0, parentIndex).data().toInt() != sceneDuration / fps) {
            setData (index (StoryboardItem::DurationSecond, 0, parentIndex), sceneDuration / fps);
        }
        if (index(StoryboardItem::DurationFrame, 0, parentIndex).data().toInt() != sceneDuration % fps) {
            setData (index (StoryboardItem::DurationFrame, 0, parentIndex), sceneDuration % fps);
        }
    }
 
    return true;
}

References data(), StoryboardItem::DurationFrame, StoryboardItem::DurationSecond, StoryboardItem::FrameNumber, getFramesPerSecond(), index(), and setData().

visibleCommentCount()

int StoryboardModel::visibleCommentCount

(

)

const

Used in StoryboardDelegate and StoryboardView to get size of one storyboard item.

Returns

Number of visible comments.

See also

StoryboardDelegate::sizeHint(QStyleOptionViewItem,QModelIndex)

StoryboardView::visualRect(QModelIndex)

Definition at line 513 of file StoryboardModel.cpp.

{
    int visibleComments = 0;
    foreach(StoryboardComment comment, m_commentList) {
        if (comment.visibility) {
            visibleComments++;
        }
    }
    return visibleComments;
}

References m_commentList, and StoryboardComment::visibility.

visibleCommentsUpto()

int StoryboardModel::visibleCommentsUpto

(

QModelIndex

index

)

const

Used in StoryboardView to design the layout of storyboard item.

Returns

Number of visible comments upto index.

See also

StoryboardView::visualRect(QModelIndex)

Definition at line 531 of file StoryboardModel.cpp.

{
    int commentRow = index.row() - 4;
    int visibleComments = 0;
    for (int row = 0; row < commentRow; row++) {
        if (m_commentList.at(row).visibility) {
            visibleComments++;
        }
    }
    return visibleComments;
}

References index(), and m_commentList.

visualizeScene()

void StoryboardModel::visualizeScene	(	const QModelIndex &	index,
		bool	useUndo = true )

Definition at line 1291 of file StoryboardModel.cpp.

{
    if (scene.parent().isValid() || !m_image) {
        return;
    }
 
    int frameTime = index(StoryboardItem::FrameNumber, 0, scene).data().toInt();
 
    if (frameTime != m_image->animationInterface()->currentTime()) {
        m_image->animationInterface()->switchCurrentTimeAsync(frameTime, useUndo ? KisImageAnimationInterface::STAO_USE_UNDO : KisImageAnimationInterface::STAO_NONE);
    }
}

References KisImage::animationInterface(), KisImageAnimationInterface::currentTime(), StoryboardItem::FrameNumber, index(), m_image, KisImageAnimationInterface::STAO_NONE, KisImageAnimationInterface::STAO_USE_UNDO, and KisImageAnimationInterface::switchCurrentTimeAsync().

Friends And Related Symbol Documentation

KisMoveStoryboardCommand

friend class KisMoveStoryboardCommand

friend

Definition at line 335 of file StoryboardModel.h.

Member Data Documentation

m_activeNode

KisNodeWSP StoryboardModel::m_activeNode

private

Definition at line 347 of file StoryboardModel.h.

m_commentList

QVector<StoryboardComment> StoryboardModel::m_commentList

private

Definition at line 338 of file StoryboardModel.h.

m_commentModel

StoryboardCommentModel* StoryboardModel::m_commentModel {0}

private

Definition at line 339 of file StoryboardModel.h.

{0};

m_freezeKeyframePositions

bool StoryboardModel::m_freezeKeyframePositions {false}

private

Definition at line 340 of file StoryboardModel.h.

{false};

m_image

KisImageWSP StoryboardModel::m_image

private

Definition at line 345 of file StoryboardModel.h.

m_imageIdleWatcher

KisIdleWatcher StoryboardModel::m_imageIdleWatcher

private

Definition at line 344 of file StoryboardModel.h.

m_items

StoryboardItemList StoryboardModel::m_items

private

Definition at line 337 of file StoryboardModel.h.

m_lastScene

int StoryboardModel::m_lastScene {0}

private

Definition at line 343 of file StoryboardModel.h.

{0};

m_lockBoards

bool StoryboardModel::m_lockBoards {false}

private

Definition at line 341 of file StoryboardModel.h.

{false};

m_renderScheduler

KisStoryboardThumbnailRenderScheduler* StoryboardModel::m_renderScheduler {0}

private

Definition at line 348 of file StoryboardModel.h.

{0};

m_renderSchedulingCompressor

KisSignalCompressor StoryboardModel::m_renderSchedulingCompressor

private

Definition at line 349 of file StoryboardModel.h.

m_reorderingKeyframes

bool StoryboardModel::m_reorderingKeyframes {false}

private

Definition at line 342 of file StoryboardModel.h.

{false};

m_view

StoryboardView* StoryboardModel::m_view {0}

private

Definition at line 346 of file StoryboardModel.h.

{0};

---

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

• plugins/dockers/storyboarddocker/StoryboardModel.h
• plugins/dockers/storyboarddocker/StoryboardModel.cpp