#include <kis_layer.h>

Inheritance diagram for KisLayer:

Public Member Functions
bool	alphaChannelDisabled () const

void	buildProjectionUpToNode (KisPaintDeviceSP projection, KisNodeSP lastNode, const QRect &rect)

QBitArray &	channelFlags () const

KisFilterMaskSP	colorOverlayMask () const

const KoColorSpace *	colorSpace () const override
	returns the image's colorSpace or null, if there is no image

const KoCompositeOp *	compositeOp () const override
	returns the layer's composite op for the colorspace of the layer's parent.

virtual KisLayerSP	createMergedLayerTemplate (KisLayerSP prevLayer)

QImage	createThumbnail (qint32 w, qint32 h, Qt::AspectRatioMode aspectRatioMode=Qt::IgnoreAspectRatio) override

QImage	createThumbnailForFrame (qint32 w, qint32 h, int time, Qt::AspectRatioMode aspectRatioMode=Qt::IgnoreAspectRatio) override

void	disableAlphaChannel (bool disable)

QList< KisEffectMaskSP >	effectMasks () const

QList< KisEffectMaskSP >	effectMasks (KisNodeSP lastNode) const

QRect	exactBounds () const override

QRect	extent () const override

virtual void	fillMergedLayerTemplate (KisLayerSP dstLayer, KisLayerSP prevLayer, bool skipPaintingThisLayer=false)

bool	hasClones () const

bool	hasEffectMasks () const

virtual KisLayerProjectionPlaneSP	internalProjectionPlane () const

	KisLayer (const KisLayer &rhs)

	KisLayer (KisImageWSP image, const QString &name, quint8 opacity)

KisPSDLayerStyleSP	layerStyle () const

QRect	looseUserVisibleBounds () const

KisMetaData::Store *	metaData ()

virtual bool	needProjection () const

void	notifyChildMaskChanged ()

KisPaintDeviceSP	original () const override=0

KisLayerSP	parentLayer () const

QRect	partialChangeRect (KisNodeSP lastNode, const QRect &rect)

	Private (KisLayer *q)

KisPaintDeviceSP	projection () const override

KisAbstractProjectionPlaneSP	projectionPlane () const override

void	registerClone (KisCloneLayerWSP clone)

const QList< KisCloneLayerWSP >	registeredClones () const

KisBaseNode::PropertyList	sectionModelProperties () const override

virtual KisSelectionSP	selection () const

virtual KisSelectionMaskSP	selectionMask () const

virtual void	setChannelFlags (const QBitArray &channelFlags)

void	setImage (KisImageWSP image) override

void	setLayerStyle (KisPSDLayerStyleSP layerStyle)

void	setSectionModelProperties (const KisBaseNode::PropertyList &properties) override

void	setTemporary (bool t)

void	setX (qint32 x) override

void	setY (qint32 y) override

bool	temporary () const

int	thumbnailSeqNo () const override

QRect	tightUserVisibleBounds () const

void	unregisterClone (KisCloneLayerWSP clone)

void	updateClones (const QRect &rect, bool dontInvalidateFrames)

qint32	x () const override

qint32	y () const override

	~KisLayer () override

Public Member Functions inherited from Private
	Private (KisCanvas2 *c)

Public Member Functions inherited from KisNode
bool	accept (KisNodeVisitor &v) override

void	accept (KisProcessingVisitor &visitor, KisUndoAdapter *undoAdapter) override

virtual bool	allowAsChild (KisNodeSP) const =0

KisNodeSP	at (quint32 index) const

KisBusyProgressIndicator *	busyProgressIndicator () const

quint32	childCount () const

QList< KisNodeSP >	childNodes (const QStringList &nodeTypes, const KoProperties &properties) const

virtual KisNodeSP	clone () const =0

const KisNode *	findSymmetricClone (const KisNode srcRoot, const KisNode dstRoot, const KisNode *srcTarget)

KisNodeSP	firstChild () const

virtual KisPaintDeviceList	getLodCapableDevices () const

KisNodeGraphListener *	graphListener () const

int	graphSequenceNumber () const

void	handleKeyframeChannelFrameAboutToBeRemoved (const KisKeyframeChannel *channel, int time)

virtual void	handleKeyframeChannelFrameAdded (const KisKeyframeChannel *channel, int time)

virtual void	handleKeyframeChannelFrameChange (const KisKeyframeChannel *channel, int time)

void	handleKeyframeChannelFrameHasBeenRemoved (const KisKeyframeChannel *channel, int time)

KisFrameChangeUpdateRecipe	handleKeyframeChannelUpdateImpl (const KisKeyframeChannel *channel, int time)

int	index (const KisNodeSP node) const

void	invalidateFrames (const KisTimeSpan &range, const QRect &rect)

	KisNode (const KisNode &rhs)

	KisNode (KisImageWSP image)

KisNodeSP	lastChild () const

KisNodeSP	nextSibling () const

KisNodeProgressProxy *	nodeProgressProxy () const

KisNodeSP	parent () const

KisNodeSP	prevSibling () const

	Private (KisNode *node)

void	processDuplicatedClones (const KisNode srcDuplicationRoot, const KisNode dstDuplicationRoot, KisNode *node)

virtual KisProjectionLeafSP	projectionLeaf () const

void	requestTimeSwitch (int time)

virtual void	setDirty ()

void	setDirty (const KisRegion &region)

void	setDirty (const QRect &rect)

virtual void	setDirty (const QVector< QRect > &rects)

void	setDirtyDontResetAnimationCache ()

void	setDirtyDontResetAnimationCache (const QRect &rect)

void	setDirtyDontResetAnimationCache (const QVector< QRect > &rects)
	setDirtyDontResetAnimationCache does almost the same thing as usual setDirty() call, but doesn't reset the animation cache (since onion skins are not used when rendering animation.

void	setGraphListener (KisNodeGraphListener *graphListener)

void	setImage (KisImageWSP newImage) override

virtual void	syncLodCache ()

	~KisNode () override

Public Member Functions inherited from KisBaseNode
bool	belongsToIsolatedGroup () const

bool	check (const KoProperties &properties) const

bool	collapsed () const

int	colorLabelIndex () const

virtual KisPaintDeviceSP	colorSampleSourceDevice () const

const QString &	compositeOpId () const

void	enableAnimation ()

KisKeyframeChannel *	getKeyframeChannel (const QString &id) const

KisKeyframeChannel *	getKeyframeChannel (const QString &id, bool create)

bool	hasEditablePaintDevice () const

virtual QIcon	icon () const

KisImageWSP	image () const

bool	isAnimated () const

bool	isEditable (bool checkVisibility=true) const

virtual bool	isFakeNode () const

bool	isIsolatedRoot () const

bool	isPinnedToTimeline () const

QMap< QString, KisKeyframeChannel * >	keyframeChannels () const

	KisBaseNode (const KisBaseNode &rhs)

	KisBaseNode (KisImageWSP image)

void	mergeNodeProperties (const KoProperties &properties)

QString	name () const

const KoProperties &	nodeProperties () const

quint8	opacity () const

virtual KisPaintDeviceSP	paintDevice () const =0

quint8	percentOpacity () const

	Private (const Private &rhs)

	Private (KisImageWSP p_image)

void	setCollapsed (bool collapsed)

void	setColorLabelIndex (int index)

void	setCompositeOpId (const QString &compositeOpId)

void	setName (const QString &name)

void	setNodeProperty (const QString &name, const QVariant &value)

void	setOpacity (quint8 val)

void	setPercentOpacity (quint8 val)

void	setPinnedToTimeline (bool pinned)

virtual void	setUserLocked (bool l)

void	setUuid (const QUuid &id)

virtual void	setVisible (bool visible, bool loading=false)

virtual bool	supportsKeyframeChannel (const QString &id)

bool	supportsLodMoves () const

virtual bool	supportsLodPainting () const

virtual void	updateSettings ()

bool	userLocked () const

QUuid	uuid () const

virtual bool	visible (bool recursive=false) const

	~KisBaseNode () override

Public Member Functions inherited from KisShared
bool	deref ()

bool	ref ()

int	refCount ()

QAtomicInt *	sharedWeakReference ()

Public Attributes
QBitArray	channelFlags

KisCloneLayersList	clonesList

KisPSDLayerStyleSP	layerStyle

