#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 ()

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	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 74 of file kis_painting_assistants_decoration.h.

Constructor & Destructor Documentation

◆ KisPaintingAssistantsDecoration()

KisPaintingAssistantsDecoration::KisPaintingAssistantsDecoration ( QPointer< KisView > parent )

Definition at line 59 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 72 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 509 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 96 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);
    setVisible(!assistants.isEmpty());
    Q_EMIT assistantChanged();
}

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

◆ adjustLine()

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

Definition at line 247 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 167 of file kis_painting_assistants_decoration.cpp.

{
 
    if (assistants().empty()) {
        // No assistants, so no adjustment
        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()));
 
    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, KisImage::xRes(), and KisImage::yRes().

◆ assistantChanged

void KisPaintingAssistantsDecoration::assistantChanged ( )

signal

◆ assistants()

QList< KisPaintingAssistantSP > KisPaintingAssistantsDecoration::assistants ( ) const

Definition at line 412 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 465 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 516 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 439 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 304 of file kis_painting_assistants_decoration.cpp.

{
    if(assistants().isEmpty()) {
        return; // no assistants to worry about, ok to exit
    }
 
    if (!canvas) {
        dbgFile<<"canvas does not exist in painting assistant decoration, you may have passed arguments incorrectly:"<<canvas;
    } else {
        d->m_canvas = canvas;
    }
 
    // 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();
 
    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(), d, dbgFile, KisCanvas2::displayRendererInterface(), drawEditorWidget(), drawHandles(), isEditingAssistants(), KIS_SAFE_ASSERT_RECOVER_RETURN, KisPaintingAssistantsDecoration::Private::m_canvas, KisPaintingAssistantsDecoration::Private::m_isEditingAssistants, outlineVisibility(), KisToolProxy::supportsPaintingAssistants(), KisPaintingAssistantsDecoration::Private::useCache, and KisCanvasDecoration::view().

◆ drawEditorWidget()

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

protected

Definition at line 587 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;
    bgPath.addRoundedRect(QRectF(actionsBGRectangle.x(), actionsBGRectangle.y(), globalEditorWidgetData.boundingSize.width(), globalEditorWidgetData.boundingSize.height()), 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);
 
    //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, buttonRect, pos, renderInterface, QPoint(5, 5));
    }
    if (globalEditorWidgetData.snapButtonActivated) {
        QPoint pos = QPointF(actionsPosition + globalEditorWidgetData.snapIconPosition).toPoint();
        drawDoubleState(gc, globalEditorWidgetData.m_iconSnapOn, globalEditorWidgetData.m_iconSnapOff, buttonRect, pos, assistant->isSnappingActive(), renderInterface);
    }
    if (globalEditorWidgetData.lockButtonActivated) {
        QPoint pos = QPointF(actionsPosition + globalEditorWidgetData.lockedIconPosition).toPoint();
        drawDoubleState(gc, globalEditorWidgetData.m_iconLockOn, globalEditorWidgetData.m_iconLockOff, buttonRect, pos, assistant->isLocked(), renderInterface);
    }
    if (globalEditorWidgetData.duplicateButtonActivated) {
        QPoint pos = QPointF(actionsPosition + globalEditorWidgetData.duplicateIconPosition).toPoint();
        drawDoubleState(gc, globalEditorWidgetData.m_iconDuplicate, globalEditorWidgetData.m_iconDuplicate, buttonRect, pos, !assistant->isDuplicating(), renderInterface);
    }
    if (globalEditorWidgetData.deleteButtonActivated) {
        QPoint pos = QPointF(actionsPosition + globalEditorWidgetData.deleteIconPosition).toPoint();
        drawSingleState(gc, globalEditorWidgetData.m_iconDelete, buttonRect, pos, renderInterface);
    }
}

◆ drawHandles()

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

protected

Definition at line 344 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 295 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 491 of file kis_painting_assistants_decoration.cpp.

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

References KisCanvasDecoration::view().

◆ handles()

QList< KisPaintingAssistantHandleSP > KisPaintingAssistantsDecoration::handles ( )

Definition at line 394 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 384 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 423 of file kis_painting_assistants_decoration.cpp.

{
    return !assistants().isEmpty();
}

References assistants().

◆ 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 526 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 469 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 110 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);
    setVisible(!assistants.isEmpty());
    Q_EMIT assistantChanged();
 
}

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

◆ removeAll()

void KisPaintingAssistantsDecoration::removeAll ( )

Definition at line 136 of file kis_painting_assistants_decoration.cpp.

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

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

◆ removeAssistant()

void KisPaintingAssistantsDecoration::removeAssistant ( KisPaintingAssistantSP assistant )

Definition at line 124 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);
        setVisible(!assistants.isEmpty());
        Q_EMIT assistantChanged();
    }
}

References assistantChanged(), assistants(), KIS_ASSERT_RECOVER_NOOP, KisCanvasDecoration::setVisible(), 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 428 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 157 of file kis_painting_assistants_decoration.cpp.

{
    if (!assistants().empty()) {
        Q_FOREACH (KisPaintingAssistantSP assistant, assistants()) {
            assistant->setAdjustedBrushPosition(position);
        }
    }
}

References assistants().

◆ setAssistants()

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

Definition at line 146 of file kis_painting_assistants_decoration.cpp.

{
    Q_FOREACH (KisPaintingAssistantSP assistant, assistants) {
        assistant->setAssistantGlobalColorCache(view()->document()->assistantsGlobalColor());
    }
    view()->document()->setAssistants(assistants);
    setVisible(!assistants.isEmpty());
 
    Q_EMIT assistantChanged();
}

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

◆ setAssistantVisible()

void KisPaintingAssistantsDecoration::setAssistantVisible ( bool set )

sets whether the main assistant is visible

Definition at line 445 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 460 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 496 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 389 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 455 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 450 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 433 of file kis_painting_assistants_decoration.cpp.

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

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

◆ slotConfigChanged

void KisPaintingAssistantsDecoration::slotConfigChanged ( )

slot

Definition at line 86 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 77 of file kis_painting_assistants_decoration.cpp.

{
    const bool shouldBeVisible = !assistants().isEmpty();
 
    if (visible() != shouldBeVisible) {
        setVisible(shouldBeVisible);
    }
}

References assistants(), KisCanvasDecoration::setVisible(), and KisCanvasDecoration::visible().

◆ snapToGuide [1/2]

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

slot

Definition at line 544 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 531 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.

◆ toggleAssistantVisible

void KisPaintingAssistantsDecoration::toggleAssistantVisible ( )

slot

toggles whether the assistant is active or not

Definition at line 479 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 485 of file kis_painting_assistants_decoration.cpp.

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

References outlineVisibility(), and setOutlineVisible().

◆ uncache()

void KisPaintingAssistantsDecoration::uncache ( )

uncache all assistants

Definition at line 473 of file kis_painting_assistants_decoration.cpp.

{
    Q_FOREACH (KisPaintingAssistantSP assistant, assistants()) {
        assistant->uncache();
    }
}

References assistants().

Member Data Documentation

◆ d

Private* const KisPaintingAssistantsDecoration::d

private

Definition at line 168 of file kis_painting_assistants_decoration.h.

◆ globalEditorWidgetData

struct AssistantEditorData KisPaintingAssistantsDecoration::globalEditorWidgetData

Definition at line 92 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()

◆ slotConfigChanged

◆ slotUpdateDecorationVisibility

◆ snapToGuide [1/2]

◆ snapToGuide [2/2]

◆ toggleAssistantVisible

◆ toggleOutlineVisible

◆ uncache()

Member Data Documentation

◆ d

◆ globalEditorWidgetData