KoShapeManager Class Reference

#include <KoShapeManager.h>

Inheritance diagram for KoShapeManager:

Classes
struct	PaintJob
struct	PaintJobsOrder
struct	ShapeInterface

Public Types
enum	Repaint { PaintShapeOnAdd , AddWithoutRepaint }
	enum for add() More...

Public Slots
void	addShape (KoShape *shape, KoShapeManager::Repaint repaint=PaintShapeOnAdd)
void	remove (KoShape *shape)

Signals
void	contentChanged ()
	emitted when any object changed (moved/rotated etc)
void	forwardUpdate ()
	Emitted upon update and used to update the canvas.
void	selectionChanged ()
	emitted when the selection is changed
void	selectionContentChanged ()
	emitted when an object in the selection is changed (moved/rotated etc)

Public Member Functions
void	explicitlyIssueShapeChangedSignals ()
void	forwardCompressedUpdate ()
	KoShapeManager (KoCanvasBase *canvas)
	KoShapeManager (KoCanvasBase *canvas, const QList< KoShape * > &shapes)
void	notifyShapeChanged (KoShape *shape)
void	paint (QPainter &painter)
void	paintJob (QPainter &painter, const KoShapeManager::PaintJob &job)
void	preparePaintJobs (PaintJobsOrder &jobsOrder, KoShape *excludeRoot)
	Private (KoShapeManager *shapeManager, KoCanvasBase *c)
KoSelection *	selection () const
	return the selection shapes for this shapeManager
void	setShapes (const QList< KoShape * > &shapes, Repaint repaint=PaintShapeOnAdd)
void	setUpdatesBlocked (bool value)
KoShape *	shapeAt (const QPointF &position, KoFlake::ShapeSelection selection=KoFlake::ShapeOnTop, bool omitHiddenShapes=true)
ShapeInterface *	shapeInterface ()
QList< KoShape * >	shapes () const
	returns the list of maintained shapes
QList< KoShape * >	shapesAt (const QRectF &rect, bool omitHiddenShapes=true, bool containedMode=false)
QList< KoShape * >	topLevelShapes () const
void	unlinkFromShapesRecursively (const QList< KoShape * > &shapes)
void	update (const QRectF &rect, const KoShape *shape=0, bool selectionHandles=false)
bool	updatesBlocked () const
void	updateTree ()
	~KoShapeManager () override
	~Private ()

Static Public Member Functions
static void	renderSingleShape (KoShape *shape, QPainter &painter)
	renderSingleShape renders a shape on painter. This method includes all the needed steps for painting a single shape: setting transformations, clipping and masking.

Public Attributes
QSet< KoShape * >	aggregate4update
KoCanvasBase *	canvas
QRectF	compressedUpdate
QSet< const KoShape * >	compressedUpdatedShapes
KoShapeManager *	q
KoSelection *	selection
QHash< KoShape *, int >	shapeIndexesBeforeUpdate
KoShapeManager::ShapeInterface	shapeInterface
QList< KoShape * >	shapes
QMutex	shapesMutex
KoRTree< KoShape * >	tree
QMutex	treeMutex
bool	updatesBlocked = false

Private Member Functions
KoCanvasBase *	canvas ()
Private Member Functions inherited from Private
	Private (KisCanvas2 *c)

Private Attributes
Private *const	d
Private Attributes inherited from Private
KisCanvas2 *	canvas
int	displayedFrame
int	intendedFrame

Detailed Description

The shape manager hold a list of all shape which are in scope. There is one shape manager per canvas. This makes the shape manager different from QGraphicsScene, which contains the datamodel for all graphics items: KoShapeManager only contains the subset of shapes that are shown in its canvas.

The selection in the different views can be different.

Definition at line 41 of file KoShapeManager.h.

Member Enumeration Documentation

Repaint

enum KoShapeManager::Repaint

enum for add()

Enumerator
PaintShapeOnAdd	Causes each shapes 'update()' to be called after being added to the shapeManager.
AddWithoutRepaint	Avoids each shapes 'update()' to be called for faster addition when its possible.

