#include <KisAnimTimelineFramesModel.h>

Inheritance diagram for KisAnimTimelineFramesModel:

Classes
struct	NodeManipulationInterface

struct	Private

Public Types
enum	ItemDataRole { ActiveLayerRole = KisTimeBasedItemModel::UserRole , TimelinePropertiesRole , OtherLayersRole , PinnedToTimelineRole , FrameColorLabelIndexRole }

enum	MimeCopyPolicy { UndefinedPolicy = 0 , MoveFramesPolicy , CopyFramesPolicy , CloneFramesPolicy }

typedef TimelineNodeListKeeper::OtherLayer	OtherLayer

typedef TimelineNodeListKeeper::OtherLayersList	OtherLayersList

typedef KisBaseNode::Property	Property

typedef KisBaseNode::PropertyList	PropertyList

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

Public Slots
void	slotCurrentNodeChanged (KisNodeSP node)

Signals
void	requestCurrentNodeChanged (KisNodeSP node)

void	requestTransferSelectionBetweenRows (int rowFrom, int rowTo)

void	sigEnsureRowVisible (int row)

void	sigFullClipRangeChanged ()

void	sigInfiniteTimelineUpdateNeeded ()

Public Member Functions
int	activeLayerRow () const

QString	audioChannelFileName () const

qreal	audioVolume () const

bool	canDropFrameData (const QMimeData *data, const QModelIndex &index)

void	clearEntireCache ()

bool	copyFrame (const QModelIndex &dstIndex)

bool	createFrame (const QModelIndexList &dstIndex)

QVariant	data (const QModelIndex &index, int role) const override

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

bool	dropMimeDataExtended (const QMimeData data, Qt::DropAction action, const QModelIndex &parent, bool dataMoved=0)

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

bool	hasConnectionToCanvas () const

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

bool	insertFrames (int dstColumn, const QList< int > &dstRows, int count, int timing=1)

bool	insertHoldFrames (const QModelIndexList &selectedIndexes, int insertCount)

bool	insertOtherLayer (int index, int dstRow)

bool	insertRows (int row, int count, const QModelIndex &parent) override

bool	isAudioMuted () const

	KisAnimTimelineFramesModel (QObject *parent)

void	makeClonesUnique (const QModelIndexList &indices)

QMimeData *	mimeData (const QModelIndexList &indexes) const override

QMimeData *	mimeDataExtended (const QModelIndexList &indexes, const QModelIndex &baseIndex, MimeCopyPolicy copyPolicy) const

QStringList	mimeTypes () const override

KisNodeSP	nodeAt (QModelIndex index) const override

bool	removeRows (int row, int count, const QModelIndex &parent) override

int	rowCount (const QModelIndex &parent=QModelIndex()) const override

void	setActiveLayerSelectedTimes (const QSet< int > &times)

void	setAudioChannelFileName (const QFileInfo &fileName)

void	setAudioMuted (bool value)

void	setAudioVolume (qreal value)

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

void	setDocumentClipRangeEnd (int column)

void	setDocumentClipRangeStart (int column)

void	setDummiesFacade (KisDummiesFacadeBase dummiesFacade, KisImageSP image, KisNodeDisplayModeAdapter displayModeAdapter)

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

void	setLastClickedIndex (const QModelIndex &index)

void	setNodeManipulationInterface (NodeManipulationInterface *iface)

Qt::DropActions	supportedDragActions () const override

Qt::DropActions	supportedDropActions () const override

	~KisAnimTimelineFramesModel () override

Public Member Functions inherited from TimelineNodeListKeeper::ModelWithExternalNotifications
void	callBeginInsertRows (const QModelIndex &parent, int first, int last)

void	callBeginRemoveRows (const QModelIndex &parent, int first, int last)

void	callBeginResetModel ()

void	callEndInsertRows ()

void	callEndRemoveRows ()

void	callEndResetModel ()

void	callIndexChanged (const QModelIndex &index0, const QModelIndex &index1)

	ModelWithExternalNotifications (QObject *parent)

Public Member Functions inherited from KisTimeBasedItemModel
int	columnCount (const QModelIndex &parent=QModelIndex()) const override

int	currentTime () const

QVariant	data (const QModelIndex &index, int role) const override

KisDocument *	document () const

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

bool	isFrameCached (const int frame)

bool	isPlaybackActive () const

bool	isPlaybackPaused () const

bool	isScrubbing ()

	KisTimeBasedItemModel (QObject *parent)

bool	mirrorFrames (QModelIndexList indexes)

bool	removeFrames (const QModelIndexList &indexes)

bool	removeFramesAndOffset (QModelIndexList indicesToRemove)

void	scrubHorizontalHeaderUpdate (int activeHeader)

void	setAnimationPlayer (KisCanvasAnimationState *player)

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

void	setDocument (class KisDocument *document)

void	setFrameCache (KisAnimationFrameCacheSP cache)

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

void	setImage (KisImageWSP image)

void	setLastVisibleFrame (int time)

void	setPlaybackRange (const KisTimeSpan &range)

void	setScrubState (bool active)

void	stopPlayback () const

	~KisTimeBasedItemModel () override

Protected Member Functions
KisKeyframeChannel *	channelByID (QModelIndex index, const QString &id) const override

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

Protected Member Functions inherited from KisTimeBasedItemModel
int	cloneCount (const QModelIndex &index) const

bool	cloneOfActiveFrame (const QModelIndex &index) const

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

KisImageWSP	image () const

Private Slots
void	processUpdateQueue ()

void	slotDummyChanged (KisNodeDummy *dummy)

void	slotImageContentChanged ()

Private Attributes
const QScopedPointer< Private >	m_d

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

Detailed Description

Definition at line 45 of file KisAnimTimelineFramesModel.h.

Member Typedef Documentation

◆ OtherLayer

typedef TimelineNodeListKeeper::OtherLayer KisAnimTimelineFramesModel::OtherLayer

Definition at line 127 of file KisAnimTimelineFramesModel.h.

◆ OtherLayersList

typedef TimelineNodeListKeeper::OtherLayersList KisAnimTimelineFramesModel::OtherLayersList

Definition at line 128 of file KisAnimTimelineFramesModel.h.

◆ Property

typedef KisBaseNode::Property KisAnimTimelineFramesModel::Property

Definition at line 124 of file KisAnimTimelineFramesModel.h.

◆ PropertyList

typedef KisBaseNode::PropertyList KisAnimTimelineFramesModel::PropertyList

Definition at line 125 of file KisAnimTimelineFramesModel.h.

Member Enumeration Documentation

◆ ItemDataRole

enum KisAnimTimelineFramesModel::ItemDataRole

Enumerator
ActiveLayerRole
TimelinePropertiesRole
OtherLayersRole
PinnedToTimelineRole
FrameColorLabelIndexRole

