Krita

Node.cpp
1/*
2 * SPDX-FileCopyrightText: 2016 Boudewijn Rempt <boud@valdyas.org>
3 *
4 * SPDX-License-Identifier: LGPL-2.0-or-later
5 */
6#include <QUrl>
7#include <QScopedPointer>
8#include <QUuid>
9
10#include <KoColorSpace.h>
11#include <KoColorSpaceRegistry.h>
12#include <KoColorTransformation.h>
13
14#include <KisDocument.h>
15#include <KisMimeDatabase.h>
16#include <KisPart.h>
17#include <kis_image.h>
18#include <kis_types.h>
19#include <kis_node.h>
20#include <kis_paint_layer.h>
21#include <kis_group_layer.h>
22#include <kis_file_layer.h>
23#include <kis_adjustment_layer.h>
24#include <kis_generator_layer.h>
25#include <kis_clone_layer.h>
26#include <kis_shape_layer.h>
27#include <KisReferenceImagesLayer.h>
28#include <kis_transparency_mask.h>
29#include <kis_filter_mask.h>
30#include <kis_transform_mask.h>
31#include <kis_selection_mask.h>
32#include <lazybrush/kis_colorize_mask.h>
33#include <kis_layer.h>
34#include <kis_meta_data_merge_strategy.h>
35#include <kis_meta_data_merge_strategy_registry.h>
36#include <kis_filter_strategy.h>
37#include <commands/kis_node_compositeop_command.h>
38#include <commands/kis_image_layer_add_command.h>
39#include <commands/kis_image_layer_remove_command.h>
40#include <commands_new/kis_set_layer_style_command.h>
41#include <kis_processing_applicator.h>
42#include <kis_asl_layer_style_serializer.h>
43
44#include <kis_raster_keyframe_channel.h>
45#include <kis_keyframe.h>
46#include "kis_selection.h"
47
48#include "InfoObject.h"
49#include "Krita.h"
50#include "Node.h"
51#include "Channel.h"
52#include "Filter.h"
53#include "Selection.h"
54
55#include "GroupLayer.h"
56#include "CloneLayer.h"
57#include "FilterLayer.h"
58#include "FillLayer.h"
59#include "FileLayer.h"
60#include "VectorLayer.h"
61#include "FilterMask.h"
62#include "SelectionMask.h"
63#include "TransparencyMask.h"
64#include "TransformMask.h"
65#include "ColorizeMask.h"
66
67#include "LibKisUtils.h"
68#include <kis_layer_utils.h>
69
70struct Node::Private {
71 Private() {}
72 KisImageWSP image;
73 KisNodeSP node;
74};
75
76Node::Node(KisImageSP image, KisNodeSP node, QObject *parent)
77 : QObject(parent)
78 , d(new Private)
79{
80 d->image = image;
81 d->node = node;
82}
83
84Node *Node::createNode(KisImageSP image, KisNodeSP node, QObject *parent)
85{
86 if (node.isNull()) {
87 return 0;
88 }
89 if (node->inherits("KisGroupLayer")) {
90 return new GroupLayer(dynamic_cast<KisGroupLayer*>(node.data()));
91 }
92 else if (node->inherits("KisCloneLayer")) {
93 return new CloneLayer(dynamic_cast<KisCloneLayer*>(node.data()));
94 }
95 else if (node->inherits("KisFileLayer")) {
96 return new FileLayer(dynamic_cast<KisFileLayer*>(node.data()));
97 }
98 else if (node->inherits("KisAdjustmentLayer")) {
99 return new FilterLayer(dynamic_cast<KisAdjustmentLayer*>(node.data()));
100 }
101 else if (node->inherits("KisGeneratorLayer")) {
102 return new FillLayer(dynamic_cast<KisGeneratorLayer*>(node.data()));
103 }
104 else if (node->inherits("KisShapeLayer")) {
105 return new VectorLayer(dynamic_cast<KisShapeLayer*>(node.data()));
106 }
107 else if (node->inherits("KisFilterMask")) {
108 return new FilterMask(image, dynamic_cast<KisFilterMask*>(node.data()));
109 }
110 else if (node->inherits("KisSelectionMask")) {
111 return new SelectionMask(image, dynamic_cast<KisSelectionMask*>(node.data()));
112 }
113 else if (node->inherits("KisTransparencyMask")) {
114 return new TransparencyMask(image, dynamic_cast<KisTransparencyMask*>(node.data()));
115 }
116 else if (node->inherits("KisTransformMask")) {
117 return new TransformMask(image, dynamic_cast<KisTransformMask*>(node.data()));
118 }
119 else if (node->inherits("KisColorizeMask")) {
120 return new ColorizeMask(image, dynamic_cast<KisColorizeMask*>(node.data()));
121 }
122 else {
123 return new Node(image, node, parent);
124 }
125}
126
127Node::~Node()
128{
129 delete d;
130}
131
132bool Node::operator==(const Node &other) const
133{
134 return (d->node == other.d->node
135 && d->image == other.d->image);
136}
137
138bool Node::operator!=(const Node &other) const
139{
140 return !(operator==(other));
141}
142
144{
145 KisNodeSP clone = d->node->clone();
146 Node *node = Node::createNode(0, clone);
147 return node;
148}
149
150
152{
153 if (!d->node) return false;
155 if (paintLayer) {
156 return paintLayer->alphaLocked();
157 }
158 return false;
159}
160
161void Node::setAlphaLocked(bool value)
162{
163 if (!d->node) return;
165 if (paintLayer) {
166 paintLayer->setAlphaLocked(value);
167 }
168}
169
170
172{
173 if (!d->node) return QString();
174
175 return d->node->compositeOpId();
176}
177
179{
180 if (!d->node) return;
181
183 value);
184
185 KisProcessingApplicator::runSingleCommandStroke(d->image, cmd);
186 d->image->waitForDone();
187}
188
189
191{
193
194 if (!d->node) return channels;
195 if (!d->node->inherits("KisLayer")) return channels;
196
197 Q_FOREACH(KoChannelInfo *info, d->node->colorSpace()->channels()) {
198 Channel *channel = new Channel(d->node, info);
199 channels << channel;
200 }
201
202 return channels;
203}
204
206{
208 if (d->node) {
210 int childCount = d->node->childCount();
211 for (int i = 0; i < childCount; ++i) {
212 nodeList << d->node->at(i);
213 }
214 nodes = LibKisUtils::createNodeList(nodeList, d->image);
215 }
216 return nodes;
217}
218
219QList<Node*> Node::findChildNodes(const QString &name, bool recursive, bool partialMatch, const QString &type, int colorLabelIndex) const
220{
221 if (!d->node) return {};
222
224 KisNodeList nodeList = KisLayerUtils::findNodesByName(d->node, name, recursive, partialMatch);
225
226 if (!type.isEmpty()) {
227 for (int i = nodeList.size() - 1; i >= 0; i--) {
228 if ((type == "paintlayer" && !qobject_cast<const KisPaintLayer*>(nodeList.at(i))) ||
229 (type == "vectorlayer" && !qobject_cast<const KisShapeLayer*>(nodeList.at(i))) ||
230 (type == "grouplayer" && !qobject_cast<const KisGroupLayer*>(nodeList.at(i))) ||
231 (type == "filelayer" && !qobject_cast<const KisFileLayer*>(nodeList.at(i))) ||
232 (type == "filterlayer" && !qobject_cast<const KisAdjustmentLayer*>(nodeList.at(i))) ||
233 (type == "filllayer" && !qobject_cast<const KisGeneratorLayer*>(nodeList.at(i))) ||
234 (type == "clonelayer" && !qobject_cast<const KisCloneLayer*>(nodeList.at(i))) ||
235 (type == "transformmask" && !qobject_cast<const KisTransformMask*>(nodeList.at(i))) ||
236 (type == "referenceimageslayer" && !qobject_cast<const KisReferenceImagesLayer*>(nodeList.at(i))) ||
237 (type == "transparencymask" && !qobject_cast<const KisTransformMask*>(nodeList.at(i))) ||
238 (type == "filtermask" && !qobject_cast<const KisFilterMask*>(nodeList.at(i))) ||
239 (type == "selectionmask" && !qobject_cast<const KisSelectionMask*>(nodeList.at(i))) ||
240 (type == "colorizemask" && !qobject_cast<const KisColorizeMask*>(nodeList.at(i)))
241 ) {
242 nodeList.removeAt(i);
243 }
244 }
245 }
246
247 if (colorLabelIndex > 0) {
248 for (int i = nodeList.size() - 1; i >= 0; i--) {
249 if (nodeList.at(i)->colorLabelIndex() != colorLabelIndex) {
250 nodeList.removeAt(i);
251 }
252 }
253 }
254
255 return LibKisUtils::createNodeList(nodeList, d->image);
256}
257
258bool Node::addChildNode(Node *child, Node *above)
259{
260 if (!d->node) return false;
261
262 KUndo2Command *cmd = 0;
263
264 if (above) {
265 cmd = new KisImageLayerAddCommand(d->image, child->node(), d->node, above->node());
266 } else {
267 cmd = new KisImageLayerAddCommand(d->image, child->node(), d->node, d->node->childCount());
268 }
269
270 KisProcessingApplicator::runSingleCommandStroke(d->image, cmd);
271 d->image->waitForDone();
272
273 return true;
274}
275
277{
278 if (!d->node) return false;
279 return child->remove();
280}
281
283{
284 if (!d->node) return;
285 KisNodeSP node = d->node->firstChild();
286 while (node) {
287 d->image->removeNode(node);
288 node = node->nextSibling();
289 }
290 Q_FOREACH(Node *node, nodes) {
291 d->image->addNode(node->node(), d->node);
292 }
293}
294
296{
297 if (!d->node) return 0;
298 return d->node->colorLabelIndex();
299}
300
301void Node::setColorLabel(int index)
302{
303 if (!d->node) return;
304 d->node->setColorLabelIndex(index);
305}
306
308{
309 if (!d->node) return "";
310 if (!d->node->projection()) return d->node->colorSpace()->colorDepthId().id();
311 return d->node->projection()->colorSpace()->colorDepthId().id();
312}
313
315{
316 if (!d->node) return "";
317 if (!d->node->projection()) return d->node->colorSpace()->colorModelId().id();
318 return d->node->projection()->colorSpace()->colorModelId().id();
319}
320
321
323{
324 if (!d->node) return "";
325 if (!d->node->projection()) return d->node->colorSpace()->profile()->name();
326 return d->node->projection()->colorSpace()->profile()->name();
327}
328
329bool Node::setColorProfile(const QString &colorProfile)
330{
331 if (!d->node) return false;
332 if (!d->node->inherits("KisLayer")) return false;
333 KisLayer *layer = qobject_cast<KisLayer*>(d->node.data());
334 const KoColorProfile *profile = KoColorSpaceRegistry::instance()->profileByName(colorProfile);
335 bool result = d->image->assignLayerProfile(layer, profile);
336 d->image->waitForDone();
337 return result;
338}
339
340bool Node::setColorSpace(const QString &colorModel, const QString &colorDepth, const QString &colorProfile)
341{
342 if (!d->node) return false;
343 if (!d->node->inherits("KisLayer")) return false;
344 const KoColorProfile *profile = KoColorSpaceRegistry::instance()->profileByName(colorProfile);
345 if (!profile) return false;
346 const KoColorSpace *dstCs = KoColorSpaceRegistry::instance()->colorSpace(colorModel,
348 profile);
349 d->image->convertLayerColorSpace(d->node, dstCs, KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags());
350 d->image->waitForDone();
351 return true;
352}
353
354bool Node::animated() const
355{
356 if (!d->node) return false;
357 return d->node->isAnimated();
358}
359
361{
362 if (!d->node) return;
363 d->node->enableAnimation();
364}
365
366void Node::setPinnedToTimeline(bool pinned) const
367{
368 if (!d->node) return;
369 d->node->setPinnedToTimeline(pinned);
370}
371
373{
374 if (!d->node) return false;
375 return d->node->isPinnedToTimeline();
376}
377
378bool Node::collapsed() const
379{
380 if (!d->node) return false;
381 return d->node->collapsed();
382}
383
384void Node::setCollapsed(bool collapsed)
385{
386 if (!d->node) return;
387 d->node->setCollapsed(collapsed);
388}
389
391{
392 if (!d->node) return false;
393 if (!d->node->inherits("KisLayer")) return false;
394 return qobject_cast<const KisLayer*>(d->node)->alphaChannelDisabled();
395}
396
397void Node::setInheritAlpha(bool value)
398{
399 if (!d->node) return;
400 if (!d->node->inherits("KisLayer")) return;
401 const_cast<KisLayer*>(qobject_cast<const KisLayer*>(d->node))->disableAlphaChannel(value);
402}
403
404bool Node::locked() const
405{
406 if (!d->node) return false;
407 return d->node->userLocked();
408}
409
410void Node::setLocked(bool value)
411{
412 if (!d->node) return;
413 d->node->setUserLocked(value);
414}
415
417{
418 return !d->node->extent().isEmpty();
419}
420
422{
423 if (!d->node) return QString();
424 return d->node->name();
425}
426
428{
429 if (!d->node) return;
430 d->node->setName(name);
431}
432
433
434int Node::opacity() const
435{
436 if (!d->node) return 0;
437 return d->node->opacity();
438}
439
440void Node::setOpacity(int value)
441{
442 if (!d->node) return;
443 if (value < 0) value = 0;
444 if (value > 255) value = 255;
445 d->node->setOpacity(value);
446}
447
448
450{
451 if (!d->node) return 0;
452 if (!d->node->parent()) return 0;
453 return Node::createNode(d->image, d->node->parent());
454}
455
457{
458 if (!d->node) return QString();
460 return "paintlayer";
461 }
462 else if (qobject_cast<const KisGroupLayer*>(d->node)) {
463 return "grouplayer";
464 }
466 return "filelayer";
467 }
469 return "filterlayer";
470 }
472 return "filllayer";
473 }
475 return "clonelayer";
476 }
478 return "referenceimageslayer";
479 }
481 return "vectorlayer";
482 }
484 return "transparencymask";
485 }
487 return "filtermask";
488 }
490 return "transformmask";
491 }
493 return "selectionmask";
494 }
496 return "colorizemask";
497 }
498 return QString();
499}
500
502{
503 QIcon icon;
504 if (d->node) {
505 icon = d->node->icon();
506 }
507 return icon;
508}
509
510bool Node::visible() const
511{
512 if (!d->node) return false;
513 return d->node->visible();
514}
515
516bool Node::hasKeyframeAtTime(int frameNumber)
517{
518 if (!d->node || !d->node->isAnimated()) return false;
519
520 KisRasterKeyframeChannel *rkc = dynamic_cast<KisRasterKeyframeChannel*>(d->node->getKeyframeChannel(KisKeyframeChannel::Raster.id()));
521 if (!rkc) return false;
522
524
525 if (!currentKeyframe) {
526 return false;
527 }
528
529 return true;
530}
531
532void Node::setVisible(bool visible)
533{
534 if (!d->node) return;
535 d->node->setVisible(visible);
536}
537
538
539QByteArray Node::pixelData(int x, int y, int w, int h) const
540{
542
543 if (!d->node) return ba;
544
545 KisPaintDeviceSP dev = d->node->paintDevice();
546 if (!dev) return ba;
547
548 ba.resize(w * h * dev->pixelSize());
549 dev->readBytes(reinterpret_cast<quint8*>(ba.data()), x, y, w, h);
550 return ba;
551}
552
553QByteArray Node::pixelDataAtTime(int x, int y, int w, int h, int time) const
554{
556
557 if (!d->node || !d->node->isAnimated()) return ba;
558
559 //
560 KisRasterKeyframeChannel *rkc = dynamic_cast<KisRasterKeyframeChannel*>(d->node->getKeyframeChannel(KisKeyframeChannel::Raster.id()));
561 if (!rkc) return ba;
562 KisRasterKeyframeSP frame = rkc->keyframeAt<KisRasterKeyframe>(time);
563 if (!frame) return ba;
564 KisPaintDeviceSP dev = new KisPaintDevice(*d->node->paintDevice(), KritaUtils::DeviceCopyMode::CopySnapshot);
565 if (!dev) return ba;
566
567 frame->writeFrameToDevice(dev);
568
569 ba.resize(w * h * dev->pixelSize());
570 dev->readBytes(reinterpret_cast<quint8*>(ba.data()), x, y, w, h);
571 return ba;
572}
573
574
575QByteArray Node::projectionPixelData(int x, int y, int w, int h) const
576{
578
579 if (!d->node) return ba;
580
582 if (const KisColorizeMask *mask = qobject_cast<const KisColorizeMask*>(d->node)) {
583
584 dev = mask->coloringProjection();
585 } else {
586 dev = d->node->projection();
587 }
588 if (!dev) return ba;
589
590 ba.resize(w * h * dev->pixelSize());
591 dev->readBytes(reinterpret_cast<quint8*>(ba.data()), x, y, w, h);
592 return ba;
593}
594
595bool Node::setPixelData(QByteArray value, int x, int y, int w, int h)
596{
597 if (!d->node) return false;
598 KisPaintDeviceSP dev = d->node->paintDevice();
599 if (!dev) return false;
600 if (value.length() < w * h * (int)dev->colorSpace()->pixelSize()) {
601 qWarning() << "Node::setPixelData: not enough data to write to the paint device";
602 return false;
603 }
604 dev->writeBytes((const quint8*)value.constData(), x, y, w, h);
605 return true;
606}
607
609{
610 if (!d->node) return QRect();
611 return d->node->exactBounds();
612}
613
614void Node::move(int x, int y)
615{
616 if (!d->node) return;
617 d->node->setX(x);
618 d->node->setY(y);
619}
620
622{
623 if (!d->node) return QPoint();
624 return QPoint(d->node->x(), d->node->y());
625}
626
628{
629 if (!d->node) return false;
630 if (!d->node->parent()) return false;
631
632 KUndo2Command *cmd = new KisImageLayerRemoveCommand(d->image, d->node);
633
634 KisProcessingApplicator::runSingleCommandStroke(d->image, cmd);
635 d->image->waitForDone();
636
637 return true;
638}
639
641{
642 if (!d->node) return 0;
643 return Node::createNode(d->image, d->node->clone());
644}
645
646bool Node::save(const QString &filename, double xRes, double yRes, const InfoObject &exportConfiguration, const QRect &exportRect)
647{
648 if (!d->node) return false;
649 if (filename.isEmpty()) return false;
650
651 KisPaintDeviceSP projection = d->node->projection();
652 QRect bounds = (exportRect.isEmpty())? d->node->exactBounds() : exportRect;
653
654 QString mimeType = KisMimeDatabase::mimeTypeForFile(filename, false);
655 QScopedPointer<KisDocument> doc(KisPart::instance()->createDocument());
656
657 KisImageSP dst = new KisImage(doc->createUndoStore(),
658 bounds.right(),
659 bounds.bottom(),
660 projection->compositionSourceColorSpace(),
661 d->node->name());
662 dst->setResolution(xRes, yRes);
663 doc->setFileBatchMode(Krita::instance()->batchmode());
664 doc->setCurrentImage(dst);
665 KisPaintLayer* paintLayer = new KisPaintLayer(dst, "paint device", d->node->opacity());
666 paintLayer->paintDevice()->makeCloneFrom(projection, bounds);
667 dst->addNode(paintLayer, dst->rootLayer(), KisLayerSP(0));
668 dst->cropImage(bounds);
669 dst->initialRefreshGraph();
670
671 bool r = doc->exportDocumentSync(filename, mimeType.toLatin1(), exportConfiguration.configuration());
672 if (!r) {
673 qWarning() << doc->errorMessage();
674 }
675 return r;
676}
677
679{
680 if (!d->node) return 0;
681 if (!qobject_cast<KisLayer*>(d->node.data())) return 0;
682 if (!d->node->prevSibling()) return 0;
683
684 d->image->mergeDown(qobject_cast<KisLayer*>(d->node.data()), KisMetaData::MergeStrategyRegistry::instance()->get("Drop"));
685 d->image->waitForDone();
686
687 return Node::createNode(d->image, d->node->prevSibling());
688}
689
690void Node::scaleNode(QPointF origin, int width, int height, QString strategy)
691{
692 if (!d->node) return;
693 if (!qobject_cast<KisLayer*>(d->node.data())) return;
694 if (!d->node->parent()) return;
695
696 KisFilterStrategy *actualStrategy = KisFilterStrategyRegistry::instance()->get(strategy);
697 if (!actualStrategy) actualStrategy = KisFilterStrategyRegistry::instance()->get("Bicubic");
698
699 const QRect bounds(d->node->exactBounds());
700
701 d->image->scaleNode(d->node,
702 origin,
703 qreal(width) / bounds.width(),
704 qreal(height) / bounds.height(),
705 actualStrategy, 0);
706 d->image->waitForDone();
707}
708
709void Node::rotateNode(double radians)
710{
711 if (!d->node) return;
712 if (!qobject_cast<KisLayer*>(d->node.data())) return;
713 if (!d->node->parent()) return;
714
715 d->image->rotateNode(d->node, radians, 0);
716 d->image->waitForDone();
717}
718
719void Node::cropNode(int x, int y, int w, int h)
720{
721 if (!d->node) return;
722 if (!qobject_cast<KisLayer*>(d->node.data())) return;
723 if (!d->node->parent()) return;
724
725 QRect rect = QRect(x, y, w, h);
726 d->image->cropNode(d->node, rect);
727 d->image->waitForDone();
728}
729
730void Node::shearNode(double angleX, double angleY)
731{
732 if (!d->node) return;
733 if (!qobject_cast<KisLayer*>(d->node.data())) return;
734 if (!d->node->parent()) return;
735
736 d->image->shearNode(d->node, angleX, angleY, 0);
737 d->image->waitForDone();
738}
739
741{
742 if (!d->node) return QImage();
743 return d->node->createThumbnail(w, h);
744}
745
747{
748 if (!d->node) return QString();
749
750 KisLayer *layer = qobject_cast<KisLayer*>(d->node.data());
751
752 if (!layer) return QString();
753
754 KisPSDLayerStyleSP layerStyle = layer->layerStyle();
755
756 if (!layerStyle) return QString();
757
759
760 serializer.setStyles(QVector<KisPSDLayerStyleSP>() << layerStyle);
761
762 return serializer.formPsdXmlDocument().toString();
763}
764
766{
767 if (!d->node) return false;
768
769 KisLayer *layer = qobject_cast<KisLayer*>(d->node.data());
770
771 if (!layer) return false;
772
774
775 if (!aslDoc.setContent(asl)) {
776 qWarning() << "ASL string format is invalid!";
777 return false;
778 }
779
781
782 serializer.registerPSDPattern(aslDoc);
783 serializer.readFromPSDXML(aslDoc);
784
785 if (serializer.styles().size() != 1) return false;
786
787 KisPSDLayerStyleSP newStyle = serializer.styles().first();
788 KUndo2Command *cmd = new KisSetLayerStyleCommand(layer, layer->layerStyle(), newStyle);
789
790 KisProcessingApplicator::runSingleCommandStroke(d->image, cmd);
791 d->image->waitForDone();
792
793 return true;
794}
795
796int Node::index() const
797{
798 if (!d->node) return -1;
799 if (!d->node->parent()) return -1;
800
801 return d->node->parent()->index(d->node);
802}
803
805{
806 if (!d->node) return QUuid();
807 return d->node->uuid();
808}
809
810KisPaintDeviceSP Node::paintDevice() const
811{
812 return d->node->paintDevice();
813}
814
815KisImageSP Node::image() const
816{
817 return d->image;
818}
819
820KisNodeSP Node::node() const
821{
822 return d->node;
823}
A Channel represents a single channel in a Node.
Definition Channel.h:23
The CloneLayer class A clone layer is a layer that takes a reference inside the image and shows the e...
Definition CloneLayer.h:26
The ColorizeMask class A colorize mask is a mask type node that can be used to color in line art.
The FileLayer class A file layer is a layer that can reference an external image and show said refere...
Definition FileLayer.h:27
The FillLayer class A fill layer is much like a filter layer in that it takes a name and filter.
Definition FillLayer.h:25
The FilterLayer class A filter layer will, when compositing, take the composited image up to the poin...
Definition FilterLayer.h:34
The FilterMask class A filter mask, unlike a filter layer, will add a non-destructive filter to the c...
Definition FilterMask.h:29
The GroupLayer class A group layer is a layer that can contain other layers.
Definition GroupLayer.h:30
InfoObject wrap a properties map.
Definition InfoObject.h:20
static Krita * instance()
instance retrieve the singleton instance of the Application object.
Definition Krita.cpp:402
Node represents a layer or mask in a Krita image's Node hierarchy.
Definition Node.h:22
bool alphaLocked() const
alphaLocked checks whether the node is a paint layer and returns whether it is alpha locked
Definition Node.cpp:151
void setBlendingMode(QString value)
setBlendingMode set the blending mode of the node to the given value
Definition Node.cpp:178
QList< Node * > childNodes() const
childNodes
Definition Node.cpp:205
void scaleNode(QPointF origin, int width, int height, QString strategy)
scaleNode
Definition Node.cpp:690
void setAlphaLocked(bool value)
setAlphaLocked set the layer to value if the node is paint layer.
Definition Node.cpp:161
Node * mergeDown()
mergeDown merges the given node with the first visible node underneath this node in the layerstack.
Definition Node.cpp:678
void setCollapsed(bool collapsed)
Sets the state of the node to the value of.
Definition Node.cpp:384
QList< Channel * > channels() const
channels creates a list of Channel objects that can be used individually to show or hide certain chan...
Definition Node.cpp:190
QList< Node * > findChildNodes(const QString &name=QString(), bool recursive=false, bool partialMatch=false, const QString &type=QString(), int colorLabelIndex=0) const
findChildNodes
Definition Node.cpp:219
void enableAnimation() const
enableAnimation make the current layer animated, so it can have frames.
Definition Node.cpp:360
QString colorDepth() const
colorDepth A string describing the color depth of the image:
Definition Node.cpp:307
void setOpacity(int value)
set the opacity of the Node to the given value.
Definition Node.cpp:440
bool locked() const
locked checks whether the Node is locked.
Definition Node.cpp:404
QUuid uniqueId() const
uniqueId uniqueId of the node
Definition Node.cpp:804
QPoint position() const
position returns the position of the paint device of this node.
Definition Node.cpp:621
void setPinnedToTimeline(bool pinned) const
Sets whether or not node should be pinned to the Timeline Docker, regardless of selection activity.
Definition Node.cpp:366
void move(int x, int y)
move the pixels to the given x, y location in the image coordinate space.
Definition Node.cpp:614
void setChildNodes(QList< Node * > nodes)
setChildNodes this replaces the existing set of child nodes with the new set.
Definition Node.cpp:282
QIcon icon() const
icon
Definition Node.cpp:501
bool visible() const
Check whether the current Node is visible in the layer stack.
Definition Node.cpp:510
QString colorModel() const
colorModel retrieve the current color model of this document:
Definition Node.cpp:314
bool hasKeyframeAtTime(int frameNumber)
Check to see if frame number on layer is a keyframe.
Definition Node.cpp:516
void shearNode(double angleX, double angleY)
shearNode perform a shear operation on this node.
Definition Node.cpp:730
bool setPixelData(QByteArray value, int x, int y, int w, int h)
setPixelData writes the given bytes, of which there must be enough, into the Node,...
Definition Node.cpp:595
bool setColorSpace(const QString &colorModel, const QString &colorDepth, const QString &colorProfile)
setColorSpace convert the node to the given colorspace
Definition Node.cpp:340
virtual QString type() const
type Krita has several types of nodes, split in layers and masks.
Definition Node.cpp:456
void setLocked(bool value)
set the Locked flag to the give value
Definition Node.cpp:410
bool animated() const
Krita layers can be animated, i.e., have frames.
Definition Node.cpp:354
bool remove()
remove removes this node from its parent image.
Definition Node.cpp:627
bool inheritAlpha() const
inheritAlpha checks whether this node has the inherits alpha flag set
Definition Node.cpp:390
QByteArray pixelData(int x, int y, int w, int h) const
pixelData reads the given rectangle from the Node's paintable pixels, if those exist,...
Definition Node.cpp:539
void setName(QString name)
rename the Node to the given name
Definition Node.cpp:427
bool save(const QString &filename, double xRes, double yRes, const InfoObject &exportConfiguration, const QRect &exportRect=QRect())
save exports the given node with this filename.
Definition Node.cpp:646
void cropNode(int x, int y, int w, int h)
cropNode crop this layer.
Definition Node.cpp:719
void rotateNode(double radians)
rotateNode rotate this layer by the given radians.
Definition Node.cpp:709
int index() const
index the index of the node inside the parent
Definition Node.cpp:796
int opacity() const
return the opacity of the Node.
Definition Node.cpp:434
bool collapsed() const
returns the collapsed state of this node
Definition Node.cpp:378
bool setLayerStyleFromAsl(const QString &asl)
setLayerStyleFromAsl set a new layer style for this node.
Definition Node.cpp:765
int colorLabel() const
Sets a color label index associated to the layer.
Definition Node.cpp:295
QString blendingMode() const
Definition Node.cpp:171
QString layerStyleToAsl()
layerStyleToAsl retrieve the current layer's style in ASL format.
Definition Node.cpp:746
bool setColorProfile(const QString &colorProfile)
setColorProfile set the color profile of the image to the given profile.
Definition Node.cpp:329
bool addChildNode(Node *child, Node *above)
addChildNode adds the given node in the list of children.
Definition Node.cpp:258
QImage thumbnail(int w, int h)
thumbnail create a thumbnail of the given dimensions.
Definition Node.cpp:740
bool hasExtents()
does the node have any content in it?
Definition Node.cpp:416
Node * duplicate()
duplicate returns a full copy of the current node.
Definition Node.cpp:640
void setInheritAlpha(bool value)
set the Inherit Alpha flag to the given value
Definition Node.cpp:397
bool removeChildNode(Node *child)
removeChildNode removes the given node from the list of children.
Definition Node.cpp:276
QString name() const
Definition Node.cpp:421
Node * parentNode() const
return the Node that is the parent of the current Node, or 0 if this is the root Node.
Definition Node.cpp:449
void setVisible(bool visible)
Set the visibility of the current node to.
Definition Node.cpp:532
QByteArray projectionPixelData(int x, int y, int w, int h) const
projectionPixelData reads the given rectangle from the Node's projection (that is,...
Definition Node.cpp:575
void setColorLabel(int index)
setColorLabel sets a color label index associated to the layer.
Definition Node.cpp:301
Node * clone() const
clone clone the current node.
Definition Node.cpp:143
QByteArray pixelDataAtTime(int x, int y, int w, int h, int time) const
pixelDataAtTime a basic function to get pixeldata from an animated node at a given time.
Definition Node.cpp:553
bool isPinnedToTimeline() const
Definition Node.cpp:372
QRect bounds() const
bounds return the exact bounds of the node's paint device
Definition Node.cpp:608
QString colorProfile() const
Definition Node.cpp:322
The SelectionMask class A selection mask is a mask type node that can be used to store selections.
The TransformMask class A transform mask is a mask type node that can be used to store transformation...
The TransparencyMask class A transparency mask is a mask type node that can be used to show and hide ...
The VectorLayer class A vector layer is a special layer that stores and shows vector shapes.
Definition VectorLayer.h:32
const char * constData() const const
qsizetype length() const const
QObject * parent() const const
T qobject_cast(QObject *object)
int bottom() const const
int height() const const
int right() const const
int width() const const
bool isEmpty() const const
QByteArray toLatin1() const const
This file is part of the KDE documentation.
Documentation copyright © 1996-2024 The KDE developers.
Generated on Fri May 24 2024 11:56:55 by doxygen 1.10.0 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.