#include <kis_shape_layer_canvas.h>

Inheritance diagram for KisShapeLayerCanvas:

Public Member Functions
void	forceRepaint () override

void	forceRepaintWithHiddenAreas () override

bool	hasPendingUpdates () const override

	KisShapeLayerCanvas (const KisShapeLayerCanvas &rhs, KisShapeLayer *parent)

	KisShapeLayerCanvas (const KoColorSpace cs, KisDefaultBoundsBaseSP defaultBounds, KisShapeLayer parent)

KisPaintDeviceSP	projection () const override

void	rerenderAfterBeingInvisible () override

void	resetCache (const KoColorSpace *colorSpace=0) override

void	setImage (KisImageWSP image) override

void	setProjection (KisPaintDeviceSP projection)
	This canvas won't render onto a widget, but a projection.

void	updateCanvas (const QRectF &rc) override

void	updateCanvas (const QVector< QRectF > &region)

	~KisShapeLayerCanvas () override

Public Member Functions inherited from KisShapeLayerCanvasBase
void	addCommand (KUndo2Command *command) override

const QWidget *	canvasWidget () const override

QWidget *	canvasWidget () override

void	gridSize (QPointF offset, QSizeF spacing) const override

bool	hasChangedWhileBeingInvisible ()

	KisShapeLayerCanvasBase (const KisShapeLayerCanvasBase &rhs, KisShapeLayer *parent)

	KisShapeLayerCanvasBase (KisShapeLayer *parent)

void	prepareForDestroying ()

KoSelectedShapesProxy *	selectedShapesProxy () const override
	selectedShapesProxy() is a special interface for keeping a persistent connections to selectionChanged() and selectionContentChanged() signals. While shapeManager() can change throughout the life time of the canvas, selectedShapesProxy() is guaranteed to stay the same.

void	setCursor (const QCursor &) override

KoShapeManager *	shapeManager () const override

bool	snapToGrid () const override

KoToolProxy *	toolProxy () const override

KoUnit	unit () const override

const KoViewConverter *	viewConverter () const override

KoViewConverter *	viewConverter () override

Public Member Functions inherited from KoCanvasBase
KoCanvasController *	canvasController () const

virtual bool	canvasIsOpenGL () const

virtual void	clipToDocument (const KoShape *shape, QPointF &move) const

virtual void	disconnectCanvasObserver (QObject *object)

virtual QPoint	documentOrigin () const

	KoCanvasBase (KoShapeControllerBase shapeController, KoCanvasResourceProvider sharedResourceManager=0)

	Private ()

KoCanvasResourceProvider *	resourceManager () const

void	setCanvasController (KoCanvasController *controller)
	called by KoCanvasController to set the controller that handles this canvas.

KoShapeController *	shapeController () const

KoSnapGuide *	snapGuide () const

virtual QPointF	viewToDocument (const QPointF &viewPoint) const

	~KoCanvasBase () override

	~Private ()

Private Member Functions
void	repaint ()

void	slotImageSizeChanged ()

void	slotStartAsyncRepaint ()

Private Attributes
KisThreadSafeSignalCompressor	m_asyncUpdateSignalCompressor

QRect	m_cachedImageRect

QRegion	m_dirtyRegion

QMutex	m_dirtyRegionMutex

bool	m_forceUpdateHiddenAreasOnly = false

volatile bool	m_hasUpdateInCompressor = false

bool	m_hasUpdateOnSetImage = false

KisImageWSP	m_image

KisSignalAutoConnectionsStore	m_imageConnections

KoShapeManager::PaintJobsOrder	m_paintJobsOrder

KisShapeLayer *	m_parentLayer {0}

KisPaintDeviceSP	m_projection

KisSafeBlockingQueueConnectionProxy< void >	m_safeForcedConnection

Friends
class	KisRepaintShapeLayerLayerJob

Additional Inherited Members
Public Attributes inherited from KoCanvasBase
KoCanvasController *	controller

bool	isResourceManagerShared

QPointer< KoCanvasResourceProvider >	resourceManager

QPointer< KoShapeController >	shapeController

KoSnapGuide *	snapGuide

Protected Attributes inherited from KisShapeLayerCanvasBase
bool	m_hasChangedWhileBeingInvisible {false}

bool	m_isDestroying {false}

QScopedPointer< KoSelectedShapesProxy >	m_selectedShapesProxy

QScopedPointer< KoShapeManager >	m_shapeManager