KisLayerStyleProjectionPlaneSP	layerStyleProjectionPlane

KisLayerMasksCache	masksCache

KisMetaData::Store *	metaDataStore {nullptr}

KisLayerProjectionPlaneSP	projectionPlane

KisSafeNodeProjectionStoreSP	safeProjection

Public Attributes inherited from Private
KisCanvas2 *	canvas

int	displayedFrame

int	intendedFrame

Public Attributes inherited from KisNode
KisBusyProgressIndicator *	busyProgressIndicator

std::optional< KisFrameChangeUpdateRecipe >	frameRemovalUpdateRecipe

KisNodeGraphListener *	graphListener

KisNodeProgressProxy *	nodeProgressProxy

KisSafeReadNodeList	nodes

QReadWriteLock	nodeSubgraphLock

KisNodeWSP	parent

KisProjectionLeafSP	projectionLeaf

Public Attributes inherited from KisBaseNode
bool	animated {false}

bool	collapsed {false}

QString	compositeOp

KisBaseNode::Property	hack_visible

QUuid	id

KisImageWSP	image

QMap< QString, KisKeyframeChannel * >	keyframeChannels

KisAnimatedOpacityProperty	opacityProperty

bool	pinnedToTimeline {false}

KoProperties	properties

bool	supportsLodMoves {false}

Protected Member Functions
virtual QRect	amortizedProjectionRectForCleanupInChangePass () const

QRect	applyMasks (const KisPaintDeviceSP source, KisPaintDeviceSP destination, const QRect &requestedRect, KisNodeSP filthyNode, KisNodeSP lastNode, KisRenderPassFlags flags) const

bool	canMergeAndKeepBlendOptions (KisLayerSP otherLayer)

QRect	changeRect (const QRect &rect, PositionToFilthy pos=N_FILTHY) const override

void	childNodeChanged (KisNodeSP changedChildNode) override

virtual void	copyOriginalToProjection (const KisPaintDeviceSP original, KisPaintDeviceSP projection, const QRect &rect) const

virtual QRect	incomingChangeRect (const QRect &rect) const

QRect	masksChangeRect (const QList< KisEffectMaskSP > &masks, const QRect &requestedRect, bool &rectVariesFlag) const

QRect	masksNeedRect (const QList< KisEffectMaskSP > &masks, const QRect &changeRect, QStack< QRect > &applyRects, bool &rectVariesFlag) const

QRect	needRectForOriginal (const QRect &rect) const

virtual QRect	outgoingChangeRect (const QRect &rect) const

QList< KisEffectMaskSP >	searchEffectMasks (KisNodeSP lastNode) const

QRect	updateProjection (const QRect &rect, KisNodeSP filthyNode, KisRenderPassFlags flags)

Protected Member Functions inherited from KisNode
virtual QRect	accessRect (const QRect &rect, PositionToFilthy pos=N_FILTHY) const

void	addKeyframeChannel (KisKeyframeChannel *channel) override

void	baseNodeChangedCallback () override

void	baseNodeCollapsedChangedCallback () override

void	baseNodeInvalidateAllFramesCallback () override

virtual KisFrameChangeUpdateRecipe	handleKeyframeChannelFrameAboutToBeRemovedImpl (const KisKeyframeChannel *channel, int time)

virtual QRect	needRect (const QRect &rect, PositionToFilthy pos=N_FILTHY) const

void	notifyParentVisibilityChanged (bool value) override

KisBaseNodeSP	parentCallback () const override

Protected Member Functions inherited from KisBaseNode
virtual KisKeyframeChannel *	requestKeyframeChannel (const QString &id)

void	setSupportsLodMoves (bool value)

Protected Member Functions inherited from KisShared
	KisShared ()

	~KisShared ()

Private Member Functions
QRect	layerExtentImpl (bool exactBounds) const

QRect	userVisibleBoundsImpl (bool exactBounds) const

Private Attributes
Private *const	m_d

Friends
class	KisLayerMasksCache

class	KisLayerProjectionPlane

class	KisLayerTest

class	KisTransformMask

Additional Inherited Members
Public Types inherited from KisNode
enum	PositionToFilthy { N_ABOVE_FILTHY = 0x08 , N_FILTHY_PROJECTION = 0x20 , N_FILTHY = 0x40 , N_BELOW_FILTHY = 0x80 }

Public Types inherited from KisBaseNode
typedef QList< Property >	PropertyList

Signals inherited from KisNode
void	sigNodeChangedInternal ()

Signals inherited from KisBaseNode
void	keyframeChannelAdded (KisKeyframeChannel *channel)

void	opacityChanged (quint8 value)

Detailed Description

Abstract class that represents the concept of a Layer in Krita. This is not related to the paint devices: this is merely an abstraction of how layers can be stacked and rendered differently. Regarding the previous-, first-, next- and lastChild() calls, first means that it the layer is at the top of the group in the layerlist, using next will iterate to the bottom to last, whereas previous will go up to first again.

TODO: Add a layer mode whereby the projection of the layer is used as a clipping path?

Definition at line 160 of file kis_layer.cc.

Constructor & Destructor Documentation

◆ KisLayer() [1/2]

KisLayer::KisLayer	(	KisImageWSP	image,
		const QString &	name,
		quint8	opacity )

Parameters

image	is the pointer of the image or null
opacity	is a value between OPACITY_TRANSPARENT_U8 and OPACITY_OPAQUE_U8

Definition at line 181 of file kis_layer.cc.

        : KisNode(image)
        , m_d(new Private(this))
{
    setName(name);
    setOpacity(opacity);
    m_d->metaDataStore = new KisMetaData::Store();
    m_d->projectionPlane = toQShared(new KisLayerProjectionPlane(this));
    m_d->safeProjection = new KisSafeNodeProjectionStore();
    m_d->safeProjection->setImage(image);
}

References KisBaseNode::image, KisLayerProjectionPlane, m_d, KisBaseNode::name(), KisBaseNode::opacity(), KisBaseNode::setName(), KisBaseNode::setOpacity(), and toQShared().

◆ KisLayer() [2/2]

KisLayer::KisLayer ( const KisLayer & rhs )

Definition at line 193 of file kis_layer.cc.

        : KisNode(rhs)
        , m_d(new Private(this))
{
    if (this != &rhs) {
        m_d->metaDataStore = new KisMetaData::Store(*rhs.m_d->metaDataStore);
        m_d->channelFlags = rhs.m_d->channelFlags;
 
        setName(rhs.name());
        m_d->projectionPlane = toQShared(new KisLayerProjectionPlane(this));
        m_d->safeProjection = new KisSafeNodeProjectionStore(*rhs.m_d->safeProjection);
        m_d->safeProjection->setImage(image());
 
        if (rhs.m_d->layerStyle) {
            m_d->layerStyle = rhs.m_d->layerStyle->clone().dynamicCast<KisPSDLayerStyle>();
 
            if (rhs.m_d->layerStyleProjectionPlane) {
                m_d->layerStyleProjectionPlane = toQShared(
                    new KisLayerStyleProjectionPlane(*rhs.m_d->layerStyleProjectionPlane,
                                                     this,
                                                     m_d->layerStyle));
            }
        }
    }
}

References KisBaseNode::image, KisLayerProjectionPlane, m_d, KisBaseNode::name(), KisBaseNode::setName(), and toQShared().

◆ ~KisLayer()

KisLayer::~KisLayer ( )

override

Definition at line 219 of file kis_layer.cc.

{
    delete m_d->metaDataStore;
    delete m_d;
}

References m_d.

Member Function Documentation

◆ alphaChannelDisabled()

bool KisLayer::alphaChannelDisabled ( ) const

returns true if the channel flag for the alpha channel of this layer is not set. returns false otherwise.

Definition at line 334 of file kis_layer.cc.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(colorSpace(), false);
    QBitArray flags = colorSpace()->channelFlags(false, true) & m_d->channelFlags;
    return flags.count(true) == 0 && !m_d->channelFlags.isEmpty();
}