Definition at line 47 of file KoShapeManager.h.

                 {
        PaintShapeOnAdd,    
        AddWithoutRepaint   
    };

Constructor & Destructor Documentation

KoShapeManager() [1/2]

KoShapeManager::KoShapeManager ( KoCanvasBase * canvas )

explicit

Constructor.

Definition at line 336 of file KoShapeManager.cpp.

    : d(new Private(this, canvas))
{
    Q_ASSERT(d->canvas); // not optional.
    connect(d->selection, SIGNAL(selectionChanged()), this, SIGNAL(selectionChanged()));
 
    // see a comment in another constructor
    this->moveToThread(qApp->thread());
    connect(this, SIGNAL(forwardUpdate()), this, SLOT(forwardCompressedUpdate()));
}

References Private::canvas, connect(), d, forwardCompressedUpdate(), forwardUpdate(), and selectionChanged().

KoShapeManager() [2/2]

KoShapeManager::KoShapeManager	(	KoCanvasBase *	canvas,
		const QList< KoShape * > &	shapes )

Constructor that takes a list of shapes, convenience version.

Parameters

shapes	the shapes to start out with, see also setShapes()
canvas	the canvas this shape manager is working on.

Shape manager uses uses queued signals, therefore it should belong to the GUI thread.

Definition at line 321 of file KoShapeManager.cpp.

    : d(new Private(this, canvas))
{
    Q_ASSERT(d->canvas); // not optional.
    connect(d->selection, SIGNAL(selectionChanged()), this, SIGNAL(selectionChanged()));
    setShapes(shapes);
 
    this->moveToThread(qApp->thread());
    connect(this, SIGNAL(forwardUpdate()), this, SLOT(forwardCompressedUpdate()));
}

References Private::canvas, connect(), d, forwardCompressedUpdate(), forwardUpdate(), selectionChanged(), setShapes(), and shapes.

~KoShapeManager()

KoShapeManager::~KoShapeManager ( )

override

Definition at line 359 of file KoShapeManager.cpp.

{
    d->unlinkFromShapesRecursively(d->shapes);
    d->shapes.clear();
 
    delete d;
}

References d.

~Private()

KoShapeManager::~Private ( )

inline

Definition at line 37 of file KoShapeManager_p.h.

               {
        delete selection;
    }

Member Function Documentation

addShape

void KoShapeManager::addShape ( KoShape * shape, KoShapeManager::Repaint repaint = PaintShapeOnAdd )

slot

Add a KoShape to be displayed and managed by this manager. This will trigger a repaint of the shape.

Parameters

shape	the shape to add
repaint	if true it will trigger a repaint of the shape

Definition at line 389 of file KoShapeManager.cpp.

{
    {
        QMutexLocker l1(&d->shapesMutex);
 
        if (d->shapes.contains(shape))
            return;
        shape->addShapeManager(this);
        d->shapes.append(shape);
 
        if (shapeUsedInRenderingTree(shape)) {
            QMutexLocker l2(&d->treeMutex);
 
            QRectF br(shape->boundingRect());
            d->tree.insert(br, shape);
        }
    }
 
    if (repaint == PaintShapeOnAdd) {
        shape->update();
    }
 
    // add the children of a KoShapeContainer
    KoShapeContainer *container = dynamic_cast<KoShapeContainer*>(shape);
 
    if (container) {
        foreach (KoShape *containerShape, container->shapes()) {
            addShape(containerShape, repaint);
        }
    }
}

References addShape(), KoShape::addShapeManager(), KoShape::boundingRect(), d, PaintShapeOnAdd, KoShapeContainer::shapes(), and KoShape::update().

canvas()

KoCanvasBase * KoShapeManager::canvas ( )

private

contentChanged

void KoShapeManager::contentChanged ( )

signal

emitted when any object changed (moved/rotated etc)

explicitlyIssueShapeChangedSignals()

void KoShapeManager::explicitlyIssueShapeChangedSignals

