#include <kis_layer_style_projection_plane.h>

Inheritance diagram for KisLayerStyleProjectionPlane:

Public Member Functions
QRect	accessRect (const QRect &rect, KisLayer::PositionToFilthy pos) const override

QVector< KisLayerStyleFilterProjectionPlaneSP >	allStyles () const

void	apply (KisPainter *painter, const QRect &rect) override

void	applyComplexPlane (KisPainter *painter, KisLayerStyleFilterProjectionPlaneSP plane, const QRect &rect, KisPaintDeviceSP originalClone)

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

KisPaintDeviceList	getLodCapableDevices () const override

bool	hasKnockoutStyles () const

bool	hasOverlayStyles () const

void	initSourcePlane (KisLayer *sourceLayer)

	KisLayerStyleProjectionPlane (const KisLayerStyleProjectionPlane &rhs, KisLayer *sourceLayer, KisPSDLayerStyleSP clonedStyle)

	KisLayerStyleProjectionPlane (KisLayer *sourceLayer)

QRect	looseUserVisibleBounds () const override

QRect	needRect (const QRect &rect, KisLayer::PositionToFilthy pos) const override

QRect	needRectForOriginal (const QRect &rect) const override

QRect	recalculate (const QRect &rect, KisNodeSP filthyNode, KisRenderPassFlags flags) override

QRect	tightUserVisibleBounds () const override

	~KisLayerStyleProjectionPlane () override

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

Public Member Functions inherited from KisAbstractProjectionPlane
	KisAbstractProjectionPlane ()

virtual	~KisAbstractProjectionPlane ()

Static Public Member Functions
static KisAbstractProjectionPlaneSP	factoryObject (KisLayer *sourceLayer)

Public Attributes
KisCachedPaintDevice	cachedPaintDevice

KisCachedSelection	cachedSelection

bool	canHaveChildNodes = false

bool	dependsOnLowerNodes = false

KisLayer *	sourceLayer = 0

KisLayerProjectionPlaneWSP	sourceProjectionPlane

KisStrokeLayerStyleFilterProjectionPlaneSP	strokeStyle

KisPSDLayerStyleSP	style

QVector< KisLayerStyleFilterProjectionPlaneSP >	stylesAfter

QVector< KisLayerStyleFilterProjectionPlaneSP >	stylesBefore

QVector< KisLayerStyleFilterProjectionPlaneSP >	stylesOverlay

Public Attributes inherited from Private
KisCanvas2 *	canvas

int	displayedFrame

int	intendedFrame

Private Member Functions
void	init (KisLayer *sourceLayer, KisPSDLayerStyleSP layerStyle)

	KisLayerStyleProjectionPlane (KisLayer *sourceLayer, KisPSDLayerStyleSP style)

QRect	stylesNeedRect (const QRect &rect) const

Private Attributes
const QScopedPointer< Private >	m_d

Friends
class	KisLayerStyleProjectionPlaneTest

Detailed Description

Definition at line 27 of file kis_layer_style_projection_plane.cpp.

Constructor & Destructor Documentation

◆ KisLayerStyleProjectionPlane() [1/3]

KisLayerStyleProjectionPlane::KisLayerStyleProjectionPlane ( KisLayer * sourceLayer )

Definition at line 90 of file kis_layer_style_projection_plane.cpp.

    : m_d(new Private)
{
    KisPSDLayerStyleSP style = sourceLayer->layerStyle();
 
    KIS_ASSERT_RECOVER(style) {
        style = toQShared(new KisPSDLayerStyle());
    }
 
    init(sourceLayer, style);
}

References init(), KIS_ASSERT_RECOVER, KisLayer::layerStyle, sourceLayer, style, and toQShared().

◆ KisLayerStyleProjectionPlane() [2/3]

KisLayerStyleProjectionPlane::KisLayerStyleProjectionPlane	(	const KisLayerStyleProjectionPlane &	rhs,
		KisLayer *	sourceLayer,
		KisPSDLayerStyleSP	clonedStyle )