References KoColorSpace::channelFlags(), colorSpace(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, and m_d.

◆ amortizedProjectionRectForCleanupInChangePass()

QRect KisLayer::amortizedProjectionRectForCleanupInChangePass ( ) const

protectedvirtual

Internal projection device that should be updated in the changeRect pass even when the change rect is cropped by masks or something like that

Reimplemented in KisGroupLayer.

Definition at line 854 of file kis_layer.cc.

{
    return projection()->exactBoundsAmortized();
}

References KisPaintDevice::exactBoundsAmortized(), and projection().

◆ applyMasks()

QRect KisLayer::applyMasks	(	const KisPaintDeviceSP	source,
		KisPaintDeviceSP	destination,
		const QRect &	requestedRect,
		KisNodeSP	filthyNode,
		KisNodeSP	lastNode,
		KisRenderPassFlags	flags ) const

protected

FIXME: Assume that varying of the changeRect has already been taken into account while preparing walkers

A bit of optimization: All filters will read/write exactly from/to the requested rect so we needn't create temporary paint device, just apply it onto destination

We can't eliminate additional copy-op as filters' behaviour may be quite insane here, so let them work on their own paintDevice =)

Definition at line 657 of file kis_layer.cc.

{
    Q_ASSERT(source);
    Q_ASSERT(destination);
 
    QList<KisEffectMaskSP> masks = effectMasks(lastNode);
    QRect changeRect;
    QRect needRect;
 
    if (masks.isEmpty()) {
        changeRect = requestedRect;
        if (source != destination) {
            copyOriginalToProjection(source, destination, requestedRect);
        }
    } else {
        QStack<QRect> applyRects;
        bool changeRectVaries;
        bool needRectVaries;
 
        changeRectVaries = false;
        changeRect = requestedRect;
        //changeRect = masksChangeRect(masks, requestedRect,
        //                             changeRectVaries);
 
        needRect = masksNeedRect(masks, changeRect,
                                 applyRects, needRectVaries);
 
        if (!changeRectVaries && !needRectVaries) {
            Q_ASSERT(needRect == requestedRect);
 
            if (source != destination) {
                copyOriginalToProjection(source, destination, needRect);
            }
 
            Q_FOREACH (const KisEffectMaskSP& mask, masks) {
                const QRect maskApplyRect = applyRects.pop();
                const QRect maskNeedRect =
                    applyRects.isEmpty() ? needRect : applyRects.top();
                    
                PositionToFilthy maskPosition = calculatePositionToFilthy(mask, filthyNode, const_cast<KisLayer*>(this));
                mask->apply(destination, maskApplyRect, maskNeedRect, maskPosition, flags);
            }
            Q_ASSERT(applyRects.isEmpty());
        } else {
            KisPaintDeviceSP tempDevice = new KisPaintDevice(colorSpace());
            tempDevice->prepareClone(source);
            copyOriginalToProjection(source, tempDevice, needRect);
 
            QRect maskApplyRect = applyRects.pop();
            QRect maskNeedRect = needRect;
 
            Q_FOREACH (const KisEffectMaskSP& mask, masks) {
                PositionToFilthy maskPosition = calculatePositionToFilthy(mask, filthyNode, const_cast<KisLayer*>(this));
                mask->apply(tempDevice, maskApplyRect, maskNeedRect, maskPosition, flags);
 
                if (!applyRects.isEmpty()) {
                    maskNeedRect = maskApplyRect;
                    maskApplyRect = applyRects.pop();
                }
            }
            Q_ASSERT(applyRects.isEmpty());
 
            KisPainter::copyAreaOptimized(changeRect.topLeft(), tempDevice, destination, changeRect);
        }
    }
 
    return changeRect;
}

References calculatePositionToFilthy(), changeRect(), colorSpace(), KisPainter::copyAreaOptimized(), copyOriginalToProjection(), effectMasks(), masksNeedRect(), KisNode::needRect(), KisPaintDevice::prepareClone(), and source().

◆ buildProjectionUpToNode()

void KisLayer::buildProjectionUpToNode	(	KisPaintDeviceSP	projection,
		KisNodeSP	lastNode,
		const QRect &	rect )

rect is a dirty rect in layer's original() coordinates!

Definition at line 782 of file kis_layer.cc.

{
    QRect changeRect = partialChangeRect(lastNode, rect);
 
    KisPaintDeviceSP originalDevice = original();
 
    KIS_SAFE_ASSERT_RECOVER_RETURN(needProjection() || hasEffectMasks());
 
    if (!changeRect.isEmpty()) {
        applyMasks(originalDevice, projection,
                   changeRect, this, lastNode, KisRenderPassFlag::NoTransformMaskUpdates);
    }
}

References applyMasks(), changeRect(), hasEffectMasks(), KIS_SAFE_ASSERT_RECOVER_RETURN, needProjection(), NoTransformMaskUpdates, original(), partialChangeRect(), and projection().

◆ canMergeAndKeepBlendOptions()

bool KisLayer::canMergeAndKeepBlendOptions ( KisLayerSP otherLayer )

protected

Definition at line 390 of file kis_layer.cc.

{
    return
        this->compositeOpId() == otherLayer->compositeOpId() &&
        this->opacity() == otherLayer->opacity() &&
        this->channelFlags() == otherLayer->channelFlags() &&
        !this->layerStyle() && !otherLayer->layerStyle() &&
        (this->colorSpace() == otherLayer->colorSpace() ||
         *this->colorSpace() == *otherLayer->colorSpace());
}

References channelFlags, colorSpace(), KisBaseNode::compositeOpId(), layerStyle, and KisBaseNode::opacity().

◆ changeRect()

QRect KisLayer::changeRect	(	const QRect &	rect,
		PositionToFilthy	pos = N_FILTHY ) const

overrideprotectedvirtual

Returns: internal changeRect() of the node. Do not mix with

See also: projectionPlane()

Some filters will cause a change of pixels those are outside a requested rect. E.g. we change a rect of 2x2, then we want to apply a convolution filter with kernel 4x4 (changeRect is (2+2*3)x(2+2*3)=8x8) to that area. The rect that should be updated on the layer will be exactly 8x8. More than that the needRect for that update will be 14x14. See needRect.

If the projection contains some dirty areas we should also add them to the change rect, because they might have changed. E.g. when a visibility of the mask has changed while the parent layer was invincible.

Reimplemented from KisNode.

Definition at line 859 of file kis_layer.cc.

{
    QRect changeRect = rect;
    changeRect = incomingChangeRect(changeRect);
 
    if(pos == KisNode::N_FILTHY) {
        QRect projectionToBeUpdated = amortizedProjectionRectForCleanupInChangePass() & changeRect;
 
        bool changeRectVaries;
        changeRect = outgoingChangeRect(changeRect);
        changeRect = masksChangeRect(effectMasks(), changeRect, changeRectVaries);
 
        if (!projectionToBeUpdated.isEmpty() &&
            !changeRect.contains(projectionToBeUpdated)) {
 
            changeRect |= projectionToBeUpdated;
        }
    }
 
    // TODO: string comparison: optimize!
    if (pos != KisNode::N_FILTHY &&
        pos != KisNode::N_FILTHY_PROJECTION &&
        compositeOpId() != COMPOSITE_COPY) {
 
        changeRect |= rect;
    }
 
    return changeRect;
}

References amortizedProjectionRectForCleanupInChangePass(), changeRect(), COMPOSITE_COPY, KisBaseNode::compositeOpId(), effectMasks(), incomingChangeRect(), masksChangeRect(), KisNode::N_FILTHY, KisNode::N_FILTHY_PROJECTION, and outgoingChangeRect().

◆ channelFlags()

QBitArray & KisLayer::channelFlags ( ) const

Return a bit array where each bit indicates whether a particular channel is active or not. If the channelflags bit array is empty, all channels are active.

◆ childNodeChanged()

void KisLayer::childNodeChanged ( KisNodeSP changedChildNode )

overrideprotectedvirtual

Called each time direct child nodes are added or removed under this node as parent. This does not track changes inside the child nodes or the child nodes' properties.

Reimplemented from KisNode.

Definition at line 896 of file kis_layer.cc.

{
    if (dynamic_cast<KisMask*>(changedChildNode.data())) {
        notifyChildMaskChanged();
    }
}

References KisSharedPtr< T >::data(), and notifyChildMaskChanged().

◆ colorOverlayMask()

KisFilterMaskSP KisLayer::colorOverlayMask ( ) const

Returns: the top fast color overlay mask, or nullptr if there's none.

Definition at line 567 of file kis_layer.cc.