(

)

The update signals are usually emitted when the owned of the manager calls to preparePaintJobs() in the beginning of the rendering cycle. This way we avoid too many signals to be emitted. But some of the canvases (e.g. KisShapeSelectionCanvas) doesn't do any rendering (yet?), so the signals should be emitted explicitly.

Definition at line 768 of file KoShapeManager.cpp.

{
    d->updateTree();
}

References d.

forwardCompressedUpdate()

void KoShapeManager::forwardCompressedUpdate

(

)

forwardUpdate

void KoShapeManager::forwardUpdate ( )

signal

Emitted upon update and used to update the canvas.

notifyShapeChanged()

void KoShapeManager::notifyShapeChanged

(

KoShape *

shape

)

Update the tree for finding the shapes. This will remove the shape from the tree and will reinsert it again. The update to the tree will be postponed until it is needed so that successive calls will be merged into one.

Parameters

shape

the shape to updated its position in the tree.

Definition at line 721 of file KoShapeManager.cpp.

{
    {
        QMutexLocker l(&d->treeMutex);
 
        Q_ASSERT(shape);
        if (d->aggregate4update.contains(shape)) {
            return;
        }
 
        d->aggregate4update.insert(shape);
        d->shapeIndexesBeforeUpdate.insert(shape, shape->zIndex());
    }
 
    KoShapeContainer *container = dynamic_cast<KoShapeContainer*>(shape);
    if (container) {
        Q_FOREACH (KoShape *child, container->shapes())
            notifyShapeChanged(child);
    }
}

References d, notifyShapeChanged(), KoShapeContainer::shapes(), and KoShape::zIndex().

paint()

void KoShapeManager::paint

(

QPainter &

painter

)

Paint all shapes and their selection handles etc.

Parameters

painter	the painter to paint to.
forPrint	if true, make sure only actual content is drawn and no decorations.
converter	to convert between document and view coordinates.

Definition at line 561 of file KoShapeManager.cpp.

{
    d->updateTree();
 
    QMutexLocker l1(&d->shapesMutex);
 
    painter.setPen(Qt::NoPen);  // painters by default have a black stroke, lets turn that off.
    painter.setBrush(Qt::NoBrush);
 
    QList<KoShape*> unsortedShapes;
    if (painter.hasClipping()) {
        QMutexLocker l(&d->treeMutex);
 
        QRectF rect = KisPaintingTweaks::safeClipBoundingRect(painter);
        unsortedShapes = d->tree.intersects(rect);
    } else {
        unsortedShapes = d->shapes;
        warnFlake << "KoShapeManager::paint  Painting with a painter that has no clipping will lead to too much being painted!";
    }
 
    KisForest<KoShape*> renderTree;
    buildRenderTree(unsortedShapes, renderTree);
    renderShapes(childBegin(renderTree), childEnd(renderTree), painter);
}

References d, KisPaintingTweaks::safeClipBoundingRect(), and warnFlake.

paintJob()

void KoShapeManager::paintJob	(	QPainter &	painter,
		const KoShapeManager::PaintJob &	job )

Render a job on painter. No mutable internals of the shape manager are accessed, so calling this method is safe in multithreading environment.

Parameters

painter	a painter to paint on. Clip rect of the painter is expected to be setup correctly.
job	a job to paint.
forPrint	not used in Krita.

See also

preparePaintJobs

Definition at line 550 of file KoShapeManager.cpp.

{
    painter.setPen(Qt::NoPen);  // painters by default have a black stroke, lets turn that off.
    painter.setBrush(Qt::NoBrush);
 
    KisForest<KoShape*> renderTree;
    buildRenderTree(job.shapes, renderTree);
 
    renderShapes(childBegin(renderTree), childEnd(renderTree), painter);
}

References KoShapeManager::PaintJob::shapes.

preparePaintJobs()

void KoShapeManager::preparePaintJobs	(	PaintJobsOrder &	jobsOrder,
		KoShape *	excludeRoot )

