Krita Source Code Documentation
Loading...
Searching...
No Matches
kis_layer_utils.cpp
Go to the documentation of this file.
1/*
2 * SPDX-FileCopyrightText: 2015 Dmitry Kazakov <dimula73@gmail.com>
3 *
4 * SPDX-License-Identifier: GPL-2.0-or-later
5 */
6
7#include "kis_layer_utils.h"
8
9#include <algorithm>
10
11#include <QUuid>
12#include <KoColorSpaceConstants.h>
13#include <KoProperties.h>
14
15#include "kis_painter.h"
16#include "kis_image.h"
17#include "kis_node.h"
18#include "kis_layer.h"
19#include "kis_paint_layer.h"
20#include "kis_clone_layer.h"
21#include "kis_group_layer.h"
22#include "kis_selection.h"
23#include "kis_selection_mask.h"
24#include "kis_meta_data_merge_strategy.h"
25#include <kundo2command.h>
26#include "commands/kis_image_layer_add_command.h"
27#include "commands/kis_image_layer_remove_command.h"
28#include "commands/kis_image_layer_move_command.h"
29#include "commands/kis_image_change_layers_command.h"
30#include "commands_new/kis_activate_selection_mask_command.h"
31#include "commands/kis_image_change_visibility_command.h"
32#include "kis_abstract_projection_plane.h"
33#include "kis_processing_applicator.h"
34#include "kis_image_animation_interface.h"
35#include "kis_keyframe_channel.h"
36#include "kis_raster_keyframe_channel.h"
37#include "kis_projection_leaf.h"
38#include "kis_scalar_keyframe_channel.h"
39#include "kis_time_span.h"
40#include "kis_command_utils.h"
41#include "commands_new/kis_change_projection_color_command.h"
42#include "kis_layer_properties_icons.h"
43#include "lazybrush/kis_colorize_mask.h"
44#include "commands/kis_node_property_list_command.h"
45#include "commands/kis_node_compositeop_command.h"
46#include <KisDelayedUpdateNodeInterface.h>
47#include <KisCroppedOriginalLayerInterface.h>
48#include "krita_utils.h"
49#include "kis_image_signal_router.h"
50#include "kis_sequential_iterator.h"
51#include "kis_transparency_mask.h"
52#include "kis_paint_device_frames_interface.h"
53#include "kis_command_ids.h"
54#include "kis_image_config.h"
55#include "KisFutureUtils.h"
56#include "KisBatchUpdateLayerModificationCommand.h"
57#include "commands_new/KisChangeCloneLayersCommand.h"
58
59
60namespace KisLayerUtils {
61
62namespace Private {
63 void refreshHiddenAreaAsync(KisImageSP image, KisNodeSP rootNode, const QRect &preparedArea, const QRect &extraUpdateRect);
64}
65
66 void fetchSelectionMasks(KisNodeList mergedNodes, QVector<KisSelectionMaskSP> &selectionMasks)
67 {
68 foreach (KisNodeSP node, mergedNodes) {
69
70 Q_FOREACH(KisNodeSP child, node->childNodes(QStringList("KisSelectionMask"), KoProperties())) {
71
72 KisSelectionMaskSP mask = qobject_cast<KisSelectionMask*>(child.data());
73 if (mask) {
74 selectionMasks.append(mask);
75 }
76 }
77 }
78 }
79
80 struct MergeDownInfoBase {
81 MergeDownInfoBase(KisImageSP _image)
82 : image(_image),
83 storage(new SwitchFrameCommand::SharedStorage())
84 {
85 }
86
87 virtual ~MergeDownInfoBase() {}
88
89 KisImageWSP image;
90
91 QVector<KisSelectionMaskSP> selectionMasks;
92
93 KisNodeSP dstNode;
94 KisPaintLayerSP rasterizedDstLayer; // is non-null when merging takes a rasterization path
95
96 SwitchFrameCommand::SharedStorageSP storage;
97 QSet<int> frames;
98 bool pinnedToTimeline = false;
99 bool enableOnionSkins = false;
100
101 virtual KisNodeList allSrcNodes() = 0;
102
103 KisLayerSP dstLayer() {
104 return qobject_cast<KisLayer*>(dstNode.data());
105 }
106 };
107
108 struct SplitAlphaToMaskInfo {
109 SplitAlphaToMaskInfo(KisImageSP _image, KisNodeSP _node, const QString& maskName)
110 : image(_image)
111 , node(_node)
112 , storage(new SwitchFrameCommand::SharedStorage())
113 {
114 frames = fetchLayerFramesRecursive(_node);
115 mask = new KisTransparencyMask(image, maskName);
116 }
117
118 KisImageWSP image;
119 KisNodeSP node;
120 SwitchFrameCommand::SharedStorageSP storage;
121 QSet<int> frames;
122
126
127 KisMaskSP getMask() {
128 return mask;
129 }
130
131 KisLayerSP getLayer() {
132 return qobject_cast<KisLayer*>(node.data());
133 }
134
135 private:
136 KisTransparencyMaskSP mask;
137
138 };
139
140 struct MergeDownInfo : public MergeDownInfoBase {
141 MergeDownInfo(KisImageSP _image,
142 KisLayerSP _prevLayer,
143 KisLayerSP _currLayer,
144 MergeFlags flags)
145 : MergeDownInfoBase(_image),
146 prevLayer(_prevLayer),
147 currLayer(_currLayer)
148 {
149 if (!flags.testFlag(SkipMergingFrames)) {
150 frames = fetchLayerFramesRecursive(prevLayer) |
151 fetchLayerFramesRecursive(currLayer);
152 }
153
160 if (!frames.isEmpty() && !currLayer->isAnimated()) {
161 frames.insert(image->animationInterface()->currentTime());
162 }
163
164 pinnedToTimeline = prevLayer->isPinnedToTimeline() || currLayer->isPinnedToTimeline();
165
166 const KisPaintLayer *paintLayer = qobject_cast<KisPaintLayer*>(currLayer.data());
167 if (paintLayer) enableOnionSkins |= paintLayer->onionSkinEnabled();
168
169 paintLayer = qobject_cast<KisPaintLayer*>(prevLayer.data());
170 if (paintLayer) enableOnionSkins |= paintLayer->onionSkinEnabled();
171 }
172
173 KisLayerSP prevLayer;
174 KisLayerSP currLayer;
175
176 KisNodeList allSrcNodes() override {
177 KisNodeList mergedNodes;
178 mergedNodes << prevLayer;
179 mergedNodes << currLayer;
180 return mergedNodes;
181 }
182 };
183
184 struct ConvertToPaintLayerInfo {
185 ConvertToPaintLayerInfo(KisImageSP image, KisNodeSP node)
186 : storage(new SwitchFrameCommand::SharedStorage())
187 , m_sourceNode(node)
188 , m_image(image)
189 , m_pinnedToTimeline(false)
190 {
191 m_frames = fetchLayerFramesRecursive(node);
192
193 m_pinnedToTimeline = node->isPinnedToTimeline();
194
195 m_sourcePaintDevice =
196 m_sourceNode->paintDevice() ? m_sourceNode->projection() : m_sourceNode->original();
197
198 m_compositeOp = m_sourceNode->projectionLeaf()->isLayer() ? m_sourceNode->compositeOpId() : COMPOSITE_OVER;
199
200 KisColorizeMask *colorizeMask = dynamic_cast<KisColorizeMask*>(m_sourceNode.data());
201 if (colorizeMask) {
202 m_sourcePaintDevice = colorizeMask->coloringProjection();
203 const bool putBehind = colorizeMask->compositeOpId() == COMPOSITE_BEHIND;
204 if (putBehind) {
205 m_compositeOp = COMPOSITE_OVER;
206 }
207
208 m_insertionParent = m_sourceNode->parent()->parent();
209 m_insertionPutAfter = putBehind ? m_sourceNode->parent()->prevSibling() : m_sourceNode->parent();
210
211 } else if (dynamic_cast<KisMask*>(m_sourceNode.data())) {
212 m_insertionParent = m_sourceNode->parent()->parent();
213 m_insertionPutAfter = m_sourceNode->parent()->prevSibling();
214 } else {
215 m_insertionParent = m_sourceNode->parent();
216 m_insertionPutAfter = m_sourceNode;
217 }
218
219 KisCloneLayer *cloneLayer = dynamic_cast<KisCloneLayer*>(m_sourceNode.data());
220 if (cloneLayer) {
221 m_targetNode = cloneLayer->reincarnateAsPaintLayer();
222 } else if (m_sourcePaintDevice) {
223 KisPaintDeviceSP clone;
224
225 if (*m_sourcePaintDevice->colorSpace() !=
226 *m_sourcePaintDevice->compositionSourceColorSpace()) {
227
228 clone = new KisPaintDevice(m_sourcePaintDevice->compositionSourceColorSpace());
229 clone->setDefaultPixel(
230 m_sourcePaintDevice->defaultPixel().convertedTo(
231 m_sourcePaintDevice->compositionSourceColorSpace()));
232
233 QRect rc(m_sourcePaintDevice->extent());
234 KisPainter::copyAreaOptimized(rc.topLeft(), m_sourcePaintDevice, clone, rc);
235 } else {
236 clone = new KisPaintDevice(*m_sourcePaintDevice);
237 }
238
239 m_targetNode = new KisPaintLayer(m_image,
240 m_sourceNode->name(),
241 m_sourceNode->opacity(),
242 clone);
243
244 m_targetNode->setCompositeOpId(m_compositeOp);
245
246 if (sourceLayer() && targetLayer()) {
247 targetLayer()->disableAlphaChannel(sourceLayer()->alphaChannelDisabled());
248 }
249
250 if (sourcePaintLayer() && targetPaintLayer()) {
251 targetPaintLayer()->setAlphaLocked(sourcePaintLayer()->alphaLocked());
252 }
253 }
254 }
255
256 QSet<int> frames() {
257 return m_frames;
258 }
259
260 KisNodeSP sourceNode() {
261 return m_sourceNode;
262 }
263
264 KisLayerSP sourceLayer() {
265 return qobject_cast<KisLayer*>(m_sourceNode.data());
266 }
267
268 KisNodeList sourceNodes() {
269 KisNodeList list;
270 list << m_sourceNode;
271 return list;
272 }
273
274 KisPaintLayerSP sourcePaintLayer() {
275 return qobject_cast<KisPaintLayer*>(m_sourceNode.data());
276 }
277
278 bool hasTargetNode() {
279 return m_targetNode != nullptr;
280 }
281
282 KisNodeSP targetNode() {
283 return m_targetNode;
284 }
285
286 KisLayerSP targetLayer() {
287 return qobject_cast<KisLayer*>(m_targetNode.data());
288 }
289
290 KisPaintLayerSP targetPaintLayer() {
291 return qobject_cast<KisPaintLayer*>(m_targetNode.data());
292 }
293
294
295 KisImageSP image() {
296 return m_image;
297 }
298
302
303 KisNodeList toRemove() {
304 KisNodeList lst;
305 lst << m_sourceNode;
306 return lst;
307 }
308
312
313 KisNodeSP insertionParent() const {
314 return m_insertionParent;
315 }
316
317 SwitchFrameCommand::SharedStorageSP storage;
318
319 private:
320 KisNodeSP m_sourceNode;
321 KisNodeSP m_targetNode;
322 KisImageWSP m_image;
323 KisPaintDeviceSP m_sourcePaintDevice;
324 QSet<int> m_frames;
325 QString m_compositeOp;
326 bool m_pinnedToTimeline;
327
328 KisNodeSP m_insertionParent;
329 KisNodeSP m_insertionPutAfter;
330 };
331
332 struct MergeMultipleInfo : public MergeDownInfoBase {
333 MergeMultipleInfo(KisImageSP _image,
334 KisNodeList _mergedNodes,
335 MergeFlags flags)
336 : MergeDownInfoBase(_image),
337 mergedNodes(_mergedNodes)
338 {
339 foreach (KisNodeSP node, mergedNodes) {
340 if (!flags.testFlag(SkipMergingFrames)) {
341 frames |= fetchLayerFramesRecursive(node);
342 }
343 pinnedToTimeline |= node->isPinnedToTimeline();
344
345 const KisPaintLayer *paintLayer = qobject_cast<KisPaintLayer*>(node.data());
346 if (paintLayer) {
347 enableOnionSkins |= paintLayer->onionSkinEnabled();
348 }
349 }
350 }
351
352 QScopedPointer<KisSurrogateUndoStore> ephemeralCommandsStore;
353 KisNodeList mergedNodes;
354 bool nodesCompositingVaries = false;
355
356 KisNodeList allSrcNodes() override {
357 return mergedNodes;
358 }
359 };
360
361 typedef QSharedPointer<MergeDownInfoBase> MergeDownInfoBaseSP;
362 typedef QSharedPointer<MergeDownInfo> MergeDownInfoSP;
363 typedef QSharedPointer<MergeMultipleInfo> MergeMultipleInfoSP;
364 typedef QSharedPointer<SplitAlphaToMaskInfo> SplitAlphaToMaskInfoSP;
365 typedef QSharedPointer<ConvertToPaintLayerInfo> ConvertToPaintLayerInfoSP;
366
367 struct FillSelectionMasks : public KUndo2Command {
368 FillSelectionMasks(MergeDownInfoBaseSP info) : m_info(info) {}
369
370 void redo() override {
371 fetchSelectionMasks(m_info->allSrcNodes(), m_info->selectionMasks);
372 }
373
374 private:
375 MergeDownInfoBaseSP m_info;
376 };
377
378 struct DisableColorizeKeyStrokes : public KisCommandUtils::AggregateCommand {
379 DisableColorizeKeyStrokes(MergeDownInfoBaseSP info) : m_info(info) {}
380
381 void populateChildCommands() override {
382 Q_FOREACH (KisNodeSP node, m_info->allSrcNodes()) {
383 recursiveApplyNodes(node,
384 [this] (KisNodeSP node) {
385 if (dynamic_cast<KisColorizeMask*>(node.data()) &&
386 KisLayerPropertiesIcons::nodeProperty(node, KisLayerPropertiesIcons::colorizeEditKeyStrokes, true).toBool()) {
387
388 KisBaseNode::PropertyList props = node->sectionModelProperties();
389 KisLayerPropertiesIcons::setNodeProperty(&props,
390 KisLayerPropertiesIcons::colorizeEditKeyStrokes,
391 false);
392
393 addCommand(new KisNodePropertyListCommand(node, props));
394 }
395 });
396 }
397 }
398
399 private:
400 MergeDownInfoBaseSP m_info;
401 };
402
403 struct DisableOnionSkins : public KisCommandUtils::AggregateCommand {
404 DisableOnionSkins(MergeDownInfoBaseSP info) : m_info(info) {}
405
406 void populateChildCommands() override {
407 Q_FOREACH (KisNodeSP node, m_info->allSrcNodes()) {
408 recursiveApplyNodes(node,
409 [this] (KisNodeSP node) {
410 if (KisLayerPropertiesIcons::nodeProperty(node, KisLayerPropertiesIcons::onionSkins, false).toBool()) {
411
412 KisBaseNode::PropertyList props = node->sectionModelProperties();
413 KisLayerPropertiesIcons::setNodeProperty(&props,
414 KisLayerPropertiesIcons::onionSkins,
415 false);
416
417 addCommand(new KisNodePropertyListCommand(node, props));
418 }
419 });
420 }
421 }
422
423 private:
424 MergeDownInfoBaseSP m_info;
425 };
426
427 struct DisableExtraCompositing : public KisCommandUtils::AggregateCommand {
428 DisableExtraCompositing(MergeMultipleInfoSP info) : m_info(info) {}
429
430 void populateChildCommands() override {
436 if (m_info->nodesCompositingVaries) return;
437
438 // we should disable dirty requests on **redo only**, otherwise
439 // the state of the layers will not be recovered on undo
440 m_info->image->disableDirtyRequests();
441
442 Q_FOREACH (KisNodeSP node, m_info->allSrcNodes()) {
443 if (node->compositeOpId() != COMPOSITE_OVER) {
444 addCommand(new KisNodeCompositeOpCommand(node, COMPOSITE_OVER));
445 }
446
447 if (KisLayerPropertiesIcons::nodeProperty(node, KisLayerPropertiesIcons::inheritAlpha, false).toBool()) {
448
449 KisBaseNode::PropertyList props = node->sectionModelProperties();
450 KisLayerPropertiesIcons::setNodeProperty(&props,
451 KisLayerPropertiesIcons::inheritAlpha,
452 false);
453
454 addCommand(new KisNodePropertyListCommand(node, props));
455 }
456 }
457
458 m_info->image->enableDirtyRequests();
459 }
460
461 private:
462 MergeMultipleInfoSP m_info;
463 };
464
465 struct DisablePassThroughForHeadsOnly : public KisCommandUtils::AggregateCommand {
466 DisablePassThroughForHeadsOnly(MergeDownInfoBaseSP info, bool skipIfDstIsGroup = false)
467 : m_info(info),
468 m_skipIfDstIsGroup(skipIfDstIsGroup)
469 {
470 }
471
472 void populateChildCommands() override {
473 if (m_skipIfDstIsGroup &&
474 m_info->dstLayer() &&
475 m_info->dstLayer()->inherits("KisGroupLayer")) {
476
477 return;
478 }
479
480
481 Q_FOREACH (KisNodeSP node, m_info->allSrcNodes()) {
482 if (KisLayerPropertiesIcons::nodeProperty(node, KisLayerPropertiesIcons::passThrough, false).toBool()) {
483
484 KisBaseNode::PropertyList props = node->sectionModelProperties();
485 KisLayerPropertiesIcons::setNodeProperty(&props,
486 KisLayerPropertiesIcons::passThrough,
487 false);
488
489 addCommand(new KisNodePropertyListCommand(node, props));
490 }
491 }
492 }
493
494 private:
495 MergeDownInfoBaseSP m_info;
496 bool m_skipIfDstIsGroup;
497 };
498
499 struct RefreshHiddenAreas : public KisCommandUtils::AggregateCommand {
500 struct refresh_entire_image_t {};
501 static constexpr refresh_entire_image_t refresh_entire_image{};
502
503 RefreshHiddenAreas(MergeDownInfoBaseSP info) : m_image(info->image), m_nodes(info->allSrcNodes()) {}
504 RefreshHiddenAreas(MergeDownInfoBaseSP info, refresh_entire_image_t) : m_image(info->image), m_nodes(info->allSrcNodes()), m_extraUpdateRect(info->image->bounds()) {}
505 RefreshHiddenAreas(KisImageSP image, KisNodeSP node) : m_image(image), m_nodes() {
506 m_nodes << node;
507 }
508
509 void populateChildCommands() override {
510 KisImageAnimationInterface *interface = m_image->animationInterface();
511 const QRect preparedRect = !interface->externalFrameActive() ?
512 m_image->bounds() : QRect();
513
514 foreach (KisNodeSP node, m_nodes) {
515 Private::refreshHiddenAreaAsync(m_image, node, preparedRect, m_extraUpdateRect);
516 }
517 }
518
519 private:
520 KisImageWSP m_image;
521 KisNodeList m_nodes;
522 QRect m_extraUpdateRect;
523 };
524
525 struct RefreshDelayedUpdateLayers : public KUndo2Command {
526 RefreshDelayedUpdateLayers(MergeDownInfoBaseSP info)
527 : m_nodes(info->allSrcNodes()) {}
528
529 RefreshDelayedUpdateLayers(KisNodeList nodes){
530 m_nodes << nodes;
531 }
532
533 void redo() override {
534 if (m_info) {
535 m_nodes << m_info->allSrcNodes();
536 }
537
538 foreach (KisNodeSP node, m_nodes) {
539 forceAllDelayedNodesUpdate(node);
540 }
541 }
542
543 private:
544 KisNodeList m_nodes;
545 MergeDownInfoBaseSP m_info;
546 };
547
548 struct KeepMergedNodesSelected : public KisCommandUtils::AggregateCommand {
549 KeepMergedNodesSelected(MergeDownInfoSP info, bool finalizing)
550 : m_singleInfo(info),
551 m_finalizing(finalizing) {}
552
553 KeepMergedNodesSelected(MergeMultipleInfoSP info, KisNodeSP putAfter, bool finalizing)
554 : m_multipleInfo(info),
555 m_finalizing(finalizing),
556 m_putAfter(putAfter) {}
557
558 void populateChildCommands() override {
559 KisNodeSP prevNode;
560 KisNodeSP nextNode;
561 KisNodeList prevSelection;
562 KisNodeList nextSelection;
563 KisImageSP image;
564
565 if (m_singleInfo) {
566 prevNode = m_singleInfo->currLayer;
567 nextNode = m_singleInfo->dstNode;
568 image = m_singleInfo->image;
569 } else if (m_multipleInfo) {
570 prevNode = m_putAfter;
571 nextNode = m_multipleInfo->dstNode;
572 prevSelection = m_multipleInfo->allSrcNodes();
573 image = m_multipleInfo->image;
574 }
575
576 if (!m_finalizing) {
577 addCommand(new KeepNodesSelectedCommand(prevSelection, KisNodeList(),
578 prevNode, KisNodeSP(),
579 image, false));
580 } else {
581 addCommand(new KeepNodesSelectedCommand(KisNodeList(), nextSelection,
582 KisNodeSP(), nextNode,
583 image, true));
584 }
585 }
586
587 private:
588 MergeDownInfoSP m_singleInfo;
589 MergeMultipleInfoSP m_multipleInfo;
590 bool m_finalizing;
591 KisNodeSP m_putAfter;
592 };
593
594 struct CreateMergedLayer : public KisCommandUtils::AggregateCommand {
595 CreateMergedLayer(MergeDownInfoSP info) : m_info(info) {}
596
597 void populateChildCommands() override {
598 // actual merging done by KisLayer::createMergedLayer (or specialized descendant)
599 m_info->dstNode = m_info->currLayer->createMergedLayerTemplate(m_info->prevLayer);
600
601 if (m_info->frames.size() > 0) {
602 m_info->dstNode->enableAnimation();
603 m_info->dstNode->getKeyframeChannel(KisKeyframeChannel::Raster.id(), true);
604 }
605
606 m_info->dstNode->setPinnedToTimeline(m_info->pinnedToTimeline);
607 m_info->dstNode->setColorLabelIndex(m_info->allSrcNodes().first()->colorLabelIndex());
608
609 KisPaintLayer *dstPaintLayer = qobject_cast<KisPaintLayer*>(m_info->dstNode.data());
610 if (dstPaintLayer) {
611 dstPaintLayer->setOnionSkinEnabled(m_info->enableOnionSkins);
612 }
613 }
614
615 private:
616 MergeDownInfoSP m_info;
617 };
618
619 struct CreateMergedLayerMultiple : public KisCommandUtils::AggregateCommand {
620 CreateMergedLayerMultiple(MergeMultipleInfoSP info, const QString name = QString() )
621 : m_info(info),
622 m_name(name) {}
623
624 void populateChildCommands() override {
625 QString mergedLayerName;
626 if (m_name.isEmpty()){
627 const QString mergedLayerSuffix = i18n("Merged");
628 mergedLayerName = m_info->mergedNodes.first()->name();
629
630 if (KisImageConfig(true).renameMergedLayers() && !mergedLayerName.endsWith(mergedLayerSuffix)) {
631 mergedLayerName = QString("%1 %2")
632 .arg(mergedLayerName).arg(mergedLayerSuffix);
633 }
634 } else {
635 mergedLayerName = m_name;
636 }
637
638 auto channelFlagsLazy = [](KisNodeSP node) {
639 KisLayer *layer = dynamic_cast<KisLayer*>(node.data());
640 return layer ? layer->channelFlags() : QBitArray();
641 };
642
643 QString compositeOpId;
644 QBitArray channelFlags;
645 bool compositionVaries = false;
646 bool isFirstCycle = true;
647
648 foreach (KisNodeSP node, m_info->allSrcNodes()) {
649 if (isFirstCycle) {
650 compositeOpId = node->compositeOpId();
651 channelFlags = channelFlagsLazy(node);
652 isFirstCycle = false;
653 } else if (compositeOpId != node->compositeOpId() ||
654 channelFlags != channelFlagsLazy(node)) {
655 compositionVaries = true;
656 break;
657 }
658
659 KisLayerSP layer = qobject_cast<KisLayer*>(node.data());
660 if (layer && layer->layerStyle()) {
661 compositionVaries = true;
662 break;
663 }
664 }
665
670 if (!compositionVaries && m_info->frames.isEmpty()) {
671 QList<KisLayerSP> layers;
672 Q_FOREACH(KisNodeSP node, m_info->allSrcNodes()) {
673 KisLayer *layer = dynamic_cast<KisLayer*>(node.data());
674 if (!layer) {
675 layers.clear();
676 break;
677 }
678 layers << layer;
679 }
680
681 if (!layers.isEmpty()) {
686 m_info->dstNode = layers.first()->tryCreateInternallyMergedLayerFromMutipleLayers(layers);
687 }
688 }
689
693 if (!m_info->dstNode) {
694 m_info->rasterizedDstLayer = new KisPaintLayer(m_info->image, mergedLayerName, OPACITY_OPAQUE_U8);
695 m_info->dstNode = m_info->rasterizedDstLayer;
696
697 if (m_info->frames.size() > 0) {
698 m_info->dstNode->enableAnimation();
699 m_info->dstNode->getKeyframeChannel(KisKeyframeChannel::Raster.id(), true);
700 }
701
702 if (!compositionVaries) {
703 if (!compositeOpId.isEmpty()) {
704 m_info->dstNode->setCompositeOpId(compositeOpId);
705 }
706 if (m_info->dstLayer() && !channelFlags.isEmpty()) {
707 m_info->dstLayer()->setChannelFlags(channelFlags);
708 }
709 }
710
711 m_info->dstNode->setPinnedToTimeline(m_info->pinnedToTimeline);
712 m_info->dstNode->setColorLabelIndex(m_info->allSrcNodes().first()->colorLabelIndex());
713
714 m_info->rasterizedDstLayer->setOnionSkinEnabled(m_info->enableOnionSkins);
715 }
716
717 m_info->nodesCompositingVaries = compositionVaries;
718 }
719
720 private:
721 MergeMultipleInfoSP m_info;
722 QString m_name;
723 };
724
725 struct MergeLayers : public KisCommandUtils::AggregateCommand {
726 MergeLayers(MergeDownInfoSP info, bool skipMergingSourceLayer)
727 : m_info(info), m_skipMergingSourceLayer(skipMergingSourceLayer) {}
728
729 void populateChildCommands() override {
730 // actual merging done by KisLayer::createMergedLayer (or specialized descendant)
731 m_info->currLayer->fillMergedLayerTemplate(m_info->dstLayer(), m_info->prevLayer, m_skipMergingSourceLayer);
732 }
733
734 private:
735 MergeDownInfoSP m_info;
736 bool m_skipMergingSourceLayer {false};
737 };
738
739 struct MergeLayersMultiple : public KisCommandUtils::AggregateCommand {
740 MergeLayersMultiple(MergeMultipleInfoSP info) : m_info(info) {}
741
742 void populateChildCommands() override {
743 if (!m_info->rasterizedDstLayer) return;
744
745 KisPainter gc(m_info->rasterizedDstLayer->paintDevice());
746
747 foreach (KisNodeSP node, m_info->allSrcNodes()) {
748 QRect rc = node->exactBounds() | m_info->image->bounds();
749 node->projectionPlane()->apply(&gc, rc);
750 }
751 }
752
753 private:
754 MergeMultipleInfoSP m_info;
755 };
756
757 struct MergeMetaData : public KUndo2Command {
758 MergeMetaData(MergeDownInfoSP info, const KisMetaData::MergeStrategy* strategy)
759 : m_info(info),
760 m_strategy(strategy) {}
761
762 void redo() override {
763 QRect layerProjectionExtent = m_info->currLayer->projection()->extent();
764 QRect prevLayerProjectionExtent = m_info->prevLayer->projection()->extent();
765 int prevLayerArea = prevLayerProjectionExtent.width() * prevLayerProjectionExtent.height();
766 int layerArea = layerProjectionExtent.width() * layerProjectionExtent.height();
767
768 QList<double> scores;
769 double norm = qMax(prevLayerArea, layerArea);
770 scores.append(prevLayerArea / norm);
771 scores.append(layerArea / norm);
772
773 QList<const KisMetaData::Store*> srcs;
774 srcs.append(m_info->prevLayer->metaData());
775 srcs.append(m_info->currLayer->metaData());
776 m_strategy->merge(m_info->dstLayer()->metaData(), srcs, scores);
777 }
778
779 private:
780 MergeDownInfoSP m_info;
781 const KisMetaData::MergeStrategy *m_strategy;
782 };
783
784 struct InitSplitAlphaSelectionMask : public KisCommandUtils::AggregateCommand {
787
788 void populateChildCommands() override {
789 m_info->getMask()->initSelection(m_info->getLayer());
790 }
791
792 private:
793 SplitAlphaToMaskInfoSP m_info;
794 };
795
796 struct SplitAlphaCommand : public KUndo2Command {
797 SplitAlphaCommand(SplitAlphaToMaskInfoSP info)
798 : m_info(info) {
799 m_cached = new KisPaintDevice(*m_info->node->paintDevice(), KritaUtils::CopyAllFrames);
800 }
801
802 void redo() override {
803 KisPaintDeviceSP srcDevice = m_info->node->paintDevice();
804 const KoColorSpace *srcCS = srcDevice->colorSpace();
805 const QRect processRect =
806 srcDevice->exactBounds() |
807 srcDevice->defaultBounds()->bounds();
808
809 KisSequentialIterator srcIt(srcDevice, processRect);
810 KisSequentialIterator dstIt(m_info->getMaskDevice(), processRect);
811
812 while (srcIt.nextPixel() && dstIt.nextPixel()) {
813 quint8 *srcPtr = srcIt.rawData();
814 quint8 *alpha8Ptr = dstIt.rawData();
815
816 *alpha8Ptr = srcCS->opacityU8(srcPtr);
817 srcCS->setOpacity(srcPtr, OPACITY_OPAQUE_U8, 1);
818 }
819 }
820
821 void undo() override {
822 KisPaintDeviceSP srcDevice = m_info->node->paintDevice();
823
824 if (srcDevice->framesInterface()) { //Swap contents of all frames to reflect the pre-operation state.
825 KisPaintDeviceSP tempPD = new KisPaintDevice(*m_cached, KritaUtils::CopySnapshot);
826 Q_FOREACH(const int& frame, srcDevice->framesInterface()->frames() ) {
827 if (m_cached->framesInterface()->frames().contains(frame)) {
828 m_cached->framesInterface()->writeFrameToDevice(frame, tempPD);
829 srcDevice->framesInterface()->uploadFrame(frame, tempPD);
830 }
831 }
832 } else {
833 const QRect processRect =
834 srcDevice->exactBounds() |
835 srcDevice->defaultBounds()->bounds();
836
837 const KoColorSpace *srcCS = srcDevice->colorSpace();
838 KisSequentialIterator srcIt(m_cached, processRect);
839 KisSequentialIterator dstIt(srcDevice, processRect);
840
841 while (srcIt.nextPixel() && dstIt.nextPixel()) {
842 quint8 *srcPtr = srcIt.rawData();
843 quint8 *dstPtr = dstIt.rawData();
844 srcCS->setOpacity(dstPtr, srcCS->opacityU8(srcPtr), 1);
845 }
846 }
847 }
848
849 private:
850 SplitAlphaToMaskInfoSP m_info;
851 KisPaintDeviceSP m_cached;
852 };
853
854 struct UploadProjectionToFrameCommand : public KisCommandUtils::AggregateCommand {
855 UploadProjectionToFrameCommand(KisNodeSP src, KisNodeSP target, int frame)
856 : m_source(src)
857 , m_target(target)
858 , m_frame(frame)
859 {}
860
861 void populateChildCommands() override {
862 KisRasterKeyframeChannel* channel = dynamic_cast<KisRasterKeyframeChannel*>(m_target->getKeyframeChannel(KisKeyframeChannel::Raster.id()));
863 if (!channel)
864 return;
865
866
867 KisPaintDeviceSP clone = new KisPaintDevice(*m_source->projection());
868 KisRasterKeyframeSP key = channel->keyframeAt<KisRasterKeyframe>(m_frame);
869 m_target->paintDevice()->framesInterface()->uploadFrame(key->frameID(), clone);
870 }
871
872 private:
873 KisNodeSP m_source;
874 KisNodeSP m_target;
875 int m_frame;
876 };
877
878 KeepNodesSelectedCommand::KeepNodesSelectedCommand(const KisNodeList &selectedBefore,
879 const KisNodeList &selectedAfter,
880 KisNodeSP activeBefore,
881 KisNodeSP activeAfter,
882 KisImageSP image,
883 bool finalize, KUndo2Command *parent)
884 : FlipFlopCommand(finalize, parent),
885 m_selectedBefore(selectedBefore),
886 m_selectedAfter(selectedAfter),
887 m_activeBefore(activeBefore),
888 m_activeAfter(activeAfter),
889 m_image(image)
890 {
891 }
892
902
907
911
919
923
933 void RemoveNodeHelper::safeRemoveMultipleNodes(KisNodeList nodes, KisImageSP image) {
934 safeReplaceMultipleNodes(nodes, image, std::nullopt);
935 }
936
937 void RemoveNodeHelper::safeReplaceMultipleNodes(KisNodeList removedNodes, KisImageSP image,
938 std::optional<ReplacementNode> replacementNode) {
939
940 const bool lastLayer = !replacementNode && scanForLastLayer(image, removedNodes);
941
942 auto isNodeWeird = [] (KisNodeSP node) {
943 const bool normalCompositeMode = node->compositeOpId() == COMPOSITE_OVER;
944
945 KisLayer *layer = dynamic_cast<KisLayer*>(node.data());
946 const bool hasInheritAlpha = layer && layer->alphaChannelDisabled();
947 return !normalCompositeMode && !hasInheritAlpha;
948 };
949
950
951 using Recipe = KisBatchUpdateLayerModificationCommand::Recipe;
952 using RecipeSP = KisBatchUpdateLayerModificationCommand::RecipeSP;
953 RecipeSP updateRecipe(new Recipe());
954
955 if (replacementNode) {
956 updateRecipe->nodesToAdd.push_back({replacementNode->node,
957 replacementNode->doRedoUpdates,
958 replacementNode->doUndoUpdates});
959 }
960
961 Q_FOREACH (KisNodeSP node, removedNodes) {
962 updateRecipe->nodesToRemove.push_back({node, !isNodeWeird(node), true});
963 }
964
965 addCommandImpl(new KisBatchUpdateLayerModificationCommand(image, updateRecipe, KisBatchUpdateLayerModificationCommand::INITIALIZING));
966
967 if (replacementNode) {
968 addCommandImpl(new KisImageLayerAddCommand(image,
969 replacementNode->node,
970 replacementNode->parent,
971 replacementNode->putAfter,
972 false, false));
973
974 Q_FOREACH (KisSelectionMaskSP mask, replacementNode->selectionMasks) {
975 addCommandImpl(new KisImageLayerMoveCommand(image, mask, replacementNode->node, replacementNode->node->lastChild(), false));
976 addCommandImpl(new KisActivateSelectionMaskCommand(mask, false));
977 }
978
979 // relink all the clone layers onto the new replacement node
980 if (replacementNode->relinkClones) {
981 QList<KisCloneLayerWSP> clones;
982
983 Q_FOREACH (KisNodeSP node, removedNodes) {
984 KisLayerSP originalSource = dynamic_cast<KisLayer*>(node.data());
985 if (originalSource) {
986 clones.append(originalSource->registeredClones());
987 }
988 }
989
990 KisLayerSP finalSource = dynamic_cast<KisLayer*>(replacementNode->node.data());
991
992 if (finalSource && !clones.isEmpty()) {
993 addCommandImpl(new KisChangeCloneLayersCommand(implicitCastList<KisCloneLayerSP>(clones), finalSource));
994 }
995 }
996 }
997
998 while (!removedNodes.isEmpty()) {
999 KisNodeList::iterator it = removedNodes.begin();
1000
1001 while (it != removedNodes.end()) {
1002 if (!checkIsSourceForClone(*it, removedNodes)) {
1003 KisNodeSP node = *it;
1004
1005 addCommandImpl(new KisImageLayerRemoveCommand(image, node, false, false));
1006 it = removedNodes.erase(it);
1007 } else {
1008 ++it;
1009 }
1010 }
1011 }
1012
1013 addCommandImpl(new KisBatchUpdateLayerModificationCommand(image, updateRecipe, KisBatchUpdateLayerModificationCommand::FINALIZING));
1014
1015 // Hint: we shouldn't include that into the batch update since this layer doesn't trigger any updates
1016 if (lastLayer) {
1017 KisLayerSP newLayer = new KisPaintLayer(image.data(), image->nextLayerName(), OPACITY_OPAQUE_U8, image->colorSpace());
1018 addCommandImpl(new KisImageLayerAddCommand(image, newLayer,
1019 image->root(),
1020 KisNodeSP(),
1021 false, false));
1022 }
1023 }
1024
1025 bool RemoveNodeHelper::checkIsSourceForClone(KisNodeSP src, const KisNodeList &nodes) {
1026 foreach (KisNodeSP node, nodes) {
1027 if (node == src) continue;
1028
1029 KisCloneLayer *clone = dynamic_cast<KisCloneLayer*>(node.data());
1030
1031 if (clone && KisNodeSP(clone->copyFrom()) == src) {
1032 return true;
1033 }
1034 }
1035
1036 return false;
1037 }
1038
1039 bool RemoveNodeHelper::scanForLastLayer(KisImageWSP image, KisNodeList nodesToRemove) {
1040 bool removeLayers = false;
1041 Q_FOREACH(KisNodeSP nodeToRemove, nodesToRemove) {
1042 if (qobject_cast<KisLayer*>(nodeToRemove.data())) {
1043 removeLayers = true;
1044 break;
1045 }
1046 }
1047 if (!removeLayers) return false;
1048
1049 bool lastLayer = true;
1050 KisNodeSP node = image->root()->firstChild();
1051 while (node) {
1052 if (!nodesToRemove.contains(node) &&
1053 qobject_cast<KisLayer*>(node.data()) &&
1054 !node->isFakeNode()) {
1055
1056 lastLayer = false;
1057 break;
1058 }
1059 node = node->nextSibling();
1060 }
1061
1062 return lastLayer;
1063 }
1064
1065 SimpleRemoveLayers::SimpleRemoveLayers(const KisNodeList &nodes,
1066 KisImageSP image)
1067 : m_nodes(nodes),
1068 m_image(image)
1069 {
1070 }
1071
1076
1080
1081 struct InsertNode : public KisCommandUtils::AggregateCommand {
1082 InsertNode(MergeDownInfoBaseSP info, KisNodeSP putAfter)
1083 : m_info(info), m_putAfter(putAfter) {}
1084
1085 void populateChildCommands() override {
1086 addCommand(new KisImageLayerAddCommand(m_info->image,
1087 m_info->dstNode,
1088 m_putAfter->parent(),
1089 m_putAfter,
1090 true, false));
1091
1092 }
1093
1094 private:
1095 virtual void addCommandImpl(KUndo2Command *cmd) {
1096 addCommand(cmd);
1097 }
1098
1099 MergeDownInfoBaseSP m_info;
1100 KisNodeSP m_putAfter;
1101 };
1102
1103 struct SimpleAddNode : public KisCommandUtils::AggregateCommand {
1104 SimpleAddNode(KisImageSP image, KisNodeSP toAdd, KisNodeSP parent = 0, KisNodeSP putAfter = 0)
1105 : m_image(image)
1106 , m_toAdd(toAdd)
1107 , m_parent(parent)
1108 , m_putAfter(putAfter)
1109 {
1110 while (m_parent && !m_parent->allowAsChild(m_toAdd)) {
1111 m_putAfter = m_putAfter ? m_putAfter->parent() : m_parent;
1112 m_parent = m_putAfter ? m_putAfter->parent() : 0;
1113 }
1114
1115 if (!m_parent) {
1116 m_parent = m_image->root();
1117 }
1118 }
1119
1120
1121 void populateChildCommands() override {
1122 addCommand(new KisImageLayerAddCommand(m_image,
1123 m_toAdd,
1124 m_parent,
1125 m_putAfter,
1126 true, false));
1127 }
1128
1129 private:
1130 virtual void addCommandImpl(KUndo2Command *cmd) {
1131 addCommand(cmd);
1132 }
1133
1134 KisImageWSP m_image;
1135 KisNodeSP m_toAdd;
1136 KisNodeSP m_parent;
1137 KisNodeSP m_putAfter;
1138
1139 };
1140
1141
1142 void splitNonRemovableNodes(KisNodeList &nodesToRemove, KisNodeList &_nodesToHide)
1143 {
1144 QSet<KisNodeSP> nodesToHide;
1145 QSet<KisNodeSP> extraNodesToRemove;
1146
1147 for (auto it = nodesToRemove.begin(); it != nodesToRemove.end(); ++it) {
1148 KisNodeSP root = *it;
1149 KIS_SAFE_ASSERT_RECOVER_NOOP(root->visible());
1150
1151 if (!root->isEditable(false)) {
1152 nodesToHide.insert(root);
1153 } else {
1154 bool rootNeedsCarefulRemoval = false;
1155
1156 recursiveApplyNodes(root,
1157 [root, &nodesToHide, &rootNeedsCarefulRemoval] (KisNodeSP node) {
1158 if (!node->isEditable(false)) {
1159 while (node != root) {
1160 nodesToHide.insert(node);
1161 node = node->parent();
1162 KIS_SAFE_ASSERT_RECOVER_BREAK(node);
1163 }
1164 nodesToHide.insert(root);
1165 rootNeedsCarefulRemoval = true;
1166 }
1167 });
1168
1169 if (rootNeedsCarefulRemoval) {
1170 recursiveApplyNodes(root,
1171 [&extraNodesToRemove] (KisNodeSP node) {
1172 extraNodesToRemove.insert(node);
1173 });
1174 }
1175 }
1176 }
1177 nodesToRemove += KisNodeList(extraNodesToRemove.begin(), extraNodesToRemove.end());
1178 KritaUtils::filterContainer<KisNodeList>(nodesToRemove,
1179 [nodesToHide](KisNodeSP node) {
1180 return !nodesToHide.contains(node);
1181 });
1182 _nodesToHide = KisNodeList(nodesToHide.begin(), nodesToHide.end());
1183 }
1184
1185 struct CleanUpNodes : private RemoveNodeHelper, public KisCommandUtils::AggregateCommand {
1186 CleanUpNodes(MergeDownInfoBaseSP info, KisNodeSP putAfter, bool relinkClones = false)
1187 : m_info(info), m_putAfter(putAfter), m_relinkClones(relinkClones) {}
1188
1189 static void findPerfectParent(KisNodeList nodesToDelete, KisNodeSP &putAfter, KisNodeSP &parent) {
1190 if (!putAfter) {
1191 putAfter = nodesToDelete.last();
1192 }
1193
1194 // Add the new merged node on top of the active node
1195 // -- checking all parents if they are included in nodesToDelete
1196 // Not every descendant is included in nodesToDelete even if in fact
1197 // they are going to be deleted, so we need to check it.
1198 // If we consider the path from root to the putAfter node,
1199 // if there are any nodes marked for deletion, any node afterwards
1200 // is going to be deleted, too.
1201 // example: root . . . . . ! ! . . ! ! ! ! . . . . putAfter
1202 // it should be: root . . . . . ! ! ! ! ! ! ! ! ! ! ! ! !putAfter
1203 // and here: root . . . . X ! ! . . ! ! ! ! . . . . putAfter
1204 // you can see which node is "the perfect ancestor"
1205 // (marked X; called "parent" in the function arguments).
1206 // and here: root . . . . . O ! . . ! ! ! ! . . . . putAfter
1207 // you can see which node is "the topmost deleted ancestor" (marked 'O')
1208
1209 KisNodeSP node = putAfter->parent();
1210 bool foundDeletedAncestor = false;
1211 KisNodeSP topmostAncestorToDelete = nullptr;
1212
1213 while (node) {
1214
1215 if (nodesToDelete.contains(node)
1216 && !nodesToDelete.contains(node->parent())) {
1217 foundDeletedAncestor = true;
1218 topmostAncestorToDelete = node;
1219 // Here node is to be deleted and its parent is not,
1220 // so its parent is the one of the first not deleted (="perfect") ancestors.
1221 // We need the one that is closest to the top (root)
1222 }
1223
1224 node = node->parent();
1225 }
1226
1227 if (foundDeletedAncestor) {
1228 parent = topmostAncestorToDelete->parent();
1229 putAfter = topmostAncestorToDelete;
1230 }
1231 else {
1232 parent = putAfter->parent(); // putAfter (and none of its ancestors) is to be deleted, so its parent is the first not deleted ancestor
1233 }
1234
1235 }
1236
1237 void populateChildCommands() override {
1238 KisNodeList nodesToDelete = m_info->allSrcNodes();
1239
1240 KisNodeSP parent;
1241 findPerfectParent(nodesToDelete, m_putAfter, parent);
1242
1243 if (!parent) {
1244 KisNodeSP oldRoot = m_info->image->root();
1245 KisNodeSP newRoot(new KisGroupLayer(m_info->image, "root", OPACITY_OPAQUE_U8));
1246
1247 // copy all fake nodes into the new image
1248 KisLayerUtils::recursiveApplyNodes(oldRoot, [this, oldRoot, newRoot] (KisNodeSP node) {
1249 if (node->isFakeNode() && node->parent() == oldRoot) {
1250 addCommand(new KisImageLayerAddCommand(m_info->image,
1251 node->clone(),
1252 newRoot,
1253 KisNodeSP(),
1254 false, false));
1255
1256 }
1257 });
1258
1259 addCommand(new KisImageLayerAddCommand(m_info->image,
1260 m_info->dstNode,
1261 newRoot,
1262 KisNodeSP(),
1263 true, false));
1264 addCommand(new KisImageChangeLayersCommand(m_info->image, oldRoot, newRoot));
1265
1266 }
1267 else {
1268 KisNodeList safeNodesToDelete = m_info->allSrcNodes();
1269 KisNodeList safeNodesToHide;
1270
1271 splitNonRemovableNodes(safeNodesToDelete, safeNodesToHide);
1272
1273 Q_FOREACH(KisNodeSP node, safeNodesToHide) {
1274 addCommand(new KisImageChangeVisibilityCommand(false, node));
1275 }
1276
1277 safeReplaceMultipleNodes(safeNodesToDelete, m_info->image,
1278 std::make_optional<ReplacementNode>(
1279 {m_info->dstNode,
1280 parent,
1281 m_putAfter,
1282 true, false,
1283 m_info->selectionMasks,
1284 m_relinkClones}));
1285 }
1286
1287
1288 }
1289
1290 private:
1291 void addCommandImpl(KUndo2Command *cmd) override {
1292 addCommand(cmd);
1293 }
1294
1295 private:
1296 MergeDownInfoBaseSP m_info;
1297 KisNodeSP m_putAfter;
1298 bool m_relinkClones {false};
1299 };
1300
1301 SwitchFrameCommand::SharedStorage::~SharedStorage() {
1302 }
1303
1304 SwitchFrameCommand::SwitchFrameCommand(KisImageSP image, int time, bool finalize, SharedStorageSP storage)
1305 : FlipFlopCommand(finalize),
1306 m_image(image),
1307 m_newTime(time),
1308 m_storage(storage) {}
1309
1310 SwitchFrameCommand::~SwitchFrameCommand() {}
1311
1312 void SwitchFrameCommand::partA() {
1313 KisImageAnimationInterface *interface = m_image->animationInterface();
1314 const int currentTime = interface->currentTime();
1315 if (currentTime == m_newTime) {
1316 m_storage->value = m_newTime;
1317 return;
1318 }
1319
1320 interface->image()->disableUIUpdates();
1321 interface->saveAndResetCurrentTime(m_newTime, &m_storage->value);
1322 }
1323
1324 void SwitchFrameCommand::partB() {
1325 KisImageAnimationInterface *interface = m_image->animationInterface();
1326 const int currentTime = interface->currentTime();
1327 if (currentTime == m_storage->value) {
1328 return;
1329 }
1330
1331 interface->restoreCurrentTime(&m_storage->value);
1332 interface->image()->enableUIUpdates();
1333 }
1334
1335 struct AddNewFrame : public KisCommandUtils::AggregateCommand {
1336 AddNewFrame(KisNodeSP node, int frame) : m_node(node), m_frame(frame) {}
1337 AddNewFrame(KisNodeSP node, int frame, KisNodeList sampleNodes) : m_node(node), m_frame(frame), m_sampledNodes(sampleNodes) {}
1338 AddNewFrame(KisNodeSP node, int frame, KisNodeSP source) : m_node(node), m_frame(frame) { m_sampledNodes << source; }
1339 AddNewFrame(MergeDownInfoBaseSP info, int frame) : m_frame(frame), m_sampledNodes(info->allSrcNodes()), m_mergeInfo(info) {}
1340
1341 void populateChildCommands() override {
1342 KUndo2Command *cmd = new KUndo2Command;
1343 KisNodeSP node = m_node ? m_node : m_mergeInfo->dstNode;
1344 KisKeyframeChannel *channel = node->getKeyframeChannel(KisKeyframeChannel::Raster.id(), true);
1345 channel->addKeyframe(m_frame, cmd);
1346
1347 if (m_sampledNodes.count() > 0) {
1348 applyKeyframeColorLabel(channel->keyframeAt(m_frame), m_sampledNodes);
1349 }
1350
1351 addCommand(cmd);
1352 }
1353
1354 void applyKeyframeColorLabel(KisKeyframeSP dstKeyframe, KisNodeList srcNodes) {
1355 Q_FOREACH(KisNodeSP srcNode, srcNodes) {
1356 Q_FOREACH(KisKeyframeChannel *channel, srcNode->keyframeChannels().values()) {
1357 KisKeyframeSP keyframe = channel->keyframeAt(m_frame);
1358 if (!keyframe.isNull() && keyframe->colorLabel() != 0) {
1359 dstKeyframe->setColorLabel(keyframe->colorLabel());
1360 return;
1361 }
1362 }
1363 }
1364
1365 dstKeyframe->setColorLabel(0);
1366 }
1367
1368 private:
1369 KisNodeSP m_node;
1370 int m_frame;
1371 KisNodeList m_sampledNodes;
1372 MergeDownInfoBaseSP m_mergeInfo;
1373 };
1374
1375 QSet<int> fetchLayerFrames(KisNodeSP node) {
1376 QSet<int> frames;
1377 Q_FOREACH(KisKeyframeChannel *channel, node->keyframeChannels()) {
1378 if (!channel) {
1379 continue;
1380 }
1381
1382 KisRasterKeyframeChannel *rasterChan = dynamic_cast<KisRasterKeyframeChannel*>(channel);
1383 if (rasterChan) {
1384 frames.unite(rasterChan->allKeyframeTimes());
1385 continue;
1386 }
1387
1388 KisScalarKeyframeChannel *scalarChan = dynamic_cast<KisScalarKeyframeChannel*>(channel);
1389 if (scalarChan) {
1390 const int initialKeyframe = scalarChan->firstKeyframeTime();
1391
1392 if (initialKeyframe == -1) {
1393 continue;
1394 }
1395
1396 const int lastKeyframe = scalarChan->lastKeyframeTime();
1397 KisTimeSpan currentSpan = scalarChan->identicalFrames(initialKeyframe);
1398 while (!currentSpan.isInfinite() && currentSpan.isValid() && currentSpan.start() < lastKeyframe) {
1399 frames.insert(currentSpan.start());
1400 currentSpan = scalarChan->identicalFrames(currentSpan.end() + 1);
1401 }
1402
1403 frames.insert(lastKeyframe);
1404 }
1405
1406 }
1407
1408 return frames;
1409 }
1410
1411 QSet<int> fetchLayerFramesRecursive(KisNodeSP rootNode) {
1412 if (!rootNode->visible()) return QSet<int>();
1413
1414 QSet<int> frames = fetchLayerFrames(rootNode);
1415
1416 KisNodeSP node = rootNode->firstChild();
1417 while(node) {
1418 frames |= fetchLayerFramesRecursive(node);
1419 node = node->nextSibling();
1420 }
1421
1422 return frames;
1423 }
1424
1425 void updateFrameJobs(FrameJobs *jobs, KisNodeSP node) {
1426 QSet<int> frames = fetchLayerFrames(node);
1427 frames = fetchUniqueFrameTimes(node, frames, false);
1428
1429 if (frames.isEmpty()) {
1430 (*jobs)[0].insert(node);
1431 } else {
1432 foreach (int frame, frames) {
1433 (*jobs)[frame].insert(node);
1434 }
1435 }
1436 }
1437
1438 void updateFrameJobsRecursive(FrameJobs *jobs, KisNodeSP rootNode) {
1439 updateFrameJobs(jobs, rootNode);
1440
1441 KisNodeSP node = rootNode->firstChild();
1442 while(node) {
1443 updateFrameJobsRecursive(jobs, node);
1444 node = node->nextSibling();
1445 }
1446 }
1447
1451 void mergeDown(KisImageSP image, KisLayerSP layer, const KisMetaData::MergeStrategy* strategy, MergeFlags flags)
1452 {
1453 if (!layer->prevSibling()) return;
1454
1455 // XXX: this breaks if we allow free mixing of masks and layers
1456 KisLayerSP prevLayer = qobject_cast<KisLayer*>(layer->prevSibling().data());
1457
1458 while (prevLayer && prevLayer->isFakeNode()) {
1459 prevLayer = qobject_cast<KisLayer*>(prevLayer->prevSibling().data());
1460 }
1461
1462 if (!prevLayer) return;
1463
1464 if (!layer->visible() && !prevLayer->visible()) {
1465 return;
1466 }
1467
1468 KisImageSignalVector emitSignals;
1469 KisProcessingApplicator applicator(image, 0,
1470 KisProcessingApplicator::NONE,
1471 emitSignals,
1472 kundo2_i18n("Merge Down"));
1473
1474 if (layer->visible() && prevLayer->visible()) {
1475 MergeDownInfoSP info(new MergeDownInfo(image, prevLayer, layer, flags));
1476
1477 // disable key strokes on all colorize masks, all onion skins on
1478 // paint layers and wait until update is finished with a barrier
1479 applicator.applyCommand(new DisableColorizeKeyStrokes(info));
1480 applicator.applyCommand(new DisableOnionSkins(info));
1481 applicator.applyCommand(new KUndo2Command(), KisStrokeJobData::BARRIER);
1482
1483 applicator.applyCommand(new KeepMergedNodesSelected(info, false));
1484 applicator.applyCommand(new FillSelectionMasks(info));
1485 applicator.applyCommand(new CreateMergedLayer(info), KisStrokeJobData::BARRIER);
1486
1487 // NOTE: shape layer may have emitted spontaneous jobs during layer creation,
1488 // wait for them to complete!
1489 applicator.applyCommand(new RefreshDelayedUpdateLayers(info), KisStrokeJobData::BARRIER);
1490 applicator.applyCommand(new KUndo2Command(), KisStrokeJobData::BARRIER);
1491
1492 // in two-layer mode we disable pass through only when the destination layer
1493 // is not a group layer
1494 applicator.applyCommand(new DisablePassThroughForHeadsOnly(info, true));
1495 applicator.applyCommand(new KUndo2Command(), KisStrokeJobData::BARRIER);
1496
1497 if (info->frames.size() > 0) {
1502 const int currentTimeOnStart = info->image->animationInterface()->currentTime();
1503
1504 foreach (int frame, info->frames) {
1505 applicator.applyCommand(new SwitchFrameCommand(info->image, frame, false, info->storage));
1506
1507 applicator.applyCommand(new AddNewFrame(info, frame));
1514 applicator.applyCommand(new RefreshHiddenAreas(info, RefreshHiddenAreas::refresh_entire_image));
1515 applicator.applyCommand(new RefreshDelayedUpdateLayers(info), KisStrokeJobData::BARRIER);
1516
1525 const bool skipMergingSourceLayer = !layer->isAnimated() &&
1526 frame != currentTimeOnStart;
1527
1528 applicator.applyCommand(new MergeLayers(info, skipMergingSourceLayer), KisStrokeJobData::BARRIER);
1529
1530 applicator.applyCommand(new SwitchFrameCommand(info->image, frame, true, info->storage), KisStrokeJobData::BARRIER);
1531 }
1532 } else {
1533 applicator.applyCommand(new RefreshHiddenAreas(info));
1534 applicator.applyCommand(new RefreshDelayedUpdateLayers(info), KisStrokeJobData::BARRIER);
1535 applicator.applyCommand(new MergeLayers(info, false), KisStrokeJobData::BARRIER);
1536 }
1537
1538 applicator.applyCommand(new MergeMetaData(info, strategy), KisStrokeJobData::BARRIER);
1539 applicator.applyCommand(new CleanUpNodes(info, layer),
1540 KisStrokeJobData::SEQUENTIAL,
1541 KisStrokeJobData::EXCLUSIVE);
1542 applicator.applyCommand(new KeepMergedNodesSelected(info, true));
1543 } else if (layer->visible()) {
1544 applicator.applyCommand(new KeepNodesSelectedCommand(KisNodeList(), KisNodeList(),
1545 layer, KisNodeSP(),
1546 image, false));
1547
1548 applicator.applyCommand(
1549 new SimpleRemoveLayers(KisNodeList() << prevLayer,
1550 image),
1551 KisStrokeJobData::SEQUENTIAL,
1552 KisStrokeJobData::EXCLUSIVE);
1553
1554 applicator.applyCommand(new KeepNodesSelectedCommand(KisNodeList(), KisNodeList(),
1555 KisNodeSP(), layer,
1556 image, true));
1557 } else if (prevLayer->visible()) {
1558 applicator.applyCommand(new KeepNodesSelectedCommand(KisNodeList(), KisNodeList(),
1559 layer, KisNodeSP(),
1560 image, false));
1561
1562 applicator.applyCommand(
1563 new SimpleRemoveLayers(KisNodeList() << layer,
1564 image),
1565 KisStrokeJobData::SEQUENTIAL,
1566 KisStrokeJobData::EXCLUSIVE);
1567
1568 applicator.applyCommand(new KeepNodesSelectedCommand(KisNodeList(), KisNodeList(),
1569 KisNodeSP(), prevLayer,
1570 image, true));
1571 }
1572
1573 applicator.end();
1574 }
1575
1576 bool checkIsChildOf(KisNodeSP node, const KisNodeList &parents)
1577 {
1578 KisNodeList nodeParents;
1579
1580 KisNodeSP parent = node->parent();
1581 while (parent) {
1582 nodeParents << parent;
1583 parent = parent->parent();
1584 }
1585
1586 foreach(KisNodeSP perspectiveParent, parents) {
1587 if (nodeParents.contains(perspectiveParent)) {
1588 return true;
1589 }
1590 }
1591
1592 return false;
1593 }
1594
1595 bool checkIsCloneOf(KisNodeSP node, const KisNodeList &nodes)
1596 {
1597 bool result = false;
1598
1599 KisCloneLayer *clone = dynamic_cast<KisCloneLayer*>(node.data());
1600 if (clone) {
1601 KisNodeSP cloneSource = KisNodeSP(clone->copyFrom());
1602
1603 Q_FOREACH(KisNodeSP subtree, nodes) {
1604 result =
1605 recursiveFindNode(subtree,
1606 [cloneSource](KisNodeSP node) -> bool
1607 {
1608 return node == cloneSource;
1609 });
1610
1611 if (!result) {
1612 result = checkIsCloneOf(cloneSource, nodes);
1613 }
1614
1615 if (result) {
1616 break;
1617 }
1618 }
1619 }
1620
1621 return result;
1622 }
1623
1624 void filterMergeableNodes(KisNodeList &nodes, bool allowMasks)
1625 {
1626 KisNodeList::iterator it = nodes.begin();
1627
1628 while (it != nodes.end()) {
1629 if ((!allowMasks && !qobject_cast<KisLayer*>(it->data())) ||
1630 checkIsChildOf(*it, nodes)) {
1631 //qDebug() << "Skipping node" << ppVar((*it)->name());
1632 it = nodes.erase(it);
1633 } else {
1634 ++it;
1635 }
1636 }
1637 }
1638
1639 void sortMergeableNodes(KisNodeSP root, KisNodeList &inputNodes, KisNodeList &outputNodes)
1640 {
1641 KisNodeList::iterator it = std::find(inputNodes.begin(), inputNodes.end(), root);
1642
1643 if (it != inputNodes.end()) {
1644 outputNodes << *it;
1645 inputNodes.erase(it);
1646 }
1647
1648 if (inputNodes.isEmpty()) {
1649 return;
1650 }
1651
1652 KisNodeSP child = root->firstChild();
1653 while (child) {
1654 sortMergeableNodes(child, inputNodes, outputNodes);
1655 child = child->nextSibling();
1656 }
1657
1661 KIS_ASSERT_RECOVER_NOOP(root->parent() || inputNodes.isEmpty());
1662 }
1663
1664 KisNodeList sortMergeableNodes(KisNodeSP root, KisNodeList nodes)
1665 {
1666 KisNodeList result;
1667 sortMergeableNodes(root, nodes, result);
1668 return result;
1669 }
1670
1671 KisNodeList sortAndFilterMergeableInternalNodes(KisNodeList nodes, bool allowMasks)
1672 {
1673 KIS_SAFE_ASSERT_RECOVER(!nodes.isEmpty()) { return nodes; }
1674
1675 KisNodeSP root;
1676 Q_FOREACH(KisNodeSP node, nodes) {
1677 KisNodeSP localRoot = node;
1678 while (localRoot->parent()) {
1679 localRoot = localRoot->parent();
1680 }
1681
1682 if (!root) {
1683 root = localRoot;
1684 }
1685 KIS_SAFE_ASSERT_RECOVER(root == localRoot) { return nodes; }
1686 }
1687
1688 KisNodeList result;
1689 sortMergeableNodes(root, nodes, result);
1690 filterMergeableNodes(result, allowMasks);
1691 return result;
1692 }
1693
1694 KisNodeList sortMergeableInternalNodes(KisNodeList nodes)
1695 {
1696 KIS_SAFE_ASSERT_RECOVER(!nodes.isEmpty()) { return nodes; }
1697
1698 KisNodeSP root;
1699 Q_FOREACH(KisNodeSP node, nodes) {
1700 KisNodeSP localRoot = node;
1701 while (localRoot->parent()) {
1702 localRoot = localRoot->parent();
1703 }
1704
1705 if (!root) {
1706 root = localRoot;
1707 }
1708 KIS_SAFE_ASSERT_RECOVER(root == localRoot) { return nodes; }
1709 }
1710
1711 KisNodeList result;
1712 sortMergeableNodes(root, nodes, result);
1713 return result;
1714 }
1715
1716 KisNodeList sortAndFilterAnyMergeableNodesSafe(const KisNodeList &nodes, KisImageSP image) {
1717 KisNodeList filteredNodes = nodes;
1718 KisNodeList sortedNodes;
1719
1720 KisLayerUtils::filterMergeableNodes(filteredNodes, true);
1721
1722 bool haveExternalNodes = false;
1723 Q_FOREACH (KisNodeSP node, nodes) {
1724 if (node->graphListener() != image->root()->graphListener()) {
1725 haveExternalNodes = true;
1726 break;
1727 }
1728 }
1729
1730 if (!haveExternalNodes) {
1731 KisLayerUtils::sortMergeableNodes(image->root(), filteredNodes, sortedNodes);
1732 } else {
1733 sortedNodes = filteredNodes;
1734 }
1735
1736 return sortedNodes;
1737 }
1738
1739
1740 void addCopyOfNameTag(KisNodeSP node)
1741 {
1742 if (!KisImageConfig(true).renameDuplicatedLayers()) { return; }
1743
1744 const QString prefix = i18n("Copy of");
1745 QString newName = node->name();
1746 if (!newName.startsWith(prefix)) {
1747 newName = QString("%1 %2").arg(prefix).arg(newName);
1748 node->setName(newName);
1749 }
1750 }
1751
1752 KisNodeList findNodesWithProps(KisNodeSP root, const KoProperties &props, bool excludeRoot)
1753 {
1754 KisNodeList nodes;
1755
1756 if ((!excludeRoot || root->parent()) && root->check(props)) {
1757 nodes << root;
1758 }
1759
1760 KisNodeSP node = root->firstChild();
1761 while (node) {
1762 nodes += findNodesWithProps(node, props, excludeRoot);
1763 node = node->nextSibling();
1764 }
1765
1766 return nodes;
1767 }
1768
1769 KisNodeList filterInvisibleNodes(const KisNodeList &nodes, KisNodeList *invisibleNodes, KisNodeSP *putAfter)
1770 {
1771 KIS_ASSERT_RECOVER(invisibleNodes) { return nodes; }
1772 KIS_ASSERT_RECOVER(putAfter) { return nodes; }
1773
1774 KisNodeList visibleNodes;
1775 int putAfterIndex = -1;
1776
1777 Q_FOREACH(KisNodeSP node, nodes) {
1778 if (node->visible()) {
1779 visibleNodes << node;
1780 } else if (node->userLocked()) {
1785 } else {
1786 *invisibleNodes << node;
1787
1788 if (node == *putAfter) {
1789 putAfterIndex = visibleNodes.size() - 1;
1790 }
1791 }
1792 }
1793
1794 if (!visibleNodes.isEmpty() && putAfterIndex >= 0) {
1795 putAfterIndex = qBound(0, putAfterIndex, visibleNodes.size() - 1);
1796 *putAfter = visibleNodes[putAfterIndex];
1797 }
1798
1799 return visibleNodes;
1800 }
1801
1802 void filterUnlockedNodes(KisNodeList &nodes)
1803 {
1804 KisNodeList::iterator it = nodes.begin();
1805
1806 while (it != nodes.end()) {
1807 if ((*it)->userLocked()) {
1808 it = nodes.erase(it);
1809 } else {
1810 ++it;
1811 }
1812 }
1813 }
1814
1815 void changeImageDefaultProjectionColor(KisImageSP image, const KoColor &color)
1816 {
1817 KisImageSignalVector emitSignals;
1818 KisProcessingApplicator applicator(image,
1819 image->root(),
1820 KisProcessingApplicator::RECURSIVE,
1821 emitSignals,
1822 kundo2_i18n("Change projection color"),
1823 0,
1824 KisCommandUtils::ChangeProjectionColorCommand);
1825 applicator.applyCommand(new KisChangeProjectionColorCommand(image, color), KisStrokeJobData::BARRIER, KisStrokeJobData::EXCLUSIVE);
1826 applicator.end();
1827 }
1828
1829 struct EphemeralCommandsWrapper : KisCommandUtils::AggregateCommand
1830 {
1831 EphemeralCommandsWrapper(MergeMultipleInfoSP info, QVector<KUndo2Command*> commands, bool cleanupNodes)
1832 : m_info(info)
1833 , m_commands(commands)
1834 , m_cleanupNodes(cleanupNodes)
1835 {
1836 }
1837
1838 void populateChildCommands() {
1839 if (!m_cleanupNodes && !m_info->ephemeralCommandsStore) {
1840 m_info->ephemeralCommandsStore.reset(new KisSurrogateUndoStore());
1841 }
1842
1843 Q_FOREACH (KUndo2Command *cmd, m_commands) {
1844 if (m_cleanupNodes) {
1845 addCommand(cmd);
1846 } else {
1847 m_info->ephemeralCommandsStore->addCommand(cmd);
1848 }
1849 }
1850 m_commands.clear();
1851 m_info.reset();
1852 }
1853
1854 private:
1855 MergeMultipleInfoSP m_info;
1856 QVector<KUndo2Command*> m_commands;
1857 bool m_cleanupNodes {true};
1858 };
1859
1860 struct UndoEphemeralCommands : KisCommandUtils::AggregateCommand
1861 {
1862 UndoEphemeralCommands(MergeMultipleInfoSP info)
1863 : m_info(info)
1864 {
1865 }
1866
1867 void populateChildCommands() {
1868 KIS_SAFE_ASSERT_RECOVER_RETURN(m_info->ephemeralCommandsStore);
1869 m_info->ephemeralCommandsStore->undoAll();
1870
1871 }
1872
1873 private:
1874 MergeMultipleInfoSP m_info;
1875 };
1876
1902 void mergeMultipleLayersImpl(KisImageSP image, KisNodeList mergedNodes, KisNodeSP putAfter,
1903 bool flattenSingleLayer, const KUndo2MagicString &actionName,
1904 bool cleanupNodes = true, const QString layerName = QString(),
1905 MergeFlags flags = None)
1906 {
1907 if (!putAfter) {
1908 putAfter = mergedNodes.first();
1909 }
1910
1911 filterMergeableNodes(mergedNodes);
1912 {
1913 KisNodeList tempNodes;
1914 std::swap(mergedNodes, tempNodes);
1915 sortMergeableNodes(image->root(), tempNodes, mergedNodes);
1916 }
1917
1918 if (mergedNodes.size() <= 1 &&
1919 (!flattenSingleLayer && mergedNodes.size() == 1)) return;
1920
1921 KisImageSignalVector emitSignals;
1922 emitSignals << ComplexNodeReselectionSignal(KisNodeSP(), KisNodeList(), KisNodeSP(), mergedNodes);
1923
1924
1925
1926 KisNodeList originalNodes = mergedNodes;
1927 KisNodeList invisibleNodes;
1928 mergedNodes = filterInvisibleNodes(originalNodes, &invisibleNodes, &putAfter);
1929
1930 if (mergedNodes.isEmpty()) return;
1931
1932
1933 // make sure we don't add the new layer into a locked group
1934 KIS_SAFE_ASSERT_RECOVER_RETURN(putAfter->parent());
1935 while (putAfter->parent() && !putAfter->parent()->isEditable()) {
1936 putAfter = putAfter->parent();
1937 }
1938
1946 if (!putAfter->parent()) {
1947 return;
1948 }
1949
1950 KisProcessingApplicator applicator(image, 0,
1951 KisProcessingApplicator::NONE,
1952 emitSignals,
1953 actionName);
1954
1955
1956 if (!invisibleNodes.isEmpty() && cleanupNodes) {
1957
1958 /* If the putAfter node is invisible,
1959 * we should instead pick one of the nodes
1960 * to be merged to avoid a null putAfter
1961 * after we remove all invisible layers from
1962 * the image.
1963 * (The assumption is that putAfter is among
1964 * the layers to merge, so if it's invisible,
1965 * it's going to be removed)
1966 */
1967 if (!putAfter->visible()){
1968 putAfter = mergedNodes.first();
1969 }
1970
1971 applicator.applyCommand(
1972 new SimpleRemoveLayers(invisibleNodes,
1973 image),
1974 KisStrokeJobData::SEQUENTIAL,
1975 KisStrokeJobData::EXCLUSIVE);
1976 }
1977
1978 if (mergedNodes.size() > 1 || invisibleNodes.isEmpty()) {
1979 MergeMultipleInfoSP info(new MergeMultipleInfo(image, mergedNodes, flags));
1980
1981 // disable key strokes on all colorize masks, all onion skins on
1982 // paint layers and wait until update is finished with a barrier
1983 //
1984 // when doing "new layer from visible" we should undo these changes
1985 // before the action stops, because the source layers are **not**
1986 // removed as a result of this action
1987 applicator.applyCommand(
1988 new EphemeralCommandsWrapper(info,
1989 {
1990 new DisableColorizeKeyStrokes(info),
1991 new DisableOnionSkins(info),
1992 new DisablePassThroughForHeadsOnly(info)
1993 },
1994 cleanupNodes));
1995 applicator.applyCommand(new KUndo2Command(), KisStrokeJobData::BARRIER);
1996
1997 applicator.applyCommand(new KeepMergedNodesSelected(info, putAfter, false));
1998 applicator.applyCommand(new FillSelectionMasks(info));
1999 applicator.applyCommand(new CreateMergedLayerMultiple(info, layerName), KisStrokeJobData::BARRIER);
2000 applicator.applyCommand(new EphemeralCommandsWrapper(info, { new DisableExtraCompositing(info) } , cleanupNodes));
2001 applicator.applyCommand(new KUndo2Command(), KisStrokeJobData::BARRIER);
2002
2003 if (!info->frames.isEmpty()) {
2004 foreach (int frame, info->frames) {
2005 applicator.applyCommand(new SwitchFrameCommand(info->image, frame, false, info->storage));
2006
2007 applicator.applyCommand(new AddNewFrame(info, frame));
2014 applicator.applyCommand(new RefreshHiddenAreas(info, RefreshHiddenAreas::refresh_entire_image));
2015 applicator.applyCommand(new RefreshDelayedUpdateLayers(info), KisStrokeJobData::BARRIER);
2016 applicator.applyCommand(new MergeLayersMultiple(info), KisStrokeJobData::BARRIER);
2017
2018 applicator.applyCommand(new SwitchFrameCommand(info->image, frame, true, info->storage));
2019 }
2020 } else {
2021 applicator.applyCommand(new RefreshHiddenAreas(info));
2022 applicator.applyCommand(new RefreshDelayedUpdateLayers(info), KisStrokeJobData::BARRIER);
2023 applicator.applyCommand(new MergeLayersMultiple(info), KisStrokeJobData::BARRIER);
2024 }
2025
2026 //applicator.applyCommand(new MergeMetaData(info, strategy), KisStrokeJobData::BARRIER);
2027 if (cleanupNodes){
2028 applicator.applyCommand(new CleanUpNodes(info, putAfter, flattenSingleLayer),
2029 KisStrokeJobData::SEQUENTIAL,
2030 KisStrokeJobData::EXCLUSIVE);
2031 } else {
2032 applicator.applyCommand(new UndoEphemeralCommands(info));
2033 applicator.applyCommand(new InsertNode(info, putAfter),
2034 KisStrokeJobData::SEQUENTIAL,
2035 KisStrokeJobData::EXCLUSIVE);
2036 }
2037
2038 applicator.applyCommand(new KeepMergedNodesSelected(info, putAfter, true));
2039 }
2040
2041 applicator.end();
2042
2043 }
2044
2045 void mergeMultipleLayers(KisImageSP image, KisNodeList mergedNodes, KisNodeSP putAfter, MergeFlags flags)
2046 {
2047 mergeMultipleLayersImpl(image, mergedNodes, putAfter,
2048 false, kundo2_i18n("Merge Selected Nodes"),
2049 true, QString(),
2050 flags);
2051 }
2052
2053 void mergeMultipleNodes(KisImageSP image, KisNodeList mergedNodes, KisNodeSP putAfter, MergeFlags flags)
2054 {
2055 if (!tryMergeSelectionMasks(image, mergedNodes, putAfter)) {
2056 mergeMultipleLayers(image, mergedNodes, putAfter, flags);
2057 }
2058 }
2059
2060 void newLayerFromVisible(KisImageSP image, KisNodeSP putAfter, MergeFlags flags)
2061 {
2062 KisNodeList mergedNodes;
2063 mergedNodes << image->root();
2064
2065 mergeMultipleLayersImpl(image, mergedNodes, putAfter,
2066 true, kundo2_i18n("New From Visible"),
2067 false, i18nc("New layer created from all the visible layers", "Visible"),
2068 flags);
2069 }
2070
2071 struct MergeSelectionMasks : public KisCommandUtils::AggregateCommand {
2072 MergeSelectionMasks(MergeDownInfoBaseSP info, KisNodeSP putAfter)
2073 : m_info(info),
2074 m_putAfter(putAfter){}
2075
2076 void populateChildCommands() override {
2077 KisNodeSP parent;
2078 CleanUpNodes::findPerfectParent(m_info->allSrcNodes(), m_putAfter, parent);
2079
2080 KisLayerSP parentLayer;
2081 do {
2082 parentLayer = qobject_cast<KisLayer*>(parent.data());
2083
2084 parent = parent->parent();
2085 } while(!parentLayer && parent);
2086
2087 KisSelectionSP selection = new KisSelection();
2088
2089 foreach (KisNodeSP node, m_info->allSrcNodes()) {
2090 KisMaskSP mask = dynamic_cast<KisMask*>(node.data());
2091 if (!mask) continue;
2092
2093 selection->pixelSelection()->applySelection(
2094 mask->selection()->pixelSelection(), SELECTION_ADD);
2095 }
2096
2097 KisSelectionMaskSP mergedMask = new KisSelectionMask(m_info->image, i18n("Selection Mask"));
2098 mergedMask->initSelection(parentLayer);
2099 mergedMask->setSelection(selection);
2100
2101 m_info->dstNode = mergedMask;
2102 }
2103
2104 private:
2105 MergeDownInfoBaseSP m_info;
2106 KisNodeSP m_putAfter;
2107 };
2108
2109 struct ActivateSelectionMask : public KisCommandUtils::AggregateCommand {
2112
2113 void populateChildCommands() override {
2114 KisSelectionMaskSP mergedMask = dynamic_cast<KisSelectionMask*>(m_info->dstNode.data());
2115 addCommand(new KisActivateSelectionMaskCommand(mergedMask, true));
2116 }
2117
2118 private:
2119 MergeDownInfoBaseSP m_info;
2120 };
2121
2122 bool tryMergeSelectionMasks(KisImageSP image, KisNodeList mergedNodes, KisNodeSP putAfter)
2123 {
2124 QList<KisSelectionMaskSP> selectionMasks;
2125
2126 for (auto it = mergedNodes.begin(); it != mergedNodes.end(); /*noop*/) {
2127 KisSelectionMaskSP mask = dynamic_cast<KisSelectionMask*>(it->data());
2128 if (!mask) {
2129 it = mergedNodes.erase(it);
2130 } else {
2131 selectionMasks.append(mask);
2132 ++it;
2133 }
2134 }
2135
2136 if (mergedNodes.isEmpty()) return false;
2137
2138 KisLayerSP parentLayer = qobject_cast<KisLayer*>(selectionMasks.first()->parent().data());
2139 KIS_ASSERT_RECOVER(parentLayer) { return 0; }
2140
2141 KisImageSignalVector emitSignals;
2142
2143 KisProcessingApplicator applicator(image, 0,
2144 KisProcessingApplicator::NONE,
2145 emitSignals,
2146 kundo2_i18n("Merge Selection Masks"));
2147
2148 MergeMultipleInfoSP info(new MergeMultipleInfo(image, mergedNodes, None));
2149
2150
2151 applicator.applyCommand(new MergeSelectionMasks(info, putAfter));
2152 applicator.applyCommand(new CleanUpNodes(info, putAfter),
2153 KisStrokeJobData::SEQUENTIAL,
2154 KisStrokeJobData::EXCLUSIVE);
2155 applicator.applyCommand(new ActivateSelectionMask(info));
2156 applicator.end();
2157
2158 return true;
2159 }
2160
2161 void flattenLayer(KisImageSP image, KisLayerSP layer, MergeFlags flags)
2162 {
2163 if (!layer->childCount() && !layer->layerStyle())
2164 return;
2165
2166 KisNodeList mergedNodes;
2167 mergedNodes << layer;
2168
2169 mergeMultipleLayersImpl(image, mergedNodes, layer,
2170 true, kundo2_i18n("Flatten Layer"),
2171 true, QString(),
2172 flags);
2173 }
2174
2175 void flattenImage(KisImageSP image, KisNodeSP activeNode, MergeFlags flags)
2176 {
2177 if (!activeNode) {
2178 activeNode = image->root()->lastChild();
2179 }
2180
2181
2182 KisNodeList mergedNodes;
2183 mergedNodes << image->root();
2184
2185 mergeMultipleLayersImpl(image, mergedNodes, activeNode,
2186 true, kundo2_i18n("Flatten Image"),
2187 true, QString(),
2188 flags);
2189 }
2190
2191 KisSimpleUpdateCommand::KisSimpleUpdateCommand(KisNodeList nodes, bool finalize, KUndo2Command *parent)
2192 : FlipFlopCommand(finalize, parent),
2193 m_nodes(nodes)
2194 {
2195 }
2200 void KisSimpleUpdateCommand::updateNodes(const KisNodeList &nodes)
2201 {
2202 Q_FOREACH(KisNodeSP node, nodes) {
2203 node->setDirty(node->extent());
2204 }
2205 }
2206
2207 KisNodeSP recursiveFindNode(KisNodeSP node, std::function<bool(KisNodeSP)> func)
2208 {
2209 if (func(node)) {
2210 return node;
2211 }
2212
2213 node = node->firstChild();
2214 while (node) {
2215 KisNodeSP resultNode = recursiveFindNode(node, func);
2216 if (resultNode) {
2217 return resultNode;
2218 }
2219 node = node->nextSibling();
2220 }
2221
2222 return 0;
2223 }
2224
2225 KisNodeSP findNodeByUuid(KisNodeSP root, const QUuid &uuid)
2226 {
2227 return recursiveFindNode(root,
2228 [uuid] (KisNodeSP node) {
2229 return node->uuid() == uuid;
2230 });
2231 }
2232
2233 QList<KisNodeSP> findNodesByName(KisNodeSP root, const QString &name, bool recursive, bool partialMatch)
2234 {
2235 KisNodeList nodeList;
2236 KisNodeSP child = root->firstChild();
2237
2238 while (child) {
2239 if (name.isEmpty() || (!partialMatch && child->name() == name) || (partialMatch && child->name().contains(name, Qt::CaseInsensitive))) {
2240 nodeList << child;
2241 }
2242 if (recursive && child->childCount() > 0) {
2243 nodeList << findNodesByName(child, name, recursive, partialMatch);
2244 }
2245 child = child->nextSibling();
2246 }
2247
2248 return nodeList;
2249 }
2250
2251 KisNodeSP findNodeByName(KisNodeSP root, const QString &name)
2252 {
2253 return recursiveFindNode(root,
2254 [name] (KisNodeSP node) {
2255 return node->name() == name;
2256 });
2257 }
2258
2259 KisNodeSP findIsolationRoot(KisNodeSP node)
2260 {
2261 KisImageSP image = node->image();
2262 if (image)
2263 return image->isolationRootNode();
2264 return nullptr;
2265 }
2266
2267 void forceAllDelayedNodesUpdate(KisNodeSP root)
2268 {
2269 KisLayerUtils::recursiveApplyNodes(root,
2270 [] (KisNodeSP node) {
2271 KisDelayedUpdateNodeInterface *delayedUpdate =
2272 dynamic_cast<KisDelayedUpdateNodeInterface*>(node.data());
2273 if (delayedUpdate) {
2274 delayedUpdate->forceUpdateTimedNode();
2275 }
2276 });
2277 }
2278
2279 bool hasDelayedNodeWithUpdates(KisNodeSP root)
2280 {
2281 return recursiveFindNode(root,
2282 [] (KisNodeSP node) {
2283 KisDelayedUpdateNodeInterface *delayedUpdate =
2284 dynamic_cast<KisDelayedUpdateNodeInterface*>(node.data());
2285
2286 return delayedUpdate ? delayedUpdate->hasPendingTimedUpdates() : false;
2287 });
2288 }
2289
2290 void forceAllHiddenOriginalsUpdate(KisNodeSP root)
2291 {
2292 KisLayerUtils::recursiveApplyNodes(root,
2293 [] (KisNodeSP node) {
2294 KisCroppedOriginalLayerInterface *croppedUpdate =
2295 dynamic_cast<KisCroppedOriginalLayerInterface*>(node.data());
2296 if (croppedUpdate) {
2297 croppedUpdate->forceUpdateHiddenAreaOnOriginal();
2298 }
2299 });
2300 }
2301
2302 KisImageSP findImageByHierarchy(KisNodeSP node)
2303 {
2304 while (node) {
2305 const KisLayer *layer = dynamic_cast<const KisLayer*>(node.data());
2306 if (layer) {
2307 return layer->image();
2308 }
2309
2310 node = node->parent();
2311 }
2312
2313 return 0;
2314 }
2315
2316 namespace Private {
2317 QRect realNodeChangeRect(KisNodeSP rootNode, QRect currentRect = QRect()) {
2318 KisNodeSP node = rootNode->firstChild();
2319
2320 while(node) {
2321 currentRect |= realNodeChangeRect(node, currentRect);
2322 node = node->nextSibling();
2323 }
2324
2325 if (!rootNode->isFakeNode() && !rootNode->projectionLeaf()->isMask()) {
2326 // TODO: it would be better to count up changeRect inside
2327 // node's extent() method
2328 //
2329 // NOTE: when flattening a group layer, we should take the change rect of the
2330 // all the child layers as the source of the change. We are calculating
2331 // the change rect **before** the update itself, therefore rootNode->exactBounds()
2332 // is not yet prepared, hence its exact bounds still contail old values.
2333 currentRect |= rootNode->projectionPlane()->changeRect(rootNode->exactBounds() | currentRect);
2334 }
2335
2336 return currentRect;
2337 }
2338 }
2339
2340namespace Private {
2341 void refreshHiddenAreaAsync(KisImageSP image, KisNodeSP rootNode, const QRect &preparedArea, const QRect &extraUpdateRect) {
2342 QRect realNodeRect = Private::realNodeChangeRect(rootNode) | extraUpdateRect;
2343 if (!preparedArea.contains(realNodeRect)) {
2344
2345 QRegion dirtyRegion = realNodeRect;
2346 dirtyRegion -= preparedArea;
2347
2348 auto rc = dirtyRegion.begin();
2349 while (rc != dirtyRegion.end()) {
2350 image->refreshGraphAsync(rootNode, *rc, realNodeRect);
2351 rc++;
2352 }
2353 }
2354 }
2355} // namespace Private
2356
2357 void refreshHiddenAreaAsync(KisImageSP image, KisNodeSP rootNode, const QRect &preparedArea) {
2358 Private::refreshHiddenAreaAsync(image, rootNode, preparedArea, QRect());
2359 }
2360
2361 QRect recursiveTightNodeVisibleBounds(KisNodeSP rootNode)
2362 {
2363 QRect exactBounds;
2364 recursiveApplyNodes(rootNode, [&exactBounds] (KisNodeSP node) {
2365 exactBounds |= node->projectionPlane()->tightUserVisibleBounds();
2366 });
2367 return exactBounds;
2368 }
2369
2370 KisNodeSP findRoot(KisNodeSP node)
2371 {
2372 if (!node) return node;
2373
2374 while (node->parent()) {
2375 node = node->parent();
2376 }
2377 return node;
2378 }
2379
2380 bool canChangeImageProfileInvisibly(KisImageSP image)
2381 {
2382 int numLayers = 0;
2383 bool hasNonNormalLayers = false;
2384 bool hasTransparentLayer = false;
2385
2386
2387 recursiveApplyNodes(image->root(),
2388 [&numLayers, &hasNonNormalLayers, &hasTransparentLayer, image] (KisNodeSP node) {
2389 if (!node->inherits("KisLayer")) return;
2390
2391 numLayers++;
2392
2393 if (node->exactBounds().isEmpty()) return;
2394
2395 // this is only an approximation! it is not exact!
2396 if (!hasTransparentLayer &&
2397 node->exactBounds() != image->bounds()) {
2398
2399 hasTransparentLayer = true;
2400 }
2401
2402 if (!hasNonNormalLayers &&
2403 node->compositeOpId() != COMPOSITE_OVER) {
2404
2405 hasNonNormalLayers = true;
2406 }
2407 });
2408
2409 return numLayers == 1 || (!hasNonNormalLayers && !hasTransparentLayer);
2410 }
2411
2412 void splitAlphaToMask(KisImageSP image, KisNodeSP node, const QString& maskName)
2413 {
2414 SplitAlphaToMaskInfoSP info( new SplitAlphaToMaskInfo(node->image(), node, maskName) );
2415
2416 KisImageSignalVector emitSignals;
2417 KisProcessingApplicator applicator(image, 0,
2418 KisProcessingApplicator::NONE,
2419 emitSignals,
2420 kundo2_i18n("Split Alpha into a Mask"));
2421
2422 applicator.applyCommand(new SimpleAddNode(info->image, info->getMask(), info->node), KisStrokeJobData::BARRIER);
2423 applicator.applyCommand(new InitSplitAlphaSelectionMask(info));
2424 if (info->frames.count() > 0) {
2425 Q_FOREACH(const int& frame, info->frames) {
2426 applicator.applyCommand(new SwitchFrameCommand(info->image, frame, false, info->storage));
2427 applicator.applyCommand(new AddNewFrame(info->getMask(), frame, info->node));
2428 applicator.applyCommand(new SplitAlphaCommand(info), KisStrokeJobData::BARRIER);
2429 applicator.applyCommand(new SwitchFrameCommand(info->image, frame, true, info->storage));
2430 }
2431 } else {
2432 applicator.applyCommand(new SplitAlphaCommand(info), KisStrokeJobData::BARRIER);
2433 }
2434 applicator.end();
2435 }
2436
2437 std::future<KisNodeSP> convertToPaintLayer(KisImageSP image, KisNodeSP src)
2438 {
2439 //Initialize all operation dependencies.
2440 ConvertToPaintLayerInfoSP info( new ConvertToPaintLayerInfo(image, src) );
2441
2442 if (!info->hasTargetNode())
2443 return kismpl::make_ready_future(KisNodeSP());
2444
2445 KisImageSignalVector emitSignals;
2446 KisProcessingApplicator applicator(image, 0, KisProcessingApplicator::NONE, emitSignals, kundo2_i18n("Convert to a Paint Layer"));
2447
2448 applicator.applyCommand(new SimpleAddNode(info->image(), info->targetNode(), info->insertionParent(), info->insertionPutAfter()), KisStrokeJobData::BARRIER);
2449
2450 if (info->frames().count() > 0) {
2451 Q_FOREACH(const int& frame, info->frames()) {
2452 applicator.applyCommand(new SwitchFrameCommand(info->image(), frame, false, info->storage));
2453 applicator.applyCommand(new RefreshDelayedUpdateLayers(info->sourceNodes()), KisStrokeJobData::BARRIER);
2454 applicator.applyCommand(new RefreshHiddenAreas(info->image(), info->sourceNode()), KisStrokeJobData::BARRIER);
2455 applicator.applyCommand(new AddNewFrame(info->targetNode(), frame, info->sourceNode()), KisStrokeJobData::BARRIER);
2456 applicator.applyCommand(new UploadProjectionToFrameCommand(info->sourceNode(), info->targetNode(), frame));
2457 applicator.applyCommand(new SwitchFrameCommand(info->image(), frame, true, info->storage));
2458 }
2459 }
2460
2461 applicator.applyCommand(new SimpleRemoveLayers(info->toRemove(), info->image()));
2462
2463 applicator.end();
2464
2465 return kismpl::then(applicator.successfullyCompletedFuture(),
2466 [node = info->targetNode()] (std::future<bool> completed) {
2467 return completed.get() ? node : KisNodeSP();
2468 });
2469 }
2470
2471 //===========================================================
2472
2473 int fetchLayerActiveRasterFrameID(KisNodeSP node)
2474 {
2475 KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(node, -1);
2476 KisPaintDeviceSP paintDevice = node->paintDevice();
2477 KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(paintDevice, -1);
2478
2479 if (!paintDevice->keyframeChannel()) {
2480 return -1;
2481 }
2482
2483 const int activeTime = paintDevice->keyframeChannel()->activeKeyframeTime();
2484 KisRasterKeyframeSP keyframe = paintDevice->keyframeChannel()->activeKeyframeAt<KisRasterKeyframe>(activeTime);
2485 KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(keyframe, -1);
2486
2487 return keyframe->frameID();
2488 }
2489
2490 int fetchLayerActiveRasterFrameTime(KisNodeSP node)
2491 {
2492 KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(node, -1);
2493 KisPaintDeviceSP paintDevice = node->paintDevice();
2494 KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(paintDevice, -1);
2495
2496 if (!paintDevice->keyframeChannel()) {
2497 return -1;
2498 }
2499
2500 return paintDevice->keyframeChannel()->activeKeyframeTime();
2501 }
2502
2503 KisTimeSpan fetchLayerActiveRasterFrameSpan(KisNodeSP node, const int time)
2504 {
2505 KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(node, KisTimeSpan::infinite(0));
2506 KisPaintDeviceSP paintDevice = node->paintDevice();
2507 KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(paintDevice, KisTimeSpan::infinite(0));
2508 if (!paintDevice->keyframeChannel()) {
2509 return KisTimeSpan::infinite(0);
2510 }
2511
2512 return paintDevice->keyframeChannel()->affectedFrames(time);
2513 }
2514
2515 QSet<int> fetchLayerIdenticalRasterFrameTimes(KisNodeSP node, const int &frameTime)
2516 {
2517 KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(node, QSet<int>());
2518 KisPaintDeviceSP paintDevice = node->paintDevice();
2519 KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(paintDevice, QSet<int>());
2520 if (!paintDevice->keyframeChannel()) {
2521 return QSet<int>();
2522 }
2523
2524 return paintDevice->keyframeChannel()->clonesOf(node.data(), frameTime);
2525 }
2526
2527 /* Finds all frames matching a specific frame ID. useful to filter out duplicate frames. */
2528 QSet<int> fetchLayerRasterFrameTimesMatchingID(KisNodeSP node, const int frameID) {
2529 KIS_ASSERT(node);
2530 KisRasterKeyframeChannel* rasterChannel = dynamic_cast<KisRasterKeyframeChannel*>(node->getKeyframeChannel(KisKeyframeChannel::Raster.id(), false));
2531
2532 if (!rasterChannel) {
2533 return QSet<int>();
2534 }
2535
2536 return rasterChannel->timesForFrameID(frameID);
2537 }
2538
2539 QSet<int> fetchLayerRasterIDsAtTimes(KisNodeSP node, const QSet<int> &times)
2540 {
2541 KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(node, QSet<int>());
2542 KisPaintDeviceSP paintDevice = node->paintDevice();
2543 KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(paintDevice, QSet<int>());
2544 if (!paintDevice->keyframeChannel()) {
2545 return QSet<int>();
2546 }
2547
2548 QSet<int> frameIDs;
2549
2550 Q_FOREACH( const int& frame, times ) {
2551 KisRasterKeyframeSP raster = paintDevice->keyframeChannel()->activeKeyframeAt<KisRasterKeyframe>(frame);
2552 frameIDs << raster->frameID();
2553 }
2554
2555 return frameIDs;
2556 }
2557
2558 QSet<int> filterTimesForOnlyRasterKeyedTimes(KisNodeSP node, const QSet<int> &times)
2559 {
2560 KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(node, times);
2561 KisPaintDeviceSP paintDevice = node->paintDevice();
2562 KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(paintDevice, times);
2563 if (!paintDevice->keyframeChannel()) {
2564 return times;
2565 }
2566
2567 return paintDevice->keyframeChannel()->allKeyframeTimes().intersect(times);
2568 }
2569
2570 QSet<int> fetchLayerUniqueRasterTimesMatchingIDs(KisNodeSP node, QSet<int>& frameIDs)
2571 {
2572 KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(node, QSet<int>());
2573 KisPaintDeviceSP paintDevice = node->paintDevice();
2574 KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(paintDevice, QSet<int>());
2575 KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(paintDevice->framesInterface(), QSet<int>());
2576
2577 QSet<int> uniqueTimes;
2578
2579 Q_FOREACH( const int& id, frameIDs) {
2580 QSet<int> times = fetchLayerRasterFrameTimesMatchingID(node, id);
2581 if (times.count() > 0) {
2582 uniqueTimes.insert(*times.begin());
2583 }
2584 }
2585
2586 return uniqueTimes;
2587 }
2588
2589 QSet<int> fetchUniqueFrameTimes(KisNodeSP node, QSet<int> selectedTimes, bool filterActiveFrameID)
2590 {
2591 if (selectedTimes.isEmpty() || !node->supportsKeyframeChannel(KisKeyframeChannel::Raster.id()))
2592 return selectedTimes;
2593
2594 // Convert a set of selected keyframe times into set of selected "frameIDs"...
2595 QSet<int> selectedFrameIDs = KisLayerUtils::fetchLayerRasterIDsAtTimes(node, selectedTimes);
2596
2597 if (filterActiveFrameID) {
2598 // Current frame was already filtered e.g. during filter preview in `KisFilterManager::apply`...
2599 // So let's remove it...
2600 const int currentActiveFrameID = KisLayerUtils::fetchLayerActiveRasterFrameID(node);
2601 selectedFrameIDs.remove(currentActiveFrameID);
2602 }
2603
2604 // Convert frameIDs to any arbitrary frame time associated with the frameID...
2605 QSet<int> uniqueFrameTimes = node->paintDevice()->framesInterface() ? KisLayerUtils::fetchLayerUniqueRasterTimesMatchingIDs(node, selectedFrameIDs) : QSet<int>();
2606
2607 return uniqueFrameTimes;
2608 }
2609
2610}
target
KisMagneticGraph::vertex_descriptor target(typename KisMagneticGraph::edge_descriptor e, KisMagneticGraph g)
Definition KisMagneticGraph.h:257
source
KisMagneticGraph::vertex_descriptor source(typename KisMagneticGraph::edge_descriptor e, KisMagneticGraph g)
Definition KisMagneticGraph.h:251
SELECTION_ADD
@ SELECTION_ADD
Definition KisSelectionTags.h:18
OPACITY_OPAQUE_U8
const quint8 OPACITY_OPAQUE_U8
Definition KoColorSpaceConstants.h:15
COMPOSITE_OVER
const QString COMPOSITE_OVER
Definition KoCompositeOpRegistry.h:22
COMPOSITE_BEHIND
const QString COMPOSITE_BEHIND
Definition KoCompositeOpRegistry.h:72
KUndo2Command::KUndo2Command
KUndo2Command(KUndo2Command *parent=0)
Definition kundo2stack.cpp:145
KisColorizeMask::coloringProjection
KisPaintDeviceSP coloringProjection() const
Definition kis_colorize_mask.cpp:469
KisCroppedOriginalLayerInterface::forceUpdateHiddenAreaOnOriginal
virtual void forceUpdateHiddenAreaOnOriginal()=0
KisDefaultBoundsBase::bounds
virtual QRect bounds() const =0
KisDelayedUpdateNodeInterface
The KisDelayedUpdateNodeInterface class is an interface for nodes that delay their real updates with ...
Definition KisDelayedUpdateNodeInterface.h:19
KisDelayedUpdateNodeInterface::forceUpdateTimedNode
virtual void forceUpdateTimedNode()=0
forceUpdateTimedNode forces the node to regenerate its project. The update might be asynchronous,...
KisDelayedUpdateNodeInterface::hasPendingTimedUpdates
virtual bool hasPendingTimedUpdates() const =0
KisImageLayerAddCommand
The command for adding a layer.
Definition kis_image_layer_add_command.h:20
KisImageLayerMoveCommand
The command for layer moves inside the layer stack.
Definition kis_image_layer_move_command.h:19
KisImageSignalRouter::emitNotification
void emitNotification(KisImageSignalType type)
Definition kis_image_signal_router.cpp:72
KisImage::refreshGraphAsync
void refreshGraphAsync(KisNodeSP root, const QVector< QRect > &rects, const QRect &cropRect, KisProjectionUpdateFlags flags=KisProjectionUpdateFlag::None) override
Definition kis_image.cc:2221
KisImage::rootLayer
KisGroupLayerSP rootLayer() const
Definition kis_image.cc:1655
KisImage::colorSpace
const KoColorSpace * colorSpace() const
Definition kis_image.cc:1579
KisImage::animationInterface
KisImageAnimationInterface * animationInterface() const
Definition kis_image.cc:2634
KisImage::nextLayerName
QString nextLayerName(const QString &baseName="") const
Definition kis_image.cc:715
KisImage::enableUIUpdates
QVector< QRect > enableUIUpdates() override
Definition kis_image.cc:2352
KisImage::isolationRootNode
KisNodeSP isolationRootNode() const
Definition kis_image.cc:2142
KisImage::signalRouter
KisImageSignalRouter * signalRouter()
Definition kis_image.cc:1948
KisImage::bounds
QRect bounds() const override
Definition kis_image.cc:1797
KisKeyframeChannel
KisKeyframeChannel stores and manages KisKeyframes. Maps units of time to virtual keyframe values....
Definition kis_keyframe_channel.h:33
KisKeyframeChannel::allKeyframeTimes
QSet< int > allKeyframeTimes() const
Get a set of all integer times that map to a keyframe.
Definition kis_keyframe_channel.cpp:303
KisKeyframeChannel::Raster
static const KoID Raster
Definition kis_keyframe_channel.h:37
KisKeyframeChannel::keyframeAt
KisKeyframeSP keyframeAt(int time) const
Get a keyframe at specified time. Used primarily when the value of a given keyframe is needed.
Definition kis_keyframe_channel.cpp:218
KisKeyframeChannel::addKeyframe
void addKeyframe(int time, KUndo2Command *parentUndoCmd=nullptr)
Add a new keyframe to the channel at the specified time.
Definition kis_keyframe_channel.cpp:121
KisKeyframeChannel::affectedFrames
virtual KisTimeSpan affectedFrames(int time) const
Get the set of frames affected by any changes to the value or content of the active keyframe at the g...
Definition kis_keyframe_channel.cpp:372
KisKeyframeChannel::activeKeyframeAt
KisKeyframeSP activeKeyframeAt(int time) const
Definition kis_keyframe_channel.h:82
KisKeyframeChannel::activeKeyframeTime
int activeKeyframeTime(int time) const
Get the time of the active keyframe. Useful for snapping any time to that of the most recent keyframe...
Definition kis_keyframe_channel.cpp:233
KisLayerPropertiesIcons::nodeProperty
static QVariant nodeProperty(KisNodeSP node, const KoID &id, const QVariant &defaultValue)
Definition kis_layer_properties_icons.cpp:163
KisLayerPropertiesIcons::setNodeProperty
static void setNodeProperty(KisBaseNode::PropertyList *props, const KoID &id, const QVariant &value)
Definition kis_layer_properties_icons.cpp:151
KisLayerUtils::KeepNodesSelectedCommand::KeepNodesSelectedCommand
KeepNodesSelectedCommand(const KisNodeList &selectedBefore, const KisNodeList &selectedAfter, KisNodeSP activeBefore, KisNodeSP activeAfter, KisImageSP image, bool finalize, KUndo2Command *parent=0)
Definition kis_layer_utils.cpp:878
KisLayerUtils::KisSimpleUpdateCommand::updateNodes
static void updateNodes(const KisNodeList &nodes)
Definition kis_layer_utils.cpp:2200
KisLayerUtils::KisSimpleUpdateCommand::KisSimpleUpdateCommand
KisSimpleUpdateCommand(KisNodeList nodes, bool finalize, KUndo2Command *parent=0)
Definition kis_layer_utils.cpp:2191
KisLayerUtils::RemoveNodeHelper::addCommandImpl
virtual void addCommandImpl(KUndo2Command *cmd)=0
KisLayerUtils::RemoveNodeHelper::safeReplaceMultipleNodes
void safeReplaceMultipleNodes(KisNodeList removedNodes, KisImageSP image, std::optional< ReplacementNode > replacementNode)
Definition kis_layer_utils.cpp:937
KisLayerUtils::RemoveNodeHelper::safeRemoveMultipleNodes
void safeRemoveMultipleNodes(KisNodeList nodes, KisImageSP image)
Definition kis_layer_utils.cpp:933
KisLayerUtils::RemoveNodeHelper::checkIsSourceForClone
bool checkIsSourceForClone(KisNodeSP src, const KisNodeList &nodes)
Definition kis_layer_utils.cpp:1025
KisLayerUtils::RemoveNodeHelper::scanForLastLayer
static bool scanForLastLayer(KisImageWSP image, KisNodeList nodesToRemove)
Definition kis_layer_utils.cpp:1039
KisMetaData::MergeStrategy::merge
virtual void merge(Store *dst, QList< const Store * > srcs, QList< double > scores) const =0
KisNodeCompositeOpCommand
The command for setting the composite op.
Definition kis_node_compositeop_command.h:16
KisNodePropertyListCommand
The command for changing the property list of a layer.
Definition kis_node_property_list_command.h:17
KisPaintDeviceFramesInterface::writeFrameToDevice
void writeFrameToDevice(int frameId, KisPaintDeviceSP targetDevice)
Definition kis_paint_device.cc:2246
KisPaintDeviceFramesInterface::uploadFrame
void uploadFrame(int srcFrameId, int dstFrameId, KisPaintDeviceSP srcDevice)
Definition kis_paint_device.cc:2251
KisPaintDevice::keyframeChannel
KisRasterKeyframeChannel * keyframeChannel() const
Definition kis_paint_device.cc:2072
KisPaintDevice::setDefaultPixel
void setDefaultPixel(const KoColor &defPixel)
Definition kis_paint_device.cc:1509
KisPaintDevice::compositionSourceColorSpace
virtual const KoColorSpace * compositionSourceColorSpace() const
Definition kis_paint_device.cc:2122
KisPaintDevice::framesInterface
KisPaintDeviceFramesInterface * framesInterface()
Definition kis_paint_device.cc:2188
KisPaintDevice::exactBounds
QRect exactBounds() const
Definition kis_paint_device.cc:1277
KisPaintDevice::extent
QRect extent() const
Definition kis_paint_device.cc:1262
KisPaintDevice::colorSpace
const KoColorSpace * colorSpace() const
Definition kis_paint_device.cc:2080
KisPaintDevice::defaultPixel
KoColor defaultPixel() const
Definition kis_paint_device.cc:1518
KisPaintDevice::defaultBounds
KisDefaultBoundsBaseSP defaultBounds() const
Definition kis_paint_device.cc:1212
KisPainter::copyAreaOptimized
static void copyAreaOptimized(const QPoint &dstPt, KisPaintDeviceSP src, KisPaintDeviceSP dst, const QRect &originalSrcRect)
Definition kis_painter.cc:153
KisProcessingApplicator::applyCommand
void applyCommand(KUndo2Command *command, KisStrokeJobData::Sequentiality sequentiality=KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::Exclusivity exclusivity=KisStrokeJobData::NORMAL)
Definition kis_processing_applicator.cpp:423
KisProcessingApplicator::successfullyCompletedFuture
std::future< bool > && successfullyCompletedFuture()
Definition kis_processing_applicator.cpp:327
KisRasterKeyframeChannel
The KisRasterKeyframeChannel is a concrete KisKeyframeChannel subclass that stores and manages KisRas...
Definition kis_raster_keyframe_channel.h:67
KisRasterKeyframeChannel::timesForFrameID
QSet< int > timesForFrameID(int frameID) const
Definition kis_raster_keyframe_channel.cpp:298
KisRasterKeyframe
The KisRasterKeyframe class is a concrete subclass of KisKeyframe that wraps a physical raster image ...
Definition kis_raster_keyframe_channel.h:24
KisScalarKeyframeChannel
The KisScalarKeyframeChannel is a concrete KisKeyframeChannel subclass that stores and manages KisSca...
Definition kis_scalar_keyframe_channel.h:120
KisScalarKeyframeChannel::identicalFrames
virtual KisTimeSpan identicalFrames(int time) const override
Get a span of times for which the channel gives identical results compared to frame at a given time....
Definition kis_scalar_keyframe_channel.cpp:361
KisSequentialIteratorBase::rawData
ALWAYS_INLINE quint8 * rawData()
Definition kis_sequential_iterator.h:265
KisTimeSpan::start
int start() const
Definition kis_time_span.h:35
KisTimeSpan::isInfinite
bool isInfinite() const
Definition kis_time_span.h:47
KisTimeSpan::infinite
static KisTimeSpan infinite(int start)
Definition kis_time_span.h:96
KisTimeSpan::end
int end() const
Definition kis_time_span.h:39
KisTimeSpan::isValid
bool isValid() const
Definition kis_time_span.h:51
KoColorSpace::setOpacity
virtual void setOpacity(quint8 *pixels, quint8 alpha, qint32 nPixels) const =0
KoColorSpace::opacityU8
virtual quint8 opacityU8(const quint8 *pixel) const =0
KoColor::convertedTo
KoColor convertedTo(const KoColorSpace *cs, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags) const
Definition KoColor.cpp:163
KoID::id
QString id() const
Definition KoID.cpp:63
kis_abstract_projection_plane.h
kis_activate_selection_mask_command.h
KIS_ASSERT_RECOVER
#define KIS_ASSERT_RECOVER(cond)
Definition kis_assert.h:55
KIS_SAFE_ASSERT_RECOVER
#define KIS_SAFE_ASSERT_RECOVER(cond)
Definition kis_assert.h:126
KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE
#define KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(cond, val)
Definition kis_assert.h:129
KIS_SAFE_ASSERT_RECOVER_RETURN
#define KIS_SAFE_ASSERT_RECOVER_RETURN(cond)
Definition kis_assert.h:128
KIS_ASSERT_RECOVER_NOOP
#define KIS_ASSERT_RECOVER_NOOP(cond)
Definition kis_assert.h:97
KIS_SAFE_ASSERT_RECOVER_NOOP
#define KIS_SAFE_ASSERT_RECOVER_NOOP(cond)
Definition kis_assert.h:130
KIS_ASSERT
#define KIS_ASSERT(cond)
Definition kis_assert.h:33
kis_change_projection_color_command.h
kis_clone_layer.h
kis_colorize_mask.h
kis_command_ids.h
kis_command_utils.h
bounds
#define bounds(x, a, b)
Definition kis_curve_widget.cpp:46
kis_group_layer.h
kis_image.h
kis_image_animation_interface.h
kis_image_change_layers_command.h
kis_image_change_visibility_command.h
kis_image_config.h
kis_image_layer_add_command.h
kis_image_layer_move_command.h
kis_image_layer_remove_command.h
kis_image_signal_router.h
kis_keyframe_channel.h
kis_layer.h
kis_layer_properties_icons.h
kis_layer_utils.h
kis_meta_data_merge_strategy.h
kis_node.h
kis_node_compositeop_command.h
kis_node_property_list_command.h
kis_paint_device_frames_interface.h
kis_paint_layer.h
kis_painter.h
kis_processing_applicator.h
kis_projection_leaf.h
kis_raster_keyframe_channel.h
kis_scalar_keyframe_channel.h
kis_selection.h
kis_selection_mask.h
kis_sequential_iterator.h
kis_time_span.h
kis_transparency_mask.h
KisNodeList
QList< KisNodeSP > KisNodeList
Definition kis_types.h:264
KisNodeSP
KisSharedPtr< KisNode > KisNodeSP
Definition kis_types.h:86
krita_utils.h
kundo2_i18n
KUndo2MagicString kundo2_i18n(const char *text)
Definition kundo2magicstring.h:180
KisLayerUtils::Private::realNodeChangeRect
QRect realNodeChangeRect(KisNodeSP rootNode, QRect currentRect=QRect())
Definition kis_layer_utils.cpp:2317
KisLayerUtils::Private::refreshHiddenAreaAsync
void refreshHiddenAreaAsync(KisImageSP image, KisNodeSP rootNode, const QRect &preparedArea, const QRect &extraUpdateRect)
Definition kis_layer_utils.cpp:2341
KisLayerUtils::flattenImage
void flattenImage(KisImageSP image, KisNodeSP activeNode, MergeFlags flags)
Definition kis_layer_utils.cpp:2175
KisLayerUtils::checkIsCloneOf
bool checkIsCloneOf(KisNodeSP node, const KisNodeList &nodes)
Definition kis_layer_utils.cpp:1595
KisLayerUtils::findIsolationRoot
KisNodeSP findIsolationRoot(KisNodeSP node)
Definition kis_layer_utils.cpp:2259
KisLayerUtils::fetchLayerFrames
QSet< int > fetchLayerFrames(KisNodeSP node)
Definition kis_layer_utils.cpp:1375
KisLayerUtils::fetchUniqueFrameTimes
QSet< int > fetchUniqueFrameTimes(KisNodeSP node, QSet< int > selectedTimes, bool filterActiveFrameID)
Definition kis_layer_utils.cpp:2589
KisLayerUtils::hasDelayedNodeWithUpdates
bool hasDelayedNodeWithUpdates(KisNodeSP root)
Definition kis_layer_utils.cpp:2279
KisLayerUtils::updateFrameJobs
void updateFrameJobs(FrameJobs *jobs, KisNodeSP node)
Definition kis_layer_utils.cpp:1425
KisLayerUtils::filterTimesForOnlyRasterKeyedTimes
QSet< int > filterTimesForOnlyRasterKeyedTimes(KisNodeSP node, const QSet< int > &times)
Definition kis_layer_utils.cpp:2558
KisLayerUtils::updateFrameJobsRecursive
void updateFrameJobsRecursive(FrameJobs *jobs, KisNodeSP rootNode)
Definition kis_layer_utils.cpp:1438
KisLayerUtils::recursiveFindNode
KisNodeSP recursiveFindNode(KisNodeSP node, std::function< bool(KisNodeSP)> func)
Definition kis_layer_utils.cpp:2207
KisLayerUtils::splitAlphaToMask
void splitAlphaToMask(KisImageSP image, KisNodeSP node, const QString &maskName)
Definition kis_layer_utils.cpp:2412
KisLayerUtils::changeImageDefaultProjectionColor
void changeImageDefaultProjectionColor(KisImageSP image, const KoColor &color)
Definition kis_layer_utils.cpp:1815
KisLayerUtils::fetchLayerActiveRasterFrameSpan
KisTimeSpan fetchLayerActiveRasterFrameSpan(KisNodeSP node, const int time)
Definition kis_layer_utils.cpp:2503
KisLayerUtils::sortAndFilterMergeableInternalNodes
KisNodeList sortAndFilterMergeableInternalNodes(KisNodeList nodes, bool allowMasks)
Definition kis_layer_utils.cpp:1671
KisLayerUtils::FrameJobs
QMap< int, QSet< KisNodeSP > > FrameJobs
Definition kis_layer_utils.h:94
KisLayerUtils::fetchLayerActiveRasterFrameID
int fetchLayerActiveRasterFrameID(KisNodeSP node)
Definition kis_layer_utils.cpp:2473
KisLayerUtils::SplitAlphaToMaskInfoSP
QSharedPointer< SplitAlphaToMaskInfo > SplitAlphaToMaskInfoSP
Definition kis_layer_utils.cpp:364
KisLayerUtils::MergeDownInfoSP
QSharedPointer< MergeDownInfo > MergeDownInfoSP
Definition kis_layer_utils.cpp:362
KisLayerUtils::sortMergeableNodes
void sortMergeableNodes(KisNodeSP root, KisNodeList &inputNodes, KisNodeList &outputNodes)
Definition kis_layer_utils.cpp:1639
KisLayerUtils::recursiveTightNodeVisibleBounds
QRect recursiveTightNodeVisibleBounds(KisNodeSP rootNode)
Definition kis_layer_utils.cpp:2361
KisLayerUtils::findImageByHierarchy
KisImageSP findImageByHierarchy(KisNodeSP node)
Definition kis_layer_utils.cpp:2302
KisLayerUtils::fetchLayerUniqueRasterTimesMatchingIDs
QSet< int > fetchLayerUniqueRasterTimesMatchingIDs(KisNodeSP node, QSet< int > &frameIDs)
Definition kis_layer_utils.cpp:2570
KisLayerUtils::findNodeByName
KisNodeSP findNodeByName(KisNodeSP root, const QString &name)
Definition kis_layer_utils.cpp:2251
KisLayerUtils::filterInvisibleNodes
KisNodeList filterInvisibleNodes(const KisNodeList &nodes, KisNodeList *invisibleNodes, KisNodeSP *putAfter)
Definition kis_layer_utils.cpp:1769
KisLayerUtils::flattenLayer
void flattenLayer(KisImageSP image, KisLayerSP layer, MergeFlags flags)
Definition kis_layer_utils.cpp:2161
KisLayerUtils::fetchLayerRasterIDsAtTimes
QSet< int > fetchLayerRasterIDsAtTimes(KisNodeSP node, const QSet< int > &times)
Definition kis_layer_utils.cpp:2539
KisLayerUtils::findRoot
KisNodeSP findRoot(KisNodeSP node)
Definition kis_layer_utils.cpp:2370
KisLayerUtils::findNodesByName
QList< KisNodeSP > findNodesByName(KisNodeSP root, const QString &name, bool recursive, bool partialMatch)
Definition kis_layer_utils.cpp:2233
KisLayerUtils::ConvertToPaintLayerInfoSP
QSharedPointer< ConvertToPaintLayerInfo > ConvertToPaintLayerInfoSP
Definition kis_layer_utils.cpp:365
KisLayerUtils::findNodesWithProps
KisNodeList findNodesWithProps(KisNodeSP root, const KoProperties &props, bool excludeRoot)
Definition kis_layer_utils.cpp:1752
KisLayerUtils::addCopyOfNameTag
void addCopyOfNameTag(KisNodeSP node)
Definition kis_layer_utils.cpp:1740
KisLayerUtils::findNodeByUuid
KisNodeSP findNodeByUuid(KisNodeSP root, const QUuid &uuid)
Definition kis_layer_utils.cpp:2225
KisLayerUtils::newLayerFromVisible
void newLayerFromVisible(KisImageSP image, KisNodeSP putAfter, MergeFlags flags)
Definition kis_layer_utils.cpp:2060
KisLayerUtils::filterUnlockedNodes
void filterUnlockedNodes(KisNodeList &nodes)
Definition kis_layer_utils.cpp:1802
KisLayerUtils::mergeMultipleLayersImpl
void mergeMultipleLayersImpl(KisImageSP image, KisNodeList mergedNodes, KisNodeSP putAfter, bool flattenSingleLayer, const KUndo2MagicString &actionName, bool cleanupNodes=true, const QString layerName=QString(), MergeFlags flags=None)
Definition kis_layer_utils.cpp:1902
KisLayerUtils::canChangeImageProfileInvisibly
bool canChangeImageProfileInvisibly(KisImageSP image)
Definition kis_layer_utils.cpp:2380
KisLayerUtils::recursiveApplyNodes
void recursiveApplyNodes(NodePointer node, Functor func)
Definition kis_layer_utils.h:235
KisLayerUtils::fetchLayerActiveRasterFrameTime
int fetchLayerActiveRasterFrameTime(KisNodeSP node)
Definition kis_layer_utils.cpp:2490
KisLayerUtils::splitNonRemovableNodes
void splitNonRemovableNodes(KisNodeList &nodesToRemove, KisNodeList &_nodesToHide)
Definition kis_layer_utils.cpp:1142
KisLayerUtils::sortAndFilterAnyMergeableNodesSafe
KisNodeList sortAndFilterAnyMergeableNodesSafe(const KisNodeList &nodes, KisImageSP image)
Definition kis_layer_utils.cpp:1716
KisLayerUtils::filterMergeableNodes
void filterMergeableNodes(KisNodeList &nodes, bool allowMasks)
Definition kis_layer_utils.cpp:1624
KisLayerUtils::forceAllHiddenOriginalsUpdate
void forceAllHiddenOriginalsUpdate(KisNodeSP root)
Definition kis_layer_utils.cpp:2290
KisLayerUtils::fetchLayerIdenticalRasterFrameTimes
QSet< int > fetchLayerIdenticalRasterFrameTimes(KisNodeSP node, const int &frameTime)
Definition kis_layer_utils.cpp:2515
KisLayerUtils::checkIsChildOf
bool checkIsChildOf(KisNodeSP node, const KisNodeList &parents)
Definition kis_layer_utils.cpp:1576
KisLayerUtils::refreshHiddenAreaAsync
void refreshHiddenAreaAsync(KisImageSP image, KisNodeSP rootNode, const QRect &preparedArea)
Definition kis_layer_utils.cpp:2357
KisLayerUtils::mergeMultipleLayers
void mergeMultipleLayers(KisImageSP image, KisNodeList mergedNodes, KisNodeSP putAfter, MergeFlags flags)
Definition kis_layer_utils.cpp:2045
KisLayerUtils::mergeDown
void mergeDown(KisImageSP image, KisLayerSP layer, const KisMetaData::MergeStrategy *strategy, MergeFlags flags)
Definition kis_layer_utils.cpp:1451
KisLayerUtils::tryMergeSelectionMasks
bool tryMergeSelectionMasks(KisImageSP image, KisNodeList mergedNodes, KisNodeSP putAfter)
Definition kis_layer_utils.cpp:2122
KisLayerUtils::convertToPaintLayer
std::future< KisNodeSP > convertToPaintLayer(KisImageSP image, KisNodeSP src)
Definition kis_layer_utils.cpp:2437
KisLayerUtils::fetchLayerRasterFrameTimesMatchingID
QSet< int > fetchLayerRasterFrameTimesMatchingID(KisNodeSP node, const int frameID)
Definition kis_layer_utils.cpp:2528
KisLayerUtils::forceAllDelayedNodesUpdate
void forceAllDelayedNodesUpdate(KisNodeSP root)
Definition kis_layer_utils.cpp:2267
KisLayerUtils::MergeDownInfoBaseSP
QSharedPointer< MergeDownInfoBase > MergeDownInfoBaseSP
Definition kis_layer_utils.cpp:361
KisLayerUtils::fetchLayerFramesRecursive
QSet< int > fetchLayerFramesRecursive(KisNodeSP rootNode)
Definition kis_layer_utils.cpp:1411
KisLayerUtils::fetchSelectionMasks
void fetchSelectionMasks(KisNodeList mergedNodes, QVector< KisSelectionMaskSP > &selectionMasks)
Definition kis_layer_utils.cpp:66
KisLayerUtils::sortMergeableInternalNodes
KisNodeList sortMergeableInternalNodes(KisNodeList nodes)
Definition kis_layer_utils.cpp:1694
KisLayerUtils::MergeMultipleInfoSP
QSharedPointer< MergeMultipleInfo > MergeMultipleInfoSP
Definition kis_layer_utils.cpp:363
KisLayerUtils::mergeMultipleNodes
void mergeMultipleNodes(KisImageSP image, KisNodeList mergedNodes, KisNodeSP putAfter, MergeFlags flags)
Definition kis_layer_utils.cpp:2053
kismpl::then
auto then(std::future< T > &&future, Function &&func) -> std::future< decltype(func(std::move(future)))>
Definition KisFutureUtils.h:40
kismpl::make_ready_future
std::future< void > make_ready_future()
Definition KisFutureUtils.h:24
KisBaseNode::keyframeChannels
QMap< QString, KisKeyframeChannel * > keyframeChannels
Definition kis_base_node.cpp:31
KisBaseNode::uuid
QUuid uuid() const
Definition kis_base_node.cpp:366
KisBaseNode::projection
virtual KisPaintDeviceSP projection() const =0
KisBaseNode::compositeOpId
const QString & compositeOpId() const
Definition kis_base_node.cpp:133
KisBaseNode::isEditable
bool isEditable(bool checkVisibility=true) const
Definition kis_base_node.cpp:311
KisBaseNode::isPinnedToTimeline
bool isPinnedToTimeline() const
Definition kis_base_node.cpp:423
KisBaseNode::getKeyframeChannel
KisKeyframeChannel * getKeyframeChannel(const QString &id, bool create)
Definition kis_base_node.cpp:436
KisBaseNode::exactBounds
virtual QRect exactBounds() const
Definition kis_base_node.h:481
KisBaseNode::original
virtual KisPaintDeviceSP original() const =0
KisBaseNode::setName
void setName(const QString &name)
Definition kis_base_node.h:221
KisBaseNode::image
KisImageWSP image
Definition kis_base_node.cpp:38
KisBaseNode::extent
virtual QRect extent() const
Definition kis_base_node.h:473
KisBaseNode::userLocked
bool userLocked() const
Definition kis_base_node.cpp:267
KisBaseNode::isAnimated
bool isAnimated() const
Definition kis_base_node.cpp:451
KisBaseNode::paintDevice
virtual KisPaintDeviceSP paintDevice() const =0
KisBaseNode::sectionModelProperties
virtual PropertyList sectionModelProperties() const
Definition kis_base_node.cpp:147
KisBaseNode::name
QString name() const
Definition kis_base_node.h:212
KisBaseNode::setCompositeOpId
void setCompositeOpId(const QString &compositeOpId)
Definition kis_base_node.cpp:138
KisBaseNode::isFakeNode
virtual bool isFakeNode() const
Definition kis_base_node.cpp:398
KisBaseNode::opacity
quint8 opacity() const
Definition kis_base_node.cpp:112
KisBaseNode::check
bool check(const KoProperties &properties) const
Definition kis_base_node.cpp:184
KisBaseNode::visible
virtual bool visible(bool recursive=false) const
Definition kis_base_node.cpp:244
KisBaseNode::supportsKeyframeChannel
virtual bool supportsKeyframeChannel(const QString &id)
Definition kis_base_node.cpp:485
KisCloneLayer::copyFrom
KisLayerSP copyFrom
Definition kis_clone_layer.cpp:41
KisCloneLayer::reincarnateAsPaintLayer
KisLayerSP reincarnateAsPaintLayer() const
Definition kis_clone_layer.cpp:90
KisCommandUtils::AggregateCommand
The AggregateCommand struct is a command with delayed initialization. On first redo() populateChildCo...
Definition kis_command_utils.h:27
KisCommandUtils::AggregateCommand::addCommand
void addCommand(KUndo2Command *cmd)
Definition kis_command_utils.cpp:36
KisLayerUtils::ActivateSelectionMask::ActivateSelectionMask
ActivateSelectionMask(MergeDownInfoBaseSP info)
Definition kis_layer_utils.cpp:2110
KisLayerUtils::AddNewFrame::m_mergeInfo
MergeDownInfoBaseSP m_mergeInfo
Definition kis_layer_utils.cpp:1372
KisLayerUtils::AddNewFrame::AddNewFrame
AddNewFrame(KisNodeSP node, int frame, KisNodeSP source)
Definition kis_layer_utils.cpp:1338
KisLayerUtils::AddNewFrame::AddNewFrame
AddNewFrame(KisNodeSP node, int frame)
Definition kis_layer_utils.cpp:1336
KisLayerUtils::AddNewFrame::AddNewFrame
AddNewFrame(KisNodeSP node, int frame, KisNodeList sampleNodes)
Definition kis_layer_utils.cpp:1337
KisLayerUtils::AddNewFrame::applyKeyframeColorLabel
void applyKeyframeColorLabel(KisKeyframeSP dstKeyframe, KisNodeList srcNodes)
Definition kis_layer_utils.cpp:1354
KisLayerUtils::AddNewFrame::AddNewFrame
AddNewFrame(MergeDownInfoBaseSP info, int frame)
Definition kis_layer_utils.cpp:1339
KisLayerUtils::CleanUpNodes::findPerfectParent
static void findPerfectParent(KisNodeList nodesToDelete, KisNodeSP &putAfter, KisNodeSP &parent)
Definition kis_layer_utils.cpp:1189
KisLayerUtils::CleanUpNodes::CleanUpNodes
CleanUpNodes(MergeDownInfoBaseSP info, KisNodeSP putAfter, bool relinkClones=false)
Definition kis_layer_utils.cpp:1186
KisLayerUtils::CleanUpNodes::addCommandImpl
void addCommandImpl(KUndo2Command *cmd) override
Definition kis_layer_utils.cpp:1291
KisLayerUtils::ConvertToPaintLayerInfo::ConvertToPaintLayerInfo
ConvertToPaintLayerInfo(KisImageSP image, KisNodeSP node)
Definition kis_layer_utils.cpp:185
KisLayerUtils::ConvertToPaintLayerInfo::storage
SwitchFrameCommand::SharedStorageSP storage
Definition kis_layer_utils.cpp:317
KisLayerUtils::CreateMergedLayerMultiple::CreateMergedLayerMultiple
CreateMergedLayerMultiple(MergeMultipleInfoSP info, const QString name=QString())
Definition kis_layer_utils.cpp:620
KisLayerUtils::CreateMergedLayer::CreateMergedLayer
CreateMergedLayer(MergeDownInfoSP info)
Definition kis_layer_utils.cpp:595
KisLayerUtils::DisableColorizeKeyStrokes::DisableColorizeKeyStrokes
DisableColorizeKeyStrokes(MergeDownInfoBaseSP info)
Definition kis_layer_utils.cpp:379
KisLayerUtils::DisableExtraCompositing::DisableExtraCompositing
DisableExtraCompositing(MergeMultipleInfoSP info)
Definition kis_layer_utils.cpp:428
KisLayerUtils::DisableOnionSkins::DisableOnionSkins
DisableOnionSkins(MergeDownInfoBaseSP info)
Definition kis_layer_utils.cpp:404
KisLayerUtils::DisablePassThroughForHeadsOnly::DisablePassThroughForHeadsOnly
DisablePassThroughForHeadsOnly(MergeDownInfoBaseSP info, bool skipIfDstIsGroup=false)
Definition kis_layer_utils.cpp:466
KisLayerUtils::EphemeralCommandsWrapper::EphemeralCommandsWrapper
EphemeralCommandsWrapper(MergeMultipleInfoSP info, QVector< KUndo2Command * > commands, bool cleanupNodes)
Definition kis_layer_utils.cpp:1831
KisLayerUtils::FillSelectionMasks::FillSelectionMasks
FillSelectionMasks(MergeDownInfoBaseSP info)
Definition kis_layer_utils.cpp:368
KisLayerUtils::InitSplitAlphaSelectionMask::InitSplitAlphaSelectionMask
InitSplitAlphaSelectionMask(SplitAlphaToMaskInfoSP info)
Definition kis_layer_utils.cpp:785
KisLayerUtils::InsertNode::populateChildCommands
void populateChildCommands() override
Definition kis_layer_utils.cpp:1085
KisLayerUtils::InsertNode::InsertNode
InsertNode(MergeDownInfoBaseSP info, KisNodeSP putAfter)
Definition kis_layer_utils.cpp:1082
KisLayerUtils::InsertNode::addCommandImpl
virtual void addCommandImpl(KUndo2Command *cmd)
Definition kis_layer_utils.cpp:1095
KisLayerUtils::KeepMergedNodesSelected::KeepMergedNodesSelected
KeepMergedNodesSelected(MergeDownInfoSP info, bool finalizing)
Definition kis_layer_utils.cpp:549
KisLayerUtils::KeepMergedNodesSelected::KeepMergedNodesSelected
KeepMergedNodesSelected(MergeMultipleInfoSP info, KisNodeSP putAfter, bool finalizing)
Definition kis_layer_utils.cpp:553
KisLayerUtils::MergeDownInfoBase::storage
SwitchFrameCommand::SharedStorageSP storage
Definition kis_layer_utils.cpp:96
KisLayerUtils::MergeDownInfoBase::selectionMasks
QVector< KisSelectionMaskSP > selectionMasks
Definition kis_layer_utils.cpp:91
KisLayerUtils::MergeDownInfoBase::allSrcNodes
virtual KisNodeList allSrcNodes()=0
KisLayerUtils::MergeDownInfo::MergeDownInfo
MergeDownInfo(KisImageSP _image, KisLayerSP _prevLayer, KisLayerSP _currLayer, MergeFlags flags)
Definition kis_layer_utils.cpp:141
KisLayerUtils::MergeDownInfo::allSrcNodes
KisNodeList allSrcNodes() override
Definition kis_layer_utils.cpp:176
KisLayerUtils::MergeLayersMultiple::MergeLayersMultiple
MergeLayersMultiple(MergeMultipleInfoSP info)
Definition kis_layer_utils.cpp:740
KisLayerUtils::MergeLayers::MergeLayers
MergeLayers(MergeDownInfoSP info, bool skipMergingSourceLayer)
Definition kis_layer_utils.cpp:726
KisLayerUtils::MergeLayers::populateChildCommands
void populateChildCommands() override
Definition kis_layer_utils.cpp:729
KisLayerUtils::MergeMetaData::m_strategy
const KisMetaData::MergeStrategy * m_strategy
Definition kis_layer_utils.cpp:781
KisLayerUtils::MergeMetaData::MergeMetaData
MergeMetaData(MergeDownInfoSP info, const KisMetaData::MergeStrategy *strategy)
Definition kis_layer_utils.cpp:758
KisLayerUtils::MergeMultipleInfo::MergeMultipleInfo
MergeMultipleInfo(KisImageSP _image, KisNodeList _mergedNodes, MergeFlags flags)
Definition kis_layer_utils.cpp:333
KisLayerUtils::MergeMultipleInfo::ephemeralCommandsStore
QScopedPointer< KisSurrogateUndoStore > ephemeralCommandsStore
Definition kis_layer_utils.cpp:352
KisLayerUtils::MergeSelectionMasks::MergeSelectionMasks
MergeSelectionMasks(MergeDownInfoBaseSP info, KisNodeSP putAfter)
Definition kis_layer_utils.cpp:2072
KisLayerUtils::RefreshDelayedUpdateLayers::RefreshDelayedUpdateLayers
RefreshDelayedUpdateLayers(MergeDownInfoBaseSP info)
Definition kis_layer_utils.cpp:526
KisLayerUtils::RefreshHiddenAreas::refresh_entire_image_t
Definition kis_layer_utils.cpp:500
KisLayerUtils::RefreshHiddenAreas::RefreshHiddenAreas
RefreshHiddenAreas(KisImageSP image, KisNodeSP node)
Definition kis_layer_utils.cpp:505
KisLayerUtils::RefreshHiddenAreas::RefreshHiddenAreas
RefreshHiddenAreas(MergeDownInfoBaseSP info, refresh_entire_image_t)
Definition kis_layer_utils.cpp:504
KisLayerUtils::RefreshHiddenAreas::RefreshHiddenAreas
RefreshHiddenAreas(MergeDownInfoBaseSP info)
Definition kis_layer_utils.cpp:503
KisLayerUtils::RefreshHiddenAreas::refresh_entire_image
static constexpr refresh_entire_image_t refresh_entire_image
Definition kis_layer_utils.cpp:501
KisLayerUtils::SimpleAddNode::addCommandImpl
virtual void addCommandImpl(KUndo2Command *cmd)
Definition kis_layer_utils.cpp:1130
KisLayerUtils::SimpleAddNode::SimpleAddNode
SimpleAddNode(KisImageSP image, KisNodeSP toAdd, KisNodeSP parent=0, KisNodeSP putAfter=0)
Definition kis_layer_utils.cpp:1104
KisLayerUtils::SimpleRemoveLayers::SimpleRemoveLayers
SimpleRemoveLayers(const KisNodeList &nodes, KisImageSP image)
Definition kis_layer_utils.cpp:1065
KisLayerUtils::SimpleRemoveLayers::addCommandImpl
void addCommandImpl(KUndo2Command *cmd) override
Definition kis_layer_utils.cpp:1077
KisLayerUtils::SplitAlphaCommand::SplitAlphaCommand
SplitAlphaCommand(SplitAlphaToMaskInfoSP info)
Definition kis_layer_utils.cpp:797
KisLayerUtils::SplitAlphaToMaskInfo::storage
SwitchFrameCommand::SharedStorageSP storage
Definition kis_layer_utils.cpp:120
KisLayerUtils::SplitAlphaToMaskInfo::SplitAlphaToMaskInfo
SplitAlphaToMaskInfo(KisImageSP _image, KisNodeSP _node, const QString &maskName)
Definition kis_layer_utils.cpp:109
KisLayerUtils::SwitchFrameCommand
The SwitchFrameCommand struct Switches to frame with undo/redo support.
Definition kis_layer_utils.h:102
KisLayerUtils::UndoEphemeralCommands::UndoEphemeralCommands
UndoEphemeralCommands(MergeMultipleInfoSP info)
Definition kis_layer_utils.cpp:1862
KisLayerUtils::UploadProjectionToFrameCommand::UploadProjectionToFrameCommand
UploadProjectionToFrameCommand(KisNodeSP src, KisNodeSP target, int frame)
Definition kis_layer_utils.cpp:855
KisLayer::disableAlphaChannel
void disableAlphaChannel(bool disable)
Definition kis_layer.cc:319
KisLayer::channelFlags
QBitArray channelFlags
Definition kis_layer.cc:167
KisLayer::selectionMask
virtual KisSelectionMaskSP selectionMask() const
Definition kis_layer.cc:504
KisLayer::alphaChannelDisabled
bool alphaChannelDisabled() const
Definition kis_layer.cc:334
KisLayer::layerStyle
KisPSDLayerStyleSP layerStyle
Definition kis_layer.cc:171
KisLayer::registeredClones
const QList< KisCloneLayerWSP > registeredClones() const
Definition kis_layer.cc:484
KisMask::initSelection
void initSelection(KisSelectionSP copyFrom, KisLayerSP parentLayer)
initSelection initializes the selection for the mask from the given selection's projection.
Definition kis_mask.cc:157
KisMask::selection
KisSelectionSP selection
Definition kis_mask.cc:44
KisMask::paintDevice
KisPaintDeviceSP paintDevice() const override
Definition kis_mask.cc:223
KisNode::prevSibling
KisNodeSP prevSibling() const
Definition kis_node.cpp:402
KisNode::firstChild
KisNodeSP firstChild() const
Definition kis_node.cpp:361
KisNode::childNodes
QList< KisNodeSP > childNodes(const QStringList &nodeTypes, const KoProperties &properties) const
Definition kis_node.cpp:439
KisNode::projectionPlane
virtual KisAbstractProjectionPlaneSP projectionPlane() const
Definition kis_node.cpp:240
KisNode::projectionLeaf
KisProjectionLeafSP projectionLeaf
Definition kis_node.cpp:93
KisNode::childCount
quint32 childCount() const
Definition kis_node.cpp:414
KisNode::parent
KisNodeWSP parent
Definition kis_node.cpp:86
KisNode::lastChild
KisNodeSP lastChild() const
Definition kis_node.cpp:367
KisNode::nextSibling
KisNodeSP nextSibling() const
Definition kis_node.cpp:408
KisNode::graphListener
KisNodeGraphListener * graphListener
Definition kis_node.cpp:87
KisNode::setDirty
virtual void setDirty()
Definition kis_node.cpp:577
KisNode::allowAsChild
virtual bool allowAsChild(KisNodeSP) const =0
KisPaintLayer::setOnionSkinEnabled
void setOnionSkinEnabled(bool state)
Definition kis_paint_layer.cc:290
KisPaintLayer::onionSkinEnabled
bool onionSkinEnabled() const
Definition kis_paint_layer.cc:285
KisPaintLayer::setAlphaLocked
void setAlphaLocked(bool lock)
Definition kis_paint_layer.cc:269
KisPixelSelection::applySelection
void applySelection(KisPixelSelectionSP selection, SelectionAction action)
Definition kis_pixel_selection.cpp:141
KisSelectionMask::setSelection
void setSelection(KisSelectionSP selection)
Set the selection of this adjustment layer to a copy of selection.
Definition kis_selection_mask.cpp:141
KisSelection::pixelSelection
KisPixelSelectionSP pixelSelection
Definition kis_selection.cc:50