Node Class Reference

#include <Node.h>

Inheritance diagram for Node:

Classes
struct	Private

Public Slots
bool	addChildNode (Node *child, Node *above)
	addChildNode adds the given node in the list of children.
bool	alphaLocked () const
	alphaLocked checks whether the node is a paint layer and returns whether it is alpha locked
bool	animated () const
	Krita layers can be animated, i.e., have frames.
QString	blendingMode () const
QRect	bounds () const
	bounds return the exact bounds of the node's paint device
QList< Channel * >	channels () const
	channels creates a list of Channel objects that can be used individually to show or hide certain channels, and to retrieve the contents of each channel in a node separately.
QList< Node * >	childNodes () const
	childNodes
Node *	clone () const
	clone clone the current node. The node is not associated with any image.
bool	collapsed () const
QString	colorDepth () const
int	colorLabel () const
QString	colorModel () const
	colorModel retrieve the current color model of this document:
QString	colorProfile () const
void	cropNode (int x, int y, int w, int h)
	cropNode crop this layer.
Node *	duplicate ()
	duplicate returns a full copy of the current node. The node is not inserted in the graphic
void	enableAnimation () const
	enableAnimation make the current layer animated, so it can have frames.
QList< Node * >	findChildNodes (const QString &name=QString(), bool recursive=false, bool partialMatch=false, const QString &type=QString(), int colorLabelIndex=0) const
	findChildNodes
bool	hasExtents ()
	does the node have any content in it?
bool	hasKeyframeAtTime (int frameNumber)
QIcon	icon () const
	icon
int	index () const
	index the index of the node inside the parent
bool	inheritAlpha () const
	inheritAlpha checks whether this node has the inherits alpha flag set
bool	isPinnedToTimeline () const
QString	layerStyleToAsl ()
	layerStyleToAsl retrieve the current layer's style in ASL format.
bool	locked () const
	locked checks whether the Node is locked. A locked node cannot be changed.
Node *	mergeDown ()
	mergeDown merges the given node with the first visible node underneath this node in the layerstack. This will drop all per-layer metadata.
void	move (int x, int y)
QString	name () const
int	opacity () const
QString	paintAbility ()
	paintAbility can be used to determine whether this node can be painted on with the current brush preset.
void	paintEllipse (const QRectF &rect, const QString strokeStyle=PaintingResources::defaultStrokeStyle, const QString fillStyle=PaintingResources::defaultFillStyle)
	paint an ellipse on the canvas. Uses current brush preset
void	paintLine (const QPointF pointOne, const QPointF pointTwo, double pressureOne=1.0, double pressureTwo=1.0, const QString strokeStyle=PaintingResources::defaultStrokeStyle)
	paint a line on the canvas. Uses current brush preset
void	paintPath (const QPainterPath &path, const QString strokeStyle=PaintingResources::defaultStrokeStyle, const QString fillStyle=PaintingResources::defaultFillStyle)
	paint a custom path on the canvas. Uses current brush preset
void	paintPolygon (const QList< QPointF > points, const QString strokeStyle=PaintingResources::defaultStrokeStyle, const QString fillStyle=PaintingResources::defaultFillStyle)
	paint a polygon on the canvas. Uses current brush preset
void	paintPolylineStroke (const QList< StrokePoint > &points, const QString strokeStyle=PaintingResources::defaultStrokeStyle)
	paintPolylineStroke paint one continuous brush stroke with complete input information for every supplied point. Uses the current brush preset.
void	paintRectangle (const QRectF &rect, const QString strokeStyle=PaintingResources::defaultStrokeStyle, const QString fillStyle=PaintingResources::defaultFillStyle)
	paint a rectangle on the canvas. Uses current brush preset
Node *	parentNode () const
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, and returns it as a byte array. The pixel data starts top-left, and is ordered row-first.
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.
QPoint	position () const
	position returns the position of the paint device of this node. The position is always 0,0 unless the layer has been moved. If you want to know the topleft position of the rectangle around the actual non-transparent pixels in the node, use bounds().
QByteArray	projectionPixelData (int x, int y, int w, int h) const
	projectionPixelData reads the given rectangle from the Node's projection (that is, what the node looks like after all sub-Nodes (like layers in a group or masks on a layer) have been applied, and returns it as a byte array. The pixel data starts top-left, and is ordered row-first.
bool	remove ()
	remove removes this node from its parent image.
bool	removeChildNode (Node *child)
	removeChildNode removes the given node from the list of children.
void	rotateNode (double radians)
	rotateNode rotate this layer by the given radians.
bool	save (const QString &filename, double xRes, double yRes, const InfoObject &exportConfiguration, const QRect &exportRect=QRect())
	save exports the given node with this filename. The extension of the filename determines the filetype.
void	scaleNode (QPointF origin, int width, int height, QString strategy)
	scaleNode
void	setAlphaLocked (bool value)
	setAlphaLocked set the layer to value if the node is paint layer.
void	setBlendingMode (QString value)
	setBlendingMode set the blending mode of the node to the given value
void	setChildNodes (QList< Node * > nodes)
	setChildNodes this replaces the existing set of child nodes with the new set.
void	setCollapsed (bool collapsed)
void	setColorLabel (int index)
	setColorLabel sets a color label index associated to the layer. The actual color of the label and the number of available colors is defined by Krita GUI configuration.
bool	setColorProfile (const QString &colorProfile)
	setColorProfile set the color profile of the image to the given profile. The profile has to be registered with krita and be compatible with the current color model and depth; the image data is not converted.
bool	setColorSpace (const QString &colorModel, const QString &colorDepth, const QString &colorProfile)
	setColorSpace convert the node to the given colorspace
void	setInheritAlpha (bool value)
bool	setLayerStyleFromAsl (const QString &asl)
	setLayerStyleFromAsl set a new layer style for this node.
void	setLocked (bool value)
void	setName (QString name)
void	setOpacity (int value)
void	setPinnedToTimeline (bool pinned) const
	Sets whether or not node should be pinned to the Timeline Docker, regardless of selection activity.
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, if the Node has writable pixel data:
void	setVisible (bool visible)
void	shearNode (double angleX, double angleY)
	shearNode perform a shear operation on this node.
QImage	thumbnail (int w, int h)
	thumbnail create a thumbnail of the given dimensions. The thumbnail is sized according to the layer dimensions, not the image dimensions. If the requested size is too big a null QImage is created. If the current node cannot generate a thumbnail, a transparent QImage of the requested size is generated.
virtual QString	type () const
	type Krita has several types of nodes, split in layers and masks. Group layers can contain other layers, any layer can contain masks.
QUuid	uniqueId () const
	uniqueId uniqueId of the node
bool	visible () const

Public Member Functions
bool	operator!= (const Node &other) const
bool	operator== (const Node &other) const
	~Node () override

Static Public Member Functions
static Node *	createNode (KisImageSP image, KisNodeSP node, QObject *parent=0)

Private Member Functions
KisImageSP	image () const
KisNodeSP	node () const
	Node (KisImageSP image, KisNodeSP node, QObject *parent=0)
KisPaintDeviceSP	paintDevice () const
	paintDevice gives access to the internal paint device of this Node

Private Attributes
Private *const	d

Friends
class	CloneLayer
class	ColorizeMask
class	Document
class	FileLayer
class	FillLayer
class	Filter
class	FilterLayer
class	FilterMask
class	GroupLayer
class	Selection
class	SelectionMask
class	TransformMask
class	TransparencyMask
class	VectorLayer

Detailed Description

Node represents a layer or mask in a Krita image's Node hierarchy. Group layers can contain other layers and masks; layers can contain masks.

Definition at line 24 of file Node.h.

Constructor & Destructor Documentation

~Node()

Node::~Node ( )

override

Definition at line 137 of file Node.cpp.

{
    delete d;
}

References d.

Node()

Node::Node ( KisImageSP image, KisNodeSP node, QObject * parent = 0 )

explicitprivate

Definition at line 86 of file Node.cpp.

    : QObject(parent)
    , d(new Private)
{
    d->image = image;
    d->node = node;
}

References d, Node::Private::image, image(), Node::Private::node, and node().

Member Function Documentation

addChildNode

bool Node::addChildNode ( Node * child, Node * above )

slot

addChildNode adds the given node in the list of children.

Parameters

child	the node to be added
above	the node above which this node will be placed

Returns

false if adding the node failed

Definition at line 268 of file Node.cpp.

