void KisDummiesFacadeBase::setImage(KisImageWSP image)
{
if (m_d->image) {
emit sigActivateNode(0);
m_d->image->disconnect(this);
KisNodeDummy *rootDummy = this->rootDummy();
if(rootDummy) {
slotRemoveNode(rootDummy->node());
}
}
m_d->image = image;
if (image) {
slotNodeAdded(image->root());
connect(image, SIGNAL(sigNodeAddedAsync(KisNodeSP)),
SLOT(slotNodeAdded(KisNodeSP)), Qt::DirectConnection);
connect(image, SIGNAL(sigRemoveNodeAsync(KisNodeSP)),
SLOT(slotRemoveNode(KisNodeSP)), Qt::DirectConnection);
connect(image, SIGNAL(sigLayersChangedAsync()),
SLOT(slotLayersChanged()), Qt::DirectConnection);
connect(image, SIGNAL(sigNodeChanged(KisNodeSP)),
SLOT(slotNodeChanged(KisNodeSP)));
connect(image, SIGNAL(sigNodeAddedAsync(KisNodeSP)),
SLOT(slotNodeActivationRequested(KisNodeSP)), Qt::AutoConnection);
emit sigActivateNode(findFirstLayer(image->root()));
}
}
bool setLayerProperties(int row, PropertyList props) {
KisNodeDummy *dummy = converter->dummyFromRow(row);
if (!dummy) return false;
KisNodePropertyListCommand::setNodePropertiesNoUndo(dummy->node(), image, props);
return true;
}
QVariant layerProperties(int row) const {
KisNodeDummy *dummy = converter->dummyFromRow(row);
if (!dummy) return QVariant();
PropertyList props = dummy->node()->sectionModelProperties();
return QVariant::fromValue(props);
}
KisNodeSP KisNodeModel::nodeFromIndex(const QModelIndex &index) const
{
Q_ASSERT(index.isValid());
KisNodeDummy *dummy = m_d->indexConverter->dummyFromIndex(index);
return dummy->node();
}
int KisModelIndexConverterShowAll::rowCount(QModelIndex parent)
{
if(!parent.isValid()) return 1;
KisNodeDummy *parentDummy = dummyFromIndex(parent);
return parentDummy->childCount();
}
bool removeLayer(int row) {
KisNodeDummy *dummy = converter->dummyFromRow(row);
if (!dummy) return false;
if (nodeInterface) {
nodeInterface->removeNode(dummy->node());
}
return true;
}
void KisNodeDummiesGraph::unmapDummyRecursively(KisNodeDummy *dummy)
{
m_dummiesMap.remove(dummy->node());
KisNodeDummy *child = dummy->firstChild();
while(child) {
unmapDummyRecursively(child);
child = child->nextSibling();
}
}
bool frameExists(int row, int column) const {
KisNodeDummy *dummy = converter->dummyFromRow(row);
if (!dummy) return false;
KisKeyframeChannel *content =
dummy->node()->getKeyframeChannel(KisKeyframeChannel::Content.id());
if (!content) return false;
KisKeyframeSP frame = content->keyframeAt(column);
return frame;
}
KisNodeDummy* KisModelIndexConverterShowAll::dummyFromRow(int row, QModelIndex parent)
{
Q_ASSERT(parent.isValid() || !row);
if(!parent.isValid()) return m_dummiesFacade->rootDummy();
KisNodeDummy *parentDummy = dummyFromIndex(parent);
int rowCount = parentDummy->childCount();
int index = rowCount - row - 1;
return parentDummy->at(index);
}
void KisDummiesFacadeBase::slotContinueAddNode(KisNodeSP node, KisNodeSP parent, KisNodeSP aboveThis)
{
KisNodeDummy *parentDummy = parent ? dummyForNode(parent) : 0;
KisNodeDummy *aboveThisDummy = aboveThis ? dummyForNode(aboveThis) : 0;
// Add one because this node does not exist yet
int index = parentDummy && aboveThisDummy ?
parentDummy->indexOf(aboveThisDummy) + 1 : 0;
emit sigBeginInsertDummy(parentDummy, index, node->metaObject()->className(), node->isAnimated());
addNodeImpl(node, parent, aboveThis);
emit sigEndInsertDummy(dummyForNode(node));
}
QModelIndex KisModelIndexConverterShowAll::indexFromDummy(KisNodeDummy *dummy)
{
int row = 0;
KisNodeDummy *parentDummy = dummy->parent();
if(parentDummy) {
int rowCount = parentDummy->childCount();
int index = parentDummy->indexOf(dummy);
row = rowCount - index - 1;
}
return m_model->createIndex(row, 0, (void*)dummy);
}
void findOtherLayers(KisNodeDummy *root,
TimelineNodeListKeeper::OtherLayersList *list,
const QString &prefix)
{
KisNodeSP node = root->node();
if (root->parent() && !node->useInTimeline()) {
*list <<
TimelineNodeListKeeper::OtherLayer(
QString(prefix + node->name()),
root);
}
KisNodeDummy *dummy = root->lastChild();
while(dummy) {
findOtherLayers(dummy, list, prefix + " ");
dummy = dummy->prevSibling();
}
}
bool KisNodeModel::belongsToIsolatedGroup(KisImageSP image, KisNodeSP node, KisDummiesFacadeBase *dummiesFacade)
{
KisNodeSP isolatedRoot = image->isolatedModeRoot();
if (!isolatedRoot) return true;
KisNodeDummy *isolatedRootDummy =
dummiesFacade->dummyForNode(isolatedRoot);
KisNodeDummy *dummy =
dummiesFacade->dummyForNode(node);
while (dummy) {
if (dummy == isolatedRootDummy) {
return true;
}
dummy = dummy->parent();
}
return false;
}
KisNodeDummy* TimelineFramesIndexConverter::findNodeFromRow(KisNodeDummy *root, int &startCount)
{
if (isDummyVisible(root)) {
if (!startCount) {
return root;
}
startCount--;
}
KisNodeDummy *dummy = root->lastChild();
while (dummy) {
KisNodeDummy *found = findNodeFromRow(dummy, startCount);
if (found) return found;
dummy = dummy->prevSibling();
}
return 0;
}
bool TimelineFramesIndexConverter::calcNodesInPath(KisNodeDummy *root, int &startCount, KisNodeDummy *endDummy)
{
if (isDummyVisible(root)) {
if (endDummy && root == endDummy) {
return true;
}
startCount++;
}
KisNodeDummy *dummy = root->lastChild();
while (dummy) {
if (calcNodesInPath(dummy, startCount, endDummy)) {
return true;
}
dummy = dummy->prevSibling();
}
return false;
}
bool layerEditable(int row) const {
KisNodeDummy *dummy = converter->dummyFromRow(row);
if (!dummy) return true;
return dummy->node()->visible() && !dummy->node()->userLocked();
}
QVariant layerName(int row) const {
KisNodeDummy *dummy = converter->dummyFromRow(row);
if (!dummy) return QVariant();
return dummy->node()->name();
}
bool addKeyframe(int row, int column, bool copy) {
KisNodeDummy *dummy = converter->dummyFromRow(row);
if (!dummy) return false;
return KisAnimationUtils::createKeyframeLazy(image, dummy->node(), column, copy);
}