Definition at line 114 of file KisAnimTimelineFramesModel.h.

    {
        ActiveLayerRole = KisTimeBasedItemModel::UserRole,
        TimelinePropertiesRole,
        OtherLayersRole,
        PinnedToTimelineRole,
        FrameColorLabelIndexRole
    };

◆ MimeCopyPolicy

enum KisAnimTimelineFramesModel::MimeCopyPolicy

Enumerator
UndefinedPolicy
MoveFramesPolicy
CopyFramesPolicy
CloneFramesPolicy

Definition at line 50 of file KisAnimTimelineFramesModel.h.

                        {
        UndefinedPolicy = 0,
        MoveFramesPolicy,
        CopyFramesPolicy,
        CloneFramesPolicy
    };

Constructor & Destructor Documentation

◆ KisAnimTimelineFramesModel()

KisAnimTimelineFramesModel::KisAnimTimelineFramesModel ( QObject * parent )

Definition at line 220 of file KisAnimTimelineFramesModel.cpp.

    : ModelWithExternalNotifications(parent),
      m_d(new Private)
{
    connect(&m_d->updateTimer, SIGNAL(timeout()), SLOT(processUpdateQueue()));
}

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

◆ ~KisAnimTimelineFramesModel()

KisAnimTimelineFramesModel::~KisAnimTimelineFramesModel ( )

override

Definition at line 227 of file KisAnimTimelineFramesModel.cpp.

228{

229}

Member Function Documentation

◆ activeLayerRow()

int KisAnimTimelineFramesModel::activeLayerRow ( ) const

Definition at line 862 of file KisAnimTimelineFramesModel.cpp.

{
    return m_d->activeLayerIndex;
}

References m_d.

◆ audioChannelFileName()

QString KisAnimTimelineFramesModel::audioChannelFileName ( ) const

Definition at line 1090 of file KisAnimTimelineFramesModel.cpp.

{
    if (document()) {
        QVector<QFileInfo> files = document()->getAudioTracks();
        if (files.count() > 0) {
            return files.first().baseName();
        }
    }
    return QString("");
}

References KisTimeBasedItemModel::document(), and KisDocument::getAudioTracks().

◆ audioVolume()

qreal KisAnimTimelineFramesModel::audioVolume ( ) const

Definition at line 1124 of file KisAnimTimelineFramesModel.cpp.

{
    if (document()) {
        return document()->getAudioLevel();
    } else {
        return 1.0;
    }
}

References KisTimeBasedItemModel::document(), and KisDocument::getAudioLevel().

◆ canDropFrameData()

bool KisAnimTimelineFramesModel::canDropFrameData	(	const QMimeData *	data,
		const QModelIndex &	index )

Now we support D&D around any layer, so just return 'true' all the time.

Definition at line 647 of file KisAnimTimelineFramesModel.cpp.

{
    if (!index.isValid()) return false;
 
    if ( !m_d->layerEditable(index.row()) ) return false;
 
    return true;
}

References m_d.

◆ channelByID()

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

overrideprotectedvirtual

Implements KisTimeBasedItemModel.

Definition at line 262 of file KisAnimTimelineFramesModel.cpp.

{
    KisNodeSP srcDummy = nodeAt(index);
 
    if (!srcDummy) {
        return nullptr;
    }
 
    return srcDummy->getKeyframeChannel(id);
}

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

◆ channelsAt()

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

overrideprotectedvirtual

Implements KisTimeBasedItemModel.

Definition at line 251 of file KisAnimTimelineFramesModel.cpp.

{
    KisNodeSP srcDummy = nodeAt(index);
 
    if (!srcDummy) {
        return {};
    }
 
    return srcDummy->keyframeChannels();
}

References KisBaseNode::keyframeChannels, and nodeAt().

◆ clearEntireCache()

void KisAnimTimelineFramesModel::clearEntireCache ( )

Definition at line 1149 of file KisAnimTimelineFramesModel.cpp.

{
    m_d->image->animationInterface()->invalidateFrames(KisTimeSpan::infinite(0), m_d->image->bounds());
}

References KisTimeSpan::infinite(), and m_d.

◆ copyFrame()

bool KisAnimTimelineFramesModel::copyFrame ( const QModelIndex & dstIndex )

Definition at line 899 of file KisAnimTimelineFramesModel.cpp.

{
    if (!dstIndex.isValid()) return false;
 
    return m_d->addKeyframe(dstIndex.row(), dstIndex.column(), true);
}

References m_d.

◆ createFrame()

bool KisAnimTimelineFramesModel::createFrame ( const QModelIndexList & dstIndex )

Definition at line 867 of file KisAnimTimelineFramesModel.cpp.

{
    QList<QPair<int,int>> selectedCells;
 
    Q_FOREACH(const QModelIndex &index, dstIndex){
        if (!index.isValid()) continue;
        selectedCells.append(QPair<int,int>(index.row(), index.column()));
    }
 
    if (selectedCells.size() == 0) {
        return false;
    }
 
    KUndo2Command *parentCommand = new KUndo2Command(kundo2_i18np("Add blank frame", "Add %1 blank frames", selectedCells.size()));
 
    Q_FOREACH (auto &cell, selectedCells) {
        KisNodeDummy *dummy = m_d->converter->dummyFromRow(cell.first);
        if (!dummy) continue;
 
        KisNodeSP node = dummy->node();
        if (!KisAnimUtils::supportsContentFrames(node)) continue;
 
        KisAnimUtils::createKeyframeCommand(m_d->image, node, KisKeyframeChannel::Raster.id(), cell.second, false, parentCommand);
    }
 
    KisProcessingApplicator::runSingleCommandStroke(m_d->image, parentCommand,
                                                    KisStrokeJobData::BARRIER,
                                                    KisStrokeJobData::EXCLUSIVE);
 
    return true;
}

References KisStrokeJobData::BARRIER, KisAnimUtils::createKeyframeCommand(), KisStrokeJobData::EXCLUSIVE, KoID::id(), kundo2_i18np(), m_d, KisNodeDummy::node(), KisKeyframeChannel::Raster, KisProcessingApplicator::runSingleCommandStroke(), and KisAnimUtils::supportsContentFrames().

◆ data()

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

override

Definition at line 393 of file KisAnimTimelineFramesModel.cpp.

{
    if(!m_d->dummiesFacade) return QVariant();
 
    switch (role) {
        case ActiveLayerRole: {
            return index.row() == m_d->activeLayerIndex;
        }
        case FrameEditableRole: {
            return m_d->layerEditable(index.row());
        }
        case FrameHasContent: {
            return m_d->frameHasContent(index.row(), index.column());
        }
        case FrameExistsRole: {
            return m_d->frameExists(index.row(), index.column());
        }
        case SpecialKeyframeExists: {
            return m_d->specialKeyframeExists(index.row(), index.column());
        }
        case FrameColorLabelIndexRole: {
            int label = m_d->frameColorLabel(index.row(), index.column());
            return label > 0 ? label : QVariant();
        }
        case Qt::DisplayRole: {
            return m_d->layerName(index.row());
        }
        case Qt::TextAlignmentRole: {
            return QVariant(Qt::AlignHCenter | Qt::AlignVCenter);
        }
        case Qt::UserRole + KisAbstractResourceModel::LargeThumbnail: {
            KisNodeDummy *dummy = m_d->converter->dummyFromRow(index.row());
            if (!dummy) {
                return  QVariant();
            }
            const int maxSize = 200;
 
            QImage image(dummy->node()->createThumbnailForFrame(maxSize, maxSize, index.column(), Qt::KeepAspectRatio));
            return image;
        }
    }
 
    return ModelWithExternalNotifications::data(index, role);
}