{
    if (!d->node) return false;
 
    KUndo2Command *cmd = 0;
 
    if (above) {
        cmd = new KisImageLayerAddCommand(d->image, child->node(), d->node, above->node());
    } else {
        cmd = new KisImageLayerAddCommand(d->image, child->node(), d->node, d->node->childCount());
    }
 
    KisProcessingApplicator::runSingleCommandStroke(d->image, cmd);
    d->image->waitForDone();
 
    return true;
}

References KisNode::childCount(), d, Node::Private::image, Node::Private::node, node(), KisProcessingApplicator::runSingleCommandStroke(), and KisImage::waitForDone().

alphaLocked

bool Node::alphaLocked ( ) const

slot

alphaLocked checks whether the node is a paint layer and returns whether it is alpha locked

Returns

whether the paint layer is alpha locked, or false if the node is not a paint layer

Definition at line 161 of file Node.cpp.

{
    if (!d->node) return false;
    KisPaintLayerSP paintLayer = qobject_cast<KisPaintLayer*>(d->node.data());
    if (paintLayer) {
        return paintLayer->alphaLocked();
    }
    return false;
}

References KisPaintLayer::alphaLocked(), d, KisSharedPtr< T >::data(), and Node::Private::node.

animated

bool Node::animated ( ) const

slot

Krita layers can be animated, i.e., have frames.

Returns

return true if the layer has frames. Currently, the scripting framework does not give access to the animation features.

Definition at line 362 of file Node.cpp.

{
    if (!d->node) return false;
    return d->node->isAnimated();
}

References d, KisBaseNode::isAnimated(), and Node::Private::node.

blendingMode

QString Node::blendingMode ( ) const

slot

Returns

the blending mode of the layer. The values of the blending modes are defined in

See also

KoCompositeOpRegistry.h

Definition at line 181 of file Node.cpp.

{
    if (!d->node) return QString();
 
    return d->node->compositeOpId();
}

References KisBaseNode::compositeOpId(), d, and Node::Private::node.

bounds

QRect Node::bounds ( ) const

slot

bounds return the exact bounds of the node's paint device

Returns

the bounds, or an empty QRect if the node has no paint device or is empty.

Definition at line 616 of file Node.cpp.

{
    if (!d->node) return QRect();
    return d->node->exactBounds();
}

References d, KisBaseNode::exactBounds(), and Node::Private::node.

channels

QList< Channel * > Node::channels ( ) const

slot

channels creates a list of Channel objects that can be used individually to show or hide certain channels, and to retrieve the contents of each channel in a node separately.

Only layers have channels, masks do not, and calling channels on a Node that is a mask will return an empty list.

Returns

the list of channels ordered in by position of the channels in pixel position

Definition at line 200 of file Node.cpp.

{
    QList<Channel*> channels;
 
    if (!d->node) return channels;
    if (!d->node->inherits("KisLayer")) return channels;
 
    Q_FOREACH(KoChannelInfo *info, d->node->colorSpace()->channels()) {
        Channel *channel = new Channel(d->node, info);
        channels << channel;
    }
 
    return channels;
}

References channels(), KoColorSpace::channels, KisBaseNode::colorSpace(), d, and Node::Private::node.

childNodes

QList< Node * > Node::childNodes ( ) const

slot

childNodes

Returns

returns a list of child nodes of the current node. The nodes are ordered from the bottommost up. The function is not recursive.

Definition at line 215 of file Node.cpp.

{
    QList<Node*> nodes;
    if (d->node) {
        KisNodeList nodeList;
        int childCount = d->node->childCount();
        for (int i = 0; i < childCount; ++i) {
            nodeList << d->node->at(i);
        }
        nodes = LibKisUtils::createNodeList(nodeList, d->image);
    }
    return nodes;
}

References KisNode::at(), KisNode::childCount(), LibKisUtils::createNodeList(), d, Node::Private::image, and Node::Private::node.

clone

Node * Node::clone ( ) const

slot

clone clone the current node. The node is not associated with any image.

Definition at line 153 of file Node.cpp.

{
    KisNodeSP clone = d->node->clone();
    Node *node = Node::createNode(0, clone);
    return node;
}

References clone(), KisNode::clone(), createNode(), d, Node::Private::node, and node().

collapsed

bool Node::collapsed ( ) const

slot

returns the collapsed state of this node

Definition at line 386 of file Node.cpp.

{
    if (!d->node) return false;
    return d->node->collapsed();
}

References KisBaseNode::collapsed, d, and Node::Private::node.

colorDepth

QString Node::colorDepth ( ) const

slot

colorDepth A string describing the color depth of the image:

• U8: unsigned 8 bits integer, the most common type
• U16: unsigned 16 bits integer
• F16: half, 16 bits floating point. Only available if Krita was built with OpenEXR
• F32: 32 bits floating point

Returns

the color depth.

Definition at line 315 of file Node.cpp.

{
    if (!d->node) return "";
    if (!d->node->projection()) return d->node->colorSpace()->colorDepthId().id();
    return d->node->projection()->colorSpace()->colorDepthId().id();
}

References KoColorSpace::colorDepthId(), KisPaintDevice::colorSpace(), KisBaseNode::colorSpace(), d, KoID::id(), Node::Private::node, and KisBaseNode::projection().

colorLabel

int Node::colorLabel ( ) const

slot

Sets a color label index associated to the layer. The actual color of the label and the number of available colors is defined by Krita GUI configuration.

Definition at line 303 of file Node.cpp.

{
    if (!d->node) return 0;
    return d->node->colorLabelIndex();
}

References KisBaseNode::colorLabelIndex(), d, and Node::Private::node.

colorModel

QString Node::colorModel ( ) const

slot

colorModel retrieve the current color model of this document:

• A: Alpha mask
• RGBA: RGB with alpha channel (The actual order of channels is most often BGR!)
• XYZA: XYZ with alpha channel
• LABA: LAB with alpha channel
• CMYKA: CMYK with alpha channel
• GRAYA: Gray with alpha channel
• YCbCrA: YCbCr with alpha channel

Returns

the internal color model string.

Definition at line 322 of file Node.cpp.

{
    if (!d->node) return "";
    if (!d->node->projection()) return d->node->colorSpace()->colorModelId().id();
    return d->node->projection()->colorSpace()->colorModelId().id();
}

References KoColorSpace::colorModelId(), KisPaintDevice::colorSpace(), KisBaseNode::colorSpace(), d, KoID::id(), Node::Private::node, and KisBaseNode::projection().

colorProfile

QString Node::colorProfile ( ) const

slot

Returns

the name of the current color profile

Definition at line 330 of file Node.cpp.

{
    if (!d->node) return "";
    if (!d->node->projection()) return d->node->colorSpace()->profile()->name();
    return d->node->projection()->colorSpace()->profile()->name();
}

References KisPaintDevice::colorSpace(), KisBaseNode::colorSpace(), d, KoColorProfile::name, Node::Private::node, KoColorSpace::profile(), and KisBaseNode::projection().

createNode()

Node * Node::createNode ( KisImageSP image, KisNodeSP node, QObject * parent = 0 )

static

Definition at line 94 of file Node.cpp.

{
    if (node.isNull()) {
        return 0;
    }
    if (node->inherits("KisGroupLayer")) {
        return new GroupLayer(dynamic_cast<KisGroupLayer*>(node.data()));
    }
    else if (node->inherits("KisCloneLayer")) {
        return new CloneLayer(dynamic_cast<KisCloneLayer*>(node.data()));
    }
    else if (node->inherits("KisFileLayer")) {
        return new FileLayer(dynamic_cast<KisFileLayer*>(node.data()));
    }
    else if (node->inherits("KisAdjustmentLayer")) {
        return new FilterLayer(dynamic_cast<KisAdjustmentLayer*>(node.data()));
    }
    else if (node->inherits("KisGeneratorLayer")) {
        return new FillLayer(dynamic_cast<KisGeneratorLayer*>(node.data()));
    }
    else if (node->inherits("KisShapeLayer")) {
        return new VectorLayer(dynamic_cast<KisShapeLayer*>(node.data()));
    }
    else if (node->inherits("KisFilterMask")) {
        return new FilterMask(image, dynamic_cast<KisFilterMask*>(node.data()));
    }
    else if (node->inherits("KisSelectionMask")) {
        return new SelectionMask(image, dynamic_cast<KisSelectionMask*>(node.data()));
    }
    else if (node->inherits("KisTransparencyMask")) {
        return new TransparencyMask(image, dynamic_cast<KisTransparencyMask*>(node.data()));
    }
    else if (node->inherits("KisTransformMask")) {
        return new TransformMask(image, dynamic_cast<KisTransformMask*>(node.data()));
    }
    else if (node->inherits("KisColorizeMask")) {
        return new ColorizeMask(image, dynamic_cast<KisColorizeMask*>(node.data()));
    }
    else {
        return new Node(image, node, parent);
    }
}

