#include <kis_painting_assistants_decoration.h>

Inheritance diagram for KisPaintingAssistantsDecoration:

Classes
struct	Private

Public Slots
void	slotConfigChanged ()

void	slotUpdateDecorationVisibility ()

QPointF	snapToGuide (const QPointF &pt, const QPointF &offset)

QPointF	snapToGuide (KoPointerEvent *e, const QPointF &offset, bool useModifiers)

void	toggleAssistantVisible ()
	toggles whether the assistant is active or not

void	toggleOutlineVisible ()
	toggles whether there will be a preview of the assistant result when painting

Public Slots inherited from KisCanvasDecoration
virtual void	setVisible (bool v)

void	toggleVisibility ()

Signals
void	assistantChanged ()

void	selectedAssistantChanged ()

void	temporaryConstraintAvailabilityChanged ()

Public Member Functions
void	activateAssistantsEditor ()

void	addAssistant (KisPaintingAssistantSP assistant)

void	adjustLine (QPointF &point, QPointF &strokeBegin)

QPointF	adjustPosition (const QPointF &point, const QPointF &strokeBegin)

QList< KisPaintingAssistantSP >	assistants () const

bool	assistantVisibility ()
	returns assistant visibility

void	deactivateAssistantsEditor ()

void	deselectAssistant ()

void	endStroke ()

QColor	globalAssistantsColor ()

QList< KisPaintingAssistantHandleSP >	handles ()

int	handleSize ()

bool	hasPaintableAssistants () const

bool	isEditingAssistants ()

	KisPaintingAssistantsDecoration (QPointer< KisView > parent)

bool	outlineVisibility ()
	returns preview visibility

void	raiseAssistant (KisPaintingAssistantSP assistant)

void	removeAll ()

void	removeAssistant (KisPaintingAssistantSP assistant)

KisPaintingAssistantSP	selectedAssistant ()

void	setAdjustedBrushPosition (const QPointF position)

void	setAssistants (const QList< KisPaintingAssistantSP > &assistants)

void	setAssistantVisible (bool set)
	sets whether the main assistant is visible

void	setEraserSnap (bool assistant)
	sets whether eraser brushes snap

void	setGlobalAssistantsColor (QColor color)

void	setHandleSize (int handleSize)

void	setOnlyOneAssistantSnap (bool assistant)
	sets whether we snap to only one assistant

void	setOutlineVisible (bool set)
	sets whether the preview is visible

void	setSelectedAssistant (KisPaintingAssistantSP assistant)

void	setTemporaryConstraint (std::optional< KisTemporaryPaintConstraint > constraint)

std::optional< KisTemporaryPaintConstraint >	temporaryConstraint () const

void	uncache ()
	uncache all assistants

	~KisPaintingAssistantsDecoration () override

Public Member Functions inherited from KisCanvasDecoration
const QString &	id () const

	KisCanvasDecoration (const QString &id, QPointer< KisView >parent)

virtual void	notifyWindowMinimized (bool minimized)

void	paint (QPainter &gc, const QRectF &updateRect, const KisCoordinatesConverter converter, KisCanvas2 canvas)

int	priority () const

virtual void	setCanvasWidget (KisCanvasWidgetBase *canvas)

void	setView (QPointer< KisView > imageView)

bool	visible () const

	~KisCanvasDecoration () override

Public Member Functions inherited from KisShared
bool	deref ()

bool	ref ()

int	refCount ()

QAtomicInt *	sharedWeakReference ()

Public Attributes
struct AssistantEditorData	globalEditorWidgetData

Protected Member Functions
void	drawDecoration (QPainter &gc, const QRectF &updateRect, const KisCoordinatesConverter converter, KisCanvas2 canvas) override

void	drawEditorWidget (KisPaintingAssistantSP assistant, QPainter &gc, const KisCoordinatesConverter converter, const KoColorDisplayRendererInterface renderInterface)