KisImageViewConverter	m_viewConverter

Detailed Description

KisShapeLayerCanvas is a special canvas implementation that Krita uses for non-krita shapes to request updates on.

Do NOT give this canvas to tools or to the KoCanvasController, it's not made for that.

Definition at line 82 of file kis_shape_layer_canvas.h.

Constructor & Destructor Documentation

◆ KisShapeLayerCanvas() [1/2]

KisShapeLayerCanvas::KisShapeLayerCanvas	(	const KoColorSpace *	cs,
		KisDefaultBoundsBaseSP	defaultBounds,
		KisShapeLayer *	parent )

The layer should also add itself to its own shape manager, so that the canvas would track its changes/transformations

Definition at line 136 of file kis_shape_layer_canvas.cpp.

        : KisShapeLayerCanvasBase(parent)
        , m_projection(new KisPaintDevice(parent, cs, defaultBounds))
        , m_parentLayer(parent)
        , m_asyncUpdateSignalCompressor(25, KisSignalCompressor::FIRST_ACTIVE)
        , m_safeForcedConnection(std::bind(&KisShapeLayerCanvas::slotStartAsyncRepaint, this))
{
    m_shapeManager->addShape(parent, KoShapeManager::AddWithoutRepaint);
    m_shapeManager->selection()->setActiveLayer(parent);
 
    connect(&m_asyncUpdateSignalCompressor, SIGNAL(timeout()), SLOT(slotStartAsyncRepaint()));
}

References KoShapeManager::AddWithoutRepaint, connect(), m_asyncUpdateSignalCompressor, KisShapeLayerCanvasBase::m_shapeManager, and slotStartAsyncRepaint().

◆ KisShapeLayerCanvas() [2/2]

KisShapeLayerCanvas::KisShapeLayerCanvas	(	const KisShapeLayerCanvas &	rhs,
		KisShapeLayer *	parent )

The layer should also add itself to its own shape manager, so that the canvas would track its changes/transformations

Definition at line 153 of file kis_shape_layer_canvas.cpp.

        : KisShapeLayerCanvasBase(rhs, parent)
        , m_projection(new KisPaintDevice(*rhs.m_projection))
        , m_parentLayer(parent)
        , m_asyncUpdateSignalCompressor(25, KisSignalCompressor::FIRST_ACTIVE)
        , m_safeForcedConnection(std::bind(&KisShapeLayerCanvas::slotStartAsyncRepaint, this))
{
    m_shapeManager->addShape(parent, KoShapeManager::AddWithoutRepaint);
    m_shapeManager->selection()->setActiveLayer(parent);
 
    connect(&m_asyncUpdateSignalCompressor, SIGNAL(timeout()), SLOT(slotStartAsyncRepaint()));
    m_projection->setParentNode(parent);
}

References KoShapeManager::AddWithoutRepaint, connect(), m_asyncUpdateSignalCompressor, m_projection, KisShapeLayerCanvasBase::m_shapeManager, KisPaintDevice::setParentNode(), and slotStartAsyncRepaint().

◆ ~KisShapeLayerCanvas()

KisShapeLayerCanvas::~KisShapeLayerCanvas ( )

override

Definition at line 171 of file kis_shape_layer_canvas.cpp.

{
    m_shapeManager->remove(m_parentLayer);
}

References m_parentLayer, and KisShapeLayerCanvasBase::m_shapeManager.

Member Function Documentation

◆ forceRepaint()

void KisShapeLayerCanvas::forceRepaint ( )

overridevirtual

WARNING! Although forceRepaint() may be called from different threads, it is not entirely safe. If the user plays with shapes at the same time (vector tools are not ported to strokes yet), the shapes my be accessed from two different places at the same time, which will cause a crash.

The only real solution to this is to port vector tools to strokes framework.

Implements KisShapeLayerCanvasBase.

Definition at line 498 of file kis_shape_layer_canvas.cpp.

{
    if (hasPendingUpdates()) {
        m_asyncUpdateSignalCompressor.stop();
        m_safeForcedConnection.start();
    }
}

References hasPendingUpdates(), m_asyncUpdateSignalCompressor, m_safeForcedConnection, KisSafeBlockingQueueConnectionProxy< void >::start(), and KisThreadSafeSignalCompressor::stop().

◆ forceRepaintWithHiddenAreas()

void KisShapeLayerCanvas::forceRepaintWithHiddenAreas ( )