References CloneLayer, ColorizeMask, KisSharedPtr< T >::data(), FileLayer, FillLayer, FilterLayer, FilterMask, GroupLayer, image(), KisSharedPtr< T >::isNull(), node(), Node(), SelectionMask, TransformMask, TransparencyMask, and VectorLayer.

cropNode

void Node::cropNode ( int x, int y, int w, int h )

slot

cropNode crop this layer.

Parameters

x	the left edge of the cropping rectangle.
y	the top edge of the cropping rectangle
w	the right edge of the cropping rectangle
h	the bottom edge of the cropping rectangle

Definition at line 727 of file Node.cpp.

{
    if (!d->node) return;
    if (!qobject_cast<KisLayer*>(d->node.data())) return;
    if (!d->node->parent()) return;
 
    QRect rect = QRect(x, y, w, h);
    d->image->cropNode(d->node, rect);
    d->image->waitForDone();
}

References KisImage::cropNode(), d, KisSharedPtr< T >::data(), Node::Private::image, Node::Private::node, KisNode::parent, and KisImage::waitForDone().

duplicate

Node * Node::duplicate ( )

slot

duplicate returns a full copy of the current node. The node is not inserted in the graphic

Returns

a valid Node object or 0 if the node couldn't be duplicated.

Definition at line 648 of file Node.cpp.

{
    if (!d->node) return 0;
    return Node::createNode(d->image, d->node->clone());
}

References KisNode::clone(), createNode(), d, Node::Private::image, and Node::Private::node.

enableAnimation

void Node::enableAnimation ( ) const

slot

enableAnimation make the current layer animated, so it can have frames.

Definition at line 368 of file Node.cpp.

{
    if (!d->node) return;
    d->node->enableAnimation();
}

References d, KisBaseNode::enableAnimation(), and Node::Private::node.

findChildNodes

QList< Node * > Node::findChildNodes ( const QString & name = QString(), bool recursive = false, bool partialMatch = false, const QString & type = QString(), int colorLabelIndex = 0 ) const

slot

findChildNodes

Parameters

name	name of the child node to search for. Leaving this blank will return all nodes.
recursive	whether or not to search recursively. Defaults to false.
partialMatch	return if the name partially contains the string (case insensitive). Defaults to false.
type	filter returned nodes based on type
colorLabelIndex	filter returned nodes based on color label index

Returns

returns a list of child nodes and grand child nodes of the current node that match the search criteria.

Definition at line 229 of file Node.cpp.

{
    if (!d->node) return {};
 
    QList<Node*> nodes;
    KisNodeList nodeList = KisLayerUtils::findNodesByName(d->node, name, recursive, partialMatch);
 
    if (!type.isEmpty()) {
        for (int i = nodeList.size() - 1; i >= 0; i--) {
            if ((type == "paintlayer" && !qobject_cast<const KisPaintLayer*>(nodeList.at(i))) ||
                (type == "vectorlayer" && !qobject_cast<const KisShapeLayer*>(nodeList.at(i))) ||
                (type == "grouplayer" && !qobject_cast<const KisGroupLayer*>(nodeList.at(i))) ||
                (type == "filelayer" && !qobject_cast<const KisFileLayer*>(nodeList.at(i))) ||
                (type == "filterlayer" && !qobject_cast<const KisAdjustmentLayer*>(nodeList.at(i))) ||
                (type == "filllayer" && !qobject_cast<const KisGeneratorLayer*>(nodeList.at(i))) ||
                (type == "clonelayer" && !qobject_cast<const KisCloneLayer*>(nodeList.at(i))) ||
                (type == "transformmask" && !qobject_cast<const KisTransformMask*>(nodeList.at(i))) ||
                (type == "referenceimageslayer" && !qobject_cast<const KisReferenceImagesLayer*>(nodeList.at(i))) ||
                (type == "transparencymask" && !qobject_cast<const KisTransformMask*>(nodeList.at(i))) ||
                (type == "filtermask" && !qobject_cast<const KisFilterMask*>(nodeList.at(i))) ||
                (type == "selectionmask" && !qobject_cast<const KisSelectionMask*>(nodeList.at(i))) ||
                (type == "colorizemask" && !qobject_cast<const KisColorizeMask*>(nodeList.at(i)))
            ) {
                nodeList.removeAt(i);
            }
        }
    }
 
    if (colorLabelIndex > 0) {
        for (int i = nodeList.size() - 1; i >= 0; i--) {
            if (nodeList.at(i)->colorLabelIndex() != colorLabelIndex) {
                nodeList.removeAt(i);
            }
        }
    }
 
    return LibKisUtils::createNodeList(nodeList, d->image);
}

References LibKisUtils::createNodeList(), d, KisLayerUtils::findNodesByName(), Node::Private::image, name(), Node::Private::node, and type().

hasExtents

bool Node::hasExtents ( )

slot

does the node have any content in it?

Returns

if node has any content in it

Definition at line 424 of file Node.cpp.

{
    return !d->node->extent().isEmpty();
}

References d, KisBaseNode::extent(), and Node::Private::node.

hasKeyframeAtTime

bool Node::hasKeyframeAtTime ( int frameNumber )

slot

Check to see if frame number on layer is a keyframe

Definition at line 524 of file Node.cpp.

{
    if (!d->node || !d->node->isAnimated()) return false;
 
    KisRasterKeyframeChannel *rkc = dynamic_cast<KisRasterKeyframeChannel*>(d->node->getKeyframeChannel(KisKeyframeChannel::Raster.id()));
    if (!rkc) return false;
 
    KisKeyframeSP currentKeyframe = rkc->keyframeAt(frameNumber);
 
    if (!currentKeyframe) {
        return false;
    }
 
    return true;
}

References d, KisBaseNode::getKeyframeChannel(), KisBaseNode::isAnimated(), KisKeyframeChannel::keyframeAt(), Node::Private::node, and KisKeyframeChannel::Raster.

icon

QIcon Node::icon ( ) const

slot

icon

Returns

the icon associated with the layer.

Definition at line 509 of file Node.cpp.

{
    QIcon icon;
    if (d->node) {
        icon = d->node->icon();
    }
    return icon;
}

References d, KisBaseNode::icon(), icon(), and Node::Private::node.

image()

KisImageSP Node::image ( ) const

private

Definition at line 823 of file Node.cpp.

{
    return d->image;
}

References d, and Node::Private::image.

index

int Node::index ( ) const

slot

index the index of the node inside the parent

Returns

an integer representing the node's index inside the parent

Definition at line 804 of file Node.cpp.

{
    if (!d->node) return -1;
    if (!d->node->parent()) return -1;
 
    return d->node->parent()->index(d->node);
}

References d, KisNode::index(), Node::Private::node, and KisNode::parent.

inheritAlpha

bool Node::inheritAlpha ( ) const

slot

inheritAlpha checks whether this node has the inherits alpha flag set

Returns

true if the Inherit Alpha is set

Definition at line 398 of file Node.cpp.

{
    if (!d->node) return false;
    if (!d->node->inherits("KisLayer")) return false;
    return qobject_cast<const KisLayer*>(d->node)->alphaChannelDisabled();
}

References d, and Node::Private::node.

isPinnedToTimeline

bool Node::isPinnedToTimeline ( ) const

slot

Returns

Returns true if node is pinned to the Timeline Docker or false if it is not.

Definition at line 380 of file Node.cpp.

{
    if (!d->node) return false;
    return d->node->isPinnedToTimeline();
}

References d, KisBaseNode::isPinnedToTimeline(), and Node::Private::node.

layerStyleToAsl

QString Node::layerStyleToAsl ( )

slot

layerStyleToAsl retrieve the current layer's style in ASL format.

Returns

a QString in ASL format representing the layer style.

Definition at line 754 of file Node.cpp.

