KoShapeManager.cpp

Go to the documentation of this file.

/* This file is part of the KDE project
 
   SPDX-FileCopyrightText: 2006-2008 Thorsten Zachmann <zachmann@kde.org>
   SPDX-FileCopyrightText: 2006-2010 Thomas Zander <zander@kde.org>
   SPDX-FileCopyrightText: 2009-2010 Jan Hambrecht <jaham@gmx.net>
 
   SPDX-License-Identifier: LGPL-2.0-or-later
*/
 
#include "KoShapeManager.h"
#include "KoShapeManager_p.h"
#include "KoSelection.h"
#include "KoToolManager.h"
#include "KoPointerEvent.h"
#include "KoShape.h"
#include "KoShape_p.h"
#include "KoCanvasBase.h"
#include "KoShapeContainer.h"
#include "KoShapeStrokeModel.h"
#include "KoShapeGroup.h"
#include "KoToolProxy.h"
#include "KoShapeShadow.h"
#include "KoShapeLayer.h"
#include "KoFilterEffect.h"
#include "KoFilterEffectStack.h"
#include "KoFilterEffectRenderContext.h"
#include "KoShapeBackground.h"
#include <KoRTree.h>
#include "KoClipPath.h"
#include "KoClipMaskPainter.h"
#include "KoViewConverter.h"
#include "KisQPainterStateSaver.h"
#include "KoSvgTextShape.h"
#include <QApplication>
 
#include <QPainter>
#include <QPainterPath>
#include <QThread>
#include <QMutexLocker>
#include <FlakeDebug.h>
 
#include "kis_painting_tweaks.h"
#include "kis_debug.h"
#include "KisForest.h"
#include <unordered_set>
 
 
namespace {
 
inline bool shapeUsedInRenderingTree(KoShape *shape)
{
    // FIXME: make more general!
 
    return !dynamic_cast<KoShapeGroup*>(shape) &&
            !dynamic_cast<KoShapeLayer*>(shape);
}
 
inline bool shapeHasGroupEffects(KoShape *shape) {
    return shape->clipPath() ||
        (shape->filterEffectStack() && !shape->filterEffectStack()->isEmpty()) ||
        shape->clipMask();
}
 
inline bool shapeIsVisible(KoShape *shape) {
    return shape->isVisible(false) && shape->transparency() < 1.0;
}
 
 
void populateRenderSubtree(KoShape *parentShape,
                           KisForest<KoShape*>::child_iterator parentIt,
                           KisForest<KoShape*> &tree,
                           std::function<bool(KoShape*)> shouldIncludeNode,
                           std::function<bool(KoShape*)> shouldEnterSubtree)
{
    KoShapeContainer *parentContainer = dynamic_cast<KoShapeContainer*>(parentShape);
    if (!parentContainer) return;
 
    QList<KoShape*> children = parentContainer->shapes();
    std::sort(children.begin(), children.end(), KoShape::compareShapeZIndex);
 
    for (auto it = children.constBegin(); it != children.constEnd(); ++it) {
        auto newParentIt = parentIt;
 
        if (shouldIncludeNode(*it)) {
            newParentIt = tree.insert(childEnd(parentIt), *it);
        }
 
        if (shouldEnterSubtree(*it)) {
            populateRenderSubtree(*it, newParentIt, tree, shouldIncludeNode, shouldEnterSubtree);
        }
    }
 
}
 
void buildRenderTree(QList<KoShape*> leafShapes,
                     KisForest<KoShape*> &tree)
{
    QList<KoShape*> sortedShapes = leafShapes;
    std::sort(sortedShapes.begin(), sortedShapes.end(), KoShape::compareShapeZIndex);
 
    std::unordered_set<KoShape*> includedShapes;
 
    Q_FOREACH (KoShape *shape, sortedShapes) {
        bool shouldSkipShape = !shapeIsVisible(shape);
        if (shouldSkipShape) continue;
 
        bool shapeIsPartOfIncludedSubtree = false;
        QVector<KoShape*> hierarchy = {shape};
 
        while ((shape = shape->parent())) {
            if (!shapeIsVisible(shape)) {
                shouldSkipShape = true;
                break;
            }
 
            if (includedShapes.find(shape) != end(includedShapes)) {
                shapeIsPartOfIncludedSubtree = true;
                break;
            }
 
            if (shapeHasGroupEffects(shape)) {
                hierarchy << shape;
            }
        }
 
        if (shouldSkipShape) continue;
 
        if (!shapeIsPartOfIncludedSubtree &&
            includedShapes.find(hierarchy.last()) == end(includedShapes)) {
 
            tree.insert(childEnd(tree), hierarchy.last());
        }
        std::copy(hierarchy.begin(), hierarchy.end(),
                  std::inserter(includedShapes, end(includedShapes)));
    }
 
    auto shouldIncludeShape =
        [includedShapes] (KoShape *shape) {
            // included shapes are guaranteed to be visible
            return includedShapes.find(shape) != end(includedShapes);
        };
 
    for (auto it = childBegin(tree); it != childEnd(tree); ++it) {
        populateRenderSubtree(*it, it, tree, shouldIncludeShape, &shapeIsVisible);
    }
}
 
void renderShapes(typename KisForest<KoShape*>::child_iterator beginIt,
                  typename KisForest<KoShape*>::child_iterator endIt,
                  QPainter &painter)
{
    for (auto it = beginIt; it != endIt; ++it) {
        KoShape *shape = *it;
 
        KisQPainterStateSaver saver(&painter);
 
        if (!isEnd(parent(it))) {
            painter.setTransform(shape->transformation() * painter.transform());
        } else {
            painter.setTransform(shape->absoluteTransformation() * painter.transform());
        }
 
        KoClipPath::applyClipping(shape, painter);
 
        qreal transparency = shape->transparency(true);
        if (transparency > 0.0) {
            painter.setOpacity(1.0-transparency);
        }
 
        if (shape->shadow()) {
            KisQPainterStateSaver saver(&painter);
            shape->shadow()->paint(shape, painter);
        }
 
        QScopedPointer<KoClipMaskPainter> clipMaskPainter;
        QPainter *shapePainter = &painter;
 
        KoClipMask *clipMask = shape->clipMask();
        if (clipMask) {
            const QRectF bounds = painter.transform().mapRect(shape->outlineRect() & painter.clipBoundingRect());
 
            clipMaskPainter.reset(new KoClipMaskPainter(&painter, bounds));
            shapePainter = clipMaskPainter->shapePainter();
        }
 
        const QTransform sanityCheckTransformSaved = shapePainter->transform();
 
        renderShapes(childBegin(it), childEnd(it), *shapePainter);
 
        Q_FOREACH(const KoShape::PaintOrder p, shape->paintOrder()) {
            if (p == KoShape::Fill) {
                shape->paint(*shapePainter);
            } else if (p == KoShape::Stroke) {
                shape->paintStroke(*shapePainter);
            } else if (p == KoShape::Markers)  {
                shape->paintMarkers(*shapePainter);
            }
        }
 
        KIS_SAFE_ASSERT_RECOVER(shapePainter->transform() == sanityCheckTransformSaved) {
            shapePainter->setTransform(sanityCheckTransformSaved);
        }
 
        if (clipMask) {
            clipMaskPainter->maskPainter()->save();
 
            shape->clipMask()->drawMask(clipMaskPainter->maskPainter(), shape);
            clipMaskPainter->renderOnGlobalPainter();
 
            clipMaskPainter->maskPainter()->restore();
        }
    }
}
 
}
 