References ActiveLayerRole, KisBaseNode::createThumbnailForFrame(), FrameColorLabelIndexRole, KisTimeBasedItemModel::FrameEditableRole, KisTimeBasedItemModel::FrameExistsRole, KisTimeBasedItemModel::FrameHasContent, KisTimeBasedItemModel::image(), KisAbstractResourceModel::LargeThumbnail, m_d, KisNodeDummy::node(), and KisTimeBasedItemModel::SpecialKeyframeExists.

◆ dropMimeData()

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

override

Definition at line 660 of file KisAnimTimelineFramesModel.cpp.

{
    Q_UNUSED(row);
    Q_UNUSED(column);
 
    return dropMimeDataExtended(data, action, parent);
}

References data(), and dropMimeDataExtended().

◆ dropMimeDataExtended()

bool KisAnimTimelineFramesModel::dropMimeDataExtended	(	const QMimeData *	data,
		Qt::DropAction	action,
		const QModelIndex &	parent,
		bool *	dataMoved = 0 )

Definition at line 668 of file KisAnimTimelineFramesModel.cpp.

{
    bool result = false;
 
    if ((action != Qt::MoveAction && action != Qt::CopyAction && action != Qt::LinkAction) ||
        !parent.isValid()) return result;
 
    QByteArray encoded = data->data("application/x-krita-frame");
    QDataStream stream(&encoded, QIODevice::ReadOnly);
 
    int uuidLenRoot = 0;
    stream >> uuidLenRoot;
    QByteArray uuidDataRoot(uuidLenRoot, '\0');
    stream.readRawData(uuidDataRoot.data(), uuidLenRoot);
    QUuid nodeUuidRoot = QUuid::fromRfc4122(uuidDataRoot);
 
    KisPart *partInstance = KisPart::instance();
    QList<QPointer<KisDocument>> documents = partInstance->documents();
 
    KisImageSP srcImage = 0;
    Q_FOREACH(KisDocument *doc, documents) {
        KisImageSP tmpSrcImage = doc->image();
        if (tmpSrcImage->root()->uuid() == nodeUuidRoot) {
            srcImage = tmpSrcImage;
            break;
        }
    }
 
    if (!srcImage) {
        KisPart *kisPartInstance = KisPart::instance();
        kisPartInstance->currentMainwindow()->viewManager()->showFloatingMessage(
                    i18n("Dropped frames are not available in this Krita instance")
                    , QIcon());
        return false;
    }
 
    int size, baseRow, baseColumn;
    stream >> size >> baseRow >> baseColumn;
 
    const QPoint offset(parent.column() - baseColumn, parent.row() - baseRow);
    KisAnimUtils::FrameMovePairList frameMoves;
    int necessaryOffset = 0;  //Necessary offset to keep move above 0, used later.
 
    for (int i = 0; i < size; i++) {
        int relRow, relColumn;
        stream >> relRow >> relColumn;
 
        const int srcRow = baseRow + relRow;
        const int srcColumn = baseColumn + relColumn;
 
        int uuidLen = 0;
        stream >> uuidLen;
        QByteArray uuidData(uuidLen, '\0');
        stream.readRawData(uuidData.data(), uuidLen);
        QUuid nodeUuid = QUuid::fromRfc4122(uuidData);
 
        KisNodeSP srcNode;
 
        if (!nodeUuid.isNull()) {
            KisNodeUuidInfo nodeInfo(nodeUuid);
            srcNode = nodeInfo.findNode(srcImage->root());
        } else {
            QModelIndex index = this->index(srcRow, srcColumn);
            srcNode = nodeAt(index);
        }
 
        KIS_SAFE_ASSERT_RECOVER(srcNode) { continue; }
 
        const QModelIndex dstRowIndex = this->index(srcRow + offset.y(), 0);
        if (!dstRowIndex.isValid()) continue;
 
        KisNodeSP dstNode = nodeAt(dstRowIndex);
        KIS_SAFE_ASSERT_RECOVER(dstNode) { continue; }
 
        Q_FOREACH (KisKeyframeChannel *channel, srcNode->keyframeChannels().values()) {
            KisAnimUtils::FrameItem srcItem(srcNode, channel->id(), srcColumn);
            KisAnimUtils::FrameItem dstItem(dstNode, channel->id(), srcColumn + offset.x());
 
            if ((srcColumn + offset.x()) * -1 > necessaryOffset ) {
                necessaryOffset = (srcColumn + offset.x()) * -1;
            }
 
            frameMoves << std::make_pair(srcItem, dstItem);
        }
    }
 
    MimeCopyPolicy copyPolicy = UndefinedPolicy;
 
    if (!stream.atEnd()) {
        int value = 0;
        stream >> value;
        copyPolicy = MimeCopyPolicy(value);
    }
 
    const bool copyFrames = copyPolicy == UndefinedPolicy ?
        action == Qt::CopyAction :
        copyPolicy == CopyFramesPolicy;
 
    const bool cloneFrames = action == Qt::LinkAction || copyPolicy == CloneFramesPolicy;
 
    if (dataMoved) {
        *dataMoved = !copyFrames;
    }
 
    KUndo2Command *cmd = 0;
 
    if (!frameMoves.isEmpty()) {
 
        // We need to make sure that no movement ever occurs into the negative values.
        // TODO: Probably a better way to fix this, I'm not happy with this fix.
        if (necessaryOffset > 0) {
            for (int i = 0; i < frameMoves.count(); i++){
                frameMoves[i].second.time += necessaryOffset;
            }
        }
 
        KisImageBarrierLock lock(m_d->image);
 
        if (cloneFrames) {
            cmd = KisAnimUtils::createCloneKeyframesCommand(frameMoves, nullptr);
        } else {
            cmd = KisAnimUtils::createMoveKeyframesCommand(frameMoves, copyFrames, false, nullptr);
        }
    }
 
    if (cmd) {
        KisProcessingApplicator::runSingleCommandStroke(m_d->image, cmd,
                                                        KisStrokeJobData::BARRIER,
                                                        KisStrokeJobData::EXCLUSIVE);
    }
 
    return cmd;
}