Definition at line 102 of file kis_layer_style_projection_plane.cpp.

    : m_d(new Private)
{
    m_d->initSourcePlane(sourceLayer);
    m_d->style = clonedStyle;
 
    KIS_SAFE_ASSERT_RECOVER(m_d->style) {
        m_d->style = toQShared(new KisPSDLayerStyle());
    }
 
    Q_FOREACH (KisLayerStyleFilterProjectionPlaneSP plane, rhs.m_d->stylesBefore) {
        m_d->stylesBefore << toQShared(new KisLayerStyleFilterProjectionPlane(*plane, sourceLayer, m_d->style));
    }
 
    Q_FOREACH (KisLayerStyleFilterProjectionPlaneSP plane, rhs.m_d->stylesAfter) {
        m_d->stylesAfter << toQShared(new KisLayerStyleFilterProjectionPlane(*plane, sourceLayer, m_d->style));
    }
 
    Q_FOREACH (KisLayerStyleFilterProjectionPlaneSP plane, rhs.m_d->stylesOverlay) {
        m_d->stylesOverlay << toQShared(new KisLayerStyleFilterProjectionPlane(*plane, sourceLayer, m_d->style));
    }
 
    m_d->strokeStyle.reset(new KisStrokeLayerStyleFilterProjectionPlane(*rhs.m_d->strokeStyle, sourceLayer, m_d->style));
}

References KIS_SAFE_ASSERT_RECOVER, m_d, sourceLayer, and toQShared().

◆ ~KisLayerStyleProjectionPlane()

KisLayerStyleProjectionPlane::~KisLayerStyleProjectionPlane ( )

override

Definition at line 211 of file kis_layer_style_projection_plane.cpp.

212{

213}

◆ KisLayerStyleProjectionPlane() [3/3]

KisLayerStyleProjectionPlane::KisLayerStyleProjectionPlane	(	KisLayer *	sourceLayer,
		KisPSDLayerStyleSP	style )

private

Definition at line 128 of file kis_layer_style_projection_plane.cpp.

    : m_d(new Private)
{
    init(sourceLayer, layerStyle);
}

References init(), and sourceLayer.

Member Function Documentation

◆ accessRect()

QRect KisLayerStyleProjectionPlane::accessRect	(	const QRect &	rect,
		KisLayer::PositionToFilthy	pos ) const

overridevirtual

Works like KisNode::needRect(), but includes more transformations of the layer

Implements KisAbstractProjectionPlane.

Definition at line 388 of file kis_layer_style_projection_plane.cpp.

{
    KisAbstractProjectionPlaneSP sourcePlane = m_d->sourceProjectionPlane.toStrongRef();
    QRect accessRect = sourcePlane->accessRect(rect, pos);
 
    if (m_d->style->isEnabled()) {
        Q_FOREACH (const KisAbstractProjectionPlaneSP plane, m_d->allStyles()) {
            accessRect |= plane->accessRect(rect, KisLayer::N_ABOVE_FILTHY);
        }
    }
 
    return accessRect;
}

References accessRect(), m_d, and KisNode::N_ABOVE_FILTHY.

◆ allStyles()

QVector< KisLayerStyleFilterProjectionPlaneSP > KisLayerStyleProjectionPlane::allStyles ( ) const

inline

Definition at line 53 of file kis_layer_style_projection_plane.cpp.

                                                                    {
        QVector<KisLayerStyleFilterProjectionPlaneSP> result;
        result << stylesBefore;
        result << stylesOverlay;
        result << strokeStyle;
        result << stylesAfter;
        return result;
    }

◆ apply()

void KisLayerStyleProjectionPlane::apply	(	KisPainter *	painter,
		const QRect &	rect )

overridevirtual

Writes the data of the projection plane onto a global projection using painter object.

Implements KisAbstractProjectionPlane.

Definition at line 260 of file kis_layer_style_projection_plane.cpp.