{
    if (hasEffectMasks()) {
        // Iterate the masks in reverse, the last element is on top of the stack.
        auto allMasks = effectMasks();
        for (auto iter = allMasks.rbegin(); iter != allMasks.rend(); ++iter) {
            if ((*iter)->inherits("KisFilterMask")) {
                KisFilterMaskSP filterMask = qobject_cast<KisFilterMask*>((*iter).data());
                if (filterMask->filter()->name() == "fastcoloroverlay") {
                    return filterMask;
                }
            }
        }
    }
    return nullptr;
}

References effectMasks(), and hasEffectMasks().

◆ colorSpace()

const KoColorSpace * KisLayer::colorSpace ( ) const

overridevirtual

returns the image's colorSpace or null, if there is no image

Implements KisBaseNode.

Definition at line 225 of file kis_layer.cc.

{
    KisPaintDeviceSP dev = original();
    KIS_ASSERT_RECOVER_RETURN_VALUE(dev, KoColorSpaceRegistry::instance()->rgb8());
    return dev->colorSpace();
}

References KisPaintDevice::colorSpace(), KoColorSpaceRegistry::instance(), KIS_ASSERT_RECOVER_RETURN_VALUE, and original().

◆ compositeOp()

const KoCompositeOp * KisLayer::compositeOp ( ) const

overridevirtual

returns the layer's composite op for the colorspace of the layer's parent.

FIXME: This function duplicates the same function from KisMask. We can't move it to KisBaseNode as it doesn't know anything about parent() method of KisNode Please think it over...

Implements KisBaseNode.

Definition at line 232 of file kis_layer.cc.

{
    KisNodeSP parentNode = parent();
    if (!parentNode) return 0;
 
    if (!parentNode->colorSpace()) return 0;
    const KoCompositeOp* op = parentNode->colorSpace()->compositeOp(compositeOpId());
    return op ? op : parentNode->colorSpace()->compositeOp(COMPOSITE_OVER);
}

References KisBaseNode::colorSpace(), COMPOSITE_OVER, KoColorSpace::compositeOp(), KisBaseNode::compositeOpId(), and KisNode::parent.

◆ copyOriginalToProjection()

void KisLayer::copyOriginalToProjection	(	const KisPaintDeviceSP	original,
		KisPaintDeviceSP	projection,
		const QRect &	rect ) const

protectedvirtual

Layers can override this method to get some special behavior when copying data from original to projection, e.g. blend in indirect painting device. If you need to modify data outside rect, please also override outgoingChangeRect() method.

Reimplemented in KisCloneLayer, KisPaintLayer, and KisSelectionBasedLayer.

Definition at line 801 of file kis_layer.cc.

{
    KisPainter::copyAreaOptimized(rect.topLeft(), original, projection, rect);
}

References KisPainter::copyAreaOptimized(), original(), and projection().

◆ createMergedLayerTemplate()

KisLayerSP KisLayer::createMergedLayerTemplate ( KisLayerSP prevLayer )

virtual

Create and return a layer that is the result of merging this with layer.

This method is designed to be called only within KisImage::mergeLayerDown().

Descendants override this to create specific merged types when possible. The KisLayer one creates a KisPaintLayerSP via a bitBlt, and can work on all layer types.

Descendants that perform their own version do NOT call KisLayer::createMergedLayer

Reimplemented in KisGroupLayer, and KisShapeLayer.

Definition at line 401 of file kis_layer.cc.

{
    const bool keepBlendingOptions = canMergeAndKeepBlendOptions(prevLayer);
 
    KisLayerSP newLayer = new KisPaintLayer(image(), prevLayer->name(), OPACITY_OPAQUE_U8);
 
    if (keepBlendingOptions) {
        newLayer->setCompositeOpId(compositeOpId());
        newLayer->setOpacity(opacity());
        newLayer->setChannelFlags(channelFlags());
    }
 
    return newLayer;
}

References canMergeAndKeepBlendOptions(), channelFlags, KisBaseNode::compositeOpId(), KisBaseNode::image, KisBaseNode::name(), KisBaseNode::opacity(), OPACITY_OPAQUE_U8, setChannelFlags(), KisBaseNode::setCompositeOpId(), and KisBaseNode::setOpacity().

◆ createThumbnail()

QImage KisLayer::createThumbnail	(	qint32	w,
		qint32	h,
		Qt::AspectRatioMode	aspectRatioMode = Qt::IgnoreAspectRatio )

overridevirtual

Returns: a thumbnail in requested size. The thumbnail is a rgba QImage and may have transparent parts. Returns a fully transparent QImage of the requested size if the current node type cannot generate a thumbnail. If the requested size is too big, return a null QImage.

Reimplemented from KisBaseNode.

Reimplemented in KisSelectionBasedLayer.

Definition at line 930 of file kis_layer.cc.

{
    if (w == 0 || h == 0) {
        return QImage();
    }
 
    KisPaintDeviceSP originalDevice = original();
 
    return originalDevice ?
           originalDevice->createThumbnail(w, h, aspectRatioMode, 1,
                                           KoColorConversionTransformation::internalRenderingIntent(),
                                           KoColorConversionTransformation::internalConversionFlags()) : QImage();
}

References KisPaintDevice::createThumbnail(), KoColorConversionTransformation::internalConversionFlags(), KoColorConversionTransformation::internalRenderingIntent(), and original().

◆ createThumbnailForFrame()

QImage KisLayer::createThumbnailForFrame	(	qint32	w,
		qint32	h,
		int	time,
		Qt::AspectRatioMode	aspectRatioMode = Qt::IgnoreAspectRatio )

overridevirtual

Returns: a thumbnail in requested size for the defined timestamp. The thumbnail is a rgba Image and may have transparent parts. Returns a fully transparent QImage of the requested size if the current node type cannot generate a thumbnail. If the requested size is too big, return a null QImage.

Reimplemented from KisBaseNode.

Definition at line 950 of file kis_layer.cc.

{
    if (w == 0 || h == 0) {
        return QImage();
    }
 
    KisPaintDeviceSP originalDevice = original();
    if (originalDevice ) {
        KisRasterKeyframeChannel *channel = originalDevice->keyframeChannel();
 
        if (channel) {
            KisPaintDeviceSP targetDevice = new KisPaintDevice(colorSpace());
            KisRasterKeyframeSP keyframe = channel->activeKeyframeAt<KisRasterKeyframe>(time);
            keyframe->writeFrameToDevice(targetDevice);
            return targetDevice->createThumbnail(w, h, aspectRatioMode, 1,
                                                 KoColorConversionTransformation::internalRenderingIntent(),
                                                 KoColorConversionTransformation::internalConversionFlags());
        }
    }
 
    return createThumbnail(w, h);
}

References KisKeyframeChannel::activeKeyframeAt(), colorSpace(), KisPaintDevice::createThumbnail(), createThumbnail(), KoColorConversionTransformation::internalConversionFlags(), KoColorConversionTransformation::internalRenderingIntent(), KisPaintDevice::keyframeChannel(), and original().

◆ disableAlphaChannel()

void KisLayer::disableAlphaChannel ( bool disable )

set/unset the channel flag for the alpha channel of this layer

Definition at line 319 of file kis_layer.cc.

{
    QBitArray newChannelFlags = m_d->channelFlags;
 
    if(newChannelFlags.isEmpty())
        newChannelFlags = colorSpace()->channelFlags(true, true);
 
    if(disable)
        newChannelFlags &= colorSpace()->channelFlags(true, false);
    else
        newChannelFlags |= colorSpace()->channelFlags(false, true);
 
    setChannelFlags(newChannelFlags);
}

References KoColorSpace::channelFlags(), colorSpace(), m_d, and setChannelFlags().

◆ effectMasks() [1/2]

QList< KisEffectMaskSP > KisLayer::effectMasks ( ) const

Returns: the list of effect masks

Definition at line 521 of file kis_layer.cc.

{
    return m_d->masksCache.effectMasks();
}

References m_d.

◆ effectMasks() [2/2]

QList< KisEffectMaskSP > KisLayer::effectMasks ( KisNodeSP lastNode ) const

Returns: the list of effect masks up to a certain node

Definition at line 526 of file kis_layer.cc.

{
    if (lastNode.isNull()) {
        return effectMasks();
    } else {
        // happens rarely.
        return searchEffectMasks(lastNode);
    }
}