void KoShapeManager::Private::updateTree()
{
    bool selectionModified = false;
    bool anyModified = false;
 
    {
        QMutexLocker l(&this->treeMutex);
 
        Q_FOREACH (KoShape *shape, aggregate4update) {
            selectionModified = selectionModified || selection->isSelected(shape);
            anyModified = true;
        }
 
        foreach (KoShape *shape, aggregate4update) {
            if (!shapeUsedInRenderingTree(shape)) continue;
 
            tree.remove(shape);
            QRectF br(shape->boundingRect());
            tree.insert(br, shape);
        }
 
        aggregate4update.clear();
        shapeIndexesBeforeUpdate.clear();
    }
 
    if (selectionModified) {
        Q_EMIT q->selectionContentChanged();
    }
    if (anyModified) {
        Q_EMIT q->contentChanged();
    }
}
 
void KoShapeManager::Private::forwardCompressedUpdate()
{
    bool shouldUpdateDecorations = false;
    QRectF scheduledUpdate;
 
    {
        QMutexLocker l(&shapesMutex);
 
        if (!compressedUpdate.isEmpty()) {
            scheduledUpdate = compressedUpdate;
            compressedUpdate = QRect();
        }
 
        Q_FOREACH (const KoShape *shape, compressedUpdatedShapes) {
            if (selection->isSelected(shape)) {
                shouldUpdateDecorations = true;
                break;
            }
        }
        compressedUpdatedShapes.clear();
    }
 
    if (shouldUpdateDecorations && canvas->toolProxy()) {
        canvas->toolProxy()->repaintDecorations();
    }
    canvas->updateCanvas(scheduledUpdate);
 
}
 
