kis_painting_assistants_decoration.cpp

Go to the documentation of this file.

/*
 *  SPDX-FileCopyrightText: 2009 Cyrille Berger <cberger@cberger.net>
 *  SPDX-FileCopyrightText: 2017 Scott Petrovic <scottpetrovic@gmail.com>
 *  SPDX-FileCopyrightText: 2026 Ayanami Kaine <personal@ayanamikaine.com>
 *
 *  SPDX-License-Identifier: GPL-2.0-or-later
 */
 
#include "kis_painting_assistants_decoration.h"
 
#include <optional>
#include <cstdint>
#include <limits>
 
#include <QList>
#include <QPointF>
#include <klocalizedstring.h>
#include <kactioncollection.h>
#include <ktoggleaction.h>
#include <kis_algebra_2d.h>
#include "kis_debug.h"
#include "KisDocument.h"
#include "kis_canvas2.h"
#include "kis_canvas_resource_provider.h"
#include "kis_icon_utils.h"
#include "KisViewManager.h"
#include <KoColor.h>
#include <KoCompositeOpRegistry.h>
#include <KoColorSpaceRegistry.h>
#include "kis_tool_proxy.h"
#include <KoColorDisplayRendererInterface.h>
 
#include <QPainter>
#include <QPainterPath>
#include <QApplication>
 
#include "kis_temporary_paint_constraint.h"
 
namespace {
bool hasLockedValidTemporaryConstraint(const std::optional<KisTemporaryPaintConstraint> &constraint)
{
    return constraint && constraint->isLocked() && constraint->hasValidLine();
}
}
 
struct KisPaintingAssistantsDecoration::Private {
    Private()
        : assistantVisible(false)
        , outlineVisible(false)
        , snapOnlyOneAssistant(true)
        , snapEraser(false)
        , useCache(false)
        , firstAssistant(0)
        , m_handleSize(14)
    {}
 
    bool assistantVisible;
    bool outlineVisible;
    bool snapOnlyOneAssistant;
    bool snapEraser;
    bool useCache;
    KisPaintingAssistantSP firstAssistant;
    KisPaintingAssistantSP selectedAssistant;
    bool m_isEditingAssistants = false;
    int m_handleSize; // size of editor handles on assistants
 
    KisCanvas2 * m_canvas = 0;
    std::optional<KisTemporaryPaintConstraint> temporaryConstraint;
    QPointF temporaryAdjustedBrushPosition;
    bool hasTemporaryAdjustedBrushPosition = false;
};
 
 
 
KisPaintingAssistantsDecoration::KisPaintingAssistantsDecoration(QPointer<KisView> parent) :
    KisCanvasDecoration("paintingAssistantsDecoration", parent),
    d(new Private)
{
    setAssistantVisible(true);
    setOutlineVisible(true);
    setPriority(95);
    d->snapOnlyOneAssistant = true; //turn on by default.
    d->snapEraser = false;
 
    slotConfigChanged(); // load the initial config
}
 
KisPaintingAssistantsDecoration::~KisPaintingAssistantsDecoration()
{
    delete d;
}
 
void KisPaintingAssistantsDecoration::slotUpdateDecorationVisibility()
{
    const bool shouldBeVisible = !assistants().isEmpty() || d->temporaryConstraint.has_value();
 
    if (visible() != shouldBeVisible) {
        setVisible(shouldBeVisible);
    }
}
 
void KisPaintingAssistantsDecoration::slotConfigChanged()
{
    KisConfig cfg(true);
    const KisConfig::AssistantsDrawMode drawMode = cfg.assistantsDrawMode();
 
    d->useCache =
        (drawMode == KisConfig::ASSISTANTS_DRAW_MODE_PIXMAP_CACHE) ||
        (drawMode == KisConfig::ASSISTANTS_DRAW_MODE_LARGE_PIXMAP_CACHE);
}
 
void KisPaintingAssistantsDecoration::addAssistant(KisPaintingAssistantSP assistant)
{
    QList<KisPaintingAssistantSP> assistants = view()->document()->assistants();
    if (assistants.contains(assistant)) return;
 
    assistants.append(assistant);
    assistant->setAssistantGlobalColorCache(view()->document()->assistantsGlobalColor());
 
    view()->document()->setAssistants(assistants);
    slotUpdateDecorationVisibility();
    Q_EMIT assistantChanged();
}
 