References effectMasks(), KisSharedPtr< T >::isNull(), and searchEffectMasks().

◆ exactBounds()

QRect KisLayer::exactBounds ( ) const

overridevirtual

Returns the exact bounds of where the actual data of this layer resides

Reimplemented from KisBaseNode.

Reimplemented in KisPaintLayer, and KisSelectionBasedLayer.

Definition at line 1030 of file kis_layer.cc.

{
    return layerExtentImpl(true);
}

References layerExtentImpl().

◆ extent()

QRect KisLayer::extent ( ) const

overridevirtual

Returns an approximation of where the bounds of actual data of this layer are

Reimplemented from KisBaseNode.

Reimplemented in KisPaintLayer, and KisSelectionBasedLayer.

Definition at line 1025 of file kis_layer.cc.

{
    return layerExtentImpl(false);
}

References layerExtentImpl().

◆ fillMergedLayerTemplate()

void KisLayer::fillMergedLayerTemplate	(	KisLayerSP	dstLayer,
		KisLayerSP	prevLayer,
		bool	skipPaintingThisLayer = false )

virtual

Reimplemented in KisGroupLayer, and KisShapeLayer.

Definition at line 416 of file kis_layer.cc.

{
    const bool keepBlendingOptions = canMergeAndKeepBlendOptions(prevLayer);
 
    QRect layerProjectionExtent = this->projection()->extent();
    QRect prevLayerProjectionExtent = prevLayer->projection()->extent();
    bool alphaDisabled = this->alphaChannelDisabled();
    bool prevAlphaDisabled = prevLayer->alphaChannelDisabled();
 
    KisPaintDeviceSP mergedDevice = dstLayer->paintDevice();
 
    if (!keepBlendingOptions) {
        KisPainter gc(mergedDevice);
 
        KisImageSP imageSP = image().toStrongRef();
        if (!imageSP) {
            return;
        }
 
        //Copy the pixels of previous layer with their actual alpha value
        prevLayer->disableAlphaChannel(false);
 
        prevLayer->projectionPlane()->apply(&gc, prevLayerProjectionExtent | imageSP->bounds());
 
        //Restore the previous prevLayer disableAlpha status for correct undo/redo
        prevLayer->disableAlphaChannel(prevAlphaDisabled);
 
        if (!skipPaintingThisLayer) {
            //Paint the pixels of the current layer, using their actual alpha value
            if (alphaDisabled == prevAlphaDisabled) {
                this->disableAlphaChannel(false);
            }
 
            this->projectionPlane()->apply(&gc, layerProjectionExtent | imageSP->bounds());
 
            //Restore the layer disableAlpha status for correct undo/redo
            this->disableAlphaChannel(alphaDisabled);
        }
    }
    else {
        //Copy prevLayer
        KisPaintDeviceSP srcDev = prevLayer->projection();
        mergedDevice->makeCloneFrom(srcDev, srcDev->extent());
 
        if (!skipPaintingThisLayer) {
            //Paint layer on the copy
            KisPainter gc(mergedDevice);
            gc.bitBlt(layerProjectionExtent.topLeft(), this->projection(), layerProjectionExtent);
        }
    }
}

References alphaChannelDisabled(), KisPainter::bitBlt(), KisImage::bounds(), canMergeAndKeepBlendOptions(), disableAlphaChannel(), KisPaintDevice::extent(), KisBaseNode::image, KisPaintDevice::makeCloneFrom(), KisBaseNode::paintDevice(), projection(), projectionPlane, and KisWeakSharedPtr< T >::toStrongRef().

◆ hasClones()

bool KisLayer::hasClones ( ) const

Returns whether we have a clone.

Be careful with it. It is not thread safe to add/remove clone while checking hasClones(). So there should be no updates.

Definition at line 483 of file kis_layer.cc.

{
    return m_d->clonesList.hasClones();
}

References m_d.

◆ hasEffectMasks()

bool KisLayer::hasEffectMasks ( ) const

Returns true if there are any effect masks present

Definition at line 562 of file kis_layer.cc.

{
    return  !m_d->masksCache.effectMasks().isEmpty();
}

References m_d.

◆ incomingChangeRect()

QRect KisLayer::incomingChangeRect ( const QRect & rect ) const

protectedvirtual

For KisLayer classes change rect transformation consists of two parts: incoming and outgoing.

1) incomingChangeRect(rect) chande rect transformation performed by the transformations done basing on global projection. It is performed in KisAsyncMerger + KisUpdateOriginalVisitor classes. It happens before data coming to KisLayer::original() therefore it is 'incoming'. See KisAdjustmentLayer for example of usage.

2) outgoingChangeRect(rect) change rect transformation that happens in KisLayer::copyOriginalToProjection(). It applies only when the layer is 'filthy', that is was the cause of the merge process. See KisCloneLayer for example of usage.

The flow of changed areas can be illustrated in the following way:

Current projection of size R1 is stored in KisAsyncMerger::m_currentProjection | | <– KisUpdateOriginalVisitor writes data into layer's original() device. | The changed area on KisLayer::original() is | R2 = KisLayer::incomingChangeRect(R1) |
KisLayer::original() / changed rect: R2 | | <– KisLayer::updateProjection() starts composing a layer | It calls KisLayer::copyOriginalToProjection() which copies some area | to a temporary device. The temporary device now stores | R3 = KisLayer::outgoingChangeRect(R2) |
Temporary device / changed rect: R3 | | <– KisLayer::updateProjection() continues composing a layer. It merges a mask. | R4 = KisMask::changeRect(R3) |
KisLayer::original() / changed rect: R4

So in the end rect R4 will be passed up to the next layers in the stack.

Reimplemented in KisAdjustmentLayer.

Definition at line 903 of file kis_layer.cc.

{
    return rect;
}

◆ internalProjectionPlane()

KisLayerProjectionPlaneSP KisLayer::internalProjectionPlane ( ) const

virtual

The projection plane representing the layer itself without any styles or anything else. It is used by the layer styles projection plane to stack up the planes.

Definition at line 815 of file kis_layer.cc.

{
    return m_d->projectionPlane;
}

References m_d.

◆ layerExtentImpl()

QRect KisLayer::layerExtentImpl ( bool exactBounds ) const

private

Definition at line 996 of file kis_layer.cc.

{
    QRect additionalMaskExtent = QRect();
    QList<KisEffectMaskSP> effectMasks = this->effectMasks();
 
    Q_FOREACH(KisEffectMaskSP mask, effectMasks) {
        additionalMaskExtent |= mask->nonDependentExtent();
    }
 
    KisPaintDeviceSP originalDevice = original();
    QRect layerExtent;
 
    if (originalDevice) {
        layerExtent = needExactBounds ?
            originalDevice->exactBounds() :
            originalDevice->extent();
    }
 
    QRect additionalCompositeOpExtent;
    if (compositeOpId() == COMPOSITE_COPY ||
        compositeOpId() == COMPOSITE_DESTINATION_IN ||
        compositeOpId() == COMPOSITE_DESTINATION_ATOP) {
 
        additionalCompositeOpExtent = originalDevice->defaultBounds()->bounds();
    }
 
    return layerExtent | additionalMaskExtent | additionalCompositeOpExtent;
}

References KisDefaultBoundsBase::bounds(), COMPOSITE_COPY, COMPOSITE_DESTINATION_ATOP, COMPOSITE_DESTINATION_IN, KisBaseNode::compositeOpId(), KisPaintDevice::defaultBounds(), effectMasks(), KisPaintDevice::exactBounds(), KisPaintDevice::extent(), and original().

◆ layerStyle()

KisPSDLayerStyleSP KisLayer::layerStyle ( ) const

◆ looseUserVisibleBounds()

QRect KisLayer::looseUserVisibleBounds ( ) const

Return an approximated (loose) rectangle, where the contents of the layer is placed from user's point of view. This rectangle includes all the masks and effects the layer has (excluding layer styles, they report their bounds via projection plane).

This rect is always equal or bigger than tightUserVisibleBounds()

Definition at line 849 of file kis_layer.cc.

{
    return userVisibleBoundsImpl(false);
}

References userVisibleBoundsImpl().

◆ masksChangeRect()

QRect KisLayer::masksChangeRect	(	const QList< KisEffectMaskSP > &	masks,
		const QRect &	requestedRect,
		bool &	rectVariesFlag ) const

