KisAsyncMerger Class Reference

#include <kis_async_merger.h>

Public Member Functions
void	startMerge (KisBaseRectsWalker &walker, bool notifyClones=true)

Private Member Functions
bool	compositeWithProjection (KisProjectionLeafSP leaf, const QRect &rect)
void	doNotifyClones (KisBaseRectsWalker &walker)
void	resetProjection ()
void	setupProjection (KisProjectionLeafSP currentLeaf, const QRect &rect, bool useTempProjection)
void	writeProjection (KisProjectionLeafSP topmostLeaf, bool useTempProjection, const QRect &rect)

Private Attributes
KisPaintDeviceSP	m_cachedPaintDevice
KisPaintDeviceSP	m_currentProjection
KisPaintDeviceSP	m_finalProjection

Detailed Description

Definition at line 16 of file kis_async_merger.h.

Member Function Documentation

compositeWithProjection()

bool KisAsyncMerger::compositeWithProjection ( KisProjectionLeafSP leaf, const QRect & rect )

inlineprivate

Definition at line 316 of file kis_async_merger.cpp.

                                                                                        {
 
    if (!m_currentProjection) return true;
    if (!leaf->visible()) return true;
 
    KisPainter gc(m_currentProjection);
    leaf->projectionPlane()->apply(&gc, rect);
 
    DEBUG_NODE_ACTION("Compositing projection", "", leaf, rect);
    return true;
}

References DEBUG_NODE_ACTION, and m_currentProjection.

doNotifyClones()

void KisAsyncMerger::doNotifyClones ( KisBaseRectsWalker & walker )

inlineprivate

Definition at line 328 of file kis_async_merger.cpp.

                                                              {
    KisBaseRectsWalker::CloneNotificationsVector &vector =
        walker.cloneNotifications();
 
    KisBaseRectsWalker::CloneNotificationsVector::iterator it;
 
    for(it = vector.begin(); it != vector.end(); ++it) {
        (*it).notify();
    }
}

References KisBaseRectsWalker::cloneNotifications().

resetProjection()

void KisAsyncMerger::resetProjection ( )

inlineprivate

Definition at line 272 of file kis_async_merger.cpp.

                                     {
    m_currentProjection = 0;
    m_finalProjection = 0;
}

References m_currentProjection, and m_finalProjection.

setupProjection()

void KisAsyncMerger::setupProjection ( KisProjectionLeafSP currentLeaf, const QRect & rect, bool useTempProjection )

inlineprivate

It happened so that our parent uses our own projection as its original. It means obligeChild mechanism works. We won't initialise m_currentProjection. This will cause writeProjection() and compositeWithProjection() do nothing when called.

Definition at line 277 of file kis_async_merger.cpp.

                                                                                                               {
    KisPaintDeviceSP parentOriginal = currentLeaf->parent()->lazyDestinationForSubtreeComposition();
 
    if (parentOriginal) {
        if (useTempProjection) {
            if(!m_cachedPaintDevice)
                m_cachedPaintDevice = new KisPaintDevice(parentOriginal->colorSpace());
            m_currentProjection = m_cachedPaintDevice;
            m_currentProjection->prepareClone(parentOriginal);
            m_finalProjection = parentOriginal;
        }
        else {
            parentOriginal->clear(rect);
            m_finalProjection = m_currentProjection = parentOriginal;
        }
    }
    else {
        /* NOP */
    }
}

References KisPaintDevice::clear(), KisPaintDevice::colorSpace(), m_cachedPaintDevice, m_currentProjection, m_finalProjection, and KisPaintDevice::prepareClone().

startMerge()

void KisAsyncMerger::startMerge	(	KisBaseRectsWalker &	walker,
		bool	notifyClones = true )

In some unidentified cases the nodes might be removed while the updates are still running. We have no proof of it yet, so just add a safety assert here.