// bring assistant to front of assistants list, effectively causing assistant to be rendered above the others
void KisPaintingAssistantsDecoration::raiseAssistant(KisPaintingAssistantSP assistant)
{
    QList<KisPaintingAssistantSP> assistants = view()->document()->assistants();
    assistants.removeOne(assistant);
 
    if (!assistant) return;
    assistants.append(assistant);
 
    view()->document()->setAssistants(assistants);
    slotUpdateDecorationVisibility();
    Q_EMIT assistantChanged();
 
}
 
void KisPaintingAssistantsDecoration::removeAssistant(KisPaintingAssistantSP assistant)
{
    QList<KisPaintingAssistantSP> assistants = view()->document()->assistants();
    KIS_ASSERT_RECOVER_NOOP(assistants.contains(assistant));
 
    if (assistants.removeAll(assistant)) {
        view()->document()->setAssistants(assistants);
        slotUpdateDecorationVisibility();
        Q_EMIT assistantChanged();
    }
}
 
void KisPaintingAssistantsDecoration::removeAll()
{
    QList<KisPaintingAssistantSP> assistants = view()->document()->assistants();
    assistants.clear();
    view()->document()->setAssistants(assistants);
    slotUpdateDecorationVisibility();
 
    Q_EMIT assistantChanged();
}
 
void KisPaintingAssistantsDecoration::setAssistants(const QList<KisPaintingAssistantSP> &assistants)
{
    Q_FOREACH (KisPaintingAssistantSP assistant, assistants) {
        assistant->setAssistantGlobalColorCache(view()->document()->assistantsGlobalColor());
    }
    view()->document()->setAssistants(assistants);
    slotUpdateDecorationVisibility();
 
    Q_EMIT assistantChanged();
}
 
void KisPaintingAssistantsDecoration::setAdjustedBrushPosition(const QPointF position)
{
    if (hasLockedValidTemporaryConstraint(d->temporaryConstraint)) {
        d->temporaryAdjustedBrushPosition = position;
        d->hasTemporaryAdjustedBrushPosition = true;
 
        if (d->m_canvas) {
            d->m_canvas->updateCanvasDecorations();
        }
    }
 
    if (!assistants().empty()) {
        Q_FOREACH (KisPaintingAssistantSP assistant, assistants()) {
            assistant->setAdjustedBrushPosition(position);
        }
    }
}
 
 
QPointF KisPaintingAssistantsDecoration::adjustPosition(const QPointF& point, const QPointF& strokeBegin)
{
    if (assistants().empty() && !hasLockedValidTemporaryConstraint(d->temporaryConstraint)) {
        // No assistants, so no adjustment
        return point;
    }
 
    if (!d->m_canvas && view()) {
        d->m_canvas = view()->canvasBase();
    }
 
    if (!d->m_canvas) {
        return point;
    }
 
    if  (!d->snapEraser
        && (d->m_canvas->resourceManager()->resource(KoCanvasResource::CurrentEffectiveCompositeOp).toString() == COMPOSITE_ERASE)) {
        // No snapping if eraser snapping is disabled and brush is an eraser
        return point;
    }
 
    KisImageSP image = d->m_canvas->image();
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(image, point);
 
    const KisCoordinatesConverter *converter = d->m_canvas->coordinatesConverter();
    const qreal moveThresholdPt = 4.0 / (converter->effectiveZoom() * qMax(image->xRes(), image->yRes()));
 
    if (hasLockedValidTemporaryConstraint(d->temporaryConstraint)) {
        return d->temporaryConstraint->adjustPosition(point, strokeBegin, false, 0.0);
    }
 
    QPointF best = point;
    qreal minSquareDistance = std::numeric_limits<qreal>::max();
    qreal secondSquareDistance = std::numeric_limits<qreal>::max();
 
    if (!d->snapOnlyOneAssistant || !d->firstAssistant) {
        // In these cases the best assistant needs to be determined.
        int numSuitableAssistants = 0;
        KisPaintingAssistantSP bestAssistant;
 
        Q_FOREACH (KisPaintingAssistantSP assistant, assistants()) {
            if (assistant->isSnappingActive() == true){ // the toggle button with eye icon to disable assistants
                QPointF newpoint = assistant->adjustPosition(point, strokeBegin, true, moveThresholdPt);
                // Assistants that can't or don't want to snap return NaN values (aside from possible numeric issues)
                // NOTE: It would be safer to also reject points too far outside canvas (or widget?) area,
                // because for example squashed concentric ellipses can currently shoot points far off.
                if (qIsNaN(newpoint.x()) ||  qIsNaN(newpoint.y())) {
                    continue;
                }
                ++numSuitableAssistants;
                qreal dist = kisSquareDistance(newpoint, point);
                if (dist < minSquareDistance) {
                    best = newpoint;
                    secondSquareDistance = minSquareDistance;
                    minSquareDistance = dist;
                    bestAssistant = assistant;
                } else if (dist < secondSquareDistance) {
                    secondSquareDistance = dist;
                }
                assistant->setFollowBrushPosition(true);
            }
        }
 
        // When there are multiple choices within moveThresholdPt, delay the decision until movement leaves
        // threshold to determine which curve follows cursor movement the closest. Assistants with multiple
        // snapping curves also need this movement to decide the best choice.
        // NOTE: It is currently not possible to tell painting tools that a decision is pending, or that
        // the active snapping curve changed, so certain artifact lines from snapping changes are unavoidable.
 
        if (numSuitableAssistants > 1 && KisAlgebra2D::norm(point - strokeBegin) <= moveThresholdPt
                && (sqrt(secondSquareDistance) < moveThresholdPt)) {
            return strokeBegin;
        } else if (numSuitableAssistants > 0 && d->snapOnlyOneAssistant) {
            // if only snapping to one assistant, register it
            d->firstAssistant = bestAssistant;
        }
    } else {
        // Make sure BUG:448187 doesn't crop up again
        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(d->firstAssistant->isSnappingActive(), point);
        // there already is an assistant locked in, check if it can be used
        QPointF newpoint = d->firstAssistant->adjustPosition(point, strokeBegin, false, moveThresholdPt);
        // BUGFIX: 402535
        // assistants might return (NaN,NaN), must always check for that
        if (!(qIsNaN(newpoint.x()) || qIsNaN(newpoint.y()))) {
            best = newpoint;
        }
    }
 
    return best;
}
 