void	drawHandles (KisPaintingAssistantSP assistant, QPainter &gc, const KisCoordinatesConverter converter, const KoColorDisplayRendererInterface renderInterface)

Protected Member Functions inherited from KisCanvasDecoration
int	decorationThickness () const

void	setPriority (int value)

QPointer< KisView >	view () const

Protected Member Functions inherited from KisShared
	KisShared ()

	~KisShared ()

Private Attributes
Private *const	d

Additional Inherited Members
Static Public Member Functions inherited from KisCanvasDecoration
static bool	comparePriority (KisCanvasDecorationSP decoration1, KisCanvasDecorationSP decoration2)

Detailed Description

KisPaintingAssistantsDecoration draws the assistants stored in the document on the canvas. In the application flow, each canvas holds one of these classes to manage the assistants There is an assistants manager, but that is higher up in the flow and makes sure each view gets one of these Since this is off the canvas level, the decoration can be seen across all tools. The contents from here will be in front of the kis_assistant_tool, which hold and displays the editor controls.

Many of the events this receives such as adding and removing assistants comes from kis_assistant_tool

Definition at line 78 of file kis_painting_assistants_decoration.h.

Constructor & Destructor Documentation

◆ KisPaintingAssistantsDecoration()

KisPaintingAssistantsDecoration::KisPaintingAssistantsDecoration ( QPointer< KisView > parent )

Definition at line 75 of file kis_painting_assistants_decoration.cpp.

                                                                                         :
    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
}

References d, setAssistantVisible(), setOutlineVisible(), KisCanvasDecoration::setPriority(), slotConfigChanged(), KisPaintingAssistantsDecoration::Private::snapEraser, and KisPaintingAssistantsDecoration::Private::snapOnlyOneAssistant.

◆ ~KisPaintingAssistantsDecoration()

KisPaintingAssistantsDecoration::~KisPaintingAssistantsDecoration ( )

override

Definition at line 88 of file kis_painting_assistants_decoration.cpp.

{
    delete d;
}

References d.

Member Function Documentation

◆ activateAssistantsEditor()

void KisPaintingAssistantsDecoration::activateAssistantsEditor ( )

called when assistant editor is activated right now this happens when the assistants tool is selected

Definition at line 641 of file kis_painting_assistants_decoration.cpp.

{
    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
}

References d, KisPaintingAssistantsDecoration::Private::m_isEditingAssistants, KisCanvasDecoration::setVisible(), and uncache().

◆ addAssistant()

void KisPaintingAssistantsDecoration::addAssistant ( KisPaintingAssistantSP assistant )

Definition at line 112 of file kis_painting_assistants_decoration.cpp.

{
    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();
}

References assistantChanged(), assistants(), slotUpdateDecorationVisibility(), and KisCanvasDecoration::view().

◆ adjustLine()

void KisPaintingAssistantsDecoration::adjustLine	(	QPointF &	point,
		QPointF &	strokeBegin )

Definition at line 283 of file kis_painting_assistants_decoration.cpp.

{
    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;
}

References assistants(), COMPOSITE_ERASE, KoCanvasResource::CurrentEffectiveCompositeOp, d, distance(), kisSquareDistance(), KisPaintingAssistantsDecoration::Private::m_canvas, p1, p2, KoCanvasBase::resourceManager, and KisPaintingAssistantsDecoration::Private::snapEraser.

◆ adjustPosition()

QPointF KisPaintingAssistantsDecoration::adjustPosition	(	const QPointF &	point,
		const QPointF &	strokeBegin )

Definition at line 192 of file kis_painting_assistants_decoration.cpp.

{
    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;
}