{
    if (!d->node) return QString();
 
    KisLayer *layer = qobject_cast<KisLayer*>(d->node.data());
 
    if (!layer) return QString();
 
    KisPSDLayerStyleSP layerStyle = layer->layerStyle();
 
    if (!layerStyle) return QString();
 
    KisAslLayerStyleSerializer serializer;
 
    serializer.setStyles(QVector<KisPSDLayerStyleSP>() << layerStyle);
 
    return serializer.formPsdXmlDocument().toString();
}

References d, KisSharedPtr< T >::data(), KisAslLayerStyleSerializer::formPsdXmlDocument(), KisLayer::layerStyle, Node::Private::node, and KisAslLayerStyleSerializer::setStyles().

locked

bool Node::locked ( ) const

slot

locked checks whether the Node is locked. A locked node cannot be changed.

Returns

true if the Node is locked, false if it hasn't been locked.

Definition at line 412 of file Node.cpp.

{
    if (!d->node) return false;
    return d->node->userLocked();
}

References d, Node::Private::node, and KisBaseNode::userLocked().

mergeDown

Node * Node::mergeDown ( )

slot

mergeDown merges the given node with the first visible node underneath this node in the layerstack. This will drop all per-layer metadata.

Definition at line 686 of file Node.cpp.

{
    if (!d->node) return 0;
    if (!qobject_cast<KisLayer*>(d->node.data())) return 0;
    if (!d->node->prevSibling()) return 0;
 
    d->image->mergeDown(qobject_cast<KisLayer*>(d->node.data()), KisMetaData::MergeStrategyRegistry::instance()->get("Drop"));
    d->image->waitForDone();
 
    return Node::createNode(d->image, d->node->prevSibling());
}

References createNode(), d, KisSharedPtr< T >::data(), KoGenericRegistry< T >::get(), Node::Private::image, KisMetaData::MergeStrategyRegistry::instance(), KisImage::mergeDown(), Node::Private::node, KisNode::prevSibling(), and KisImage::waitForDone().

move

void Node::move ( int x, int y )

slot

move the pixels to the given x, y location in the image coordinate space.

Definition at line 622 of file Node.cpp.

{
    if (!d->node) return;
    d->node->setX(x);
    d->node->setY(y);
}

References d, Node::Private::node, KisBaseNode::setX(), and KisBaseNode::setY().

name

QString Node::name ( ) const

slot

Returns

the user-visible name of this node.

Definition at line 429 of file Node.cpp.

{
    if (!d->node) return QString();
    return d->node->name();
}

References d, KisBaseNode::name(), and Node::Private::node.

node()

KisNodeSP Node::node ( ) const

private

Definition at line 828 of file Node.cpp.

{
    return d->node;
}

References d, and Node::Private::node.

opacity

int Node::opacity ( ) const

slot

return the opacity of the Node. The opacity is a value between 0 and 255.

Definition at line 442 of file Node.cpp.

{
    if (!d->node) return 0;
    return d->node->opacity();
}

References d, Node::Private::node, and KisBaseNode::opacity().

operator!=()

bool Node::operator!=

(

const Node &

other

)

const

Definition at line 148 of file Node.cpp.

{
    return !(operator==(other));
}

References operator==().

operator==()

bool Node::operator==

(

const Node &

other

)

const

Definition at line 142 of file Node.cpp.

{
    return (d->node == other.d->node
            && d->image == other.d->image);
}

References d, Node::Private::image, and Node::Private::node.

paintAbility

QString Node::paintAbility ( )

slot

paintAbility can be used to determine whether this node can be painted on with the current brush preset.

Returns

QString, one of the following:

• VECTOR - This node is vector-based.
• CLONE - This node is a Clone Layer.
• PAINT - This node is paintable by the current brush preset.
• UNPAINTABLE - This node is not paintable, or a null preset is somehow selected./li>
• MYPAINTBRUSH_UNPAINTABLE - This node's non-RGBA colorspace cannot be painted on by the currently selected MyPaint brush.

Definition at line 833 of file Node.cpp.

{
    // Taken from KisTool:nodePaintAbility().
    KisMainWindow *mainWindow = KisPart::instance()->currentMainwindow();
    KisCanvas2 *canvas = mainWindow->activeView()->canvasBase();
    if (canvas->resourceManager()->resource(KoCanvasResource::CurrentPaintOpPreset).isNull()) {
        return "UNPAINTABLE";
    }
 
    if (!d->node) {
        return "UNPAINTABLE";
    }
 
    if (d->node->inherits("KisShapeLayer")) {
        return "VECTOR";
    }
    if (d->node->inherits("KisCloneLayer")) {
        return "CLONE";
    }
    if (d->node->paintDevice()) {
 
        KisPaintOpPresetSP currentPaintOpPreset = canvas->resourceManager()->resource(KoCanvasResource::CurrentPaintOpPreset).value<KisPaintOpPresetSP>();
        if (currentPaintOpPreset->paintOp().id() == "mypaintbrush") {
            const KoColorSpace *colorSpace = d->node->paintDevice()->colorSpace();
            if (colorSpace->colorModelId() != RGBAColorModelID) {
                return "MYPAINTBRUSH_UNPAINTABLE";
            }
        }
 
        return "PAINT";
    }
 
    return "UNPAINTABLE";
}

References KisMainWindow::activeView, KoColorSpace::colorModelId(), KisPaintDevice::colorSpace(), KisPart::currentMainwindow(), KoCanvasResource::CurrentPaintOpPreset, d, KisPart::instance(), Node::Private::node, KisBaseNode::paintDevice(), KoCanvasBase::resourceManager, and RGBAColorModelID.

paintDevice()

KisPaintDeviceSP Node::paintDevice ( ) const

private

paintDevice gives access to the internal paint device of this Node

Returns

the paintdevice or 0 if the node does not have an editable paint device.

Definition at line 818 of file Node.cpp.

{
    return d->node->paintDevice();
}

References d, Node::Private::node, and KisBaseNode::paintDevice().

paintEllipse

void Node::paintEllipse ( const QRectF & rect, const QString strokeStyle = PaintingResources::defaultStrokeStyle, const QString fillStyle = PaintingResources::defaultFillStyle )

slot

paint an ellipse on the canvas. Uses current brush preset

Parameters

rect	QRect with x, y, width, and height None ForegroundColor BackgroundColor Default is ForegroundColor.
fillStyle	appearance of the fill, one of: None ForegroundColor BackgroundColor Pattern Default is None.

Definition at line 955 of file Node.cpp.

{
    if (paintAbility() != "PAINT") {
        dbgScript << "Script attempted to use Node::paintEllipse() on an unpaintable node, ignoring.";
        return;
    }
 
    KisFigurePaintingToolHelper helper = PaintingResources::createHelper(d->image, node(), strokeStyle, fillStyle);
    helper.paintEllipse(rect);
}

References PaintingResources::createHelper(), d, dbgScript, Node::Private::image, node(), paintAbility(), and KisFigurePaintingToolHelper::paintEllipse().

paintLine

void Node::paintLine ( const QPointF pointOne, const QPointF pointTwo, double pressureOne = 1.0, double pressureTwo = 1.0, const QString strokeStyle = PaintingResources::defaultStrokeStyle )

slot

paint a line on the canvas. Uses current brush preset

Parameters

pointOne	starting point
pointTwo	end point
pressureOne	starting pressure
pressureTwo	end pressure
strokeStyle	appearance of the outline, one of: None - will use Foreground Color, since line would be invisible otherwise ForegroundColor BackgroundColor

Definition at line 868 of file Node.cpp.

{
    if (paintAbility() != "PAINT") {
        dbgScript << "Script attempted to use Node::paintLine() on an unpaintable node, ignoring.";
        return;
    }
 
    KisPaintInformation pointOneInfo;
    pointOneInfo.setPressure(pressureOne);
    pointOneInfo.setPos(pointOne);
 
    KisPaintInformation pointTwoInfo;
    pointTwoInfo.setPressure(pressureTwo);
    pointTwoInfo.setPos(pointTwo);
 
    KisFigurePaintingToolHelper helper = PaintingResources::createHelper(d->image, node(), strokeStyle);
    helper.paintLine(pointOneInfo, pointTwoInfo);
}

References PaintingResources::createHelper(), d, dbgScript, Node::Private::image, node(), paintAbility(), KisFigurePaintingToolHelper::paintLine(), KisPaintInformation::setPos(), and KisPaintInformation::setPressure().

paintPath

void Node::paintPath ( const QPainterPath & path, const QString strokeStyle = PaintingResources::defaultStrokeStyle, const QString fillStyle = PaintingResources::defaultFillStyle )