void KisPaintingAssistantsDecoration::adjustLine(QPointF &point, QPointF &strokeBegin)
{
    if (assistants().empty()) {
        // No assistants, so no adjustment
        return;
    }
 
    // TODO: figure it out
    if  (!d->snapEraser
        && (d->m_canvas->resourceManager()->resource(KoCanvasResource::CurrentEffectiveCompositeOp).toString() == COMPOSITE_ERASE)) {
        // No snapping if eraser snapping is disabled and brush is an eraser
        return;
    }
 
    QPointF originalPoint = point;
    QPointF originalStrokeBegin = strokeBegin;
 
    qreal minDistance = 10000.0;
    bool minDistValid = false;
    QPointF finalPoint = originalPoint;
    QPointF finalStrokeBegin = originalStrokeBegin;
    KisPaintingAssistantSP bestAssistant;
    Q_FOREACH (KisPaintingAssistantSP assistant, assistants()) {
        if(assistant->isSnappingActive() == true){//this checks if the assistant in question has it's snapping boolean turned on//
            //QPointF pt = assistant->adjustPosition(point, strokeBegin, true);
            QPointF p1 = originalPoint;
            QPointF p2 = originalStrokeBegin;
            assistant->adjustLine(p1, p2);
            if (p1.isNull() || p2.isNull()) {
                // possibly lines cannot snap to this assistant, or this line cannot, at least
                continue;
            }
            qreal distance = kisSquareDistance(p1, originalPoint) + kisSquareDistance(p2, originalStrokeBegin);
            if (distance < minDistance || !minDistValid) {
                finalPoint = p1;
                finalStrokeBegin = p2;
                minDistValid = true;
                bestAssistant = assistant;
            }
        }
    }
    if (bestAssistant) {
        bestAssistant->setFollowBrushPosition(true);
    }
    point = finalPoint;
    strokeBegin = finalStrokeBegin;
}
 
void KisPaintingAssistantsDecoration::endStroke()
{
    d->firstAssistant.clear();
 
    Q_FOREACH (KisPaintingAssistantSP assistant, assistants()) {
        assistant->endStroke();
    }
}
 