overridevirtual

Reimplemented from KisShapeLayerCanvasBase.

Definition at line 520 of file kis_shape_layer_canvas.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_image);
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_parentLayer->image());
    KIS_SAFE_ASSERT_RECOVER_RETURN(!m_isDestroying);
 
    {
        QMutexLocker locker(&m_dirtyRegionMutex);
        m_forceUpdateHiddenAreasOnly = true;
    }
 
    m_asyncUpdateSignalCompressor.stop();
    m_safeForcedConnection.start();
}

References KisBaseNode::image, KIS_SAFE_ASSERT_RECOVER_RETURN, m_asyncUpdateSignalCompressor, m_dirtyRegionMutex, m_forceUpdateHiddenAreasOnly, m_image, KisShapeLayerCanvasBase::m_isDestroying, m_parentLayer, m_safeForcedConnection, KisSafeBlockingQueueConnectionProxy< void >::start(), and KisThreadSafeSignalCompressor::stop().

◆ hasPendingUpdates()

bool KisShapeLayerCanvas::hasPendingUpdates ( ) const

overridevirtual

Implements KisShapeLayerCanvasBase.

Definition at line 515 of file kis_shape_layer_canvas.cpp.

{
    return m_hasUpdateInCompressor;
}

References m_hasUpdateInCompressor.

◆ projection()

KisPaintDeviceSP KisShapeLayerCanvas::projection ( ) const

overridevirtual

Implements KisShapeLayerCanvasBase.

Definition at line 181 of file kis_shape_layer_canvas.cpp.

{
    return m_projection;
}

References m_projection.

◆ repaint()

void KisShapeLayerCanvas::repaint ( )

private

Sometimes two update jobs might not override and the second one will arrive right after the first one

Definition at line 402 of file kis_shape_layer_canvas.cpp.

{
 
    KoShapeManager::PaintJobsOrder paintJobsOrder;
 
    {
        QMutexLocker locker(&m_dirtyRegionMutex);
        std::swap(paintJobsOrder, m_paintJobsOrder);
    }
 
    if (paintJobsOrder.isEmpty()) return;
 
    const qint32 MASK_IMAGE_WIDTH = 256;
    const qint32 MASK_IMAGE_HEIGHT = 256;
 
    QImage image(MASK_IMAGE_WIDTH, MASK_IMAGE_HEIGHT, QImage::Format_ARGB32);
    QPainter tempPainter(&image);
 
    if(m_parentLayer->antialiased()) {
        tempPainter.setRenderHint(QPainter::Antialiasing);
        tempPainter.setRenderHint(QPainter::TextAntialiasing);
    }
 
    quint8 * dstData = new quint8[MASK_IMAGE_WIDTH * MASK_IMAGE_HEIGHT * m_projection->pixelSize()];
 
    QRect repaintRect = paintJobsOrder.uncroppedViewUpdateRect;
    m_projection->clear(repaintRect);
 
    Q_FOREACH (const KoShapeManager::PaintJob &job, paintJobsOrder.jobs) {
        if (job.isEmpty()) {
            m_projection->clear(job.viewUpdateRect);
            continue;
        }
 
        KIS_SAFE_ASSERT_RECOVER(job.viewUpdateRect.width() <= MASK_IMAGE_WIDTH &&
                                job.viewUpdateRect.height() <= MASK_IMAGE_HEIGHT) {
            continue;
        }
 
        image.fill(0);
 
        tempPainter.setTransform(QTransform());
        tempPainter.setClipRect(QRect(0,0,job.viewUpdateRect.width(), job.viewUpdateRect.height()));
        tempPainter.setTransform(viewConverter()->documentToView() *
                                 QTransform::fromTranslate(-job.viewUpdateRect.x(), -job.viewUpdateRect.y()));
 
        m_shapeManager->paintJob(tempPainter, job);
 
        if (image.size() != job.viewUpdateRect.size()) {
            const quint8 *imagePtr = image.constBits();
            const int imageRowStride = 4 * image.width();
 
            for (int y = 0; y < job.viewUpdateRect.height(); y++) {
 
                KoColorSpaceRegistry::instance()->rgb8()
                        ->convertPixelsTo(imagePtr, dstData, m_projection->colorSpace(),
                                          job.viewUpdateRect.width(),
                                          KoColorConversionTransformation::internalRenderingIntent(),
                                          KoColorConversionTransformation::internalConversionFlags());
 
                m_projection->writeBytes(dstData,
                                         job.viewUpdateRect.x(),
                                         job.viewUpdateRect.y() + y,
                                         job.viewUpdateRect.width(),
                                         1);
 
                imagePtr += imageRowStride;
            }
        } else {
            KoColorSpaceRegistry::instance()->rgb8()
                    ->convertPixelsTo(image.constBits(), dstData, m_projection->colorSpace(),
                                      MASK_IMAGE_WIDTH * MASK_IMAGE_HEIGHT,
                                      KoColorConversionTransformation::internalRenderingIntent(),
                                      KoColorConversionTransformation::internalConversionFlags());
 
            m_projection->writeBytes(dstData,
                                     job.viewUpdateRect.x(),
                                     job.viewUpdateRect.y(),
                                     MASK_IMAGE_WIDTH,
                                     MASK_IMAGE_HEIGHT);
 
        }
        repaintRect |= job.viewUpdateRect;
    }
 
    delete[] dstData;
    m_projection->purgeDefaultPixels();
    m_parentLayer->setDirty(repaintRect);
 
    m_hasChangedWhileBeingInvisible |= !m_parentLayer->visible(true);
}

