KisPaintingAssistantsDecoration Class Reference

#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
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 508 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;
    int id = 0;
    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;
            }
        }
        id ++;
    }
    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 411 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 464 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 515 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 438 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 305 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 561 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;
    int height = actionsPosition.y()+globalEditorWidgetData.boundingSize.height()+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);
    }
 
 
 
 
}

References AssistantEditorData::boundingSize, d, AssistantEditorData::deleteButtonActivated, AssistantEditorData::deleteIconPosition, KisCoordinatesConverter::documentToWidgetTransform(), AssistantEditorData::dragDecorationWidth, AssistantEditorData::duplicateButtonActivated, AssistantEditorData::duplicateIconPosition, globalEditorWidgetData, AssistantEditorData::lockButtonActivated, AssistantEditorData::lockedIconPosition, KisPaintingAssistantsDecoration::Private::m_canvas, AssistantEditorData::m_iconDelete, AssistantEditorData::m_iconDuplicate, AssistantEditorData::m_iconLockOff, AssistantEditorData::m_iconLockOn, AssistantEditorData::m_iconMove, AssistantEditorData::m_iconSnapOff, AssistantEditorData::m_iconSnapOn, KisViewManager::mainWindowAsQWidget(), AssistantEditorData::moveButtonActivated, AssistantEditorData::moveIconPosition, selectedAssistant(), AssistantEditorData::snapButtonActivated, AssistantEditorData::snapIconPosition, KisCanvas2::viewManager(), AssistantEditorData::widgetActivated, and AssistantEditorData::widgetOffset.

drawHandles()

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

protected

Definition at line 345 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 296 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 490 of file kis_painting_assistants_decoration.cpp.

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

References KisCanvasDecoration::view().

handles()

QList< KisPaintingAssistantHandleSP > KisPaintingAssistantsDecoration::handles

(

)

Definition at line 393 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 383 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 422 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 525 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 468 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 427 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 444 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 459 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 495 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 388 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 454 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 449 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 432 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 543 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 530 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 478 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 484 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 472 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