{
    KisLayerProjectionPlaneSP sourcePlane = m_d->sourceProjectionPlane.toStrongRef();
 
    if (m_d->style->isEnabled()) {
        if (m_d->hasOverlayStyles() || m_d->hasKnockoutStyles()) {
            KisCachedPaintDevice::Guard d1(painter->device(), m_d->cachedPaintDevice);
            KisPaintDeviceSP originalClone = d1.device();
            originalClone->makeCloneFromRough(painter->device(), rect);
 
            Q_FOREACH (const KisLayerStyleFilterProjectionPlaneSP plane, m_d->stylesBefore) {
                m_d->applyComplexPlane(painter, plane, rect, originalClone);
            }
 
            KritaUtils::ThresholdMode sourceThresholdMode =
                !m_d->strokeStyle->isEmpty() ?
                m_d->strokeStyle->sourcePlaneOpacityThresholdRequirement() :
                KritaUtils::ThresholdNone;
 
            if (m_d->hasOverlayStyles()) {
                KisCachedSelection::Guard s1(m_d->cachedSelection);
                KisSelectionSP knockoutSelection = s1.selection();
                KisLsUtils::selectionFromAlphaChannel(m_d->sourceLayer->projection(), knockoutSelection, rect);
 
                KisCachedPaintDevice::Guard d2(painter->device(), m_d->cachedPaintDevice);
                KisPaintDeviceSP sourceProjection = d2.device();
                sourceProjection->makeCloneFromRough(painter->device(), rect);
 
                {
                    KisPainter overlayPainter(sourceProjection);
                    sourcePlane->applyMaxOutAlpha(&overlayPainter, rect, KritaUtils::ThresholdMaxOut);
 
                    Q_FOREACH (const KisAbstractProjectionPlaneSP plane, m_d->stylesOverlay) {
                        plane->apply(&overlayPainter, rect);
                    }
                }
 
                KritaUtils::thresholdOpacityAlpha8(knockoutSelection->pixelSelection(), rect, sourceThresholdMode);
 
                KisLayerStyleKnockoutBlower blower;
                blower.setKnockoutSelection(knockoutSelection);
                blower.apply(painter, sourceProjection, rect);
 
                blower.resetKnockoutSelection();
            } else {
                sourcePlane->applyMaxOutAlpha(painter, rect, sourceThresholdMode);
            }
 
            if (!m_d->strokeStyle->isEmpty()) {
                m_d->applyComplexPlane(painter, m_d->strokeStyle, rect, originalClone);
            }
 
            Q_FOREACH (KisLayerStyleFilterProjectionPlaneSP plane, m_d->stylesAfter) {
                m_d->applyComplexPlane(painter, plane, rect, originalClone);
            }
        } else {
            Q_FOREACH (const KisAbstractProjectionPlaneSP plane, m_d->stylesBefore) {
                plane->apply(painter, rect);
            }
 
            sourcePlane->apply(painter, rect);
 
            Q_FOREACH (const KisAbstractProjectionPlaneSP plane, m_d->stylesAfter) {
                plane->apply(painter, rect);
            }
        }
    } else {
        sourcePlane->apply(painter, rect);
    }
}

References KisLayerStyleKnockoutBlower::apply(), KisCachedPaintDevice::Guard::device(), KisPainter::device, m_d, KisPaintDevice::makeCloneFromRough(), KisSelection::pixelSelection, KisLayerStyleKnockoutBlower::resetKnockoutSelection(), s1, KisLsUtils::selectionFromAlphaChannel(), KisLayerStyleKnockoutBlower::setKnockoutSelection(), KisPainter::strokeStyle, KritaUtils::ThresholdMaxOut, KritaUtils::ThresholdNone, and KritaUtils::thresholdOpacityAlpha8().

◆ applyComplexPlane()

void KisLayerStyleProjectionPlane::applyComplexPlane	(	KisPainter *	painter,
		KisLayerStyleFilterProjectionPlaneSP	plane,
		const QRect &	rect,
		KisPaintDeviceSP	originalClone )

◆ changeRect()

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

overridevirtual

Works like KisNode::changeRect(), but includes more transformations of the layer

Implements KisAbstractProjectionPlane.

Definition at line 373 of file kis_layer_style_projection_plane.cpp.

{
    KisAbstractProjectionPlaneSP sourcePlane = m_d->sourceProjectionPlane.toStrongRef();
    QRect layerChangeRect = sourcePlane->changeRect(rect, pos);
    QRect changeRect = layerChangeRect;
 
    if (m_d->style->isEnabled() && !layerChangeRect.isEmpty()) {
        Q_FOREACH (const KisAbstractProjectionPlaneSP plane, m_d->allStyles()) {
            changeRect |= plane->changeRect(layerChangeRect, KisLayer::N_ABOVE_FILTHY);
        }
    }
 
    return changeRect;
}