References KisShapeLayer::antialiased(), KisPaintDevice::clear(), KisPaintDevice::colorSpace(), KoColorSpace::convertPixelsTo(), KoColorSpaceRegistry::instance(), KoColorConversionTransformation::internalConversionFlags(), KoColorConversionTransformation::internalRenderingIntent(), KoShapeManager::PaintJob::isEmpty(), KoShapeManager::PaintJobsOrder::isEmpty(), KoShapeManager::PaintJobsOrder::jobs, KIS_SAFE_ASSERT_RECOVER, m_dirtyRegionMutex, KisShapeLayerCanvasBase::m_hasChangedWhileBeingInvisible, m_paintJobsOrder, m_parentLayer, m_projection, KisShapeLayerCanvasBase::m_shapeManager, KisPaintDevice::pixelSize(), KisPaintDevice::purgeDefaultPixels(), KoColorSpaceRegistry::rgb8(), KisNode::setDirty(), KoShapeManager::PaintJobsOrder::uncroppedViewUpdateRect, KisShapeLayerCanvasBase::viewConverter(), KoShapeManager::PaintJob::viewUpdateRect, KisShapeLayer::visible(), and KisPaintDevice::writeBytes().

◆ rerenderAfterBeingInvisible()

void KisShapeLayerCanvas::rerenderAfterBeingInvisible ( )

overridevirtual

Implements KisShapeLayerCanvasBase.

Definition at line 546 of file kis_shape_layer_canvas.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_parentLayer->visible(true));
 
    m_hasChangedWhileBeingInvisible = false;
    resetCache();
}

References KIS_SAFE_ASSERT_RECOVER_RETURN, KisShapeLayerCanvasBase::m_hasChangedWhileBeingInvisible, m_parentLayer, resetCache(), and KisShapeLayer::visible().

◆ resetCache()

void KisShapeLayerCanvas::resetCache ( const KoColorSpace * colorSpace = 0 )

overridevirtual

Implements KisShapeLayerCanvasBase.

Definition at line 535 of file kis_shape_layer_canvas.cpp.

{
    Q_UNUSED(colorSpace);
    m_projection->clear();
 
    QList<KoShape*> shapes = m_shapeManager->shapes();
    Q_FOREACH (const KoShape* shape, shapes) {
        shape->update();
    }
}

References KisPaintDevice::clear(), m_projection, KisShapeLayerCanvasBase::m_shapeManager, and KoShape::update().

◆ setImage()

void KisShapeLayerCanvas::setImage ( KisImageWSP image )

overridevirtual

Reimplemented from KisShapeLayerCanvasBase.

Definition at line 186 of file kis_shape_layer_canvas.cpp.

{
    m_imageConnections.clear();
 
    KisShapeLayerCanvasBase::setImage(image);
    m_image = image;
 
    if (image) {
        m_imageConnections.addUniqueConnection(m_image, SIGNAL(sigSizeChanged(QPointF,QPointF)), this, SLOT(slotImageSizeChanged()));
        m_cachedImageRect = m_image->bounds();
        m_projection->convertTo(image->colorSpace());
    }
    m_projection->setDefaultBounds(new KisDefaultBounds(image));
    if (image && m_hasUpdateOnSetImage) {
        m_hasUpdateOnSetImage = false;
        updateCanvas(m_cachedImageRect);
    }
}