References assistants(), COMPOSITE_ERASE, KisCanvas2::coordinatesConverter, KoCanvasResource::CurrentEffectiveCompositeOp, d, KisCoordinatesConverter::effectiveZoom(), KisPaintingAssistantsDecoration::Private::firstAssistant, KisCanvas2::image(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, kisSquareDistance(), KisPaintingAssistantsDecoration::Private::m_canvas, KisAlgebra2D::norm(), KoCanvasBase::resourceManager, KisPaintingAssistantsDecoration::Private::snapEraser, KisPaintingAssistantsDecoration::Private::snapOnlyOneAssistant, KisPaintingAssistantsDecoration::Private::temporaryConstraint, KisCanvasDecoration::view(), KisImage::xRes(), and KisImage::yRes().

◆ assistantChanged

void KisPaintingAssistantsDecoration::assistantChanged ( )

signal

◆ assistants()

QList< KisPaintingAssistantSP > KisPaintingAssistantsDecoration::assistants ( ) const

Definition at line 538 of file kis_painting_assistants_decoration.cpp.

{
    QList<KisPaintingAssistantSP> assistants;
    if (view()) {
        if (view()->document()) {
            assistants = view()->document()->assistants();
        }
    }
    return assistants;
}

References assistants(), and KisCanvasDecoration::view().

◆ assistantVisibility()

bool KisPaintingAssistantsDecoration::assistantVisibility ( )

returns assistant visibility

Definition at line 591 of file kis_painting_assistants_decoration.cpp.

{
    return d->assistantVisible;
}

References KisPaintingAssistantsDecoration::Private::assistantVisible, and d.

◆ deactivateAssistantsEditor()

void KisPaintingAssistantsDecoration::deactivateAssistantsEditor ( )

called when assistant editor is deactivated right now this happens when the assistants tool is un-selected

Definition at line 648 of file kis_painting_assistants_decoration.cpp.

{
    if (!d->m_canvas) {
        return;
    }
 
    d->m_isEditingAssistants = false; // some elements are hidden when we aren't editing
    uncache(); // updates visuals when not editing
}

References d, KisPaintingAssistantsDecoration::Private::m_canvas, KisPaintingAssistantsDecoration::Private::m_isEditingAssistants, and uncache().

◆ deselectAssistant()

void KisPaintingAssistantsDecoration::deselectAssistant ( )

Definition at line 565 of file kis_painting_assistants_decoration.cpp.

{
    d->selectedAssistant.clear();
}

References d, and KisPaintingAssistantsDecoration::Private::selectedAssistant.

◆ drawDecoration()

void KisPaintingAssistantsDecoration::drawDecoration	(	QPainter &	gc,
		const QRectF &	updateRect,
		const KisCoordinatesConverter *	converter,
		KisCanvas2 *	canvas )

overrideprotectedvirtual

Implements KisCanvasDecoration.

Definition at line 366 of file kis_painting_assistants_decoration.cpp.

{
    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());
        }
     }
}

References assistants(), assistantVisibility(), KoColorDisplayRendererInterface::convertColorToDisplayColorSpace(), d, dbgFile, KisCanvas2::displayRendererInterface(), KisCoordinatesConverter::documentToWidgetTransform(), drawEditorWidget(), drawHandles(), globalAssistantsColor(), KisPaintingAssistantsDecoration::Private::hasTemporaryAdjustedBrushPosition, KoColorSpaceRegistry::instance(), KisAlgebra2D::intersectLineRect(), isEditingAssistants(), KIS_SAFE_ASSERT_RECOVER_RETURN, KisPaintingAssistantsDecoration::Private::m_canvas, KisPaintingAssistantsDecoration::Private::m_isEditingAssistants, KisAlgebra2D::normSquared(), outlineVisibility(), p1, p2, KisToolProxy::supportsPaintingAssistants(), KisPaintingAssistantsDecoration::Private::temporaryAdjustedBrushPosition, KisPaintingAssistantsDecoration::Private::temporaryConstraint, KisPaintingAssistantsDecoration::Private::useCache, and KisCanvasDecoration::view().

◆ drawEditorWidget()

void KisPaintingAssistantsDecoration::drawEditorWidget	(	KisPaintingAssistantSP	assistant,
		QPainter &	gc,
		const KisCoordinatesConverter *	converter,
		const KoColorDisplayRendererInterface *	renderInterface )