protected

Parameters

rectVariesFlag (out param) a flag, showing whether a rect varies from mask to mask

Returns: an area that should be updated because of the change of @requestedRect of the layer

We set default value of the change rect for the case when there is no mask at all

Definition at line 584 of file kis_layer.cc.

{
    rectVariesFlag = false;
 
    QRect prevChangeRect = requestedRect;
 
    QRect changeRect = requestedRect;
 
    Q_FOREACH (const KisEffectMaskSP& mask, masks) {
        changeRect = mask->changeRect(prevChangeRect);
 
        if (changeRect != prevChangeRect)
            rectVariesFlag = true;
 
        prevChangeRect = changeRect;
    }
 
    return changeRect;
}

References changeRect().

◆ masksNeedRect()

QRect KisLayer::masksNeedRect	(	const QList< KisEffectMaskSP > &	masks,
		const QRect &	changeRect,
		QStack< QRect > &	applyRects,
		bool &	rectVariesFlag ) const

protected

Get needRects for all masks

Parameters

changeRect	requested rect to be updated on final projection. Should be a return value of masksChangedRect()
applyRects	(out param) a stack of the rects where filters should be applied
rectVariesFlag	(out param) a flag, showing whether a rect varies from mask to mask

Returns: a needRect that should be prepared on the layer's paintDevice for all masks to succeed

Definition at line 610 of file kis_layer.cc.

{
    rectVariesFlag = false;
 
    QRect prevNeedRect = changeRect;
    QRect needRect;
    
    for (qint32 i = masks.size() - 1; i >= 0; i--) {
        applyRects.push(prevNeedRect);
 
        needRect = masks[i]->needRect(prevNeedRect);
 
        if (prevNeedRect != needRect)
            rectVariesFlag = true;
 
        prevNeedRect = needRect;
    }
 
    return needRect;
}

References changeRect(), and KisNode::needRect().

◆ metaData()

KisMetaData::Store * KisLayer::metaData ( )

Returns: the metadata object associated with this object.

Definition at line 1040 of file kis_layer.cc.

{
    return m_d->metaDataStore;
}

References m_d.

◆ needProjection()

bool KisLayer::needProjection ( ) const

virtual

Reimplemented in KisCloneLayer, KisPaintLayer, and KisSelectionBasedLayer.

Definition at line 796 of file kis_layer.cc.

{
    return false;
}

◆ needRectForOriginal()

QRect KisLayer::needRectForOriginal ( const QRect & rect ) const

protected

Return need rect that should be prepared on original() device of the layer to get rect on its projection.

This method is used either for layers that can have other layers as children (yes, KisGroupLayer, I'm looking at you!), or for layers that depend on the lower nodes (it's you, KisAdjustmentLayer!).

These layers may have some filter masks that need a bit more pixels than requested, therefore child nodes should do a bit more work to prepare them.

Definition at line 913 of file kis_layer.cc.

{
    QRect needRect = rect;
 
    const QList<KisEffectMaskSP> masks = effectMasks();
 
    if (!masks.isEmpty()) {
        QStack<QRect> applyRects;
        bool needRectVaries;
 
        needRect = masksNeedRect(masks, rect,
                                 applyRects, needRectVaries);
    }
 
    return needRect;
}

References effectMasks(), masksNeedRect(), and KisNode::needRect().

◆ notifyChildMaskChanged()

void KisLayer::notifyChildMaskChanged ( )

Informs this layers that its masks might have changed.

Definition at line 493 of file kis_layer.cc.

{
    m_d->masksCache.setDirty();
}

References m_d.

◆ original()

KisPaintDeviceSP KisLayer::original ( ) const

overridepure virtual

Return the layer data before the effect masks have had their go at it.

Implements KisBaseNode.

Implemented in KisCloneLayer, KisGroupLayer, KisPaintLayer, KisSelectionBasedLayer, KisShapeLayer, KisFileLayer, and KisDecorationsWrapperLayer.

◆ outgoingChangeRect()

QRect KisLayer::outgoingChangeRect ( const QRect & rect ) const

protectedvirtual

See also: incomingChangeRect()

Reimplemented in KisCloneLayer.

Definition at line 908 of file kis_layer.cc.

{
    return rect;
}

◆ parentLayer()

KisLayerSP KisLayer::parentLayer ( ) const

Get the group layer that contains this layer.

Definition at line 1035 of file kis_layer.cc.

{
    return qobject_cast<KisLayer*>(parent().data());
}

References KisNode::parent.

◆ partialChangeRect()

QRect KisLayer::partialChangeRect	(	KisNodeSP	lastNode,
		const QRect &	rect )

Definition at line 769 of file kis_layer.cc.

{
    bool changeRectVaries = false;
    QRect changeRect = outgoingChangeRect(rect);
    changeRect = masksChangeRect(effectMasks(lastNode), changeRect,
                                 changeRectVaries);
 
    return changeRect;
}

References changeRect(), effectMasks(), masksChangeRect(), and outgoingChangeRect().

◆ Private()

KisLayer::Private ( KisLayer * q )

inline

Definition at line 162 of file kis_layer.cc.

        : masksCache(q)
    {
    }

◆ projection()

KisPaintDeviceSP KisLayer::projection ( ) const

overridevirtual

Return the fully rendered representation of this layer: its data and its effect masks

Implements KisBaseNode.

Definition at line 820 of file kis_layer.cc.

{
    KisPaintDeviceSP originalDevice = original();
 
    return needProjection() || hasEffectMasks() ?
        m_d->safeProjection->getDeviceLazy(originalDevice) : originalDevice;
}

References hasEffectMasks(), m_d, needProjection(), and original().

◆ projectionPlane()

KisAbstractProjectionPlaneSP KisLayer::projectionPlane ( ) const

overridevirtual

See also: a comment in KisNode::projectionPlane()

Reimplemented from KisNode.

◆ registerClone()

void KisLayer::registerClone ( KisCloneLayerWSP clone )

Clones should be informed about updates of the original layer, so this is a way to register them

Definition at line 468 of file kis_layer.cc.

{
    m_d->clonesList.addClone(clone);
}

References KisNode::clone(), and m_d.

◆ registeredClones()

const QList< KisCloneLayerWSP > KisLayer::registeredClones ( ) const

Return the list of the clones of this node. Be careful with the list, because it is not thread safe.

Definition at line 478 of file kis_layer.cc.

{
    return m_d->clonesList.registeredClones();
}

References m_d.

◆ searchEffectMasks()

QList< KisEffectMaskSP > KisLayer::searchEffectMasks ( KisNodeSP lastNode ) const

protected

Definition at line 536 of file kis_layer.cc.

{
    QList<KisEffectMaskSP> masks;
 
    KIS_SAFE_ASSERT_RECOVER_NOOP(projectionLeaf());
 
    KisProjectionLeafSP child = projectionLeaf()->firstChild();
    while (child) {
        if (child->node() == lastNode) break;
 
        KIS_SAFE_ASSERT_RECOVER_NOOP(child);
        KIS_SAFE_ASSERT_RECOVER_NOOP(child->node());
 
        if (child->visible()) {
            KisEffectMaskSP mask = dynamic_cast<KisEffectMask*>(const_cast<KisNode*>(child->node().data()));
            if (mask) {
                masks.append(mask);
            }
        }
 
        child = child->nextSibling();
    }
 
    return masks;
}

References KIS_SAFE_ASSERT_RECOVER_NOOP, and KisNode::projectionLeaf.

◆ sectionModelProperties()

KisBaseNode::PropertyList KisLayer::sectionModelProperties ( ) const

overridevirtual