KoShapeManager::KoShapeManager(KoCanvasBase *canvas, const QList<KoShape *> &shapes)
    : 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()));
}
 
KoShapeManager::KoShapeManager(KoCanvasBase *canvas)
    : 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()));
}
 
void KoShapeManager::Private::unlinkFromShapesRecursively(const QList<KoShape*> &shapes)
{
    Q_FOREACH (KoShape *shape, shapes) {
        shape->removeShapeManager(q);
 
        KoShapeContainer *container = dynamic_cast<KoShapeContainer*>(shape);
        if (container) {
            unlinkFromShapesRecursively(container->shapes());
        }
    }
}
 
KoShapeManager::~KoShapeManager()
{
    d->unlinkFromShapesRecursively(d->shapes);
    d->shapes.clear();
 
    delete d;
}
 
void KoShapeManager::setShapes(const QList<KoShape *> &shapes, Repaint repaint)
{
    {
        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);
    }
}
 
void KoShapeManager::addShape(KoShape *shape, Repaint repaint)
{
    {
        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);
        }
    }
}
 
void KoShapeManager::remove(KoShape *shape)
{
    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);
        }
    }
}
 
KoShapeManager::ShapeInterface::ShapeInterface(KoShapeManager *_q)
    : q(_q)
{
}
 
void KoShapeManager::ShapeInterface::notifyShapeDestructed(KoShape *shape)
{
    QMutexLocker l1(&q->d->shapesMutex);
    QMutexLocker l2(&q->d->treeMutex);
 
    q->d->selection->deselect(shape);
    q->d->aggregate4update.remove(shape);
    q->d->compressedUpdatedShapes.remove(shape);
 
    // we cannot access RTTI of the semi-destructed shape, so just
    // unlink it lazily
    if (q->d->tree.contains(shape)) {
        q->d->tree.remove(shape);
    }
 
    q->d->shapes.removeAll(shape);
}
 
 
KoShapeManager::ShapeInterface *KoShapeManager::shapeInterface()
{
    return &d->shapeInterface;
}
 
void KoShapeManager::preparePaintJobs(PaintJobsOrder &jobsOrder,
                                      KoShape *excludeRoot)
{
    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];
        }
    }
}
 
void KoShapeManager::paintJob(QPainter &painter, const KoShapeManager::PaintJob &job)
{
    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);
}
 
void KoShapeManager::paint(QPainter &painter)
{
    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);
}
 
void KoShapeManager::renderSingleShape(KoShape *shape, QPainter &painter)
{
    KisForest<KoShape*> renderTree;
 
    KoViewConverter converter;
 
    auto root = renderTree.insert(childBegin(renderTree), shape);
    populateRenderSubtree(shape, root, renderTree, &shapeIsVisible, &shapeIsVisible);
    renderShapes(childBegin(renderTree), childEnd(renderTree), painter);
}
 
KoShape *KoShapeManager::shapeAt(const QPointF &position, KoFlake::ShapeSelection selection, bool omitHiddenShapes)
{
    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
}
 
QList<KoShape *> KoShapeManager::shapesAt(const QRectF &rect, bool omitHiddenShapes, bool containedMode)
{
    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;
}
 
void KoShapeManager::update(const QRectF &rect, const KoShape *shape, bool selectionHandles)
{
    if (d->updatesBlocked) return;
 
    {
        QMutexLocker l(&d->shapesMutex);
 
        d->compressedUpdate |= rect;
 
        if (selectionHandles) {
            d->compressedUpdatedShapes.insert(shape);
        }
    }
 
    emit(forwardUpdate());
}
 
void KoShapeManager::setUpdatesBlocked(bool value)
{
    d->updatesBlocked = value;
}
 
bool KoShapeManager::updatesBlocked() const
{
    return d->updatesBlocked;
}
void KoShapeManager::notifyShapeChanged(KoShape *shape)
{
    {
        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);
    }
}
 
QList<KoShape*> KoShapeManager::shapes() const
{
    QMutexLocker l(&d->shapesMutex);
 
    return d->shapes;
}
 
QList<KoShape*> KoShapeManager::topLevelShapes() const
{
    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;
}
 
KoSelection *KoShapeManager::selection() const
{
    return d->selection;
}
 
void KoShapeManager::explicitlyIssueShapeChangedSignals()
{
    d->updateTree();
}
 
KoCanvasBase *KoShapeManager::canvas()
{
    return d->canvas;
}
 
//have to include this because of Q_PRIVATE_SLOT
#include "moc_KoShapeManager.cpp"