References changeRect(), m_d, and KisNode::N_ABOVE_FILTHY.

◆ factoryObject()

KisAbstractProjectionPlaneSP KisLayerStyleProjectionPlane::factoryObject ( KisLayer * sourceLayer )

static

Definition at line 215 of file kis_layer_style_projection_plane.cpp.

{
    Q_ASSERT(sourceLayer);
    return toQShared(new KisLayerStyleProjectionPlane(sourceLayer));
}

References KisLayerStyleProjectionPlane(), sourceLayer, and toQShared().

◆ getLodCapableDevices()

KisPaintDeviceList KisLayerStyleProjectionPlane::getLodCapableDevices ( ) const

overridevirtual

Returns a list of devices which should synchronize the lod cache on update

Implements KisAbstractProjectionPlane.

Definition at line 331 of file kis_layer_style_projection_plane.cpp.

{
    KisPaintDeviceList list;
    KisAbstractProjectionPlaneSP sourcePlane = m_d->sourceProjectionPlane.toStrongRef();
 
    if (m_d->style->isEnabled()) {
        Q_FOREACH (const KisAbstractProjectionPlaneSP plane, m_d->allStyles()) {
            list << plane->getLodCapableDevices();
        }
 
        list << sourcePlane->getLodCapableDevices();
    } else {
        list << sourcePlane->getLodCapableDevices();
    }
 
    return list;
}

References m_d.

◆ hasKnockoutStyles()

bool KisLayerStyleProjectionPlane::hasKnockoutStyles ( ) const

inline

Definition at line 70 of file kis_layer_style_projection_plane.cpp.

                                   {
        Q_FOREACH (KisLayerStyleFilterProjectionPlaneSP plane, stylesBefore) {
            if (!plane->knockoutBlower()->isEmpty()) return true;
        }
 
        Q_FOREACH (KisLayerStyleFilterProjectionPlaneSP plane, stylesAfter) {
            if (!plane->knockoutBlower()->isEmpty()) return true;
        }
 
        if (!strokeStyle->knockoutBlower()->isEmpty()) return true;
 
        return false;
    }

◆ hasOverlayStyles()

bool KisLayerStyleProjectionPlane::hasOverlayStyles ( ) const

inline

Definition at line 62 of file kis_layer_style_projection_plane.cpp.

                                  {
        Q_FOREACH (KisLayerStyleFilterProjectionPlaneSP plane, stylesOverlay) {
            if (!plane->isEmpty()) return true;
        }
 
        return false;
    }

◆ init()

void KisLayerStyleProjectionPlane::init	(	KisLayer *	sourceLayer,
		KisPSDLayerStyleSP	layerStyle )

private