References KisStrokeJobData::BARRIER, CloneFramesPolicy, CopyFramesPolicy, KisAnimUtils::createCloneKeyframesCommand(), KisAnimUtils::createMoveKeyframesCommand(), KisPart::currentMainwindow(), data(), KisPart::documents, KisStrokeJobData::EXCLUSIVE, KisNodeUuidInfo::findNode(), KisKeyframeChannel::id(), KisDocument::image, KisPart::instance(), KisBaseNode::keyframeChannels, KIS_SAFE_ASSERT_RECOVER, m_d, nodeAt(), KisNodeFacade::root, KisProcessingApplicator::runSingleCommandStroke(), KisViewManager::showFloatingMessage(), UndefinedPolicy, KisBaseNode::uuid(), value(), and KisMainWindow::viewManager.

◆ flags()

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

override

Basically we should forbid overrides only if we D&D a single frame and allow it when we D&D multiple frames. But we cannot distinguish it here... So allow all the time.

Definition at line 802 of file KisAnimTimelineFramesModel.cpp.

{
    Qt::ItemFlags flags = ModelWithExternalNotifications::flags(index);
    if (!index.isValid()) return flags;
 
    if (m_d->frameExists(index.row(), index.column()) || m_d->specialKeyframeExists(index.row(), index.column())) {
        if (data(index, FrameEditableRole).toBool()) {
            flags |= Qt::ItemIsDragEnabled;
        }
    }
 
    flags |= Qt::ItemIsDropEnabled;
 
    return flags;
}

References data(), flags(), KisTimeBasedItemModel::FrameEditableRole, and m_d.

◆ hasConnectionToCanvas()

bool KisAnimTimelineFramesModel::hasConnectionToCanvas ( ) const

Definition at line 231 of file KisAnimTimelineFramesModel.cpp.

{
    return m_d->dummiesFacade;
}

References m_d.

◆ headerData()

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

override

Definition at line 472 of file KisAnimTimelineFramesModel.cpp.

{
    if(!m_d->dummiesFacade) return QVariant();
 
    if (orientation == Qt::Vertical) {
        switch (role) {
            case ActiveLayerRole:
                return section == m_d->activeLayerIndex;
            case Qt::DisplayRole: {
                QVariant value = headerData(section, orientation, Qt::ToolTipRole);
                if (!value.isValid()) return value;
 
                QString name = value.toString();
                const int maxNameSize = 13;
 
                if (name.size() > maxNameSize) {
                    name = QString("%1...").arg(name.left(maxNameSize));
                }
 
                return name;
            }
            case Qt::ForegroundRole: {
                // WARNING: this role doesn't work for header views! Use
                //          bold font to show isolated mode instead!
                return QVariant();
            }
            case Qt::FontRole: {
                KisNodeDummy *dummy = m_d->converter->dummyFromRow(section);
                if (!dummy) return QVariant();
                KisNodeSP node = dummy->node();
 
                QFont baseFont;
                if (node->projectionLeaf()->isDroppedNode()) {
                    baseFont.setStrikeOut(true);
                } else if (m_d->image && m_d->image->isolationRootNode() &&
                           KisNodeModel::belongsToIsolatedGroup(m_d->image, node, m_d->dummiesFacade)) {
                    baseFont.setBold(true);
                }
                return baseFont;
            }
            case Qt::ToolTipRole: {
                return m_d->layerName(section);
            }
            case TimelinePropertiesRole: {
                return QVariant::fromValue(m_d->layerProperties(section));
            }
            case OtherLayersRole: {
                TimelineNodeListKeeper::OtherLayersList list =
                    m_d->converter->otherLayersList();
 
                return QVariant::fromValue(list);
            }
            case PinnedToTimelineRole: {
                KisNodeDummy *dummy = m_d->converter->dummyFromRow(section);
                if (!dummy) return QVariant();
                return dummy->node()->isPinnedToTimeline();
            }
            case Qt::BackgroundRole: {
                int label = m_d->layerColorLabel(section);
                if (label > 0) {
                    KisNodeViewColorScheme scm;
                    QColor color = scm.colorFromLabelIndex(label);
                    QPalette pal = qApp->palette();
                    color = KisPaintingTweaks::blendColors(color, pal.color(QPalette::Button), 0.3);
                    return QBrush(color);
                } else {
                    return QVariant();
                }
            }
        }
    }
 
    return ModelWithExternalNotifications::headerData(section, orientation, role);
}

References ActiveLayerRole, KisNodeModel::belongsToIsolatedGroup(), KisPaintingTweaks::blendColors(), KisNodeViewColorScheme::colorFromLabelIndex(), headerData(), KisBaseNode::isPinnedToTimeline(), m_d, KisNodeDummy::node(), OtherLayersRole, PinnedToTimelineRole, KisNode::projectionLeaf, TimelinePropertiesRole, and value().

◆ insertFrames()

bool KisAnimTimelineFramesModel::insertFrames	(	int	dstColumn,
		const QList< int > &	dstRows,
		int	count,
		int	timing = 1 )

Definition at line 920 of file KisAnimTimelineFramesModel.cpp.

{
    if (dstRows.isEmpty() || count <= 0) return true;
    timing = qMax(timing, 1);
 
    KUndo2Command *parentCommand = new KUndo2Command(kundo2_i18np("Insert frame", "Insert %1 frames", count));
 
    {
        KisImageBarrierLock locker(m_d->image);
 
        QModelIndexList indexes;
 
        Q_FOREACH (int row, dstRows) {
            for (int column = dstColumn; column < columnCount(); column++) {
                indexes << index(row, column);
            }
        }
 
        setLastVisibleFrame(columnCount() + (count * timing) - 1);
 
        createOffsetFramesCommand(indexes, QPoint((count * timing), 0), false, false, parentCommand);
 
        Q_FOREACH (int row, dstRows) {
            KisNodeDummy *dummy = m_d->converter->dummyFromRow(row);
            if (!dummy) continue;
 
            KisNodeSP node = dummy->node();
            if (!KisAnimUtils::supportsContentFrames(node)) continue;
 
            for (int column = dstColumn; column < dstColumn + (count * timing); column += timing) {
                KisAnimUtils::createKeyframeCommand(m_d->image, node, KisKeyframeChannel::Raster.id(), column, false, parentCommand);
            }
        }
 
        const int oldTime = m_d->image->animationInterface()->currentUITime();
        const int newTime = dstColumn > oldTime ? dstColumn : dstColumn + (count * timing) - 1;
 
        new KisSwitchCurrentTimeCommand(m_d->image->animationInterface(),
                                        oldTime,
                                        newTime, parentCommand);
    }
 
    KisProcessingApplicator::runSingleCommandStroke(m_d->image, parentCommand,
                                                    KisStrokeJobData::BARRIER,
                                                    KisStrokeJobData::EXCLUSIVE);
 
    return true;
}

References KisStrokeJobData::BARRIER, KisTimeBasedItemModel::columnCount(), KisAnimUtils::createKeyframeCommand(), KisTimeBasedItemModel::createOffsetFramesCommand(), KisStrokeJobData::EXCLUSIVE, KoID::id(), kundo2_i18np(), m_d, KisNodeDummy::node(), KisKeyframeChannel::Raster, KisProcessingApplicator::runSingleCommandStroke(), KisTimeBasedItemModel::setLastVisibleFrame(), and KisAnimUtils::supportsContentFrames().