Prepare a shallow copy of all the shapes and the jobs to be rendered asynchronously later. The copies are stored in jobs, so that the user could later pass these jobs into paintJob() in a separate thread.

Parameters

jobs	a list of rects that are going to be updated. docUpdateRect and viewUpdateRect should be preinitialized by the caller.
excludeRoot	the root shape which should not be copied. It is basically a hack to avoid copying of KisShapeLayer, which is not copiable.

See also

paintJob()

a comment in KisShapeLayerCanvas::slotStartAsyncRepaint()

Definition at line 483 of file KoShapeManager.cpp.

{
    d->updateTree();
 
    QMutexLocker l1(&d->shapesMutex);
 
    QSet<KoShape*> rootShapesSet;
    Q_FOREACH (KoShape *shape, d->shapes) {
        while (shape->parent() && shape->parent() != excludeRoot) {
            shape = shape->parent();
        }
 
        if (!rootShapesSet.contains(shape) && shape != excludeRoot) {
            rootShapesSet.insert(shape);
        }
    }
    const QList<KoShape*> rootShapes(rootShapesSet.begin(), rootShapesSet.end());
    QList<KoShape*> newRootShapes;
 
    Q_FOREACH (KoShape *srcShape, rootShapes) {
        KIS_SAFE_ASSERT_RECOVER(srcShape->parent() == excludeRoot
                                || !srcShape->parent()) {
            continue;
        }
 
        KoShape *clonedShape = srcShape->cloneShape();
 
        KoShapeContainer *parentShape = srcShape->parent();
 
        if (parentShape && !parentShape->transformation().isIdentity()) {
            clonedShape->applyAbsoluteTransformation(parentShape->transformation());
        }
 
        newRootShapes << clonedShape;
    }
 
    PaintJobsOrder result;
 
    PaintJob::SharedSafeStorage shapesStorage = std::make_shared<PaintJob::ShapesStorage>();
    Q_FOREACH (KoShape *shape, newRootShapes) {
        shapesStorage->emplace_back(std::unique_ptr<KoShape>(shape));
    }
 
    const QList<KoShape*> originalShapes = KoShape::linearizeSubtreeSorted(rootShapes);
    const QList<KoShape*> clonedShapes = KoShape::linearizeSubtreeSorted(newRootShapes);
    KIS_SAFE_ASSERT_RECOVER_RETURN(clonedShapes.size() == originalShapes.size());
 
    QHash<KoShape*, KoShape*> clonedFromOriginal;
    for (int i = 0; i < originalShapes.size(); i++) {
        clonedFromOriginal[originalShapes[i]] = clonedShapes[i];
    }
 
 
    for (auto it = std::begin(jobsOrder.jobs); it != std::end(jobsOrder.jobs); ++it) {
        QMutexLocker l(&d->treeMutex);
        QList<KoShape*> unsortedOriginalShapes = d->tree.intersects(it->docUpdateRect);
 
        it->allClonedShapes = shapesStorage;
 
        Q_FOREACH (KoShape *shape, unsortedOriginalShapes) {
            KIS_SAFE_ASSERT_RECOVER(shapeUsedInRenderingTree(shape)) { continue; }
            it->shapes << clonedFromOriginal[shape];
        }
    }
}

References KoShape::applyAbsoluteTransformation(), KoShape::cloneShape(), d, KoShapeManager::PaintJobsOrder::jobs, KIS_SAFE_ASSERT_RECOVER, KIS_SAFE_ASSERT_RECOVER_RETURN, KoShape::linearizeSubtreeSorted(), KoShape::parent(), and KoShape::transformation().

Private()

KoShapeManager::Private ( KoShapeManager * shapeManager, KoCanvasBase * c )

inline

Definition at line 28 of file KoShapeManager_p.h.

        : selection(new KoSelection(shapeManager)),
          canvas(c),
          tree(4, 2),
          q(shapeManager),
          shapeInterface(shapeManager)
    {
    }

remove

void KoShapeManager::remove ( KoShape * shape )

slot

Remove a KoShape from this manager