References KisSignalAutoConnectionsStore::addUniqueConnection(), KisImage::bounds(), KisSignalAutoConnectionsStore::clear(), KisImage::colorSpace(), KisPaintDevice::convertTo(), m_cachedImageRect, m_hasUpdateOnSetImage, m_image, m_imageConnections, m_projection, KisPaintDevice::setDefaultBounds(), KisShapeLayerCanvasBase::setImage(), slotImageSizeChanged(), and updateCanvas().

◆ setProjection()

void KisShapeLayerCanvas::setProjection ( KisPaintDeviceSP projection )

This canvas won't render onto a widget, but a projection.

Definition at line 176 of file kis_shape_layer_canvas.cpp.

{
    m_projection = projection;
}

References m_projection, and projection().

◆ slotImageSizeChanged()

void KisShapeLayerCanvas::slotImageSizeChanged ( )

private

Definition at line 384 of file kis_shape_layer_canvas.cpp.

{
    QRegion dirtyCacheRegion;
    dirtyCacheRegion += m_image->bounds();
    dirtyCacheRegion += m_cachedImageRect;
    dirtyCacheRegion -= m_image->bounds() & m_cachedImageRect;
 
    QVector<QRectF> dirtyRects;
    auto rc = dirtyCacheRegion.begin();
    while (rc != dirtyCacheRegion.end()) {
        dirtyRects.append(viewConverter()->viewToDocument(*rc));
        rc++;
    }
    updateCanvas(dirtyRects);
 
    m_cachedImageRect = m_image->bounds();
}

References KisImage::bounds(), m_cachedImageRect, m_image, updateCanvas(), KisShapeLayerCanvasBase::viewConverter(), and KoCanvasBase::viewToDocument().

◆ slotStartAsyncRepaint()

void KisShapeLayerCanvas::slotStartAsyncRepaint ( )

private

Don't try to start a regeneration stroke while image is locked. It may happen on loading, when all necessary conversions are not yet finished.

Since we are going to override the previous jobs, we should fetch all the area covered by it. Otherwise we'll get dirty leftovers of the layer on the projection

Vector shapes are not thread-safe against concurrent read-writes, so we need to utilize rather complicated policy on accessing them:

1) All shape writes happen in GUI thread (right in the tools) 2) No concurrent reads from the shapes may happen in other threads while the user is modifying them.

That is why our shape rendering code is split into two parts:

1) First we just fetch a shallow copy of the shapes of the layer (it takes about 1ms for complicated vector layers) and pack them into KoShapeManager::PaintJobsList jobs. It happens here, in slotStartAsyncRepaint(), which runs in the GUI thread. It guarantees that no one is accessing the shapes during the copy operation.

2) The rendering itself happens in the worker thread in repaint(). But repaint() doesn't access original shapes anymore. It accesses only they shallow copies, which means that there is no concurrent access to anything (*).

(*) "no concurrent access to anything" is a rather fragile term :) There will still be concurrent access to it, on detaching... But(!), when detaching, the original data is kept unchanged, so "it should be safe enough"(c). Especially if we guarantee that rendering thread may not cause a detach (?), and the detach can happen only from a single GUI thread.

Definition at line 275 of file kis_shape_layer_canvas.cpp.