◆ insertHoldFrames()

bool KisAnimTimelineFramesModel::insertHoldFrames	(	const QModelIndexList &	selectedIndexes,
		int	insertCount )

Definition at line 969 of file KisAnimTimelineFramesModel.cpp.

{
    if (selectedIndexes.isEmpty() || insertCount == 0) return true;
 
    QScopedPointer<KUndo2Command> parentCommand(new KUndo2Command(kundo2_i18np("Insert frame", "Insert %1 frames", insertCount)));
 
    {
        KisImageBarrierLock locker(m_d->image);
 
        // Find Keyframes in selection...
        QSet<TimelineSelectionEntry> uniqueKeyframesInSelection;
        int earliestAffectedTime = std::numeric_limits<int>::max();
 
        Q_FOREACH (const QModelIndex &index, selectedIndexes) {
            KisNodeSP node = nodeAt(index);
            KIS_SAFE_ASSERT_RECOVER(node) { continue; }
 
            KisRasterKeyframeChannel *channel = dynamic_cast<KisRasterKeyframeChannel*>(node->getKeyframeChannel(KisKeyframeChannel::Raster.id()));
            if (!channel) continue;
 
            earliestAffectedTime = qMin(earliestAffectedTime, index.column()); // Earliest of selection... (to be continued.)
 
            int time = channel->activeKeyframeTime(index.column());
            KisRasterKeyframeSP keyframe = channel->activeKeyframeAt<KisRasterKeyframe>(index.column());
 
            if (keyframe) {
                uniqueKeyframesInSelection.insert(TimelineSelectionEntry{channel, time, keyframe});
            }
        }
 
        // Determine which keyframes need to move and sort by time...
        QList<TimelineSelectionEntry> keyframesToMove;
 
        for (auto it = uniqueKeyframesInSelection.begin(); it != uniqueKeyframesInSelection.end(); ++it) {
            TimelineSelectionEntry keyframeEntry = *it;
 
            KisRasterKeyframeChannel *channel = keyframeEntry.channel;
            int nextKeyframeTime = channel->nextKeyframeTime(keyframeEntry.time);
            KisRasterKeyframeSP nextKeyframe = channel->keyframeAt<KisRasterKeyframe>(nextKeyframeTime);
 
            if (nextKeyframe) {
                keyframesToMove << TimelineSelectionEntry{ channel, nextKeyframeTime, nextKeyframe };
            }
        }
 
        std::sort(keyframesToMove.begin(), keyframesToMove.end(),
            [] (TimelineSelectionEntry lhs, TimelineSelectionEntry rhs) {
                return lhs.time > rhs.time;
            });
 
        if (keyframesToMove.isEmpty()) return true;
 
        const int oldTime = m_d->image->animationInterface()->currentUITime();
        const int maxColumn = columnCount();
 
        // Store the original active keyframe, so we can switch to its new time at the end.
        // (This helps to keep artist drawing on the right keyframe even while adding and removing hold frames.)
        QModelIndex activeIndex = index(m_d->activeLayerIndex, oldTime);
        KisNodeSP activeNode = nodeAt(activeIndex);
        KisRasterKeyframeChannel *activeChannel = dynamic_cast<KisRasterKeyframeChannel*>(activeNode->getKeyframeChannel(KisKeyframeChannel::Raster.id()));
 
        KisRasterKeyframeSP originalActiveKeyframe = nullptr;
        if (activeChannel) {
            originalActiveKeyframe = activeChannel->activeKeyframeAt<KisRasterKeyframe>(oldTime);
        }
 
        // Create keyframe movement commands...
        if (insertCount > 0) {
            setLastVisibleFrame(columnCount() + insertCount);
        }
 
        Q_FOREACH (TimelineSelectionEntry entry, keyframesToMove) {
            int plannedFrameMove = insertCount;
 
            if (insertCount < 0) {
                KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(entry.time > 0, false);
 
                int prevKeyframeTime = entry.channel->previousKeyframeTime(entry.time);
                KisRasterKeyframeSP prevFrame = entry.channel->keyframeAt<KisRasterKeyframe>(prevKeyframeTime);
                KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(prevFrame, false);
 
                // Clamp values so that they never exceed or overlap the previous frame
                plannedFrameMove = qMax(insertCount, prevKeyframeTime - entry.time + 1);
 
                earliestAffectedTime = qMin(earliestAffectedTime, prevKeyframeTime); // No longer limited to selection.
            }
 
            KisNodeDummy *dummy = m_d->dummiesFacade->dummyForNode(entry.channel->node());
            KIS_SAFE_ASSERT_RECOVER(dummy) { continue; }
 
            const int row = m_d->converter->rowForDummy(dummy);
            KIS_SAFE_ASSERT_RECOVER(row >= 0) { continue; }
 
            QModelIndexList indices;
            for (int column = entry.time; column < maxColumn; column++) {
                indices << index(row, column);
            }
 
            createOffsetFramesCommand(indices,
                                      QPoint(plannedFrameMove, 0),
                                      false,
                                      true,
                                      parentCommand.data());
        }
 
        if (originalActiveKeyframe) {
        new KisSwitchCurrentTimeToKeyframeCommand(m_d->image->animationInterface(),
                                        oldTime,
                                        activeNode,
                                        KisKeyframeChannel::Raster,
                                        originalActiveKeyframe,
                                        parentCommand.data());
        }
    }
 
    KisProcessingApplicator::runSingleCommandStroke(m_d->image, parentCommand.take(),
                                                    KisStrokeJobData::BARRIER,
                                                    KisStrokeJobData::EXCLUSIVE);
    return true;
}

References KisKeyframeChannel::activeKeyframeAt(), KisKeyframeChannel::activeKeyframeTime(), KisStrokeJobData::BARRIER, TimelineSelectionEntry::channel, KisTimeBasedItemModel::columnCount(), KisTimeBasedItemModel::createOffsetFramesCommand(), KisStrokeJobData::EXCLUSIVE, KisBaseNode::getKeyframeChannel(), KisKeyframeChannel::keyframeAt(), KIS_SAFE_ASSERT_RECOVER, KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, kundo2_i18np(), m_d, KisKeyframeChannel::nextKeyframeTime(), KisKeyframeChannel::node(), nodeAt(), KisKeyframeChannel::previousKeyframeTime(), KisKeyframeChannel::Raster, KisProcessingApplicator::runSingleCommandStroke(), KisTimeBasedItemModel::setLastVisibleFrame(), and TimelineSelectionEntry::time.

◆ insertOtherLayer()

bool KisAnimTimelineFramesModel::insertOtherLayer	(	int	index,
		int	dstRow )

Definition at line 846 of file KisAnimTimelineFramesModel.cpp.