Return a the properties of this base node (locked, visible etc, with the right icons for their representation and their state.

Subclasses can extend this list with new properties, like opacity for layers or visualized for masks.

The order of properties is, unfortunately, for now, important, so take care which properties superclasses of your class define.

KisBaseNode defines visible = 0, locked = 1 KisLayer defines opacity = 2, compositeOp = 3 KisMask defines active = 2 (KisMask does not inherit kislayer)

Reimplemented from KisBaseNode.

Reimplemented in KisPaintLayer, and KisShapeLayer.

Definition at line 272 of file kis_layer.cc.

{
    KisBaseNode::PropertyList l = KisBaseNode::sectionModelProperties();
    l << KisBaseNode::Property(KoID("opacity", i18n("Opacity")), i18n("%1%", percentOpacity()));
 
    const KoCompositeOp * compositeOp = this->compositeOp();
 
    if (compositeOp) {
        l << KisBaseNode::Property(KoID("compositeop", i18n("Blending Mode")), compositeOp->description());
    }
 
    if (m_d->layerStyle && !m_d->layerStyle->isEmpty()) {
        l << KisLayerPropertiesIcons::getProperty(KisLayerPropertiesIcons::layerStyle, m_d->layerStyle->isEnabled());
    }
 
    l << KisLayerPropertiesIcons::getProperty(KisLayerPropertiesIcons::inheritAlpha, alphaChannelDisabled());
 
    if (colorOverlayMask()) {
        // Use an immutable property (with a string value), to hide it in the layer properties dialog.
        l << KisBaseNode::Property(KisLayerPropertiesIcons::colorOverlay, "true");
    }
 
    return l;
}

References alphaChannelDisabled(), KisLayerPropertiesIcons::colorOverlay, colorOverlayMask(), compositeOp(), KoCompositeOp::description, KisLayerPropertiesIcons::getProperty(), KisLayerPropertiesIcons::inheritAlpha, KisLayerPropertiesIcons::layerStyle, m_d, KisBaseNode::percentOpacity(), and KisBaseNode::sectionModelProperties().

◆ selection()

KisSelectionSP KisLayer::selection ( ) const

virtual

Returns: the selection contained in the first KisSelectionMask associated with this layer or the image, if either exists, otherwise, return 0.

Definition at line 503 of file kis_layer.cc.

{
    KisSelectionMaskSP mask = selectionMask();
 
    if (mask) {
        return mask->selection();
    }
 
    KisImageSP image = this->image();
    if (image) {
        return image->globalSelection();
    }
    return KisSelectionSP();
}

References KisImage::globalSelection(), KisBaseNode::image, KisMask::selection, and selectionMask().

◆ selectionMask()

KisSelectionMaskSP KisLayer::selectionMask ( ) const

virtual

Returns: the selection associated with this layer, if there is one. Otherwise, return 0;

Definition at line 498 of file kis_layer.cc.

{
    return m_d->masksCache.selectionMask();
}

References m_d.

◆ setChannelFlags()

void KisLayer::setChannelFlags ( const QBitArray & channelFlags )

virtual

set the channelflags for this layer to the specified bit array. The bit array must have exactly the same number of channels as the colorspace this layer is in, or be empty, in which case all channels are active.

Reimplemented in KisAdjustmentLayer.

Definition at line 342 of file kis_layer.cc.

{
    Q_ASSERT(channelFlags.isEmpty() ||((quint32)channelFlags.count() == colorSpace()->channelCount()));
 
    if (KritaUtils::compareChannelFlags(channelFlags,
                                        this->channelFlags())) {
        return;
    }
 
    if (!channelFlags.isEmpty() &&
        channelFlags == QBitArray(channelFlags.size(), true)) {
 
        m_d->channelFlags.clear();
    } else {
        m_d->channelFlags = channelFlags;
    }
 
    baseNodeChangedCallback();
    baseNodeInvalidateAllFramesCallback();
}

References KisNode::baseNodeChangedCallback(), KisNode::baseNodeInvalidateAllFramesCallback(), channelFlags, colorSpace(), KritaUtils::compareChannelFlags(), and m_d.

◆ setImage()

void KisLayer::setImage ( KisImageWSP image )

overridevirtual

Set the image this layer belongs to.

Reimplemented from KisBaseNode.

Reimplemented in KisPaintLayer, KisSelectionBasedLayer, and KisShapeLayer.

Definition at line 378 of file kis_layer.cc.

{
    // we own the projection device, so we should take care about it
    KisPaintDeviceSP projection = this->projection();
    if (projection && projection != original()) {
        projection->setDefaultBounds(new KisDefaultBounds(image));
    }
    m_d->safeProjection->setImage(image);
 
    KisNode::setImage(image);
}

References KisBaseNode::image, m_d, original(), projection(), KisPaintDevice::setDefaultBounds(), and KisNode::setImage().

◆ setLayerStyle()

void KisLayer::setLayerStyle ( KisPSDLayerStyleSP layerStyle )

Definition at line 254 of file kis_layer.cc.

{
    if (layerStyle) {
        KIS_SAFE_ASSERT_RECOVER_NOOP(layerStyle->hasLocalResourcesSnapshot());
 
        m_d->layerStyle = layerStyle;
 
        KisLayerStyleProjectionPlaneSP plane = !layerStyle->isEmpty() ?
            KisLayerStyleProjectionPlaneSP(new KisLayerStyleProjectionPlane(this)) :
            KisLayerStyleProjectionPlaneSP(0);
 
        m_d->layerStyleProjectionPlane = plane;
    } else {
        m_d->layerStyleProjectionPlane.clear();
        m_d->layerStyle.clear();
    }
}

References KIS_SAFE_ASSERT_RECOVER_NOOP, layerStyle, and m_d.

◆ setSectionModelProperties()

void KisLayer::setSectionModelProperties ( const KisBaseNode::PropertyList & properties )

overridevirtual

Change the section model properties.

Reimplemented from KisBaseNode.

Reimplemented in KisPaintLayer, and KisShapeLayer.

Definition at line 297 of file kis_layer.cc.

{
    KisBaseNode::setSectionModelProperties(properties);
 
    Q_FOREACH (const KisBaseNode::Property &property, properties) {
        if (property.id == KisLayerPropertiesIcons::inheritAlpha.id()) {
            disableAlphaChannel(property.state.toBool());
        }
 
        if (property.id == KisLayerPropertiesIcons::layerStyle.id()) {
            if (m_d->layerStyle &&
                m_d->layerStyle->isEnabled() != property.state.toBool()) {
 
                m_d->layerStyle->setEnabled(property.state.toBool());
 
                baseNodeChangedCallback();
                baseNodeInvalidateAllFramesCallback();
            }
        }
    }
}

References KisNode::baseNodeChangedCallback(), KisNode::baseNodeInvalidateAllFramesCallback(), disableAlphaChannel(), KoID::id(), KisBaseNode::Property::id, KisLayerPropertiesIcons::inheritAlpha, KisLayerPropertiesIcons::layerStyle, m_d, KisBaseNode::properties, KisBaseNode::setSectionModelProperties(), and KisBaseNode::Property::state.

◆ setTemporary()

void KisLayer::setTemporary ( bool t )

Set to true if this layer should not appear in the layerbox, even though it is temporarily in the layer stack and taken into account on recomposition.

Definition at line 373 of file kis_layer.cc.

{
    setNodeProperty("temporary", t);
}

References KisBaseNode::setNodeProperty().

◆ setX()

void KisLayer::setX ( qint32 )

overridevirtual

Set the x offset of this layer in the image place. Re-implement this where it makes sense, by default it does nothing. It should not move child nodes.

Reimplemented from KisBaseNode.

Reimplemented in KisSelectionBasedLayer, and KisShapeLayer.

Definition at line 983 of file kis_layer.cc.

{
    KisPaintDeviceSP originalDevice = original();
    if (originalDevice)
        originalDevice->setX(x);
}

References original(), KisPaintDevice::setX(), and x().

◆ setY()

void KisLayer::setY ( qint32 )

overridevirtual

Set the y offset of this layer in the image place. Re-implement this where it makes sense, by default it does nothing. It should not move child nodes.

Reimplemented from KisBaseNode.

Reimplemented in KisSelectionBasedLayer, and KisShapeLayer.

Definition at line 989 of file kis_layer.cc.

{
    KisPaintDeviceSP originalDevice = original();
    if (originalDevice)
        originalDevice->setY(y);
}

References original(), KisPaintDevice::setY(), and y().

◆ temporary()

bool KisLayer::temporary ( ) const

Returns true if this layer is temporary: i.e., it should not appear in the layerbox, even though it is temporarily in the layer stack and taken into account on recomposition.

Definition at line 368 of file kis_layer.cc.

{
    return nodeProperties().boolProperty("temporary", false);
}

References KoProperties::boolProperty(), and KisBaseNode::nodeProperties().

◆ thumbnailSeqNo()

int KisLayer::thumbnailSeqNo ( ) const

overridevirtual

Returns: a sequence number of the thumbnail of the node. Every time the layer changes, the sequence number increases.

Reimplemented from KisBaseNode.

Reimplemented in KisSelectionBasedLayer.

Definition at line 944 of file kis_layer.cc.

{
    KisPaintDeviceSP originalDevice = original();
    return originalDevice ? originalDevice->sequenceNumber() : -1;
}

References original(), and KisPaintDevice::sequenceNumber().

◆ tightUserVisibleBounds()

QRect KisLayer::tightUserVisibleBounds ( ) const

Return a tight rectangle, where the contents of the layer is placed from user's point of view. This rectangle includes all the masks and effects the layer has (excluding layer styles, they report their bounds via projection plane).

Definition at line 844 of file kis_layer.cc.

{
    return userVisibleBoundsImpl(true);
}

References userVisibleBoundsImpl().

◆ unregisterClone()

void KisLayer::unregisterClone ( KisCloneLayerWSP clone )

Deregisters the clone from the update list

See also: registerClone()

Definition at line 473 of file kis_layer.cc.

{
    m_d->clonesList.removeClone(clone);
}

References KisNode::clone(), and m_d.

◆ updateClones()

void KisLayer::updateClones	(	const QRect &	rect,
		bool	dontInvalidateFrames )

It is called by the async merger after projection update is done

Definition at line 488 of file kis_layer.cc.

{
    m_d->clonesList.setDirty(rect, dontInvalidateFrames);
}

References m_d.

◆ updateProjection()

QRect KisLayer::updateProjection	(	const QRect &	rect,
		KisNodeSP	filthyNode,
		KisRenderPassFlags	flags )

protected

Ask the layer to assemble its data & apply all the effect masks to it.

Definition at line 747 of file kis_layer.cc.

{
    QRect updatedRect = rect;
    KisPaintDeviceSP originalDevice = original();
    if (!rect.isValid() ||
        (!visible() && !isIsolatedRoot() && !hasClones()) ||
        !originalDevice) return QRect();
 
    if (!needProjection() && !hasEffectMasks()) {
        m_d->safeProjection->releaseDevice();
    } else {
 
        if (!updatedRect.isEmpty()) {
            KisPaintDeviceSP projection = m_d->safeProjection->getDeviceLazy(originalDevice);
            updatedRect = applyMasks(originalDevice, projection,
                                     updatedRect, filthyNode, 0, flags);
        }
    }
 
    return updatedRect;
}

References applyMasks(), hasClones(), hasEffectMasks(), KisBaseNode::isIsolatedRoot(), m_d, needProjection(), original(), projection(), and KisBaseNode::visible().

◆ userVisibleBoundsImpl()

QRect KisLayer::userVisibleBoundsImpl ( bool exactBounds ) const

private

we do not use incomingChangeRect() here, because exactBounds() already takes it into account (it was used while preparing original())

Definition at line 828 of file kis_layer.cc.

{
    QRect changeRect = exactBounds ? this->exactBounds() : this->extent();
 
 
    bool changeRectVaries;
    changeRect = outgoingChangeRect(changeRect);
    changeRect = masksChangeRect(effectMasks(), changeRect, changeRectVaries);
 
    return changeRect;
}

References changeRect(), effectMasks(), exactBounds(), extent(), masksChangeRect(), and outgoingChangeRect().

◆ x()

qint32 KisLayer::x ( ) const

overridevirtual

Returns: the x-offset of this layer in the image plane.

Reimplemented from KisBaseNode.

Reimplemented in KisSelectionBasedLayer, and KisShapeLayer.

Definition at line 973 of file kis_layer.cc.

{
    KisPaintDeviceSP originalDevice = original();
    return originalDevice ? originalDevice->x() : 0;
}

References original(), and KisPaintDevice::x().

◆ y()

qint32 KisLayer::y ( ) const

overridevirtual

Returns: the y-offset of this layer in the image plane.

Reimplemented from KisBaseNode.

Reimplemented in KisSelectionBasedLayer, and KisShapeLayer.

Definition at line 978 of file kis_layer.cc.

{
    KisPaintDeviceSP originalDevice = original();
    return originalDevice ? originalDevice->y() : 0;
}

References original(), and KisPaintDevice::y().

Friends And Related Symbol Documentation

◆ KisLayerMasksCache

friend class KisLayerMasksCache

friend

Definition at line 427 of file kis_layer.h.

◆ KisLayerProjectionPlane

friend class KisLayerProjectionPlane

friend

Definition at line 428 of file kis_layer.h.

◆ KisLayerTest

friend class KisLayerTest

friend

Definition at line 430 of file kis_layer.h.

◆ KisTransformMask

friend class KisTransformMask

friend

Definition at line 429 of file kis_layer.h.

Member Data Documentation

◆ channelFlags

QBitArray & KisLayer::channelFlags

Definition at line 167 of file kis_layer.cc.

◆ clonesList

KisCloneLayersList KisLayer::clonesList

Definition at line 169 of file kis_layer.cc.

◆ layerStyle

KisPSDLayerStyleSP KisLayer::layerStyle

Definition at line 171 of file kis_layer.cc.

◆ layerStyleProjectionPlane

KisLayerStyleProjectionPlaneSP KisLayer::layerStyleProjectionPlane

Definition at line 172 of file kis_layer.cc.

◆ m_d

Private* const KisLayer::m_d

private

Definition at line 438 of file kis_layer.h.

◆ masksCache

KisLayerMasksCache KisLayer::masksCache

Definition at line 177 of file kis_layer.cc.

◆ metaDataStore

KisMetaData::Store* KisLayer::metaDataStore {nullptr}

Definition at line 168 of file kis_layer.cc.

168{nullptr};

◆ projectionPlane

KisAbstractProjectionPlaneSP KisLayer::projectionPlane

Definition at line 174 of file kis_layer.cc.

◆ safeProjection

KisSafeNodeProjectionStoreSP KisLayer::safeProjection

Definition at line 175 of file kis_layer.cc.

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

libs/image/kis_layer.cc
libs/image/kis_layer.h

Public Member Functions

Public Attributes

Protected Member Functions

Private Member Functions

Private Attributes

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ KisLayer() [1/2]

◆ KisLayer() [2/2]

◆ ~KisLayer()

Member Function Documentation

◆ alphaChannelDisabled()

◆ amortizedProjectionRectForCleanupInChangePass()

◆ applyMasks()

◆ buildProjectionUpToNode()

◆ canMergeAndKeepBlendOptions()

◆ changeRect()

◆ channelFlags()

◆ childNodeChanged()

◆ colorOverlayMask()

◆ colorSpace()

◆ compositeOp()

◆ copyOriginalToProjection()

◆ createMergedLayerTemplate()

◆ createThumbnail()

◆ createThumbnailForFrame()

◆ disableAlphaChannel()

◆ effectMasks() [1/2]

◆ effectMasks() [2/2]

◆ exactBounds()

◆ extent()

◆ fillMergedLayerTemplate()

◆ hasClones()

◆ hasEffectMasks()

◆ incomingChangeRect()

◆ internalProjectionPlane()

◆ layerExtentImpl()

◆ layerStyle()

◆ looseUserVisibleBounds()

◆ masksChangeRect()

◆ masksNeedRect()

◆ metaData()

◆ needProjection()

◆ needRectForOriginal()

◆ notifyChildMaskChanged()

◆ original()

◆ outgoingChangeRect()

◆ parentLayer()

◆ partialChangeRect()

◆ Private()

◆ projection()

◆ projectionPlane()

◆ registerClone()

◆ registeredClones()

◆ searchEffectMasks()

◆ sectionModelProperties()

◆ selection()

◆ selectionMask()

◆ setChannelFlags()

◆ setImage()

◆ setLayerStyle()

◆ setSectionModelProperties()

◆ setTemporary()

◆ setX()

◆ setY()

◆ temporary()

◆ thumbnailSeqNo()

◆ tightUserVisibleBounds()

◆ unregisterClone()

◆ updateClones()

◆ updateProjection()

◆ userVisibleBoundsImpl()

◆ x()

◆ y()

Friends And Related Symbol Documentation

◆ KisLayerMasksCache

◆ KisLayerProjectionPlane

◆ KisLayerTest