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

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

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

Constructor & Destructor Documentation

◆ KisPaintingAssistantsDecoration()

KisPaintingAssistantsDecoration::KisPaintingAssistantsDecoration ( QPointer< KisView > parent )

Definition at line 58 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 71 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 506 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 95 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 246 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 166 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 409 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 462 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 513 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 436 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 303 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, d->useCache, canvas, assistantVisibility(), outlineVisible);
 
        if (isEditingAssistants()) {
            drawHandles(assistant, gc, converter);
        }
    }
 
    // 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);
        }
     }
}

References assistants(), assistantVisibility(), d, dbgFile, 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 )

protected

Definition at line 559 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
    QBrush backgroundColor = d->m_canvas->viewManager()->mainWindowAsQWidget()->palette().window();
    QPointF actionsBGRectangle(actionsPosition + QPointF(globalEditorWidgetData.widgetOffset,globalEditorWidgetData.widgetOffset));
    QPen stroke(QColor(60, 60, 60, 80), 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(qApp->palette().color(QPalette::Highlight));
 
        }
    }
 
    gc.setPen(stroke);
    gc.drawPath(bgPath);
    gc.fillPath(bgPath, backgroundColor);
 
 
    //draw drag handle
    QColor dragDecorationColor(150,150,150,255);
 
    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;
    QColor dragDecorationDotsColor(50,50,50,255);
    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);
 
 
    //loop over all visible buttons and render them
    if (globalEditorWidgetData.moveButtonActivated) {
        QPointF iconMovePosition(actionsPosition + globalEditorWidgetData.moveIconPosition);
        gc.drawPixmap(iconMovePosition, globalEditorWidgetData.m_iconMove);
    }
    if (globalEditorWidgetData.snapButtonActivated) {
        QPointF iconSnapPosition(actionsPosition + globalEditorWidgetData.snapIconPosition);
        if (assistant->isSnappingActive() == true) {
            gc.drawPixmap(iconSnapPosition, globalEditorWidgetData.m_iconSnapOn);
        }else {
            gc.drawPixmap(iconSnapPosition, globalEditorWidgetData.m_iconSnapOff);
        }
    }
    if (globalEditorWidgetData.lockButtonActivated) {
        QPointF iconLockedPosition(actionsPosition + globalEditorWidgetData.lockedIconPosition);
        if (assistant->isLocked()) {
            gc.drawPixmap(iconLockedPosition, globalEditorWidgetData.m_iconLockOn);
        } else {
            qreal oldOpacity = gc.opacity();
            gc.setOpacity(0.35);
            gc.drawPixmap(iconLockedPosition, globalEditorWidgetData.m_iconLockOff);
            gc.setOpacity(oldOpacity);
        }
    }
    if (globalEditorWidgetData.duplicateButtonActivated) {
        QPointF iconDuplicatePosition(actionsPosition + globalEditorWidgetData.duplicateIconPosition);
        if(assistant->isDuplicating()) {
            //draw button depressed
            qreal oldOpacity = gc.opacity();
            gc.setOpacity(0.35);
            gc.drawPixmap(iconDuplicatePosition,globalEditorWidgetData.m_iconDuplicate);
            gc.setOpacity(oldOpacity);
        }else {
            gc.drawPixmap(iconDuplicatePosition,globalEditorWidgetData.m_iconDuplicate);
        }
    }
    if (globalEditorWidgetData.deleteButtonActivated) {
        QPointF iconDeletePosition(actionsPosition + globalEditorWidgetData.deleteIconPosition);
        gc.drawPixmap(iconDeletePosition, globalEditorWidgetData.m_iconDelete);
    }
 
 
 
 
}

◆ drawHandles()

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

protected

Definition at line 343 of file kis_painting_assistants_decoration.cpp.

{
        QTransform initialTransform = converter->documentToWidgetTransform();
 
        QColor colorToPaint = assistant->effectiveAssistantColor();
 
        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 KisCoordinatesConverter::documentToWidgetTransform(), and handleSize().

◆ endStroke()

void KisPaintingAssistantsDecoration::endStroke ( )

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

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

References KisCanvasDecoration::view().

◆ handles()

QList< KisPaintingAssistantHandleSP > KisPaintingAssistantsDecoration::handles ( )

Definition at line 391 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 381 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 420 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 523 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 466 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 109 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 135 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 123 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 425 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 156 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 145 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 442 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 457 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 493 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 386 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 452 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 447 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 430 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 85 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 76 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 541 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 528 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 476 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 482 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 470 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 167 of file kis_painting_assistants_decoration.h.

◆ globalEditorWidgetData

struct AssistantEditorData KisPaintingAssistantsDecoration::globalEditorWidgetData

Definition at line 91 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