{
    Q_UNUSED(dstRow);
 
    TimelineNodeListKeeper::OtherLayersList list =
        m_d->converter->otherLayersList();
 
    if (index < 0 || index >= list.size()) return false;
 
    list[index].dummy->node()->setPinnedToTimeline(true);
    dstRow = m_d->converter->rowForDummy(list[index].dummy);
    setData(this->index(dstRow, 0), true, ActiveLayerRole);
 
    return true;
}

References ActiveLayerRole, m_d, and setData().

◆ insertRows()

bool KisAnimTimelineFramesModel::insertRows	(	int	row,
		int	count,
		const QModelIndex &	parent )

override

Definition at line 823 of file KisAnimTimelineFramesModel.cpp.

{
    Q_UNUSED(parent);
 
    KIS_ASSERT_RECOVER(count == 1) { return false; }
 
    if (row < 0 || row > rowCount()) return false;
 
    bool result = m_d->addNewLayer(row);
    return result;
}

References KIS_ASSERT_RECOVER, m_d, and rowCount().

◆ isAudioMuted()

bool KisAnimTimelineFramesModel::isAudioMuted ( ) const

Definition at line 1113 of file KisAnimTimelineFramesModel.cpp.

{
    return KisPart::instance()->playbackEngine()->isMute();
}

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

◆ makeClonesUnique()

void KisAnimTimelineFramesModel::makeClonesUnique ( const QModelIndexList & indices )

Definition at line 906 of file KisAnimTimelineFramesModel.cpp.

{
    KisAnimUtils::FrameItemList frameItems;
 
    Q_FOREACH (const QModelIndex &index, indices) {
        const int time = index.column();
        KisKeyframeChannel *channel = channelByID(index, KisKeyframeChannel::Raster.id());
        if (!channel) continue;
        frameItems << KisAnimUtils::FrameItem(channel->node(), channel->id(), time);
    }
 
    KisAnimUtils::makeClonesUnique(m_d->image, frameItems);
}

References channelByID(), KisKeyframeChannel::id(), m_d, KisAnimUtils::makeClonesUnique(), KisKeyframeChannel::node(), and KisKeyframeChannel::Raster.

◆ mimeData()

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

override

Definition at line 598 of file KisAnimTimelineFramesModel.cpp.

{
    return mimeDataExtended(indexes, m_d->lastClickedIndex, UndefinedPolicy);
}

References m_d, mimeDataExtended(), and UndefinedPolicy.

◆ mimeDataExtended()

QMimeData * KisAnimTimelineFramesModel::mimeDataExtended	(	const QModelIndexList &	indexes,
		const QModelIndex &	baseIndex,
		KisAnimTimelineFramesModel::MimeCopyPolicy	copyPolicy ) const

Definition at line 603 of file KisAnimTimelineFramesModel.cpp.

{
    QMimeData *data = new QMimeData();
 
    QByteArray encoded;
    QDataStream stream(&encoded, QIODevice::WriteOnly);
 
    const int baseRow = baseIndex.row();
    const int baseColumn = baseIndex.column();
 
    const QByteArray uuidDataRoot = m_d->image->root()->uuid().toRfc4122();
    stream << int(uuidDataRoot.size());
    stream.writeRawData(uuidDataRoot.data(), uuidDataRoot.size());
 
    stream << indexes.size();
    stream << baseRow << baseColumn;
 
    Q_FOREACH (const QModelIndex &index, indexes) {
        KisNodeSP node = nodeAt(index);
        KIS_SAFE_ASSERT_RECOVER(node) { continue; }
 
        stream << index.row() - baseRow << index.column() - baseColumn;
 
        const QByteArray uuidData = node->uuid().toRfc4122();
        stream << int(uuidData.size());
        stream.writeRawData(uuidData.data(), uuidData.size());
    }
 
    stream << int(copyPolicy);
    data->setData("application/x-krita-frame", encoded);
 
    return data;
}

References data(), KIS_SAFE_ASSERT_RECOVER, m_d, nodeAt(), and KisBaseNode::uuid().

◆ mimeTypes()

QStringList KisAnimTimelineFramesModel::mimeTypes ( ) const

override

Definition at line 586 of file KisAnimTimelineFramesModel.cpp.

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

◆ nodeAt()

KisNodeSP KisAnimTimelineFramesModel::nodeAt ( QModelIndex index ) const

overridevirtual

The dummy might not exist because the user could (quickly) change active layer and the list of the nodes in m_d->converter will change.

Implements KisTimeBasedItemModel.

Definition at line 241 of file KisAnimTimelineFramesModel.cpp.

{
    KisNodeDummy *dummy = m_d->converter->dummyFromRow(index.row());
    return dummy ? dummy->node() : nullptr;
}

References m_d, and KisNodeDummy::node().

◆ processUpdateQueue

void KisAnimTimelineFramesModel::processUpdateQueue ( )

privateslot

Definition at line 328 of file KisAnimTimelineFramesModel.cpp.

{
    if (!m_d->converter) return;
 
    Q_FOREACH (KisNodeDummy *dummy, m_d->updateQueue) {
        int row = m_d->converter->rowForDummy(dummy);
 
        if (row >= 0) {
            Q_EMIT headerDataChanged (Qt::Vertical, row, row);
            Q_EMIT dataChanged(this->index(row, 0), this->index(row, columnCount() - 1));
        }
    }
    m_d->updateQueue.clear();
}

References KisTimeBasedItemModel::columnCount(), and m_d.

◆ removeRows()

bool KisAnimTimelineFramesModel::removeRows	(	int	row,
		int	count,
		const QModelIndex &	parent )

override

Definition at line 835 of file KisAnimTimelineFramesModel.cpp.

{
    Q_UNUSED(parent);
    KIS_ASSERT_RECOVER(count == 1) { return false; }
 
    if (row < 0 || row >= rowCount()) return false;
 
    bool result = m_d->removeLayer(row);
    return result;
}

References KIS_ASSERT_RECOVER, m_d, and rowCount().

◆ requestCurrentNodeChanged

void KisAnimTimelineFramesModel::requestCurrentNodeChanged ( KisNodeSP node )

signal

◆ requestTransferSelectionBetweenRows

void KisAnimTimelineFramesModel::requestTransferSelectionBetweenRows	(	int	rowFrom,
		int	rowTo )

signal

◆ rowCount()

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

override

Definition at line 385 of file KisAnimTimelineFramesModel.cpp.

{
    Q_UNUSED(parent);
    if(!m_d->dummiesFacade) return 0;
 
    return m_d->converter->rowCount();
}

References m_d.

◆ setActiveLayerSelectedTimes()

void KisAnimTimelineFramesModel::setActiveLayerSelectedTimes ( const QSet< int > & times )

Definition at line 1154 of file KisAnimTimelineFramesModel.cpp.

{
    if (!m_d->image) return;
 
    m_d->image->animationInterface()->setActiveLayerSelectedTimes(times);
}