slot

paint a custom path on the canvas. Uses current brush preset

Parameters

path	QPainterPath to determine path None ForegroundColor BackgroundColor Default is ForegroundColor.
fillStyle	appearance of the fill, one of: None ForegroundColor BackgroundColor Pattern Default is None.

Definition at line 967 of file Node.cpp.

{
    if (paintAbility() != "PAINT") {
        dbgScript << "Script attempted to use Node::paintPath() on an unpaintable node, ignoring.";
        return;
    }
 
    KisFigurePaintingToolHelper helper = PaintingResources::createHelper(d->image, node(), strokeStyle, fillStyle);
    helper.paintPainterPath(path);
}

References PaintingResources::createHelper(), d, dbgScript, Node::Private::image, node(), paintAbility(), and KisFigurePaintingToolHelper::paintPainterPath().

paintPolygon

void Node::paintPolygon ( const QList< QPointF > points, const QString strokeStyle = PaintingResources::defaultStrokeStyle, const QString fillStyle = PaintingResources::defaultFillStyle )

slot

paint a polygon on the canvas. Uses current brush preset

Parameters

list	of Qpoints None ForegroundColor BackgroundColor Default is ForegroundColor.
fillStyle	appearance of the fill, one of: None ForegroundColor BackgroundColor Pattern Default is None.

Definition at line 941 of file Node.cpp.

{
    if (paintAbility() != "PAINT") {
        dbgScript << "Script attempted to use Node::paintPolygon() on an unpaintable node, ignoring.";
        return;
    }
 
    // strategy needs points in vPointF format
    QVector<QPointF> points = points.fromList(listPoint);
    KisFigurePaintingToolHelper helper = PaintingResources::createHelper(d->image, node(), strokeStyle, fillStyle);
    helper.paintPolygon(points);
}

References PaintingResources::createHelper(), d, dbgScript, Node::Private::image, node(), paintAbility(), and KisFigurePaintingToolHelper::paintPolygon().

paintPolylineStroke

void Node::paintPolylineStroke ( const QList< StrokePoint > & points, const QString strokeStyle = PaintingResources::defaultStrokeStyle )

slot

paintPolylineStroke paint one continuous brush stroke with complete input information for every supplied point. Uses the current brush preset.

The stroke is submitted as one undoable freehand stroke, so brush spacing, randomness, and distance-based sensors are continuous across all segments. A single point paints one dab.

Parameters

points	input samples in image coordinates. Time is elapsed milliseconds from the beginning of the stroke; speed is normalized.
strokeStyle	appearance of the outline; see paintLine().

Definition at line 887 of file Node.cpp.

{
    if (paintAbility() != "PAINT") {
        dbgScript << "Script attempted to use Node::paintPolylineStroke() on an unpaintable node, ignoring.";
        return;
    }
 
    if (points.isEmpty()) {
        return;
    }
 
    auto paintInformation = [] (const StrokePoint &point) {
        return KisPaintInformation(point.position(),
                                   point.pressure(),
                                   point.xTilt(),
                                   point.yTilt(),
                                   point.rotation(),
                                   point.tangentialPressure(),
                                   1.0,
                                   point.time(),
                                   point.speed());
    };
 
    KisFigurePaintingToolHelper helper = PaintingResources::createHelper(d->image, node(), strokeStyle);
 
    KisPaintInformation previous = paintInformation(points.first());
    if (points.size() == 1) {
        helper.paintLine(previous, previous);
        return;
    }
 
    for (auto it = std::next(points.cbegin()); it != points.cend(); ++it) {
        KisPaintInformation current = paintInformation(*it);
        helper.paintLine(previous, current);
        previous = current;
    }
}

References PaintingResources::createHelper(), d, dbgScript, Node::Private::image, node(), paintAbility(), and KisFigurePaintingToolHelper::paintLine().

paintRectangle

void Node::paintRectangle ( const QRectF & rect, const QString strokeStyle = PaintingResources::defaultStrokeStyle, const QString fillStyle = PaintingResources::defaultFillStyle )

slot

paint a rectangle on the canvas. Uses current brush preset

Parameters

rect	QRect with x, y, width, and height
strokeStyle	appearance of the outline, one of: None ForegroundColor BackgroundColor Default is ForegroundColor.
fillStyle	appearance of the fill, one of: None ForegroundColor BackgroundColor Pattern Default is None.

Definition at line 926 of file Node.cpp.

{
    if (paintAbility() != "PAINT") {
        dbgScript << "Script attempted to use Node::paintRectangle() on an unpaintable node, ignoring.";
        return;
    }
 
    // reference class where this stuff is being done. Maybe can use the "facade" like that does for setup?
    // void KisFigurePaintingToolHelper::paintRect(const QRectF &rect)
 
    KisFigurePaintingToolHelper helper = PaintingResources::createHelper(d->image, node(), strokeStyle, fillStyle);
    helper.paintRect(rect);
}

References PaintingResources::createHelper(), d, dbgScript, Node::Private::image, node(), paintAbility(), and KisFigurePaintingToolHelper::paintRect().

parentNode

Node * Node::parentNode ( ) const

slot

return the Node that is the parent of the current Node, or 0 if this is the root Node.

Definition at line 457 of file Node.cpp.

{
    if (!d->node) return 0;
    if (!d->node->parent()) return 0;
    return Node::createNode(d->image, d->node->parent());
}

References createNode(), d, Node::Private::image, Node::Private::node, and KisNode::parent.

pixelData

QByteArray Node::pixelData ( int x, int y, int w, int h ) const

slot

pixelData reads the given rectangle from the Node's paintable pixels, if those exist, and returns it as a byte array. The pixel data starts top-left, and is ordered row-first.

The byte array can be interpreted as follows: 8 bits images have one byte per channel, and as many bytes as there are channels. 16 bits integer images have two bytes per channel, representing an unsigned short. 16 bits float images have two bytes per channel, representing a half, or 16 bits float. 32 bits float images have four bytes per channel, representing a float.

You can read outside the node boundaries; those pixels will be transparent black.

The order of channels is:

• Integer RGBA: Blue, Green, Red, Alpha
• Float RGBA: Red, Green, Blue, Alpha
• GrayA: Gray, Alpha
• Selection: selectedness
• LabA: L, a, b, Alpha
• CMYKA: Cyan, Magenta, Yellow, Key, Alpha
• XYZA: X, Y, Z, A
• YCbCrA: Y, Cb, Cr, Alpha

The byte array is a copy of the original node data. In Python, you can use bytes, bytearray and the struct module to interpret the data and construct, for instance, a Pillow Image object.

If you read the pixeldata of a mask, a filter or generator layer, you get the selection bytes, which is one channel with values in the range from 0..255.

If you want to change the pixels of a node you can write the pixels back after manipulation with setPixelData(). This will only succeed on nodes with writable pixel data, e.g not on groups or file layers.

Parameters

x	x position from where to start reading
y	y position from where to start reading
w	row length to read
h	number of rows to read

Returns

a QByteArray with the pixel data. The byte array may be empty.

Definition at line 547 of file Node.cpp.

{
    QByteArray ba;
 
    if (!d->node) return ba;
 
    KisPaintDeviceSP dev = d->node->paintDevice();
    if (!dev) return ba;
 
    ba.resize(w * h * dev->pixelSize());
    dev->readBytes(reinterpret_cast<quint8*>(ba.data()), x, y, w, h);
    return ba;
}

References d, Node::Private::node, KisBaseNode::paintDevice(), KisPaintDevice::pixelSize(), and KisPaintDevice::readBytes().

pixelDataAtTime

QByteArray Node::pixelDataAtTime ( int x, int y, int w, int h, int time ) const

slot

pixelDataAtTime a basic function to get pixeldata from an animated node at a given time.

Parameters

x	the position from the left to start reading.
y	the position from the top to start reader
w	the row length to read
h	the number of rows to read
time	the frame number

Returns

a QByteArray with the pixel data. The byte array may be empty.

Definition at line 561 of file Node.cpp.