void KisPaintingAssistantsDecoration::setTemporaryConstraint(std::optional<KisTemporaryPaintConstraint> constraint)
{
    const bool hadTemporaryConstraint = d->temporaryConstraint.has_value();
    d->temporaryConstraint = constraint;
    const bool hasTemporaryConstraint = d->temporaryConstraint.has_value();
 
    if (!hasLockedValidTemporaryConstraint(d->temporaryConstraint)) {
        d->hasTemporaryAdjustedBrushPosition = false;
    }
 
    if (hadTemporaryConstraint != hasTemporaryConstraint) {
        Q_EMIT temporaryConstraintAvailabilityChanged();
    }
 
    slotUpdateDecorationVisibility();
 
    if (d->m_canvas) {
        d->m_canvas->updateCanvasDecorations();
    }
}
 
std::optional<KisTemporaryPaintConstraint> KisPaintingAssistantsDecoration::temporaryConstraint() const
{
    return d->temporaryConstraint;
}
 
void KisPaintingAssistantsDecoration::drawDecoration(QPainter& gc, const QRectF& updateRect, const KisCoordinatesConverter *converter, KisCanvas2* canvas)
{
    if (!canvas) {
        dbgFile<<"canvas does not exist in painting assistant decoration, you may have passed arguments incorrectly:"<<canvas;
    } else {
        d->m_canvas = canvas;
    }
 
    if(assistants().isEmpty() && !d->temporaryConstraint) {
        return; // no assistants to worry about, ok to exit
    }
 
    // the preview functionality for assistants. do not show while editing
 
    KoToolProxy *proxy = view()->canvasBase()->toolProxy();
    KIS_SAFE_ASSERT_RECOVER_RETURN(proxy);
    KisToolProxy *kritaProxy = dynamic_cast<KisToolProxy*>(proxy);
    KIS_SAFE_ASSERT_RECOVER_RETURN(kritaProxy);
 
    const bool outlineVisible =
        outlineVisibility() &&
        !d->m_isEditingAssistants &&
        kritaProxy->supportsPaintingAssistants();
 
    if (outlineVisible && d->temporaryConstraint && d->temporaryConstraint->hasLine()) {
        gc.save();
        gc.resetTransform();
        gc.setRenderHint(QPainter::Antialiasing, true);
 
        QTransform initialTransform = converter->documentToWidgetTransform();
        QPointF p1 = initialTransform.map(d->temporaryConstraint->lineAnchor());
        QPointF p2 = initialTransform.map(d->temporaryConstraint->lineSecondPoint());
 
        QColor color = globalAssistantsColor();
        color.setAlpha(180);
        QPen pen(canvas->displayRendererInterface()->convertColorToDisplayColorSpace(KoColor(color, KoColorSpaceRegistry::instance()->rgb8())), 1);
        pen.setCosmetic(true);
        gc.setPen(pen);
 
        if (!d->temporaryConstraint->isLocked()) {
            QPen anchorOutlinePen(QColor(0, 0, 0, 180), 1.0);
            anchorOutlinePen.setCosmetic(true);
            gc.setPen(anchorOutlinePen);
            gc.setBrush(Qt::NoBrush);
            gc.drawEllipse(p1, 4.0, 4.0);
 
            QPen anchorPen(canvas->displayRendererInterface()->convertColorToDisplayColorSpace(KoColor(color, KoColorSpaceRegistry::instance()->rgb8())), 1.0);
            anchorPen.setCosmetic(true);
            gc.setPen(anchorPen);
            gc.drawLine(p1 + QPointF(-6.0, 0.0), p1 + QPointF(6.0, 0.0));
            gc.drawLine(p1 + QPointF(0.0, -6.0), p1 + QPointF(0.0, 6.0));
        }
 
        gc.setPen(pen);
        if (KisAlgebra2D::normSquared(p1 - p2) > 1e-6) {
            QLineF snapLine(p1, p2);
            KisAlgebra2D::intersectLineRect(snapLine, gc.viewport(), true);
 
            QPainterPath path;
            path.moveTo(snapLine.p1());
            path.lineTo(snapLine.p2());
            gc.drawPath(path);
        }
 
        if (d->temporaryConstraint) {
            const QPointF markerDocPos =
                d->hasTemporaryAdjustedBrushPosition ?
                    d->temporaryAdjustedBrushPosition :
                    d->temporaryConstraint->lineSecondPoint();
 
            const QPointF brushPos = initialTransform.map(markerDocPos);
            const qreal markerRadius = 9.0;
 
            QPen markerOutlinePen(QColor(0, 0, 0, 190), 1.0);
            markerOutlinePen.setCosmetic(true);
            gc.setPen(markerOutlinePen);
            gc.setBrush(Qt::NoBrush);
            gc.drawEllipse(brushPos, markerRadius, markerRadius);
 
            QPen markerPen(canvas->displayRendererInterface()->convertColorToDisplayColorSpace(KoColor(color, KoColorSpaceRegistry::instance()->rgb8())), 1.0);
            markerPen.setCosmetic(true);
            gc.setPen(markerPen);
            gc.drawEllipse(brushPos, markerRadius - 2.0, markerRadius - 2.0);
        }
        gc.restore();
    }
 
 
    Q_FOREACH (KisPaintingAssistantSP assistant, assistants()) {
        assistant->drawAssistant(gc, updateRect, converter, canvas->displayRendererInterface(), d->useCache, canvas, assistantVisibility(), outlineVisible);
 
        if (isEditingAssistants()) {
            drawHandles(assistant, gc, converter, canvas->displayRendererInterface());
        }
    }
 
    // draw editor controls on top of all assistant lines (why this code is last)
    if (isEditingAssistants()) {
        Q_FOREACH (KisPaintingAssistantSP assistant, assistants()) {
            drawEditorWidget(assistant, gc, converter, canvas->displayRendererInterface());
        }
     }
}
 