Definition at line 134 of file kis_layer_style_projection_plane.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(sourceLayer);
    m_d->initSourcePlane(sourceLayer);
    m_d->style = style;
 
    {
        KisLayerStyleFilterProjectionPlane *dropShadow =
            new KisLayerStyleFilterProjectionPlane(sourceLayer);
        dropShadow->setStyle(new KisLsDropShadowFilter(KisLsDropShadowFilter::DropShadow), style);
        m_d->stylesBefore << toQShared(dropShadow);
    }
 
    {
        KisLayerStyleFilterProjectionPlane *outerGlow =
            new KisLayerStyleFilterProjectionPlane(sourceLayer);
        outerGlow->setStyle(new KisLsDropShadowFilter(KisLsDropShadowFilter::OuterGlow), style);
        m_d->stylesAfter << toQShared(outerGlow);
    }
 
    {
        KisStrokeLayerStyleFilterProjectionPlane *stroke =
            new KisStrokeLayerStyleFilterProjectionPlane(sourceLayer);
        stroke->setStyle(new KisLsStrokeFilter(), style);
        m_d->strokeStyle.reset(stroke);
    }
 
    {
        KisLayerStyleFilterProjectionPlane *bevelEmboss =
            new KisLayerStyleFilterProjectionPlane(sourceLayer);
        bevelEmboss->setStyle(new KisLsBevelEmbossFilter(), style);
        m_d->stylesAfter << toQShared(bevelEmboss);
    }
 
    {
        KisLayerStyleFilterProjectionPlane *patternOverlay =
            new KisLayerStyleFilterProjectionPlane(sourceLayer);
        patternOverlay->setStyle(new KisLsOverlayFilter(KisLsOverlayFilter::Pattern), style);
        m_d->stylesOverlay << toQShared(patternOverlay);
    }
 
    {
        KisLayerStyleFilterProjectionPlane *gradientOverlay =
            new KisLayerStyleFilterProjectionPlane(sourceLayer);
        gradientOverlay->setStyle(new KisLsOverlayFilter(KisLsOverlayFilter::Gradient), style);
        m_d->stylesOverlay << toQShared(gradientOverlay);
    }
 
    {
        KisLayerStyleFilterProjectionPlane *colorOverlay =
            new KisLayerStyleFilterProjectionPlane(sourceLayer);
        colorOverlay->setStyle(new KisLsOverlayFilter(KisLsOverlayFilter::Color), style);
        m_d->stylesOverlay << toQShared(colorOverlay);
    }
 
    {
        KisLayerStyleFilterProjectionPlane *satin =
            new KisLayerStyleFilterProjectionPlane(sourceLayer);
        satin->setStyle(new KisLsSatinFilter(), style);
        m_d->stylesOverlay << toQShared(satin);
    }
 
    {
        KisLayerStyleFilterProjectionPlane *innerGlow =
            new KisLayerStyleFilterProjectionPlane(sourceLayer);
        innerGlow->setStyle(new KisLsDropShadowFilter(KisLsDropShadowFilter::InnerGlow), style);
        m_d->stylesOverlay << toQShared(innerGlow);
    }
 
    {
        KisLayerStyleFilterProjectionPlane *innerShadow =
            new KisLayerStyleFilterProjectionPlane(sourceLayer);
        innerShadow->setStyle(new KisLsDropShadowFilter(KisLsDropShadowFilter::InnerShadow), style);
        m_d->stylesOverlay << toQShared(innerShadow);
    }
}

References KisLsOverlayFilter::Color, KisLsDropShadowFilter::DropShadow, KisLsOverlayFilter::Gradient, KisLsDropShadowFilter::InnerGlow, KisLsDropShadowFilter::InnerShadow, KIS_SAFE_ASSERT_RECOVER_RETURN, m_d, KisLsDropShadowFilter::OuterGlow, KisLsOverlayFilter::Pattern, KisLayerStyleFilterProjectionPlane::setStyle(), sourceLayer, style, and toQShared().

◆ initSourcePlane()

void KisLayerStyleProjectionPlane::initSourcePlane ( KisLayer * sourceLayer )

inline

Definition at line 45 of file kis_layer_style_projection_plane.cpp.

                                                {
        KIS_SAFE_ASSERT_RECOVER_RETURN(sourceLayer);
        sourceProjectionPlane = sourceLayer->internalProjectionPlane();
        canHaveChildNodes = sourceLayer->projectionLeaf()->canHaveChildLayers();
        dependsOnLowerNodes = sourceLayer->projectionLeaf()->dependsOnLowerNodes();
        this->sourceLayer = sourceLayer;
    }

References KisLayer::internalProjectionPlane(), KIS_SAFE_ASSERT_RECOVER_RETURN, and KisNode::projectionLeaf.

◆ looseUserVisibleBounds()

QRect KisLayerStyleProjectionPlane::looseUserVisibleBounds ( ) const

overridevirtual

Return an approximate (loose) rectangle, where the contents of the plane is placed from user's point of view. It includes everything belonging to the plane (e.g. layer styles).

This rectangle contains or is bigger than the rectangle returned by tightUserVisibleBounds().

Implements KisAbstractProjectionPlane.

Definition at line 435 of file kis_layer_style_projection_plane.cpp.

{
    KisAbstractProjectionPlaneSP sourcePlane = m_d->sourceProjectionPlane.toStrongRef();
    QRect rect = sourcePlane->looseUserVisibleBounds();
 
    Q_FOREACH (const KisAbstractProjectionPlaneSP plane, m_d->allStyles()) {
        rect |= plane->looseUserVisibleBounds();
    }
 
    return rect;
}

References m_d.

◆ needRect()

QRect KisLayerStyleProjectionPlane::needRect	(	const QRect &	rect,
		KisLayer::PositionToFilthy	pos ) const