{
    QByteArray ba;
 
    if (!d->node || !d->node->isAnimated()) return ba;
 
    //
    KisRasterKeyframeChannel *rkc = dynamic_cast<KisRasterKeyframeChannel*>(d->node->getKeyframeChannel(KisKeyframeChannel::Raster.id()));
    if (!rkc) return ba;
    KisRasterKeyframeSP frame = rkc->keyframeAt<KisRasterKeyframe>(time);
    if (!frame) return ba;
    KisPaintDeviceSP dev = new KisPaintDevice(*d->node->paintDevice(), KritaUtils::DeviceCopyMode::CopySnapshot);
    if (!dev) return ba;
 
    frame->writeFrameToDevice(dev);
 
    ba.resize(w * h * dev->pixelSize());
    dev->readBytes(reinterpret_cast<quint8*>(ba.data()), x, y, w, h);
    return ba;
}

References KritaUtils::CopySnapshot, d, KisBaseNode::getKeyframeChannel(), KisBaseNode::isAnimated(), KisKeyframeChannel::keyframeAt(), Node::Private::node, KisBaseNode::paintDevice(), KisPaintDevice::pixelSize(), KisKeyframeChannel::Raster, and KisPaintDevice::readBytes().

position

QPoint Node::position ( ) const

slot

position returns the position of the paint device of this node. The position is always 0,0 unless the layer has been moved. If you want to know the topleft position of the rectangle around the actual non-transparent pixels in the node, use bounds().

Returns

the top-left position of the node

Definition at line 629 of file Node.cpp.

{
    if (!d->node) return QPoint();
    return QPoint(d->node->x(), d->node->y());
}

References d, Node::Private::node, KisBaseNode::x(), and KisBaseNode::y().

projectionPixelData

QByteArray Node::projectionPixelData ( int x, int y, int w, int h ) const

slot

projectionPixelData reads the given rectangle from the Node's projection (that is, what the node looks like after all sub-Nodes (like layers in a group or masks on a layer) have been applied, and returns it as a byte array. The pixel data starts top-left, and is ordered row-first.

The byte array can be interpreted as follows: 8 bits images have one byte per channel, and as many bytes as there are channels. 16 bits integer images have two bytes per channel, representing an unsigned short. 16 bits float images have two bytes per channel, representing a half, or 16 bits float. 32 bits float images have four bytes per channel, representing a float.

You can read outside the node boundaries; those pixels will be transparent black.

The order of channels is:

• Integer RGBA: Blue, Green, Red, Alpha
• Float RGBA: Red, Green, Blue, Alpha
• GrayA: Gray, Alpha
• Selection: selectedness
• LabA: L, a, b, Alpha
• CMYKA: Cyan, Magenta, Yellow, Key, Alpha
• XYZA: X, Y, Z, A
• YCbCrA: Y, Cb, Cr, Alpha

The byte array is a copy of the original node data. In Python, you can use bytes, bytearray and the struct module to interpret the data and construct, for instance, a Pillow Image object.

If you read the projection of a mask, you get the selection bytes, which is one channel with values in the range from 0..255.

If you want to change the pixels of a node you can write the pixels back after manipulation with setPixelData(). This will only succeed on nodes with writable pixel data, e.g not on groups or file layers.

Parameters

x	x position from where to start reading
y	y position from where to start reading
w	row length to read
h	number of rows to read

Returns

a QByteArray with the pixel data. The byte array may be empty.

Definition at line 583 of file Node.cpp.

{
    QByteArray ba;
 
    if (!d->node) return ba;
 
    KisPaintDeviceSP dev;
    if (const KisColorizeMask *mask = qobject_cast<const KisColorizeMask*>(d->node)) {
 
        dev = mask->coloringProjection();
    } else {
        dev = d->node->projection();
    }
    if (!dev) return ba;
 
    ba.resize(w * h * dev->pixelSize());
    dev->readBytes(reinterpret_cast<quint8*>(ba.data()), x, y, w, h);
    return ba;
}

References d, Node::Private::node, KisPaintDevice::pixelSize(), KisBaseNode::projection(), and KisPaintDevice::readBytes().

remove

bool Node::remove ( )

slot

remove removes this node from its parent image.

Definition at line 635 of file Node.cpp.

{
    if (!d->node) return false;
    if (!d->node->parent()) return false;
 
    KUndo2Command *cmd = new KisImageLayerRemoveCommand(d->image, d->node);
 
    KisProcessingApplicator::runSingleCommandStroke(d->image, cmd);
    d->image->waitForDone();
 
    return true;
}

References d, Node::Private::image, Node::Private::node, KisNode::parent, KisProcessingApplicator::runSingleCommandStroke(), and KisImage::waitForDone().

removeChildNode

bool Node::removeChildNode ( Node * child )

slot

removeChildNode removes the given node from the list of children.

Parameters

child

the node to be removed

Definition at line 286 of file Node.cpp.

{
    if (!d->node) return false;
    return child->remove();
}

References d, Node::Private::node, and remove().

rotateNode

void Node::rotateNode ( double radians )

slot

rotateNode rotate this layer by the given radians.

Parameters

radians

amount the layer should be rotated in, in radians.

Definition at line 717 of file Node.cpp.

{
    if (!d->node) return;
    if (!qobject_cast<KisLayer*>(d->node.data())) return;
    if (!d->node->parent()) return;
 
    d->image->rotateNode(d->node, radians, 0);
    d->image->waitForDone();
}

References d, KisSharedPtr< T >::data(), Node::Private::image, Node::Private::node, KisNode::parent, KisImage::rotateNode(), and KisImage::waitForDone().

save

bool Node::save ( const QString & filename, double xRes, double yRes, const InfoObject & exportConfiguration, const QRect & exportRect = QRect() )

slot

save exports the given node with this filename. The extension of the filename determines the filetype.

Parameters

filename	the filename including extension
xRes	the horizontal resolution in pixels per pt (there are 72 pts in an inch)
yRes	the horizontal resolution in pixels per pt (there are 72 pts in an inch)
exportConfiguration	a configuration object appropriate to the file format.
exportRect	the export bounds for saving a node as a QRect If exportRect is empty, then save exactBounds() of the node. If you'd like to save the image- aligned area of the node, just pass image->bounds() there. See Document->exportImage for InfoObject details.

Returns

true if saving succeeded, false if it failed.

Definition at line 654 of file Node.cpp.

{
    if (!d->node) return false;
    if (filename.isEmpty()) return false;
 
    KisPaintDeviceSP projection = d->node->projection();
    QRect bounds = (exportRect.isEmpty())? d->node->exactBounds() : exportRect;
 
    QString mimeType = KisMimeDatabase::mimeTypeForFile(filename, false);
    QScopedPointer<KisDocument> doc(KisPart::instance()->createDocument());
 
    KisImageSP dst = new KisImage(doc->createUndoStore(),
                                  bounds.right(),
                                  bounds.bottom(),
                                  projection->compositionSourceColorSpace(),
                                  d->node->name());
    dst->setResolution(xRes, yRes);
    doc->setFileBatchMode(Krita::instance()->batchmode());
    doc->setCurrentImage(dst);
    KisPaintLayer* paintLayer = new KisPaintLayer(dst, "paint device", d->node->opacity());
    paintLayer->paintDevice()->makeCloneFrom(projection, bounds);
    dst->addNode(paintLayer, dst->rootLayer(), KisLayerSP(0));
    dst->cropImage(bounds);
    dst->initialRefreshGraph();
 
    bool r = doc->exportDocumentSync(filename, mimeType.toLatin1(), exportConfiguration.configuration());
    if (!r) {
        qWarning() << doc->errorMessage();
    }
    return r;
}

References KisNodeFacade::addNode(), bounds, KisPaintDevice::compositionSourceColorSpace(), InfoObject::configuration(), KisImage::cropImage(), d, KisBaseNode::exactBounds(), KisImage::initialRefreshGraph(), Krita::instance(), KisPart::instance(), KisPaintDevice::makeCloneFrom(), KisMimeDatabase::mimeTypeForFile(), KisBaseNode::name(), Node::Private::node, KisBaseNode::opacity(), KisPaintLayer::paintDevice, KisBaseNode::projection(), KisImage::rootLayer(), and KisImage::setResolution().

scaleNode

void Node::scaleNode ( QPointF origin, int width, int height, QString strategy )

slot

scaleNode

Parameters

origin	the origin point
width	the width
height	the height
strategy	the scaling strategy. There's several ones amongst these that aren't available in the regular UI. Hermite Bicubic - Adds pixels using the color of surrounding pixels. Produces smoother tonal gradations than Bilinear. Box - Replicate pixels in the image. Preserves all the original detail, but can produce jagged effects. Bilinear - Adds pixels averaging the color values of surrounding pixels. Produces medium quality results when the image is scaled from half to two times the original size. Bell BSpline Lanczos3 - Offers similar results than Bicubic, but maybe a little bit sharper. Can produce light and dark halos along strong edges. Mitchell