Parameters

shape

the shape to remove

Definition at line 421 of file KoShapeManager.cpp.

{
    QRectF dirtyRect;
    {
        QMutexLocker l1(&d->shapesMutex);
        QMutexLocker l2(&d->treeMutex);
 
        dirtyRect = shape->boundingRect();
 
        shape->removeShapeManager(this);
        d->selection->deselect(shape);
        d->aggregate4update.remove(shape);
        d->compressedUpdatedShapes.remove(shape);
 
        if (shapeUsedInRenderingTree(shape)) {
            d->tree.remove(shape);
        }
        d->shapes.removeAll(shape);
    }
 
    if (!dirtyRect.isEmpty()) {
        d->canvas->updateCanvas(dirtyRect);
    }
 
    // remove the children of a KoShapeContainer
    KoShapeContainer *container = dynamic_cast<KoShapeContainer*>(shape);
    if (container) {
        foreach (KoShape *containerShape, container->shapes()) {
            remove(containerShape);
        }
    }
}

References KoShape::boundingRect(), Private::canvas, d, remove(), KoShape::removeShapeManager(), KoShapeContainer::shapes(), and KisCanvas2::updateCanvas().

renderSingleShape()

void KoShapeManager::renderSingleShape ( KoShape * shape, QPainter & painter )

static

renderSingleShape renders a shape on painter. This method includes all the needed steps for painting a single shape: setting transformations, clipping and masking.

Definition at line 586 of file KoShapeManager.cpp.

{
    KisForest<KoShape*> renderTree;
 
    KoViewConverter converter;
 
    auto root = renderTree.insert(childBegin(renderTree), shape);
    populateRenderSubtree(shape, root, renderTree, &shapeIsVisible, &shapeIsVisible);
    renderShapes(childBegin(renderTree), childEnd(renderTree), painter);
}

References KisForestDetail::Forest< T >::insert().

selection()

KoSelection * KoShapeManager::selection

(

)

const

return the selection shapes for this shapeManager

selectionChanged

void KoShapeManager::selectionChanged ( )

signal

emitted when the selection is changed

selectionContentChanged

void KoShapeManager::selectionContentChanged ( )

signal

emitted when an object in the selection is changed (moved/rotated etc)

setShapes()

void KoShapeManager::setShapes	(	const QList< KoShape * > &	shapes,
		Repaint	repaint = PaintShapeOnAdd )

Remove all previously owned shapes and make the argument list the new shapes to be managed by this manager.

Parameters

shapes	the new shapes to manage.
repaint	if true it will trigger a repaint of the shapes

Definition at line 367 of file KoShapeManager.cpp.

{
    {
        QMutexLocker l1(&d->shapesMutex);
        QMutexLocker l2(&d->treeMutex);
 
        //clear selection
        d->selection->deselectAll();
        d->unlinkFromShapesRecursively(d->shapes);
        d->compressedUpdate = QRect();
        d->compressedUpdatedShapes.clear();
        d->aggregate4update.clear();
        d->shapeIndexesBeforeUpdate.clear();
        d->tree.clear();
        d->shapes.clear();
    }
 
    Q_FOREACH (KoShape *shape, shapes) {
        addShape(shape, repaint);
    }
}

References addShape(), d, and shapes.

setUpdatesBlocked()

void KoShapeManager::setUpdatesBlocked

(

bool

value

)

Block all updates initiated with update() call. The incoming updates will be dropped completely.

Definition at line 712 of file KoShapeManager.cpp.

{
    d->updatesBlocked = value;
}

References d, and value().

shapeAt()

KoShape * KoShapeManager::shapeAt	(	const QPointF &	position,
		KoFlake::ShapeSelection	selection = KoFlake::ShapeOnTop,
		bool	omitHiddenShapes = true )

Returns the shape located at a specific point in the document. If more than one shape is located at the specific point, the given selection type controls which of them is returned.

Parameters

position	the position in the document coordinate system.
selection	controls which shape is returned when more than one shape is at the specific point
omitHiddenShapes	if true, only visible shapes are considered