protected

Definition at line 744 of file kis_painting_assistants_decoration.cpp.

{
    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);
    }
}

◆ drawHandles()

void KisPaintingAssistantsDecoration::drawHandles	(	KisPaintingAssistantSP	assistant,
		QPainter &	gc,
		const KisCoordinatesConverter *	converter,
		const KoColorDisplayRendererInterface *	renderInterface )

protected

Definition at line 470 of file kis_painting_assistants_decoration.cpp.

{
        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();
         }
}

References KoColorDisplayRendererInterface::convertColorToDisplayColorSpace(), KisCoordinatesConverter::documentToWidgetTransform(), KoColor::fromQColor(), and handleSize().

◆ endStroke()

void KisPaintingAssistantsDecoration::endStroke ( )

Definition at line 331 of file kis_painting_assistants_decoration.cpp.

{
    d->firstAssistant.clear();
 
    Q_FOREACH (KisPaintingAssistantSP assistant, assistants()) {
        assistant->endStroke();
    }
}

References assistants(), d, and KisPaintingAssistantsDecoration::Private::firstAssistant.

◆ globalAssistantsColor()

QColor KisPaintingAssistantsDecoration::globalAssistantsColor ( )

Definition at line 623 of file kis_painting_assistants_decoration.cpp.

{
    return view()->document()->assistantsGlobalColor();
}

References KisCanvasDecoration::view().

◆ handles()

QList< KisPaintingAssistantHandleSP > KisPaintingAssistantsDecoration::handles ( )

Definition at line 520 of file kis_painting_assistants_decoration.cpp.

{
    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;
}

References assistants().

◆ handleSize()

int KisPaintingAssistantsDecoration::handleSize ( )

Definition at line 510 of file kis_painting_assistants_decoration.cpp.

{
    return  d->m_handleSize;
}

References d, and KisPaintingAssistantsDecoration::Private::m_handleSize.

◆ hasPaintableAssistants()

bool KisPaintingAssistantsDecoration::hasPaintableAssistants ( ) const

Definition at line 549 of file kis_painting_assistants_decoration.cpp.

{
    return !assistants().isEmpty() || hasLockedValidTemporaryConstraint(d->temporaryConstraint);
}

References assistants(), d, and KisPaintingAssistantsDecoration::Private::temporaryConstraint.

◆ isEditingAssistants()

bool KisPaintingAssistantsDecoration::isEditingAssistants ( )

brings back if we are currently editing assistants or not useful for some assistants (like spline) that draw bezier curves

Definition at line 658 of file kis_painting_assistants_decoration.cpp.

{
    return d->m_isEditingAssistants;
}

References d, and KisPaintingAssistantsDecoration::Private::m_isEditingAssistants.

◆ outlineVisibility()

bool KisPaintingAssistantsDecoration::outlineVisibility ( )

returns preview visibility

Definition at line 595 of file kis_painting_assistants_decoration.cpp.

{
    return d->outlineVisible;
}

References d, and KisPaintingAssistantsDecoration::Private::outlineVisible.

◆ raiseAssistant()

void KisPaintingAssistantsDecoration::raiseAssistant ( KisPaintingAssistantSP assistant )

Definition at line 126 of file kis_painting_assistants_decoration.cpp.

{
    QList<KisPaintingAssistantSP> assistants = view()->document()->assistants();
    assistants.removeOne(assistant);
 
    if (!assistant) return;
    assistants.append(assistant);
 
    view()->document()->setAssistants(assistants);
    slotUpdateDecorationVisibility();
    Q_EMIT assistantChanged();
 
}

References assistantChanged(), assistants(), slotUpdateDecorationVisibility(), and KisCanvasDecoration::view().

◆ removeAll()

void KisPaintingAssistantsDecoration::removeAll ( )

Definition at line 152 of file kis_painting_assistants_decoration.cpp.