Definition at line 698 of file Node.cpp.

{
    if (!d->node) return;
    if (!qobject_cast<KisLayer*>(d->node.data())) return;
    if (!d->node->parent()) return;
 
    KisFilterStrategy *actualStrategy = KisFilterStrategyRegistry::instance()->get(strategy);
    if (!actualStrategy) actualStrategy = KisFilterStrategyRegistry::instance()->get("Bicubic");
 
    const QRect bounds(d->node->exactBounds());
 
    d->image->scaleNode(d->node,
                        origin,
                        qreal(width) / bounds.width(),
                        qreal(height) / bounds.height(),
                        actualStrategy, 0);
    d->image->waitForDone();
}

References bounds, d, KisSharedPtr< T >::data(), KisBaseNode::exactBounds(), KoGenericRegistry< T >::get(), Node::Private::image, KisFilterStrategyRegistry::instance(), Node::Private::node, KisNode::parent, KisImage::scaleNode(), and KisImage::waitForDone().

setAlphaLocked

void Node::setAlphaLocked ( bool value )

slot

setAlphaLocked set the layer to value if the node is paint layer.

Definition at line 171 of file Node.cpp.

{
    if (!d->node) return;
    KisPaintLayerSP paintLayer = qobject_cast<KisPaintLayer*>(d->node.data());
    if (paintLayer) {
        paintLayer->setAlphaLocked(value);
    }
}

References d, KisSharedPtr< T >::data(), Node::Private::node, KisPaintLayer::setAlphaLocked(), and value().

setBlendingMode

void Node::setBlendingMode ( QString value )

slot

setBlendingMode set the blending mode of the node to the given value

Parameters

value

one of the string values from

See also

KoCompositeOpRegistry.h

Definition at line 188 of file Node.cpp.

{
    if (!d->node) return;
 
    KUndo2Command *cmd = new KisNodeCompositeOpCommand(d->node,
                                                       value);
 
    KisProcessingApplicator::runSingleCommandStroke(d->image, cmd);
    d->image->waitForDone();
}

References d, Node::Private::image, Node::Private::node, KisProcessingApplicator::runSingleCommandStroke(), value(), and KisImage::waitForDone().

setChildNodes

void Node::setChildNodes ( QList< Node * > nodes )

slot

setChildNodes this replaces the existing set of child nodes with the new set.

Parameters

nodes

The list of nodes that will become children, bottom-up – the first node, is the bottom-most node in the stack.

Definition at line 292 of file Node.cpp.

{
    if (!d->node) return;
    while (d->node->firstChild()) {
        d->image->removeNode(d->node->firstChild());
    }
    Q_FOREACH(Node *node, nodes) {
        d->image->addNode(node->node(), d->node);
    }
}

References KisNodeFacade::addNode(), d, KisNode::firstChild(), Node::Private::image, Node::Private::node, node(), and KisNodeFacade::removeNode().

setCollapsed

void Node::setCollapsed ( bool collapsed )

slot

Sets the state of the node to the value of

Parameters

collapsed

Definition at line 392 of file Node.cpp.

{
    if (!d->node) return;
    d->node->setCollapsed(collapsed);
}

References collapsed(), d, Node::Private::node, and KisBaseNode::setCollapsed().

setColorLabel

void Node::setColorLabel ( int index )

slot

setColorLabel sets a color label index associated to the layer. The actual color of the label and the number of available colors is defined by Krita GUI configuration.

Parameters

index

an integer corresponding to the set of available color labels.

Definition at line 309 of file Node.cpp.

{
    if (!d->node) return;
    d->node->setColorLabelIndex(index);
}

References d, index(), Node::Private::node, and KisBaseNode::setColorLabelIndex().

setColorProfile

bool Node::setColorProfile ( const QString & colorProfile )

slot

setColorProfile set the color profile of the image to the given profile. The profile has to be registered with krita and be compatible with the current color model and depth; the image data is not converted.

Parameters

colorProfile

Returns

if assigning the color profile worked

Definition at line 337 of file Node.cpp.

{
    if (!d->node) return false;
    if (!d->node->inherits("KisLayer")) return false;
    KisLayer *layer = qobject_cast<KisLayer*>(d->node.data());
    const KoColorProfile *profile = KoColorSpaceRegistry::instance()->profileByName(colorProfile);
    bool result = d->image->assignLayerProfile(layer, profile);
    d->image->waitForDone();
    return result;
}

References KisImage::assignLayerProfile(), colorProfile(), d, KisSharedPtr< T >::data(), Node::Private::image, KoColorSpaceRegistry::instance(), Node::Private::node, KoColorSpaceRegistry::profileByName(), and KisImage::waitForDone().

setColorSpace

bool Node::setColorSpace ( const QString & colorModel, const QString & colorDepth, const QString & colorProfile )

slot

setColorSpace convert the node to the given colorspace

Parameters

colorModel	A string describing the color model of the node: A: Alpha mask RGBA: RGB with alpha channel (The actual order of channels is most often BGR!) XYZA: XYZ with alpha channel LABA: LAB with alpha channel CMYKA: CMYK with alpha channel GRAYA: Gray with alpha channel YCbCrA: YCbCr with alpha channel
colorDepth	A string describing the color depth of the image: U8: unsigned 8 bits integer, the most common type U16: unsigned 16 bits integer F16: half, 16 bits floating point. Only available if Krita was built with OpenEXR F32: 32 bits floating point
colorProfile	a valid color profile for this color model and color depth combination.

Definition at line 348 of file Node.cpp.

{
    if (!d->node) return false;
    if (!d->node->inherits("KisLayer")) return false;
    const KoColorProfile *profile = KoColorSpaceRegistry::instance()->profileByName(colorProfile);
    if (!profile) return false;
    const KoColorSpace *dstCs = KoColorSpaceRegistry::instance()->colorSpace(colorModel,
                                                                             colorDepth,
                                                                             profile);
    d->image->convertLayerColorSpace(d->node, dstCs, KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags());
    d->image->waitForDone();
    return true;
}

References colorDepth(), colorModel(), colorProfile(), KoColorSpaceRegistry::colorSpace(), KisImage::convertLayerColorSpace(), d, Node::Private::image, KoColorSpaceRegistry::instance(), KoColorConversionTransformation::internalConversionFlags(), KoColorConversionTransformation::internalRenderingIntent(), Node::Private::node, KoColorSpaceRegistry::profileByName(), and KisImage::waitForDone().

setInheritAlpha

void Node::setInheritAlpha ( bool value )

slot

set the Inherit Alpha flag to the given value

Definition at line 405 of file Node.cpp.

{
    if (!d->node) return;
    if (!d->node->inherits("KisLayer")) return;
    const_cast<KisLayer*>(qobject_cast<const KisLayer*>(d->node))->disableAlphaChannel(value);
}

References d, Node::Private::node, and value().

setLayerStyleFromAsl

bool Node::setLayerStyleFromAsl ( const QString & asl )

slot

setLayerStyleFromAsl set a new layer style for this node.

Parameters

aslContent

a string formatted in ASL format containing the layer style

Returns

true if layer style was set, false if failed.

Definition at line 773 of file Node.cpp.

{
    if (!d->node) return false;
 
    KisLayer *layer = qobject_cast<KisLayer*>(d->node.data());
 
    if (!layer) return false;
 
    QDomDocument aslDoc;
 
    if (!aslDoc.setContent(asl)) {
        qWarning() << "ASL string format is invalid!";
        return false;
    }
 
    KisAslLayerStyleSerializer serializer;
 
    serializer.registerPSDPattern(aslDoc);
    serializer.readFromPSDXML(aslDoc);
 
    if (serializer.styles().size() != 1) return false;
 
    KisPSDLayerStyleSP newStyle = serializer.styles().first();
    KUndo2Command *cmd = new KisSetLayerStyleCommand(layer, layer->layerStyle(), newStyle);
 
    KisProcessingApplicator::runSingleCommandStroke(d->image, cmd);
    d->image->waitForDone();
 
    return true;
}

References d, KisSharedPtr< T >::data(), Node::Private::image, KisLayer::layerStyle, Node::Private::node, KisAslLayerStyleSerializer::readFromPSDXML(), KisAslLayerStyleSerializer::registerPSDPattern(), KisProcessingApplicator::runSingleCommandStroke(), KisAslLayerStyleSerializer::styles(), and KisImage::waitForDone().