References m_d.

◆ setAudioChannelFileName()

void KisAnimTimelineFramesModel::setAudioChannelFileName ( const QFileInfo & fileName )

Definition at line 1101 of file KisAnimTimelineFramesModel.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(document());
 
    QVector<QFileInfo> tracks;
    if (fileName.exists()) {
        tracks << fileName;
    }
 
    document()->setAudioTracks(tracks);
}

References KisTimeBasedItemModel::document(), KIS_SAFE_ASSERT_RECOVER_RETURN, and KisDocument::setAudioTracks().

◆ setAudioMuted()

void KisAnimTimelineFramesModel::setAudioMuted ( bool value )

Definition at line 1118 of file KisAnimTimelineFramesModel.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->image);
    KisPart::instance()->playbackEngine()->setMute(value);
}

References KisPart::instance(), KIS_SAFE_ASSERT_RECOVER_RETURN, m_d, KisPart::playbackEngine, and value().

◆ setAudioVolume()

void KisAnimTimelineFramesModel::setAudioVolume ( qreal value )

Definition at line 1133 of file KisAnimTimelineFramesModel.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(document());
    document()->setAudioVolume(value);
}

References KisTimeBasedItemModel::document(), KIS_SAFE_ASSERT_RECOVER_RETURN, KisDocument::setAudioVolume(), and value().

◆ setData()

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

override

Definition at line 438 of file KisAnimTimelineFramesModel.cpp.

{
    if (!index.isValid() || !m_d->dummiesFacade) return false;
 
    switch (role) {
        case ActiveLayerRole: {
            if (value.toBool() &&
                index.row() != m_d->activeLayerIndex) {
                int prevLayer = m_d->activeLayerIndex;
                m_d->activeLayerIndex = index.row();
 
                Q_EMIT dataChanged(this->index(prevLayer, 0), this->index(prevLayer, columnCount() - 1));
                Q_EMIT dataChanged(this->index(m_d->activeLayerIndex, 0), this->index(m_d->activeLayerIndex, columnCount() - 1));
 
                Q_EMIT headerDataChanged(Qt::Vertical, prevLayer, prevLayer);
                Q_EMIT headerDataChanged(Qt::Vertical, m_d->activeLayerIndex, m_d->activeLayerIndex);
 
                KisNodeDummy *dummy = m_d->converter->dummyFromRow(m_d->activeLayerIndex);
                KIS_ASSERT_RECOVER(dummy) { return true; }
 
                Q_EMIT requestCurrentNodeChanged(dummy->node());
                Q_EMIT sigEnsureRowVisible(m_d->activeLayerIndex);
            }
            break;
        }
        case FrameColorLabelIndexRole: {
            m_d->setFrameColorLabel(index.row(), index.column(), value.toInt());
        }
            break;
    }
 
    return ModelWithExternalNotifications::setData(index, value, role);
}

References ActiveLayerRole, KisTimeBasedItemModel::columnCount(), FrameColorLabelIndexRole, KIS_ASSERT_RECOVER, m_d, KisNodeDummy::node(), requestCurrentNodeChanged(), sigEnsureRowVisible(), and value().

◆ setDocumentClipRangeEnd()

void KisAnimTimelineFramesModel::setDocumentClipRangeEnd ( int column )

Definition at line 1144 of file KisAnimTimelineFramesModel.cpp.

{
    m_d->image->animationInterface()->setDocumentRangeEndFrame(column);
}

References m_d.

◆ setDocumentClipRangeStart()

void KisAnimTimelineFramesModel::setDocumentClipRangeStart ( int column )

Definition at line 1139 of file KisAnimTimelineFramesModel.cpp.

{
    m_d->image->animationInterface()->setDocumentRangeStartFrame(column);
}

References m_d.

◆ setDummiesFacade()

void KisAnimTimelineFramesModel::setDummiesFacade	(	KisDummiesFacadeBase *	dummiesFacade,
		KisImageSP	image,
		KisNodeDisplayModeAdapter *	displayModeAdapter )

Definition at line 273 of file KisAnimTimelineFramesModel.cpp.

{
    KisDummiesFacadeBase *oldDummiesFacade = m_d->dummiesFacade;
 
    if (m_d->dummiesFacade && m_d->image) {
        m_d->image->animationInterface()->disconnect(this);
        m_d->image->disconnect(this);
        m_d->dummiesFacade->disconnect(this);
    }
 
    m_d->image = image;
    KisTimeBasedItemModel::setImage(image);
 
    m_d->dummiesFacade = dummiesFacade;
    m_d->converter.reset();
 
    if (m_d->dummiesFacade) {
        m_d->converter.reset(new TimelineNodeListKeeper(this, m_d->dummiesFacade, displayModeAdapter));
        connect(m_d->dummiesFacade, SIGNAL(sigDummyChanged(KisNodeDummy*)), this, SLOT(slotDummyChanged(KisNodeDummy*)));
        connect(m_d->image->animationInterface(), SIGNAL(sigPlaybackRangeChanged()), this, SIGNAL(sigInfiniteTimelineUpdateNeeded()));
        connect(m_d->image, SIGNAL(sigImageModified()), this, SLOT(slotImageContentChanged()));
        connect(m_d->image, SIGNAL(sigIsolatedModeChanged()), this, SLOT(slotImageContentChanged()));
    }
 
    if (m_d->dummiesFacade != oldDummiesFacade) {
        beginResetModel();
        endResetModel();
    }
 
    if (m_d->dummiesFacade) {
        Q_EMIT sigInfiniteTimelineUpdateNeeded();
        slotCurrentTimeChanged(m_d->image->animationInterface()->currentUITime());
    }
}

References KisImage::animationInterface(), connect(), KisImageAnimationInterface::image(), KisDummiesFacadeBase::image(), KisTimeBasedItemModel::image(), m_d, KisTimeBasedItemModel::setImage(), sigInfiniteTimelineUpdateNeeded(), KisTimeBasedItemModel::slotCurrentTimeChanged(), slotDummyChanged(), and slotImageContentChanged().

◆ setHeaderData()

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

override

Definition at line 547 of file KisAnimTimelineFramesModel.cpp.

{
    if (!m_d->dummiesFacade) return false;
 
    if (orientation == Qt::Vertical) {
        switch (role) {
            case ActiveLayerRole: {
                setData(index(section, 0), value, role);
                break;
            }
            case TimelinePropertiesRole: {
                KisAnimTimelineFramesModel::PropertyList props = value.value<KisAnimTimelineFramesModel::PropertyList>();
 
                int result = m_d->setLayerProperties(section, props);
                Q_EMIT headerDataChanged (Qt::Vertical, section, section);
                return result;
            }
            case PinnedToTimelineRole: {
                KisNodeDummy *dummy = m_d->converter->dummyFromRow(section);
                if (!dummy) return false;
                dummy->node()->setPinnedToTimeline(value.toBool());
                return true;
            }
        }
    }
 
    return ModelWithExternalNotifications::setHeaderData(section, orientation, value, role);
}