void KisPaintingAssistantsDecoration::drawHandles(KisPaintingAssistantSP assistant, QPainter& gc, const KisCoordinatesConverter *converter, const KoColorDisplayRendererInterface *renderInterface)
{
        QTransform initialTransform = converter->documentToWidgetTransform();
 
    KoColor c;
        c.fromQColor(assistant->effectiveAssistantColor());
        QColor colorToPaint = renderInterface->convertColorToDisplayColorSpace(c);
 
        Q_FOREACH (const KisPaintingAssistantHandleSP handle, assistant->handles()) {
 
 
            QPointF transformedHandle = initialTransform.map(*handle);
            QRectF ellipse(transformedHandle -  QPointF(handleSize() * 0.5, handleSize() * 0.5), QSizeF(handleSize(), handleSize()));
 
            QPainterPath path;
            path.addEllipse(ellipse);
 
            gc.save();
            gc.setPen(Qt::NoPen);
            gc.setBrush(colorToPaint);
            gc.drawPath(path);
            gc.restore();
        }
 
         // some assistants have side handles like the vanishing point assistant
         Q_FOREACH (const KisPaintingAssistantHandleSP handle, assistant->sideHandles()) {
             QPointF transformedHandle = initialTransform.map(*handle);
             QRectF ellipse(transformedHandle -  QPointF(handleSize() * 0.5, handleSize() * 0.5), QSizeF(handleSize(), handleSize()));
 
             QPainterPath path;
             path.addEllipse(ellipse);
 
             gc.save();
             gc.setPen(Qt::NoPen);
             gc.setBrush(colorToPaint);
             gc.drawPath(path);
             gc.restore();
         }
}
 
int KisPaintingAssistantsDecoration::handleSize()
{
    return  d->m_handleSize;
}
 
void KisPaintingAssistantsDecoration::setHandleSize(int handleSize)
{
    d->m_handleSize = handleSize;
}
 
QList<KisPaintingAssistantHandleSP> KisPaintingAssistantsDecoration::handles()
{
    QList<KisPaintingAssistantHandleSP> hs;
    Q_FOREACH (KisPaintingAssistantSP assistant, assistants()) {
        Q_FOREACH (const KisPaintingAssistantHandleSP handle, assistant->handles()) {
            if (!hs.contains(handle)) {
                hs.push_back(handle);
            }
        }
        Q_FOREACH (const KisPaintingAssistantHandleSP handle, assistant->sideHandles()) {
            if (!hs.contains(handle)) {
                hs.push_back(handle);
            }
        }
    }
    return hs;
}
 
QList<KisPaintingAssistantSP> KisPaintingAssistantsDecoration::assistants() const
{
    QList<KisPaintingAssistantSP> assistants;
    if (view()) {
        if (view()->document()) {
            assistants = view()->document()->assistants();
        }
    }
    return assistants;
}
 
bool KisPaintingAssistantsDecoration::hasPaintableAssistants() const
{
    return !assistants().isEmpty() || hasLockedValidTemporaryConstraint(d->temporaryConstraint);
}
 
KisPaintingAssistantSP KisPaintingAssistantsDecoration::selectedAssistant()
{
    return d->selectedAssistant;
}
 