setLocked

void Node::setLocked ( bool value )

slot

set the Locked flag to the give value

Definition at line 418 of file Node.cpp.

{
    if (!d->node) return;
    d->node->setUserLocked(value);
}

References d, Node::Private::node, KisBaseNode::setUserLocked(), and value().

setName

void Node::setName ( QString name )

slot

rename the Node to the given name

Definition at line 435 of file Node.cpp.

{
    if (!d->node) return;
    d->node->setName(name);
}

References d, name(), Node::Private::node, and KisBaseNode::setName().

setOpacity

void Node::setOpacity ( int value )

slot

set the opacity of the Node to the given value. The opacity is a value between 0 and 255.

Definition at line 448 of file Node.cpp.

{
    if (!d->node) return;
    if (value < 0) value = 0;
    if (value > 255) value = 255;
    d->node->setOpacity(value);
}

References d, Node::Private::node, KisBaseNode::setOpacity(), and value().

setPinnedToTimeline

void Node::setPinnedToTimeline ( bool pinned ) const

slot

Sets whether or not node should be pinned to the Timeline Docker, regardless of selection activity.

Definition at line 374 of file Node.cpp.

{
    if (!d->node) return;
    d->node->setPinnedToTimeline(pinned);
}

References d, Node::Private::node, and KisBaseNode::setPinnedToTimeline().

setPixelData

bool Node::setPixelData ( QByteArray value, int x, int y, int w, int h )

slot

setPixelData writes the given bytes, of which there must be enough, into the Node, if the Node has writable pixel data:

• paint layer: the layer's original pixels are overwritten
• filter layer, generator layer, any mask: the embedded selection's pixels are overwritten. Note: for these

File layers, Group layers, Clone layers cannot be written to. Calling setPixelData on those layer types will silently do nothing.

Parameters

value	the byte array representing the pixels. There must be enough bytes available. Krita will take the raw pointer from the QByteArray and start reading, not stopping before (number of channels * size of channel * w * h) bytes are read.
x	the x position to start writing from
y	the y position to start writing from
w	the width of each row
h	the number of rows to write

Returns

true if writing the pixeldata worked

Definition at line 603 of file Node.cpp.

{
    if (!d->node) return false;
    KisPaintDeviceSP dev = d->node->paintDevice();
    if (!dev) return false;
    if (value.length() <  w * h * (int)dev->colorSpace()->pixelSize()) {
        qWarning() << "Node::setPixelData: not enough data to write to the paint device";
        return false;
    }
    dev->writeBytes((const quint8*)value.constData(), x, y, w, h);
    return true;
}

References KisPaintDevice::colorSpace(), d, Node::Private::node, KisBaseNode::paintDevice(), KoColorSpace::pixelSize(), value(), and KisPaintDevice::writeBytes().

setVisible

void Node::setVisible ( bool visible )

slot

Set the visibility of the current node to

Parameters

visible

Definition at line 540 of file Node.cpp.

{
    if (!d->node) return;
    d->node->setVisible(visible);
}

References d, Node::Private::node, KisBaseNode::setVisible(), and visible().

shearNode

void Node::shearNode ( double angleX, double angleY )

slot

shearNode perform a shear operation on this node.

Parameters

angleX	the X-angle in degrees to shear by
angleY	the Y-angle in degrees to shear by

Definition at line 738 of file Node.cpp.

{
    if (!d->node) return;
    if (!qobject_cast<KisLayer*>(d->node.data())) return;
    if (!d->node->parent()) return;
 
    d->image->shearNode(d->node, angleX, angleY, 0);
    d->image->waitForDone();
}

References d, KisSharedPtr< T >::data(), Node::Private::image, Node::Private::node, KisNode::parent, KisImage::shearNode(), and KisImage::waitForDone().

thumbnail

QImage Node::thumbnail ( int w, int h )

slot

thumbnail create a thumbnail of the given dimensions. The thumbnail is sized according to the layer dimensions, not the image dimensions. If the requested size is too big a null QImage is created. If the current node cannot generate a thumbnail, a transparent QImage of the requested size is generated.

Returns

a QImage representing the layer contents.

Definition at line 748 of file Node.cpp.

{
    if (!d->node) return QImage();
    return d->node->createThumbnail(w, h);
}

References KisBaseNode::createThumbnail(), d, and Node::Private::node.

type

QString Node::type ( ) const

virtualslot

type Krita has several types of nodes, split in layers and masks. Group layers can contain other layers, any layer can contain masks.

Returns

The type of the node. Valid types are:

• paintlayer
• grouplayer
• filelayer
• filterlayer
• filllayer
• clonelayer
• vectorlayer
• transparencymask
• filtermask
• transformmask
• selectionmask
• colorizemask

If the Node object isn't wrapping a valid Krita layer or mask object, and empty string is returned.

Definition at line 464 of file Node.cpp.

{
    if (!d->node) return QString();
    if (qobject_cast<const KisPaintLayer*>(d->node)) {
        return "paintlayer";
    }
    else if (qobject_cast<const KisGroupLayer*>(d->node)) {
        return "grouplayer";
    }
    if (qobject_cast<const KisFileLayer*>(d->node)) {
        return "filelayer";
    }
    if (qobject_cast<const KisAdjustmentLayer*>(d->node)) {
        return "filterlayer";
    }
    if (qobject_cast<const KisGeneratorLayer*>(d->node)) {
        return "filllayer";
    }
    if (qobject_cast<const KisCloneLayer*>(d->node)) {
        return "clonelayer";
    }
    if (qobject_cast<const KisReferenceImagesLayer*>(d->node)) {
        return "referenceimageslayer";
    }
    if (qobject_cast<const KisShapeLayer*>(d->node)) {
        return "vectorlayer";
    }
    if (qobject_cast<const KisTransparencyMask*>(d->node)) {
        return "transparencymask";
    }
    if (qobject_cast<const KisFilterMask*>(d->node)) {
        return "filtermask";
    }
    if (qobject_cast<const KisTransformMask*>(d->node)) {
        return "transformmask";
    }
    if (qobject_cast<const KisSelectionMask*>(d->node)) {
        return "selectionmask";
    }
    if (qobject_cast<const KisColorizeMask*>(d->node)) {
        return "colorizemask";
    }
    return QString();
}

References d, and Node::Private::node.

uniqueId

QUuid Node::uniqueId ( ) const

slot

uniqueId uniqueId of the node

Returns

a QUuid representing a unique id to identify the node

Definition at line 812 of file Node.cpp.

{
    if (!d->node) return QUuid();
    return d->node->uuid();
}

References d, Node::Private::node, and KisBaseNode::uuid().

visible

bool Node::visible ( ) const

slot

Check whether the current Node is visible in the layer stack

Definition at line 518 of file Node.cpp.

{
    if (!d->node) return false;
    return d->node->visible();
}

References d, Node::Private::node, and KisBaseNode::visible().

Friends And Related Symbol Documentation

CloneLayer

friend class CloneLayer

friend

Definition at line 724 of file Node.h.

ColorizeMask

friend class ColorizeMask

friend

Definition at line 723 of file Node.h.

Document

friend class Document

friend

Definition at line 712 of file Node.h.

FileLayer

friend class FileLayer

friend

Definition at line 715 of file Node.h.

FillLayer

friend class FillLayer

friend

Definition at line 717 of file Node.h.

Filter

friend class Filter

friend

Definition at line 711 of file Node.h.

FilterLayer

friend class FilterLayer

friend

Definition at line 716 of file Node.h.

FilterMask

friend class FilterMask

friend

Definition at line 719 of file Node.h.

GroupLayer

friend class GroupLayer

friend

Definition at line 714 of file Node.h.

Selection

friend class Selection

friend

Definition at line 713 of file Node.h.

SelectionMask

friend class SelectionMask

friend

Definition at line 720 of file Node.h.

TransformMask

friend class TransformMask

friend

Definition at line 722 of file Node.h.

TransparencyMask

friend class TransparencyMask

friend

Definition at line 721 of file Node.h.

VectorLayer

friend class VectorLayer

friend

Definition at line 718 of file Node.h.

Member Data Documentation

d

Private* const Node::d

private

Definition at line 737 of file Node.h.

---

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

• libs/libkis/Node.h
• libs/libkis/Node.cpp