{
    KisImageSP image = m_image;
    if (!image || !m_parentLayer->image()) {
        return;
    }
 
    if (image->locked()) {
        m_asyncUpdateSignalCompressor.start();
        return;
    }
 
    QRect repaintRect;
    QRect uncroppedRepaintRect;
    bool forceUpdateHiddenAreasOnly = false;
    const qint32 MASK_IMAGE_WIDTH = 256;
    const qint32 MASK_IMAGE_HEIGHT = 256;
    {
        QMutexLocker locker(&m_dirtyRegionMutex);
 
        repaintRect = m_dirtyRegion.boundingRect();
        forceUpdateHiddenAreasOnly = m_forceUpdateHiddenAreasOnly;
 
        Q_FOREACH (const KoShapeManager::PaintJob &job, m_paintJobsOrder.jobs) {
            repaintRect |= viewConverter()->documentToView().mapRect(job.docUpdateRect).toAlignedRect();
        }
        m_paintJobsOrder.clear();
 
        m_dirtyRegion = QRegion();
        m_forceUpdateHiddenAreasOnly = false;
    }
 
    if (!forceUpdateHiddenAreasOnly) {
        if (repaintRect.isEmpty()) {
            return;
        }
 
        // Crop the update rect by the image bounds. We keep the cache consistent
        // by tracking the size of the image in slotImageSizeChanged()
        uncroppedRepaintRect = repaintRect;
        repaintRect = repaintRect.intersected(image->bounds());
    } else {
        const QRectF shapesBounds = KoShape::boundingRect(m_shapeManager->shapes());
        repaintRect |= kisGrowRect(viewConverter()->documentToView(shapesBounds).toAlignedRect(), 2);
        uncroppedRepaintRect = repaintRect;
    }
 
    const QVector<QRect> updateRects =
        KritaUtils::splitRectIntoPatchesTight(repaintRect,
                                              QSize(MASK_IMAGE_WIDTH, MASK_IMAGE_HEIGHT));
 
    KoShapeManager::PaintJobsOrder jobsOrder;
    Q_FOREACH (const QRect &viewUpdateRect, updateRects) {
        jobsOrder.jobs << KoShapeManager::PaintJob(viewConverter()->viewToDocument().mapRect(QRectF(viewUpdateRect)),
                                              viewUpdateRect);
    }
    jobsOrder.uncroppedViewUpdateRect = uncroppedRepaintRect;
 
    m_shapeManager->preparePaintJobs(jobsOrder, m_parentLayer);
 
    {
        QMutexLocker locker(&m_dirtyRegionMutex);
 
        // check if it is still empty! It should be true, because GUI thread is
        // the only actor that can add stuff to it.
        KIS_SAFE_ASSERT_RECOVER_NOOP(m_paintJobsOrder.isEmpty());
        m_paintJobsOrder = jobsOrder;
    }
 
    m_hasUpdateInCompressor = false;
    image->addSpontaneousJob(new KisRepaintShapeLayerLayerJob(m_parentLayer, this));
}

References KisImage::addSpontaneousJob(), KoShape::boundingRect(), KisImage::bounds(), KoShapeManager::PaintJobsOrder::clear(), KoViewConverter::documentToView(), KoShapeManager::PaintJob::docUpdateRect, KisBaseNode::image, KoShapeManager::PaintJobsOrder::isEmpty(), KoShapeManager::PaintJobsOrder::jobs, KIS_SAFE_ASSERT_RECOVER_NOOP, kisGrowRect(), KisRepaintShapeLayerLayerJob, KisImage::locked(), m_asyncUpdateSignalCompressor, m_dirtyRegion, m_dirtyRegionMutex, m_forceUpdateHiddenAreasOnly, m_hasUpdateInCompressor, m_image, m_paintJobsOrder, m_parentLayer, KisShapeLayerCanvasBase::m_shapeManager, KritaUtils::splitRectIntoPatchesTight(), KisThreadSafeSignalCompressor::start(), KoShapeManager::PaintJobsOrder::uncroppedViewUpdateRect, KisShapeLayerCanvasBase::viewConverter(), and KoCanvasBase::viewToDocument().

◆ updateCanvas() [1/2]

void KisShapeLayerCanvas::updateCanvas ( const QRectF & rc )

overridevirtual

Tell the canvas to repaint the specified rectangle. The coordinates are document coordinates, not view coordinates.

Implements KoCanvasBase.

Definition at line 270 of file kis_shape_layer_canvas.cpp.

{
    updateCanvas(QVector<QRectF>({rc}));
}

References updateCanvas().

◆ updateCanvas() [2/2]

void KisShapeLayerCanvas::updateCanvas ( const QVector< QRectF > & region )

Definition at line 246 of file kis_shape_layer_canvas.cpp.

{
    if (!m_image){
        m_hasUpdateOnSetImage = true;
        return;
    }
    if (!m_parentLayer->image() || m_isDestroying) {
        return;
    }
 
    {
        QMutexLocker locker(&m_dirtyRegionMutex);
        Q_FOREACH (const QRectF &rc, region) {
            // grow for antialiasing
            const QRect imageRect = kisGrowRect(viewConverter()->documentToView(rc).toAlignedRect(), 2);
            m_dirtyRegion += imageRect;
        }
    }
 
    m_asyncUpdateSignalCompressor.start();
    m_hasUpdateInCompressor = true;
}