References ActiveLayerRole, m_d, KisNodeDummy::node(), PinnedToTimelineRole, setData(), KisBaseNode::setPinnedToTimeline(), TimelinePropertiesRole, and value().

◆ setLastClickedIndex()

void KisAnimTimelineFramesModel::setLastClickedIndex ( const QModelIndex & index )

Definition at line 593 of file KisAnimTimelineFramesModel.cpp.

{
    m_d->lastClickedIndex = index;
}

References m_d.

◆ setNodeManipulationInterface()

void KisAnimTimelineFramesModel::setNodeManipulationInterface ( NodeManipulationInterface * iface )

NOTE: the model has an ownership over the interface, that is it'll be deleted automatically later

Definition at line 236 of file KisAnimTimelineFramesModel.cpp.

{
    m_d->nodeInterface.reset(iface);
}

References m_d.

◆ sigEnsureRowVisible

void KisAnimTimelineFramesModel::sigEnsureRowVisible ( int row )

signal

◆ sigFullClipRangeChanged

void KisAnimTimelineFramesModel::sigFullClipRangeChanged ( )

signal

◆ sigInfiniteTimelineUpdateNeeded

void KisAnimTimelineFramesModel::sigInfiniteTimelineUpdateNeeded ( )

signal

◆ slotCurrentNodeChanged

void KisAnimTimelineFramesModel::slotCurrentNodeChanged ( KisNodeSP node )

slot

Definition at line 343 of file KisAnimTimelineFramesModel.cpp.

{    
    if (!node) {
        m_d->activeLayerIndex = -1;
        return;
    }
 
    KisNodeDummy *dummy = m_d->dummiesFacade->dummyForNode(node);
    if (!dummy) {
        // It's perfectly normal that dummyForNode returns 0; that happens
        // when views get activated while Krita is closing down.
        return;
    }
    
    int lastActiveLayerIndex = m_d->activeLayerIndex;
    const bool prevActiveWasPinned = headerData(m_d->activeLayerIndex, Qt::Vertical, PinnedToTimelineRole).toBool();
    m_d->converter->updateActiveDummy(dummy);
 
    const int row = m_d->converter->rowForDummy(dummy);
    if (row < 0) {
        qWarning() << "WARNING: TimelineFramesModel::slotCurrentNodeChanged: node not found!";
    }
 
    if (row >= 0 && m_d->activeLayerIndex != row) {
        setData(index(row, 0), true, ActiveLayerRole);
    } else if (row >= 0 ){
        sigEnsureRowVisible(row);
        
        // If the activeLayerIndex is considered to be the same "row", but the last one was pinned,
        // it means that the previousActiveLayer has actually moved down the list because a new
        // layer was inserted.
        if (prevActiveWasPinned) {
            lastActiveLayerIndex += 1;
        }
    }
    
    // NOTE: Not in love with exposing 'selection' concepts to the model,
    // but since this issue already existed, this is alright for now.
    // Especially since it's just a signal...
    requestTransferSelectionBetweenRows(lastActiveLayerIndex, m_d->activeLayerIndex);
}

References ActiveLayerRole, headerData(), m_d, PinnedToTimelineRole, requestTransferSelectionBetweenRows(), setData(), and sigEnsureRowVisible().

◆ slotDummyChanged

void KisAnimTimelineFramesModel::slotDummyChanged ( KisNodeDummy * dummy )

privateslot

Definition at line 310 of file KisAnimTimelineFramesModel.cpp.

{
    if (!m_d->updateQueue.contains(dummy)) {
        m_d->updateQueue.append(dummy);
    }
    m_d->updateTimer.start();
}

References m_d.

◆ slotImageContentChanged

void KisAnimTimelineFramesModel::slotImageContentChanged ( )

privateslot

Definition at line 318 of file KisAnimTimelineFramesModel.cpp.

{
    if (m_d->activeLayerIndex < 0) return;
 
    KisNodeDummy *dummy = m_d->converter->dummyFromRow(m_d->activeLayerIndex);
    if (!dummy) return;
 
    slotDummyChanged(dummy);
}

References m_d, and slotDummyChanged().

◆ supportedDragActions()

Qt::DropActions KisAnimTimelineFramesModel::supportedDragActions ( ) const

override

Definition at line 576 of file KisAnimTimelineFramesModel.cpp.

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

◆ supportedDropActions()

Qt::DropActions KisAnimTimelineFramesModel::supportedDropActions ( ) const

override

Definition at line 581 of file KisAnimTimelineFramesModel.cpp.

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

Member Data Documentation

◆ m_d

const QScopedPointer<Private> KisAnimTimelineFramesModel::m_d

private

Definition at line 165 of file KisAnimTimelineFramesModel.h.

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

plugins/dockers/animation/KisAnimTimelineFramesModel.h
plugins/dockers/animation/KisAnimTimelineFramesModel.cpp

Classes

Public Types

Public Slots

Signals

Public Member Functions

Protected Member Functions

Private Slots

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ OtherLayer

◆ OtherLayersList

◆ Property

◆ PropertyList

Member Enumeration Documentation

◆ ItemDataRole

◆ MimeCopyPolicy

Constructor & Destructor Documentation

◆ KisAnimTimelineFramesModel()

◆ ~KisAnimTimelineFramesModel()

Member Function Documentation

◆ activeLayerRow()

◆ audioChannelFileName()

◆ audioVolume()

◆ canDropFrameData()

◆ channelByID()

◆ channelsAt()

◆ clearEntireCache()

◆ copyFrame()

◆ createFrame()

◆ data()

◆ dropMimeData()

◆ dropMimeDataExtended()

◆ flags()

◆ hasConnectionToCanvas()

◆ headerData()

◆ insertFrames()

◆ insertHoldFrames()

◆ insertOtherLayer()

◆ insertRows()

◆ isAudioMuted()

◆ makeClonesUnique()

◆ mimeData()

◆ mimeDataExtended()

◆ mimeTypes()

◆ nodeAt()

◆ processUpdateQueue

◆ removeRows()

◆ requestCurrentNodeChanged

◆ requestTransferSelectionBetweenRows

◆ rowCount()

◆ setActiveLayerSelectedTimes()

◆ setAudioChannelFileName()

◆ setAudioMuted()

◆ setAudioVolume()

◆ setData()

◆ setDocumentClipRangeEnd()

◆ setDocumentClipRangeStart()

◆ setDummiesFacade()

◆ setHeaderData()

◆ setLastClickedIndex()

◆ setNodeManipulationInterface()

◆ sigEnsureRowVisible

◆ sigFullClipRangeChanged

◆ sigInfiniteTimelineUpdateNeeded

◆ slotCurrentNodeChanged

◆ slotDummyChanged

◆ slotImageContentChanged

◆ supportedDragActions()

◆ supportedDropActions()

Member Data Documentation

◆ m_d