void KisPaintingAssistantsDecoration::setSelectedAssistant(KisPaintingAssistantSP assistant)
{
    d->selectedAssistant = assistant;
    Q_EMIT selectedAssistantChanged();
}
 
void KisPaintingAssistantsDecoration::deselectAssistant()
{
    d->selectedAssistant.clear();
}
 
 
void KisPaintingAssistantsDecoration::setAssistantVisible(bool set)
{
    d->assistantVisible=set;
}
 
void KisPaintingAssistantsDecoration::setOutlineVisible(bool set)
{
    d->outlineVisible=set;
}
 
void KisPaintingAssistantsDecoration::setOnlyOneAssistantSnap(bool assistant)
{
    d->snapOnlyOneAssistant = assistant;
}
 
void KisPaintingAssistantsDecoration::setEraserSnap(bool assistant)
{
    d->snapEraser = assistant;
}
 
bool KisPaintingAssistantsDecoration::assistantVisibility()
{
    return d->assistantVisible;
}
bool KisPaintingAssistantsDecoration::outlineVisibility()
{
    return d->outlineVisible;
}
void KisPaintingAssistantsDecoration::uncache()
{
    Q_FOREACH (KisPaintingAssistantSP assistant, assistants()) {
        assistant->uncache();
    }
 
    // Redraw canvas decorations in case the change was made off canvas
    if (d->m_canvas) {
        d->m_canvas->updateCanvasDecorations();
    }
}
void KisPaintingAssistantsDecoration::toggleAssistantVisible()
{
    setAssistantVisible(!assistantVisibility());
    uncache();
}
 
void KisPaintingAssistantsDecoration::toggleOutlineVisible()
{
    // "outline" means assistant preview (line that depends on the mouse cursor)
    setOutlineVisible(!outlineVisibility());
    uncache();
}
 
QColor KisPaintingAssistantsDecoration::globalAssistantsColor()
{
    return view()->document()->assistantsGlobalColor();
}
 
void KisPaintingAssistantsDecoration::setGlobalAssistantsColor(QColor color)
{
    // view()->document() is referenced multiple times in this class
    // it is used to later store things in the KRA file when saving.
    view()->document()->setAssistantsGlobalColor(color);
 
    Q_FOREACH (KisPaintingAssistantSP assistant, assistants()) {
        assistant->setAssistantGlobalColorCache(color);
    }
 
    uncache();
}
 
void KisPaintingAssistantsDecoration::activateAssistantsEditor()
{
    setVisible(true); // this turns on the decorations in general. we leave it on at this point
    d->m_isEditingAssistants = true;
    uncache(); // updates visuals when editing
}
 
void KisPaintingAssistantsDecoration::deactivateAssistantsEditor()
{
    if (!d->m_canvas) {
        return;
    }
 
    d->m_isEditingAssistants = false; // some elements are hidden when we aren't editing
    uncache(); // updates visuals when not editing
}
 
bool KisPaintingAssistantsDecoration::isEditingAssistants()
{
    return d->m_isEditingAssistants;
}
 
QPointF KisPaintingAssistantsDecoration::snapToGuide(KoPointerEvent *e, const QPointF &offset, bool useModifiers)
{
    if (!d->m_canvas || !d->m_canvas->currentImage()) {
        return e->point;
    }
 
 
    KoSnapGuide *snapGuide = d->m_canvas->snapGuide();
    QPointF pos = snapGuide->snap(e->point, offset, useModifiers ? e->modifiers() : Qt::NoModifier);
 
    return pos;
}
 
QPointF KisPaintingAssistantsDecoration::snapToGuide(const QPointF& pt, const QPointF &offset)
{
    if (!d->m_canvas) {
         return pt;
    }
 
 
    KoSnapGuide *snapGuide = d->m_canvas->snapGuide();
    QPointF pos = snapGuide->snap(pt, offset, Qt::NoModifier);
 
    return pos;
}
 
/*
 * functions only used internally in this class
 * we potentially could make some of these inline to speed up performance
*/
 