Definition at line 597 of file KoShapeManager.cpp.

{
    d->updateTree();
 
    QMutexLocker l(&d->shapesMutex);
 
    QList<KoShape*> sortedShapes;
 
    {
        QMutexLocker l(&d->treeMutex);
        sortedShapes = d->tree.contains(position);
    }
 
    std::sort(sortedShapes.begin(), sortedShapes.end(), KoShape::compareShapeZIndex);
    KoShape *firstUnselectedShape = 0;
    for (int count = sortedShapes.count() - 1; count >= 0; count--) {
        KoShape *shape = sortedShapes.at(count);
        if (omitHiddenShapes && ! shape->isVisible())
            continue;
        if (! shape->hitTest(position))
            continue;
 
        switch (selection) {
        case KoFlake::ShapeOnTop:
            if (shape->isSelectable())
                return shape;
            break;
        case KoFlake::Selected:
            if (d->selection->isSelected(shape))
                return shape;
            break;
        case KoFlake::Unselected:
            if (! d->selection->isSelected(shape))
                return shape;
            break;
        case KoFlake::NextUnselected:
            // we want an unselected shape
            if (d->selection->isSelected(shape))
                continue;
            // memorize the first unselected shape
            if (! firstUnselectedShape)
                firstUnselectedShape = shape;
            // check if the shape above is selected
            if (count + 1 < sortedShapes.count() && d->selection->isSelected(sortedShapes.at(count + 1)))
                return shape;
            break;
        }
    }
    // if we want the next unselected below a selected but there was none selected,
    // return the first found unselected shape
    if (selection == KoFlake::NextUnselected && firstUnselectedShape)
        return firstUnselectedShape;
 
    if (d->selection->hitTest(position))
        return d->selection;
 
    return 0; // missed everything
}

References KoShape::compareShapeZIndex(), d, KoShape::hitTest(), KoShape::isSelectable(), KoShape::isVisible(), KoFlake::NextUnselected, KoFlake::Selected, selection, KoFlake::ShapeOnTop, and KoFlake::Unselected.

shapeInterface()

ShapeInterface * KoShapeManager::shapeInterface

(

)

shapes()

QList< KoShape * > KoShapeManager::shapes

(

)

const

returns the list of maintained shapes

shapesAt()

QList< KoShape * > KoShapeManager::shapesAt	(	const QRectF &	rect,
		bool	omitHiddenShapes = true,
		bool	containedMode = false )

Returns the shapes which intersects the specific rect in the document.

Parameters

rect	the rectangle in the document coordinate system.
omitHiddenShapes	if true, only visible shapes are considered
containedMode	if true use contained mode

Definition at line 656 of file KoShapeManager.cpp.

{
    QMutexLocker l(&d->shapesMutex);
 
    d->updateTree();
    QList<KoShape*> shapes;
 
    {
        QMutexLocker l(&d->treeMutex);
        shapes = containedMode ? d->tree.contained(rect) : d->tree.intersects(rect);
    }
 
    for (int count = shapes.count() - 1; count >= 0; count--) {
 
        KoShape *shape = shapes.at(count);
 
        if (omitHiddenShapes && !shape->isVisible()) {
            shapes.removeAt(count);
        } else {
            const QPainterPath outline = shape->absoluteTransformation().map(shape->outline());
 
            if (!containedMode && !outline.intersects(rect) && !outline.contains(rect)) {
                shapes.removeAt(count);
 
            } else if (containedMode) {
 
                QPainterPath containingPath;
                containingPath.addRect(rect);
 
                if (!containingPath.contains(outline)) {
                    shapes.removeAt(count);
                }
            }
        }
    }
 
    return shapes;
}

References KoShape::absoluteTransformation(), d, KoShape::isVisible(), KoShape::outline(), and shapes.

topLevelShapes()

QList< KoShape * > KoShapeManager::topLevelShapes

(

)

const

Get a list of all shapes that don't have a parent.

