QRect KisRasterKeyframeChannel::affectedRect(KisKeyframeSP key)
{
KeyframesMap::iterator it = keys().find(key->time());
QRect rect;
// Calculate changed area as the union of the current and previous keyframe.
// This makes sure there are no artifacts left over from the previous frame
// where the new one doesn't cover the area.
if (it == keys().begin()) {
// Using the *next* keyframe at the start of the timeline avoids artifacts
// when deleting or moving the first key
it++;
} else {
it--;
}
if (it != keys().end()) {
rect = m_d->paintDevice->framesInterface()->frameBounds(it.value()->value());
}
rect |= m_d->paintDevice->framesInterface()->frameBounds(key->value());
if (m_d->onionSkinsEnabled) {
const QRect dirtyOnionSkinsRect =
KisOnionSkinCompositor::instance()->calculateFullExtent(m_d->paintDevice);
rect |= dirtyOnionSkinsRect;
}
return rect;
}
KisKeyframeSP KisRasterKeyframeChannel::loadKeyframe(const QDomElement &keyframeNode)
{
int time = keyframeNode.attribute("time").toUInt();
QPoint offset;
KisDomUtils::loadValue(keyframeNode, "offset", &offset);
QString frameFilename = keyframeNode.attribute("frame");
KisKeyframeSP keyframe;
if (m_d->frameFilenames.isEmpty()) {
// First keyframe loaded: use the existing frame
Q_ASSERT(keyframeCount() == 1);
keyframe = constKeys().begin().value();
// Remove from keys. It will get reinserted with new time once we return
keys().remove(keyframe->time());
keyframe->setTime(time);
m_d->paintDevice->move(offset);
} else {
KUndo2Command tempCommand;
int frameId = m_d->paintDevice->framesInterface()->createFrame(false, 0, offset, &tempCommand);
keyframe = toQShared(new KisKeyframe(this, time, frameId));
}
setFrameFilename(keyframe->value(), frameFilename);
return keyframe;
}
void KisRasterKeyframeChannel::importFrame(int time, KisPaintDeviceSP sourceDevice, KUndo2Command *parentCommand)
{
KisKeyframeSP keyframe = addKeyframe(time, parentCommand);
const int frameId = keyframe->value();
m_d->paintDevice->framesInterface()->uploadFrame(frameId, sourceDevice);
}
void KisScalarKeyframeChannel::destroyKeyframe(KisKeyframeSP key, KUndo2Command *parentCommand)
{
int index = key->value();
KIS_ASSERT_RECOVER_RETURN(m_d->values.contains(index));
KUndo2Command *cmd = new Private::InsertValueCommand(m_d.data(), index, m_d->values[index], false, parentCommand);
cmd->redo();
}
KisKeyframeSP KisRasterKeyframeChannel::createKeyframe(int time, const KisKeyframeSP copySrc, KUndo2Command *parentCommand)
{
int srcFrame = (copySrc != 0) ? copySrc->value() : 0;
int frameId = m_d->paintDevice->framesInterface()->createFrame((copySrc != 0), srcFrame, QPoint(), parentCommand);
KisKeyframeSP keyframe(new KisKeyframe(this, time, (quint32)frameId));
return keyframe;
}
void KisScalarKeyframeChannel::setScalarValue(KisKeyframeSP keyframe, qreal value, KUndo2Command *parentCommand)
{
QScopedPointer<KUndo2Command> tempCommand;
if (!parentCommand) {
tempCommand.reset(new KUndo2Command());
parentCommand = tempCommand.data();
}
int index = keyframe->value();
KUndo2Command *cmd = new Private::SetValueCommand(m_d.data(), index, m_d->values[index], value, parentCommand);
cmd->redo();
}
void KisRasterKeyframeChannel::saveKeyframe(KisKeyframeSP keyframe, QDomElement keyframeElement, const QString &layerFilename)
{
int frameId = keyframe->value();
QString filename = frameFilename(frameId);
if (filename.isEmpty()) {
filename = chooseFrameFilename(frameId, layerFilename);
}
keyframeElement.setAttribute("frame", filename);
QPoint offset = m_d->paintDevice->framesInterface()->frameOffset(frameId);
KisDomUtils::saveValue(&keyframeElement, "offset", offset);
}
void KisRasterKeyframeChannel::uploadExternalKeyframe(KisKeyframeChannel *srcChannel, int srcTime, KisKeyframeSP dstFrame)
{
KisRasterKeyframeChannel *srcRasterChannel = dynamic_cast<KisRasterKeyframeChannel*>(srcChannel);
KIS_ASSERT_RECOVER_RETURN(srcRasterChannel);
const int srcId = srcRasterChannel->frameIdAt(srcTime);
const int dstId = dstFrame->value();
m_d->paintDevice->framesInterface()->
uploadFrame(srcId,
dstId,
srcRasterChannel->m_d->paintDevice);
}
void KisScalarKeyframeChannel::uploadExternalKeyframe(KisKeyframeChannel *srcChannel, int srcTime, KisKeyframeSP dstFrame)
{
KisScalarKeyframeChannel *srcScalarChannel = dynamic_cast<KisScalarKeyframeChannel*>(srcChannel);
KIS_ASSERT_RECOVER_RETURN(srcScalarChannel);
KisKeyframeSP srcFrame = srcScalarChannel->keyframeAt(srcTime);
KIS_ASSERT_RECOVER_RETURN(srcFrame);
const qreal newValue = scalarValue(srcFrame);
const int dstId = dstFrame->value();
KIS_ASSERT_RECOVER_RETURN(m_d->values.contains(dstId));
m_d->values[dstId] = newValue;
}
QRect KisRasterKeyframeChannel::frameExtents(KisKeyframeSP keyframe)
{
return m_d->paintDevice->framesInterface()->frameBounds(keyframe->value());
}
void KisRasterKeyframeChannel::fetchFrame(KisKeyframeSP keyframe, KisPaintDeviceSP targetDevice)
{
m_d->paintDevice->framesInterface()->fetchFrame(keyframe->value(), targetDevice);
}
int KisRasterKeyframeChannel::frameIdAt(int time) const
{
KisKeyframeSP key = activeKeyframeAt(time);
return key->value();
}
void KisRasterKeyframeChannel::destroyKeyframe(KisKeyframeSP key, KUndo2Command *parentCommand)
{
m_d->paintDevice->framesInterface()->deleteFrame(key->value(), parentCommand);
}
qreal KisScalarKeyframeChannel::scalarValue(const KisKeyframeSP keyframe) const
{
return m_d->values[keyframe->value()];
}
void KisScalarKeyframeChannel::saveKeyframe(KisKeyframeSP keyframe, QDomElement keyframeElement, const QString &layerFilename)
{
Q_UNUSED(layerFilename);
keyframeElement.setAttribute("value", m_d->values[keyframe->value()]);
}