void drawSingleState(QPainter& gc, const QIcon &icon, const QSize &iconSize, QRect maxRect, const QPoint &position, const KoColorDisplayRendererInterface *renderInterface, QPoint additional = QPoint()) {
    maxRect.moveTopLeft(position+additional);
    const QMargins m(2, 2, 2, 2);
 
#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
    QRect target(QPoint(), iconSize);
    target.moveCenter(maxRect.center());
    target = target.marginsRemoved(m);
    icon.paint(&gc, target);
#else
 
    QImage ic = icon.pixmap(iconSize.width(), iconSize.height()).toImage();
    QRect target(QPoint(), (ic.size()/ic.devicePixelRatioF()));
    target.moveCenter(maxRect.center());
    target = target.marginsRemoved(m);
    gc.drawImage(target.intersected(maxRect), renderInterface->convertImageToDisplayColorSpace(ic));
#endif
}
 
void drawDoubleState(QPainter& gc, const QIcon &icon, const QSize &iconSize, const QIcon &icon2, QRect maxRect, const QPoint &position, const bool state, const KoColorDisplayRendererInterface *renderInterface) {
    maxRect.moveTopLeft(position);
    const QMargins m(2, 2, 2, 2);
#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
    QRect target(QPoint(), iconSize);
    target.moveCenter(maxRect.center());
    target = target.marginsRemoved(m);
    if (state) {
        icon.paint(&gc, target);
    } else {
        gc.save();
        gc.setOpacity(0.35);
        icon2.paint(&gc, target);
        gc.restore();
    }
#else
    QImage ic = state? icon.pixmap(iconSize.width(), iconSize.height()).toImage(): icon2.pixmap(iconSize.width(), iconSize.height()).toImage();
    QRect target(QPoint(), (ic.size()/ic.devicePixelRatioF()));
    target.moveCenter(maxRect.center());
    target = target.marginsRemoved(m);
    if (state) {
        gc.drawImage(target.intersected(maxRect), renderInterface->convertImageToDisplayColorSpace(ic));
    } else {
        gc.save();
        gc.setOpacity(0.35);
        gc.drawImage(target.intersected(maxRect.marginsRemoved(m)), renderInterface->convertImageToDisplayColorSpace(ic));
        gc.restore();
    }
#endif
}
 