References KisBaseNode::image, kisGrowRect(), m_asyncUpdateSignalCompressor, m_dirtyRegion, m_dirtyRegionMutex, m_hasUpdateInCompressor, m_hasUpdateOnSetImage, m_image, KisShapeLayerCanvasBase::m_isDestroying, m_parentLayer, KisThreadSafeSignalCompressor::start(), and KisShapeLayerCanvasBase::viewConverter().

Friends And Related Symbol Documentation

◆ KisRepaintShapeLayerLayerJob

friend class KisRepaintShapeLayerLayerJob

friend

Definition at line 108 of file kis_shape_layer_canvas.h.

Member Data Documentation

◆ m_asyncUpdateSignalCompressor

KisThreadSafeSignalCompressor KisShapeLayerCanvas::m_asyncUpdateSignalCompressor

private

Definition at line 117 of file kis_shape_layer_canvas.h.

◆ m_cachedImageRect

QRect KisShapeLayerCanvas::m_cachedImageRect

private

Definition at line 127 of file kis_shape_layer_canvas.h.

◆ m_dirtyRegion

QRegion KisShapeLayerCanvas::m_dirtyRegion

private

Definition at line 123 of file kis_shape_layer_canvas.h.

◆ m_dirtyRegionMutex

QMutex KisShapeLayerCanvas::m_dirtyRegionMutex

private

Definition at line 124 of file kis_shape_layer_canvas.h.

◆ m_forceUpdateHiddenAreasOnly

bool KisShapeLayerCanvas::m_forceUpdateHiddenAreasOnly = false

private

Definition at line 122 of file kis_shape_layer_canvas.h.

◆ m_hasUpdateInCompressor

volatile bool KisShapeLayerCanvas::m_hasUpdateInCompressor = false

private

Definition at line 118 of file kis_shape_layer_canvas.h.

◆ m_hasUpdateOnSetImage

bool KisShapeLayerCanvas::m_hasUpdateOnSetImage = false

private

Definition at line 119 of file kis_shape_layer_canvas.h.

◆ m_image

KisImageWSP KisShapeLayerCanvas::m_image

private

Definition at line 129 of file kis_shape_layer_canvas.h.

◆ m_imageConnections

KisSignalAutoConnectionsStore KisShapeLayerCanvas::m_imageConnections

private

Definition at line 130 of file kis_shape_layer_canvas.h.

◆ m_paintJobsOrder

KoShapeManager::PaintJobsOrder KisShapeLayerCanvas::m_paintJobsOrder

private

Definition at line 125 of file kis_shape_layer_canvas.h.

◆ m_parentLayer

KisShapeLayer* KisShapeLayerCanvas::m_parentLayer {0}

private

Definition at line 115 of file kis_shape_layer_canvas.h.

115{0};

◆ m_projection

KisPaintDeviceSP KisShapeLayerCanvas::m_projection

private

Definition at line 114 of file kis_shape_layer_canvas.h.

◆ m_safeForcedConnection

KisSafeBlockingQueueConnectionProxy<void> KisShapeLayerCanvas::m_safeForcedConnection

private

Definition at line 120 of file kis_shape_layer_canvas.h.

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

libs/ui/flake/kis_shape_layer_canvas.h
libs/ui/flake/kis_shape_layer_canvas.cpp

Public Member Functions

Private Member Functions

Private Attributes

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ KisShapeLayerCanvas() [1/2]

◆ KisShapeLayerCanvas() [2/2]

◆ ~KisShapeLayerCanvas()

Member Function Documentation

◆ forceRepaint()

◆ forceRepaintWithHiddenAreas()

◆ hasPendingUpdates()

◆ projection()

◆ repaint()

◆ rerenderAfterBeingInvisible()

◆ resetCache()

◆ setImage()

◆ setProjection()

◆ slotImageSizeChanged()

◆ slotStartAsyncRepaint()

◆ updateCanvas() [1/2]

◆ updateCanvas() [2/2]

Friends And Related Symbol Documentation

◆ KisRepaintShapeLayerLayerJob

Member Data Documentation

◆ m_asyncUpdateSignalCompressor

◆ m_cachedImageRect

◆ m_dirtyRegion

◆ m_dirtyRegionMutex

◆ m_forceUpdateHiddenAreasOnly

◆ m_hasUpdateInCompressor

◆ m_hasUpdateOnSetImage

◆ m_image

◆ m_imageConnections

◆ m_paintJobsOrder

◆ m_parentLayer

◆ m_projection

◆ m_safeForcedConnection