Definition at line 172 of file kis_async_merger.cpp.

                                                                             {
    KisMergeWalker::LeafStack &leafStack = walker.leafStack();
 
    const bool useTempProjections = walker.needRectVaries();
 
    while(!leafStack.isEmpty()) {
        KisMergeWalker::JobItem item = leafStack.pop();
        KisProjectionLeafSP currentLeaf = item.m_leaf;
 
        KIS_SAFE_ASSERT_RECOVER_RETURN(currentLeaf);
        KIS_SAFE_ASSERT_RECOVER_RETURN(currentLeaf->node());
 
        // All the masks should be filtered by the walkers
        KIS_SAFE_ASSERT_RECOVER_RETURN(currentLeaf->isLayer());
 
        QRect applyRect = item.m_applyRect;
 
        if (currentLeaf->isRoot()) {
            currentLeaf->projectionPlane()->recalculate(applyRect, walker.startNode(), item.m_renderFlags);
            continue;
        }
 
        if(item.m_position & KisMergeWalker::N_EXTRA) {
            // The type of layers that will not go to projection.
 
            DEBUG_NODE_ACTION("Updating", "N_EXTRA", currentLeaf, applyRect);
            KisUpdateOriginalVisitor originalVisitor(applyRect,
                                                     m_currentProjection);
            currentLeaf->accept(originalVisitor);
            currentLeaf->projectionPlane()->recalculate(applyRect, currentLeaf->node(), item.m_renderFlags);
 
            continue;
        }
 
 
        if (!m_currentProjection) {
            setupProjection(currentLeaf, applyRect, useTempProjections);
        }
 
        KisUpdateOriginalVisitor originalVisitor(applyRect,
                                                 m_currentProjection);
 
        if(item.m_position & KisMergeWalker::N_FILTHY) {
            DEBUG_NODE_ACTION("Updating", "N_FILTHY", currentLeaf, applyRect);
            if (currentLeaf->shouldBeRendered()) {
                currentLeaf->accept(originalVisitor);
                currentLeaf->projectionPlane()->recalculate(applyRect, walker.startNode(), item.m_renderFlags);
            }
        }
        else if(item.m_position & KisMergeWalker::N_ABOVE_FILTHY) {
            DEBUG_NODE_ACTION("Updating", "N_ABOVE_FILTHY", currentLeaf, applyRect);
            if(currentLeaf->dependsOnLowerNodes()) {
                if (currentLeaf->shouldBeRendered()) {
                    currentLeaf->accept(originalVisitor);
                    currentLeaf->projectionPlane()->recalculate(applyRect, currentLeaf->node(), item.m_renderFlags);
                }
            }
        }
        else if(item.m_position & KisMergeWalker::N_FILTHY_PROJECTION) {
            DEBUG_NODE_ACTION("Updating", "N_FILTHY_PROJECTION", currentLeaf, applyRect);
            if (currentLeaf->shouldBeRendered()) {
                currentLeaf->projectionPlane()->recalculate(applyRect, walker.startNode(), item.m_renderFlags);
            }
        }
        else /*if(item.m_position & KisMergeWalker::N_BELOW_FILTHY)*/ {
            DEBUG_NODE_ACTION("Updating", "N_BELOW_FILTHY", currentLeaf, applyRect);
            /* nothing to do */
        }
 
        compositeWithProjection(currentLeaf, applyRect);
 
        if(item.m_position & KisMergeWalker::N_TOPMOST) {
            writeProjection(currentLeaf, useTempProjections, applyRect);
            resetProjection();
        }
 
        // FIXME: remove it from the inner loop and/or change to a warning!
        Q_ASSERT(currentLeaf->projection()->defaultBounds()->currentLevelOfDetail() ==
                 walker.levelOfDetail());
    }
 
    if(notifyClones) {
        doNotifyClones(walker);
    }
 
    if(m_currentProjection) {
        warnImage << "BUG: The walker hasn't reached the root layer!";
        warnImage << "     Start node:" << walker.startNode() << "Requested rect:" << walker.requestedRect();
        warnImage << "     An inconsistency in the walkers occurred!";
        warnImage << "     Please report a bug describing how you got this message.";
        // reset projection to avoid artifacts in next merges and allow people to work further
        resetProjection();
    }
}

References compositeWithProjection(), DEBUG_NODE_ACTION, doNotifyClones(), KIS_SAFE_ASSERT_RECOVER_RETURN, KisBaseRectsWalker::leafStack(), KisBaseRectsWalker::levelOfDetail(), KisBaseRectsWalker::JobItem::m_applyRect, m_currentProjection, KisBaseRectsWalker::JobItem::m_leaf, KisBaseRectsWalker::JobItem::m_position, KisBaseRectsWalker::JobItem::m_renderFlags, KisBaseRectsWalker::N_ABOVE_FILTHY, KisBaseRectsWalker::N_EXTRA, KisBaseRectsWalker::N_FILTHY, KisBaseRectsWalker::N_FILTHY_PROJECTION, KisBaseRectsWalker::N_TOPMOST, KisBaseRectsWalker::needRectVaries(), KisBaseRectsWalker::requestedRect(), resetProjection(), setupProjection(), KisBaseRectsWalker::startNode(), warnImage, and writeProjection().

writeProjection()

void KisAsyncMerger::writeProjection ( KisProjectionLeafSP topmostLeaf, bool useTempProjection, const QRect & rect )

inlineprivate

Definition at line 305 of file kis_async_merger.cpp.

                                                                                                               {
    Q_UNUSED(useTempProjection);
    Q_UNUSED(topmostLeaf);
    if (!m_currentProjection) return;
 
    if(m_currentProjection != m_finalProjection) {
        KisPainter::copyAreaOptimized(rect.topLeft(), m_currentProjection, m_finalProjection, rect);
    }
    DEBUG_NODE_ACTION("Writing projection", "", topmostLeaf->parent(), rect);
}

References KisPainter::copyAreaOptimized(), DEBUG_NODE_ACTION, m_currentProjection, and m_finalProjection.

Member Data Documentation

m_cachedPaintDevice

KisPaintDeviceSP KisAsyncMerger::m_cachedPaintDevice

private

Creation of the paint device is quite expensive, so we'll just save the pointer to our temporary device here and will get it when needed. This variable must not be used anywhere out of setupProjection()

Definition at line 52 of file kis_async_merger.h.

m_currentProjection

KisPaintDeviceSP KisAsyncMerger::m_currentProjection

private

The place where intermediate results of layer's merge are going. It may be equal to m_finalProjection. In this case the projection will be written directly to the original of the parent layer

Definition at line 35 of file kis_async_merger.h.

m_finalProjection

KisPaintDeviceSP KisAsyncMerger::m_finalProjection

private

The final destination of every projection of all the layers. It is equal to the original of a parental node. NOTE: This pointer is cached here to avoid race conditions

Definition at line 44 of file kis_async_merger.h.

---

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

• libs/image/kis_async_merger.h
• libs/image/kis_async_merger.cpp