Definition at line 749 of file KoShapeManager.cpp.

{
    QMutexLocker l(&d->shapesMutex);
 
    QList<KoShape*> shapes;
    // get all toplevel shapes
    Q_FOREACH (KoShape *shape, d->shapes) {
        if (!shape->parent() || dynamic_cast<KoShapeLayer*>(shape->parent())) {
            shapes.append(shape);
        }
    }
    return shapes;
}

References d, KoShape::parent(), and shapes.

unlinkFromShapesRecursively()

void KoShapeManager::unlinkFromShapesRecursively

(

const QList< KoShape * > &

shapes

)

Recursively detach the shapes from this shape manager

update()

void KoShapeManager::update	(	const QRectF &	rect,
		const KoShape *	shape = 0,
		bool	selectionHandles = false )

Request a repaint to be queued. The repaint will be restricted to the parameters rectangle, which is expected to be in points (the document coordinates system of KoShape) and it is expected to be normalized and based in the global coordinates, not any local coordinates.

This method will return immediately and only request a repaint. Successive calls will be merged into an appropriate repaint action.

Parameters

rect	the rectangle (in pt) to queue for repaint.
shape	the shape that is going to be redrawn; only needed when selectionHandles=true
selectionHandles	if true; find out if the shape is selected and repaint its selection handles at the same time.

Definition at line 695 of file KoShapeManager.cpp.

{
    if (d->updatesBlocked) return;
 
    {
        QMutexLocker l(&d->shapesMutex);
 
        d->compressedUpdate |= rect;
 
        if (selectionHandles) {
            d->compressedUpdatedShapes.insert(shape);
        }
    }
 
    emit(forwardUpdate());
}

References d, and forwardUpdate().

updatesBlocked()

bool KoShapeManager::updatesBlocked

(

)

const

See also

setUpdatesBlocked()

updateTree()

void KoShapeManager::updateTree

(

)

Update the tree when there are shapes in m_aggregate4update. This is done so not all updates to the tree are done when they are asked for but when they are needed.

Member Data Documentation

aggregate4update

QSet<KoShape *> KoShapeManager::aggregate4update

Definition at line 59 of file KoShapeManager_p.h.

canvas

KoCanvasBase * KoShapeManager::canvas

Definition at line 57 of file KoShapeManager_p.h.

compressedUpdate

QRectF KoShapeManager::compressedUpdate

Definition at line 66 of file KoShapeManager_p.h.

compressedUpdatedShapes

QSet<const KoShape*> KoShapeManager::compressedUpdatedShapes

Definition at line 67 of file KoShapeManager_p.h.

d

Private* const KoShapeManager::d

private

Definition at line 277 of file KoShapeManager.h.

q

KoShapeManager* KoShapeManager::q

Definition at line 61 of file KoShapeManager_p.h.

selection

KoSelection * KoShapeManager::selection

Definition at line 56 of file KoShapeManager_p.h.

shapeIndexesBeforeUpdate

QHash<KoShape*, int> KoShapeManager::shapeIndexesBeforeUpdate

Definition at line 60 of file KoShapeManager_p.h.

shapeInterface

KoShapeManager::ShapeInterface * KoShapeManager::shapeInterface

Definition at line 62 of file KoShapeManager_p.h.

shapes

QList< KoShape * > KoShapeManager::shapes

Definition at line 55 of file KoShapeManager_p.h.

shapesMutex

QMutex KoShapeManager::shapesMutex

Definition at line 63 of file KoShapeManager_p.h.

tree

KoRTree<KoShape *> KoShapeManager::tree

Definition at line 58 of file KoShapeManager_p.h.

treeMutex

QMutex KoShapeManager::treeMutex

Definition at line 64 of file KoShapeManager_p.h.

updatesBlocked

bool KoShapeManager::updatesBlocked = false

Definition at line 69 of file KoShapeManager_p.h.

---

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

• libs/flake/KoShapeManager.h
• libs/flake/KoShapeManager_p.h
• libs/flake/KoShapeManager.cpp