{
    QList<KisPaintingAssistantSP> assistants = view()->document()->assistants();
    assistants.clear();
    view()->document()->setAssistants(assistants);
    slotUpdateDecorationVisibility();
 
    Q_EMIT assistantChanged();
}

References assistantChanged(), assistants(), slotUpdateDecorationVisibility(), and KisCanvasDecoration::view().

◆ removeAssistant()

void KisPaintingAssistantsDecoration::removeAssistant ( KisPaintingAssistantSP assistant )

Definition at line 140 of file kis_painting_assistants_decoration.cpp.

{
    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();
    }
}

References assistantChanged(), assistants(), KIS_ASSERT_RECOVER_NOOP, slotUpdateDecorationVisibility(), and KisCanvasDecoration::view().

◆ selectedAssistant()

KisPaintingAssistantSP KisPaintingAssistantsDecoration::selectedAssistant ( )

getter and setter functions for what assistant is currently selected this is used to control some tool options that are specific to a assistant

Definition at line 554 of file kis_painting_assistants_decoration.cpp.

{
    return d->selectedAssistant;
}

References d, and KisPaintingAssistantsDecoration::Private::selectedAssistant.

◆ selectedAssistantChanged

void KisPaintingAssistantsDecoration::selectedAssistantChanged ( )

signal

◆ setAdjustedBrushPosition()

void KisPaintingAssistantsDecoration::setAdjustedBrushPosition ( const QPointF position )

Definition at line 173 of file kis_painting_assistants_decoration.cpp.

{
    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);
        }
    }
}

References assistants(), d, KisPaintingAssistantsDecoration::Private::hasTemporaryAdjustedBrushPosition, KisPaintingAssistantsDecoration::Private::m_canvas, KisPaintingAssistantsDecoration::Private::temporaryAdjustedBrushPosition, KisPaintingAssistantsDecoration::Private::temporaryConstraint, and KisCanvas2::updateCanvasDecorations().

◆ setAssistants()

void KisPaintingAssistantsDecoration::setAssistants ( const QList< KisPaintingAssistantSP > & assistants )

Definition at line 162 of file kis_painting_assistants_decoration.cpp.

{
    Q_FOREACH (KisPaintingAssistantSP assistant, assistants) {
        assistant->setAssistantGlobalColorCache(view()->document()->assistantsGlobalColor());
    }
    view()->document()->setAssistants(assistants);
    slotUpdateDecorationVisibility();
 
    Q_EMIT assistantChanged();
}

References assistantChanged(), assistants(), slotUpdateDecorationVisibility(), and KisCanvasDecoration::view().

◆ setAssistantVisible()

void KisPaintingAssistantsDecoration::setAssistantVisible ( bool set )

sets whether the main assistant is visible

Definition at line 571 of file kis_painting_assistants_decoration.cpp.

{
    d->assistantVisible=set;
}

References KisPaintingAssistantsDecoration::Private::assistantVisible, and d.

◆ setEraserSnap()

void KisPaintingAssistantsDecoration::setEraserSnap ( bool assistant )

sets whether eraser brushes snap

Definition at line 586 of file kis_painting_assistants_decoration.cpp.

{
    d->snapEraser = assistant;
}

References d, and KisPaintingAssistantsDecoration::Private::snapEraser.

◆ setGlobalAssistantsColor()

void KisPaintingAssistantsDecoration::setGlobalAssistantsColor ( QColor color )

Definition at line 628 of file kis_painting_assistants_decoration.cpp.

{
    // 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();
}

References assistants(), uncache(), and KisCanvasDecoration::view().

◆ setHandleSize()

void KisPaintingAssistantsDecoration::setHandleSize ( int handleSize )

Definition at line 515 of file kis_painting_assistants_decoration.cpp.

{
    d->m_handleSize = handleSize;
}

References d, handleSize(), and KisPaintingAssistantsDecoration::Private::m_handleSize.

◆ setOnlyOneAssistantSnap()