void KisPaintingAssistantsDecoration::drawEditorWidget(KisPaintingAssistantSP assistant, QPainter& gc, const KisCoordinatesConverter *converter, const KoColorDisplayRendererInterface *renderInterface)
{
    if (!assistant->isAssistantComplete() || !globalEditorWidgetData.widgetActivated) {
        return;
    }
 
    QTransform initialTransform = converter->documentToWidgetTransform();
    QPointF actionsPosition = initialTransform.map(assistant->viewportConstrainedEditorPosition(converter, globalEditorWidgetData.boundingSize));
 
    //draw editor widget background
    QPalette sysPalette = renderInterface->systemPaletteForDisplayColorSpace();
 
    QBrush backgroundColor = sysPalette.window();
    QPointF actionsBGRectangle(actionsPosition + QPointF(globalEditorWidgetData.widgetOffset,globalEditorWidgetData.widgetOffset));
    QPen stroke(sysPalette.window(), 2);
 
 
    gc.setRenderHint(QPainter::Antialiasing);
 
 
    QPainterPath bgPath;
    QRectF bgRect(actionsBGRectangle.x(),
                  actionsBGRectangle.y(),
                  globalEditorWidgetData.boundingSize.width(),
                  globalEditorWidgetData.boundingSize.height());
    bgPath.addRoundedRect(bgRect, 6, 6);
 
 
    // if the assistant is selected, make outline stroke fatter and use theme's highlight color
    // for better visual feedback
    if (selectedAssistant()) { // there might not be a selected assistant, so do not seg fault
        if (assistant->getEditorPosition() == selectedAssistant()->getEditorPosition()) {
            stroke.setWidth(6);
            stroke.setColor(sysPalette.color(QPalette::Highlight));
 
        }
    }
 
    gc.setPen(stroke);
    gc.drawPath(bgPath);
    gc.fillPath(bgPath, backgroundColor);
 
    // If the assistant uses a custom color, draw a colored strip at the bottom
    // of the editor rectangle so that the association is clear.
    if (assistant->useCustomColor()) {
        KoColor c;
        c.fromQColor(assistant->effectiveAssistantColor());
        QColor assistantColor = renderInterface->convertColorToDisplayColorSpace(c);
        assistantColor.setAlpha(255); // No point in having transparency here.
 
        gc.save();
        gc.setClipPath(bgPath, Qt::IntersectClip);
        gc.fillRect(QRectF(QPointF(bgRect.left(), bgRect.bottom() - 4.0), bgRect.bottomRight()), assistantColor);
        gc.restore();
    }
 
    //draw drag handle
    KoColor c;
    c.fromQColor(QColor(150,150,150,255));
    QColor dragDecorationColor = renderInterface->convertColorToDisplayColorSpace(c);
 
    QPainterPath dragRect;
    int width = actionsPosition.x()+globalEditorWidgetData.boundingSize.width()-globalEditorWidgetData.dragDecorationWidth+globalEditorWidgetData.widgetOffset;
    dragRect.addRect(QRectF(width,actionsPosition.y()+globalEditorWidgetData.widgetOffset,globalEditorWidgetData.dragDecorationWidth,globalEditorWidgetData.boundingSize.height()));
 
    gc.fillPath(bgPath.intersected(dragRect),dragDecorationColor);
 
    //draw dot decoration on handle
    QPainterPath dragRectDots;
    c.fromQColor(QColor(50,50,50,255));
    QColor dragDecorationDotsColor = renderInterface->convertColorToDisplayColorSpace(c);
    int dotSize = 2;
    dragRectDots.addEllipse(3,2.5,dotSize,dotSize);
    dragRectDots.addEllipse(3,7.5,dotSize,dotSize);
    dragRectDots.addEllipse(3,-2.5,dotSize,dotSize);
    dragRectDots.addEllipse(3,-7.5,dotSize,dotSize);
    dragRectDots.addEllipse(-3,2.5,dotSize,dotSize);
    dragRectDots.addEllipse(-3,7.5,dotSize,dotSize);
    dragRectDots.addEllipse(-3,-2.5,dotSize,dotSize);
    dragRectDots.addEllipse(-3,-7.5,dotSize,dotSize);
    dragRectDots.translate((globalEditorWidgetData.dragDecorationWidth/2)+width,(globalEditorWidgetData.boundingSize.height()/2)+actionsPosition.y()+globalEditorWidgetData.widgetOffset);
    gc.fillPath(dragRectDots,dragDecorationDotsColor);
 
    QRect buttonRect(QPoint(0,0), QSize(globalEditorWidgetData.buttonSize, globalEditorWidgetData.buttonSize));
    //loop over all visible buttons and render them
    if (globalEditorWidgetData.moveButtonActivated) {
        QPoint pos = QPointF(actionsPosition + globalEditorWidgetData.moveIconPosition).toPoint();
        drawSingleState(gc, globalEditorWidgetData.m_iconMove, QSize(globalEditorWidgetData.buttonSize+10, globalEditorWidgetData.buttonSize+10), buttonRect, pos, renderInterface, QPoint(5, 5));
    }
    if (globalEditorWidgetData.snapButtonActivated) {
        QPoint pos = QPointF(actionsPosition + globalEditorWidgetData.snapIconPosition).toPoint();
        drawDoubleState(gc, globalEditorWidgetData.m_iconSnapOn, QSize(globalEditorWidgetData.buttonSize, globalEditorWidgetData.buttonSize), globalEditorWidgetData.m_iconSnapOff, buttonRect, pos, assistant->isSnappingActive(), renderInterface);
    }
    if (globalEditorWidgetData.lockButtonActivated) {
        QPoint pos = QPointF(actionsPosition + globalEditorWidgetData.lockedIconPosition).toPoint();
        drawDoubleState(gc, globalEditorWidgetData.m_iconLockOn, QSize(globalEditorWidgetData.buttonSize, globalEditorWidgetData.buttonSize), globalEditorWidgetData.m_iconLockOff, buttonRect, pos, assistant->isLocked(), renderInterface);
    }
    if (globalEditorWidgetData.duplicateButtonActivated) {
        QPoint pos = QPointF(actionsPosition + globalEditorWidgetData.duplicateIconPosition).toPoint();
        drawDoubleState(gc, globalEditorWidgetData.m_iconDuplicate, QSize(globalEditorWidgetData.buttonSize, globalEditorWidgetData.buttonSize), globalEditorWidgetData.m_iconDuplicate, buttonRect, pos, !assistant->isDuplicating(), renderInterface);
    }
    if (globalEditorWidgetData.deleteButtonActivated) {
        QPoint pos = QPointF(actionsPosition + globalEditorWidgetData.deleteIconPosition).toPoint();
        drawSingleState(gc, globalEditorWidgetData.m_iconDelete, QSize(globalEditorWidgetData.buttonSize, globalEditorWidgetData.buttonSize), buttonRect, pos, renderInterface);
    }
}