overridevirtual

Works like KisNode::needRect(), but includes more transformations of the layer

Need rect should also be adjust for the layers that generate their 'original' based on the contents of the underlying layers like KisAdjustmentLayer

See also: bug 390299

Implements KisAbstractProjectionPlane.

Definition at line 349 of file kis_layer_style_projection_plane.cpp.

{
    QRect needRect = rect;
 
    const bool adjustmentAboveDirty = m_d->dependsOnLowerNodes &&
        (pos & KisLayer::N_FILTHY || pos & KisLayer::N_ABOVE_FILTHY);
 
    if (m_d->style->isEnabled() && adjustmentAboveDirty) {
        needRect |= stylesNeedRect(rect);
    }
 
    KisAbstractProjectionPlaneSP sourcePlane = m_d->sourceProjectionPlane.toStrongRef();
    needRect = sourcePlane->needRect(needRect, pos);
 
    return needRect;
}

References m_d, KisNode::N_ABOVE_FILTHY, KisNode::N_FILTHY, needRect(), and stylesNeedRect().

◆ needRectForOriginal()

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

overridevirtual

Works like KisLayer::needRectForOriginal(), but includes needed rects of layer styles

Need rect should also be adjust for the layers that generate their 'original' based on the contents of the child layers like KisGroupLayer

See also: bug 366419

Implements KisAbstractProjectionPlane.

Definition at line 402 of file kis_layer_style_projection_plane.cpp.

{
    QRect needRect = rect;
 
    if (m_d->style->isEnabled()) {
        needRect |= stylesNeedRect(needRect);
    }
 
    KisAbstractProjectionPlaneSP sourcePlane = m_d->sourceProjectionPlane.toStrongRef();
    needRect = sourcePlane->needRectForOriginal(needRect);
 
    return needRect;
}

References m_d, needRect(), and stylesNeedRect().

◆ recalculate()

QRect KisLayerStyleProjectionPlane::recalculate	(	const QRect &	rect,
		KisNodeSP	filthyNode,
		KisRenderPassFlags	flags )

overridevirtual

Is called by the async merger when the node is filthy and should recalculate its internal representation. For usual layers it means just calling updateProjection().

Implements KisAbstractProjectionPlane.

Definition at line 221 of file kis_layer_style_projection_plane.cpp.

{
    KisAbstractProjectionPlaneSP sourcePlane = m_d->sourceProjectionPlane.toStrongRef();
    QRect result = rect;
 
    if (m_d->style->isEnabled()) {
        result = sourcePlane->recalculate(stylesNeedRect(rect), filthyNode, flags);
 
        Q_FOREACH (const KisAbstractProjectionPlaneSP plane, m_d->allStyles()) {
            plane->recalculate(rect, filthyNode, flags);
        }
    } else {
        result = sourcePlane->recalculate(rect, filthyNode, flags);
    }
 
    return result;
}

References m_d, and stylesNeedRect().

◆ stylesNeedRect()

QRect KisLayerStyleProjectionPlane::stylesNeedRect ( const QRect & rect ) const

private

Definition at line 447 of file kis_layer_style_projection_plane.cpp.

{
    QRect needRect = rect;
 
    Q_FOREACH (const KisAbstractProjectionPlaneSP plane, m_d->allStyles()) {
        needRect |= plane->needRect(rect, KisLayer::N_ABOVE_FILTHY);
    }
 
    return needRect;
}

References m_d, KisNode::N_ABOVE_FILTHY, and needRect().

◆ tightUserVisibleBounds()

QRect KisLayerStyleProjectionPlane::tightUserVisibleBounds ( ) const

overridevirtual

Return a tight rectangle, where the contents of the plane is placed from user's point of view. It includes everything belonging to the plane (e.g. layer styles).

Implements KisAbstractProjectionPlane.

Definition at line 423 of file kis_layer_style_projection_plane.cpp.

{
    KisAbstractProjectionPlaneSP sourcePlane = m_d->sourceProjectionPlane.toStrongRef();
    QRect rect = sourcePlane->tightUserVisibleBounds();
 
    Q_FOREACH (const KisAbstractProjectionPlaneSP plane, m_d->allStyles()) {
        rect |= plane->tightUserVisibleBounds();
    }
 
    return rect;
}