void KisPaintingAssistantsDecoration::setOnlyOneAssistantSnap ( bool assistant )

sets whether we snap to only one assistant

Definition at line 581 of file kis_painting_assistants_decoration.cpp.

{
    d->snapOnlyOneAssistant = assistant;
}

References d, and KisPaintingAssistantsDecoration::Private::snapOnlyOneAssistant.

◆ setOutlineVisible()

void KisPaintingAssistantsDecoration::setOutlineVisible ( bool set )

sets whether the preview is visible

Definition at line 576 of file kis_painting_assistants_decoration.cpp.

{
    d->outlineVisible=set;
}

References d, and KisPaintingAssistantsDecoration::Private::outlineVisible.

◆ setSelectedAssistant()

void KisPaintingAssistantsDecoration::setSelectedAssistant ( KisPaintingAssistantSP assistant )

Definition at line 559 of file kis_painting_assistants_decoration.cpp.

{
    d->selectedAssistant = assistant;
    Q_EMIT selectedAssistantChanged();
}

References d, KisPaintingAssistantsDecoration::Private::selectedAssistant, and selectedAssistantChanged().

◆ setTemporaryConstraint()

void KisPaintingAssistantsDecoration::setTemporaryConstraint ( std::optional< KisTemporaryPaintConstraint > constraint )

Definition at line 340 of file kis_painting_assistants_decoration.cpp.

{
    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();
    }
}

References d, KisPaintingAssistantsDecoration::Private::hasTemporaryAdjustedBrushPosition, KisPaintingAssistantsDecoration::Private::m_canvas, slotUpdateDecorationVisibility(), KisPaintingAssistantsDecoration::Private::temporaryConstraint, temporaryConstraintAvailabilityChanged(), and KisCanvas2::updateCanvasDecorations().

◆ slotConfigChanged

void KisPaintingAssistantsDecoration::slotConfigChanged ( )

slot

Definition at line 102 of file kis_painting_assistants_decoration.cpp.

{
    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);
}

References KisConfig::ASSISTANTS_DRAW_MODE_LARGE_PIXMAP_CACHE, KisConfig::ASSISTANTS_DRAW_MODE_PIXMAP_CACHE, KisConfig::assistantsDrawMode(), d, and KisPaintingAssistantsDecoration::Private::useCache.

◆ slotUpdateDecorationVisibility

void KisPaintingAssistantsDecoration::slotUpdateDecorationVisibility ( )

slot

Definition at line 93 of file kis_painting_assistants_decoration.cpp.

{
    const bool shouldBeVisible = !assistants().isEmpty() || d->temporaryConstraint.has_value();
 
    if (visible() != shouldBeVisible) {
        setVisible(shouldBeVisible);
    }
}

References assistants(), d, KisCanvasDecoration::setVisible(), KisPaintingAssistantsDecoration::Private::temporaryConstraint, and KisCanvasDecoration::visible().

◆ snapToGuide [1/2]

QPointF KisPaintingAssistantsDecoration::snapToGuide	(	const QPointF &	pt,
		const QPointF &	offset )

slot

Definition at line 676 of file kis_painting_assistants_decoration.cpp.

{
    if (!d->m_canvas) {
         return pt;
    }
 
 
    KoSnapGuide *snapGuide = d->m_canvas->snapGuide();
    QPointF pos = snapGuide->snap(pt, offset, Qt::NoModifier);
 
    return pos;
}

References d, KisPaintingAssistantsDecoration::Private::m_canvas, KoSnapGuide::snap(), and KoCanvasBase::snapGuide.

◆ snapToGuide [2/2]

QPointF KisPaintingAssistantsDecoration::snapToGuide	(	KoPointerEvent *	e,
		const QPointF &	offset,
		bool	useModifiers )

slot

Definition at line 663 of file kis_painting_assistants_decoration.cpp.

{
    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;
}

References KisCanvas2::currentImage(), d, KisPaintingAssistantsDecoration::Private::m_canvas, KoPointerEvent::modifiers(), KoPointerEvent::point, KoSnapGuide::snap(), and KoCanvasBase::snapGuide.

◆ temporaryConstraint()

std::optional< KisTemporaryPaintConstraint > KisPaintingAssistantsDecoration::temporaryConstraint ( ) const

Definition at line 361 of file kis_painting_assistants_decoration.cpp.

{
    return d->temporaryConstraint;
}

References d, and KisPaintingAssistantsDecoration::Private::temporaryConstraint.

◆ temporaryConstraintAvailabilityChanged

void KisPaintingAssistantsDecoration::temporaryConstraintAvailabilityChanged ( )

signal

◆ toggleAssistantVisible

void KisPaintingAssistantsDecoration::toggleAssistantVisible ( )

slot

toggles whether the assistant is active or not

Definition at line 610 of file kis_painting_assistants_decoration.cpp.

{
    setAssistantVisible(!assistantVisibility());
    uncache();
}

References assistantVisibility(), setAssistantVisible(), and uncache().

◆ toggleOutlineVisible

void KisPaintingAssistantsDecoration::toggleOutlineVisible ( )

slot

toggles whether there will be a preview of the assistant result when painting

Definition at line 616 of file kis_painting_assistants_decoration.cpp.

{
    // "outline" means assistant preview (line that depends on the mouse cursor)
    setOutlineVisible(!outlineVisibility());
    uncache();
}

References outlineVisibility(), setOutlineVisible(), and uncache().

◆ uncache()

void KisPaintingAssistantsDecoration::uncache ( )

uncache all assistants

Definition at line 599 of file kis_painting_assistants_decoration.cpp.

{
    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();
    }
}

References assistants(), d, KisPaintingAssistantsDecoration::Private::m_canvas, and KisCanvas2::updateCanvasDecorations().

Member Data Documentation

◆ d

Private* const KisPaintingAssistantsDecoration::d

private

Definition at line 175 of file kis_painting_assistants_decoration.h.

◆ globalEditorWidgetData

struct AssistantEditorData KisPaintingAssistantsDecoration::globalEditorWidgetData

Definition at line 98 of file kis_painting_assistants_decoration.h.

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

libs/ui/kis_painting_assistants_decoration.h
libs/ui/kis_painting_assistants_decoration.cpp

Classes

Public Slots

Signals

Public Member Functions

Public Attributes

Protected Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ KisPaintingAssistantsDecoration()

◆ ~KisPaintingAssistantsDecoration()

Member Function Documentation

◆ activateAssistantsEditor()

◆ addAssistant()

◆ adjustLine()

◆ adjustPosition()

◆ assistantChanged

◆ assistants()

◆ assistantVisibility()

◆ deactivateAssistantsEditor()

◆ deselectAssistant()

◆ drawDecoration()

◆ drawEditorWidget()

◆ drawHandles()

◆ endStroke()

◆ globalAssistantsColor()

◆ handles()

◆ handleSize()

◆ hasPaintableAssistants()

◆ isEditingAssistants()

◆ outlineVisibility()

◆ raiseAssistant()

◆ removeAll()

◆ removeAssistant()

◆ selectedAssistant()

◆ selectedAssistantChanged

◆ setAdjustedBrushPosition()

◆ setAssistants()

◆ setAssistantVisible()

◆ setEraserSnap()

◆ setGlobalAssistantsColor()

◆ setHandleSize()

◆ setOnlyOneAssistantSnap()

◆ setOutlineVisible()

◆ setSelectedAssistant()

◆ setTemporaryConstraint()

◆ slotConfigChanged

◆ slotUpdateDecorationVisibility

◆ snapToGuide [1/2]

◆ snapToGuide [2/2]

◆ temporaryConstraint()

◆ temporaryConstraintAvailabilityChanged

◆ toggleAssistantVisible

◆ toggleOutlineVisible

◆ uncache()

Member Data Documentation

◆ d

◆ globalEditorWidgetData