#include <kis_assistant_tool.h>

Inheritance diagram for KisAssistantTool:

Public Slots
void	activate (const QSet< KoShape * > &shapes) override

void	deactivate () override

void	slotChangeFixedLength (double value)

void	slotChangeMinorSubdivisions (int value)

void	slotChangeSubdivisions (int value)

void	slotChangeTwoPointDensity (double value)

void	slotChangeTwoPointUseVertical (int value)

void	slotChangeVanishingPointAngle (double value)

void	slotEnableFixedLength (int enabled)

Public Slots inherited from KisTool
void	activate (const QSet< KoShape * > &shapes) override

void	canvasResourceChanged (int key, const QVariant &res) override

void	deactivate () override

virtual void	updateSettingsViews ()

Public Slots inherited from KoToolBase
virtual void	activate (const QSet< KoShape * > &shapes)

virtual void	canvasResourceChanged (int key, const QVariant &res)

virtual void	deactivate ()

virtual void	documentResourceChanged (int key, const QVariant &res)

virtual void	repaintDecorations ()

virtual void	requestRedoDuringStroke ()

virtual void	requestStrokeCancellation ()

virtual void	requestStrokeEnd ()

virtual void	requestUndoDuringStroke ()

void	setStatusText (const QString &statusText)

void	updateOptionsWidgetIcons ()

Public Member Functions
void	beginAlternateAction (KoPointerEvent *event, KisTool::AlternateAction action) override

void	beginPrimaryAction (KoPointerEvent *event) override

void	continueAlternateAction (KoPointerEvent *event, AlternateAction action) override

void	continuePrimaryAction (KoPointerEvent *event) override

QWidget *	createOptionWidget () override

void	endAlternateAction (KoPointerEvent *event, AlternateAction action) override

void	endPrimaryAction (KoPointerEvent *event) override

void	keyPressEvent (QKeyEvent *event) override

	KisAssistantTool (KoCanvasBase *canvas)

void	mouseMoveEvent (KoPointerEvent *event) override

virtual quint32	priority ()

	~KisAssistantTool () override

Public Member Functions inherited from KisTool
virtual void	activateAlternateAction (AlternateAction action)

virtual void	activatePrimaryAction ()

virtual bool	alternateActionSupportsHiResEvents (AlternateAction action) const

virtual void	beginAlternateDoubleClickAction (KoPointerEvent *event, AlternateAction action)

virtual void	beginPrimaryDoubleClickAction (KoPointerEvent *event)

virtual void	deactivateAlternateAction (AlternateAction action)

virtual void	deactivatePrimaryAction ()

void	deleteSelection () override

virtual int	flags () const

bool	isActive () const

	KisTool (KoCanvasBase *canvas, const QCursor &cursor)

void	mouseDoubleClickEvent (KoPointerEvent *event) override

void	mouseMoveEvent (KoPointerEvent *event) override

void	mousePressEvent (KoPointerEvent *event) override

void	mouseReleaseEvent (KoPointerEvent *event) override

void	mouseTripleClickEvent (KoPointerEvent *event) override

virtual void	newActivationWithExternalSource (KisPaintDeviceSP externalSource)
	newActivationWithExternalSource Makes sure that the tool is active and starts a new stroke, which will be able to access the pixels from the specified external source.

KisTool::NodePaintAbility	nodePaintAbility ()

virtual bool	primaryActionSupportsHiResEvents () const

virtual bool	supportsPaintingAssistants () const

	~KisTool () override

Public Member Functions inherited from Private
	Private (KisCanvas2 *c)

Public Member Functions inherited from KoToolBase
QAction *	action (const QString &name) const

KoCanvasBase *	canvas () const
	Returns the canvas the tool is working on.

virtual void	copy () const

QCursor	cursor () const
	return the last emitted cursor

virtual void	customMoveEvent (KoPointerEvent *event)

virtual void	customPressEvent (KoPointerEvent *event)

virtual void	customReleaseEvent (KoPointerEvent *event)

virtual void	cut ()

virtual QRectF	decorationsRect () const

int	decorationThickness () const
	decorationThickness The minimum thickness for tool decoration lines, this is derived from the screen magnification, thus the HiDPI settings. Note: to use this effectively, also set the pen to isCosmetic(true);

virtual void	deselect ()
	deselect the tool should clear the selection if it has one.

virtual void	dragLeaveEvent (QDragLeaveEvent *event)

virtual void	dragMoveEvent (QDragMoveEvent *event, const QPointF &point)

virtual void	dropEvent (QDropEvent *event, const QPointF &point)

virtual void	explicitUserStrokeEndRequest ()
	explicitUserStrokeEndRequest is called by the input manager when the user presses the Enter key or any equivalent key. This callback comes before requestStrokeEnd(), which comes from a different source.

KoToolFactoryBase *	factory () const

virtual void	focusInEvent (QFocusEvent *event)

virtual void	focusOutEvent (QFocusEvent *event)

virtual bool	hasSelection ()

virtual void	inputMethodEvent (QInputMethodEvent *event)

virtual QVariant	inputMethodQuery (Qt::InputMethodQuery query) const

bool	isInTextMode () const

bool	isOpacityPresetMode () const

virtual void	keyReleaseEvent (QKeyEvent *event)

	KoToolBase (KoCanvasBase *canvas)

bool	maskSyntheticEvents () const

QList< QPointer< QWidget > >	optionWidgets ()

virtual bool	paste ()

virtual QMenu *	popupActionsMenu ()

virtual KisPopupWidgetInterface *	popupWidget ()

virtual bool	selectAll ()
	selectAll select all data the tool can select.

virtual KoToolSelection *	selection ()

Q_INVOKABLE QString	toolId () const

virtual bool	wantsAutoScroll () const

	~KoToolBase () override

Protected Member Functions
void	paint (QPainter &gc, const KoViewConverter &converter) override

Protected Member Functions inherited from KisTool
bool	blockUntilOperationsFinished ()

void	blockUntilOperationsFinishedForced ()

QPointF	convertDocumentToWidget (const QPointF &pt)

QPoint	convertToImagePixelCoordFloored (KoPointerEvent *e)

QPointF	convertToPixelCoord (const QPointF &pt)

QPointF	convertToPixelCoord (KoPointerEvent *e)

QPointF	convertToPixelCoordAndAlignOnWidget (const QPointF &pt)

QPointF	convertToPixelCoordAndSnap (const QPointF &pt, const QPointF &offset=QPointF())

QPointF	convertToPixelCoordAndSnap (KoPointerEvent *e, const QPointF &offset=QPointF(), bool useModifiers=true)

QRectF	convertToPt (const QRectF &rect)

qreal	convertToPt (qreal value)

QWidget *	createOptionWidget () override

KoColor	currentBgColor ()

KoColor	currentFgColor ()

KisFilterConfigurationSP	currentGenerator ()

KoAbstractGradientSP	currentGradient ()

KisImageWSP	currentImage ()

KisNodeSP	currentNode () const

KisPaintOpPresetSP	currentPaintOpPreset ()

KoPatternSP	currentPattern ()

QCursor	cursor () const

KisImageWSP	image () const

virtual bool	listeningToModifiers ()

virtual void	listenToModifiers (bool listen)

virtual ToolMode	mode () const

bool	nodeEditable ()
	Checks checks if the current node is editable.

bool	overrideCursorIfNotEditable ()
	Override the cursor appropriately if current node is not editable.

void	paintToolOutline (QPainter *painter, const KisOptimizedBrushOutline &path)

KisOptimizedBrushOutline	pixelToView (const KisOptimizedBrushOutline &path) const

QPainterPath	pixelToView (const QPainterPath &pixelPath) const
	Convert a pixel path into a view path.

QPointF	pixelToView (const QPoint &pixelCoord) const

QPointF	pixelToView (const QPointF &pixelCoord) const
	Convert a floating point pixel coordinate into a view coordinate.

QPolygonF	pixelToView (const QPolygonF &pixelPolygon) const
	Convert a pixel polygon into a view path.

QRectF	pixelToView (const QRectF &pixelRect) const
	Convert a pixel rectangle into a view rectangle.

KisNodeList	selectedNodes () const

bool	selectionEditable ()
	Checks checks if the selection is editable, only applies to local selection as global selection is always editable.

void	setCursor (const QCursor &cursor)

virtual void	setMode (ToolMode mode)

void	updateCanvasPixelRect (const QRectF &pixelRect)
	Update the canvas for the given rectangle in image pixel coordinates.

void	updateCanvasViewRect (const QRectF &viewRect)
	Update the canvas for the given rectangle in view coordinates.

QPointF	viewToPixel (const QPointF &viewCoord) const

QPointF	widgetCenterInWidgetPixels ()

Protected Member Functions inherited from KoToolBase
virtual QList< QPointer< QWidget > >	createOptionWidgets ()

int	grabSensitivity () const
	Convenience function to get the current grab sensitivity.

qreal	handleDocRadius () const

QRectF	handleGrabRect (const QPointF &position) const

QRectF	handlePaintRect (const QPointF &position) const

int	handleRadius () const
	Convenience function to get the current handle radius.

bool	isActivated () const

	KoToolBase (KoToolBasePrivate &dd)

KoPointerEvent *	lastDeliveredPointerEvent () const

void	setAbstractResource (KoAbstractCanvasResourceInterfaceSP abstractResource)

void	setConverter (KoDerivedResourceConverterSP converter)

void	setIsOpacityPresetMode (bool value)

void	setMaskSyntheticEvents (bool value)

void	setTextMode (bool value)

QHash< int, KoAbstractCanvasResourceInterfaceSP >	toolAbstractResources ()

QHash< int, KoDerivedResourceConverterSP >	toolConverters ()

void	useCursor (const QCursor &cursor)

Protected Attributes
bool	assistantDuplicatingFlag {false}

KisPaintingAssistantSP	m_assistantDrag

QPointer< KisCanvas2 >	m_canvas

QPointF	m_currentAdjustment

QPointF	m_cursorStart

QPointF	m_dragEnd

QPointF	m_dragStart

KisPaintingAssistantHandleSP	m_handleCombine

KisPaintingAssistantHandleSP	m_handleDrag

KisPaintingAssistantHandleSP	m_handleHover

int	m_handleMaxDist {81}

QList< KisPaintingAssistantHandleSP >	m_handles

int	m_handleSize {17}

KisPaintingAssistantSP	m_newAssistant

Ui::AssistantsToolOptions	m_options

QWidget *	m_optionsWidget {0}

QPointF	m_previousHandlePos

QLineF	m_radius

QList< KisPaintingAssistantHandleSP >	m_sideHandles

bool	m_snapIsRadial {false}

Protected Attributes inherited from KoToolBase
KoToolBasePrivate *	d_ptr

Private Types
enum	PerspectiveAssistantEditionMode { MODE_CREATION , MODE_EDITING , MODE_DRAGGING_NODE , MODE_DRAGGING_TRANSLATING_TWONODES , MODE_DRAGGING_EDITOR_WIDGET }

Private Slots
void	loadAssistants ()

void	removeAllAssistants ()

void	saveAssistants ()

void	slotChangeFixedLengthUnit (int index)

void	slotCustomOpacityChanged ()

void	slotGlobalAssistantOpacityChanged ()

void	slotGlobalAssistantsColorChanged (const QColor &)

void	slotLocalAssistantCheckboxChanged ()

void	slotSelectedAssistantTypeChanged ()

void	slotToggleDeleteButton (int index)

void	slotToggleDockToolOptionsVisible ()

void	slotToggleDuplicateButton (int index)

void	slotToggleLockButton (int index)

void	slotToggleMoveButton (int index)

void	slotToggleSnapButton (int index)

void	slotUpdateCustomColor ()

void	updateToolOptionsUI ()

Private Member Functions
void	addAssistant ()

void	assistantSelected (KisPaintingAssistantSP assistant)

void	beginActionImpl (KoPointerEvent *event)

void	continueActionImpl (KoPointerEvent *event)

void	drawEditorWidget (KisPaintingAssistantSP assistant, QPainter &_gc)

void	endActionImpl (KoPointerEvent *event)

void	removeAssistant (KisPaintingAssistantSP assistant)

bool	snap (KoPointerEvent *event)

void	updateEditorWidgetData ()

Private Attributes
int	m_assistantHelperYOffset {10}

KisPaintingAssistantHandleSP	m_highlightedNode

PerspectiveAssistantEditionMode	m_internalMode { MODE_CREATION }

QList< KisPaintingAssistantSP >	m_origAssistantList

KisPaintingAssistantHandleSP	m_selectedNode1

KisPaintingAssistantHandleSP	m_selectedNode2

KisSpinBoxUnitManager *	m_unitManager {0}

bool	ToggleDockToolOptionsVisible = false

Additional Inherited Members
Public Types inherited from KisTool
enum	{ FLAG_USES_CUSTOM_PRESET =0x01 , FLAG_USES_CUSTOM_COMPOSITEOP =0x02 , FLAG_USES_CUSTOM_SIZE =0x04 }

enum	AlternateAction { ChangeSize = AlternateChangeSize , ChangeSizeSnap = AlternateChangeSizeSnap , SampleFgNode = AlternateSampleFgNode , SampleBgNode = AlternateSampleBgNode , SampleFgImage = AlternateSampleFgImage , SampleBgImage = AlternateSampleBgImage , Secondary = AlternateSecondary , Third = AlternateThird , Fourth = AlternateFourth , Fifth = AlternateFifth , NONE = 10000 }

enum	NodePaintAbility { VECTOR , CLONE , PAINT , UNPAINTABLE , MYPAINTBRUSH_UNPAINTABLE }

enum	ToolAction { Primary , AlternateChangeSize , AlternateChangeSizeSnap , AlternateSampleFgNode , AlternateSampleBgNode , AlternateSampleFgImage , AlternateSampleBgImage , AlternateSecondary , AlternateThird , AlternateFourth , AlternateFifth , Alternate_NONE = 10000 }

Signals inherited from KisTool
void	isActiveChanged (bool isActivated)

Signals inherited from KoToolBase
void	activateTool (const QString &id)

void	cursorChanged (const QCursor &cursor)

void	selectionChanged (bool hasSelection)

void	statusTextChanged (const QString &statusText)

void	textModeChanged (bool inTextMode)

Static Public Member Functions inherited from KisTool
static AlternateAction	actionToAlternateAction (ToolAction action)

Public Attributes inherited from KisTool
KoColor	currentBgColor

float	currentExposure {1.0}

KoColor	currentFgColor

KisFilterConfigurationSP	currentGenerator

KoAbstractGradientSP	currentGradient

KoPatternSP	currentPattern

QCursor	cursor

bool	m_isActive {false}

ToolMode	m_mode {HOVER_MODE}

QWidget *	optionWidget {0}

Public Attributes inherited from Private
KisCanvas2 *	canvas

int	displayedFrame

int	intendedFrame

Protected Types inherited from KisTool
enum	ToolMode : int { HOVER_MODE , PAINT_MODE , SECONDARY_PAINT_MODE , MIRROR_AXIS_SETUP_MODE , GESTURE_MODE , PAN_MODE , OTHER , OTHER_1 }

Protected Slots inherited from KisTool
virtual void	resetCursorStyle ()

Properties inherited from KisTool
bool	isActive

Detailed Description

Definition at line 34 of file kis_assistant_tool.h.

Member Enumeration Documentation

◆ PerspectiveAssistantEditionMode

enum KisAssistantTool::PerspectiveAssistantEditionMode

private

Enumerator
MODE_CREATION
MODE_EDITING
MODE_DRAGGING_NODE
MODE_DRAGGING_TRANSLATING_TWONODES
MODE_DRAGGING_EDITOR_WIDGET

Definition at line 37 of file kis_assistant_tool.h.

                                         {
        MODE_CREATION, // This is the mode when there is not yet a perspective grid
        MODE_EDITING, // This is the mode when the grid has been created, and we are waiting for the user to click on a control box
        MODE_DRAGGING_NODE, // In this mode one node is translated
        MODE_DRAGGING_TRANSLATING_TWONODES, // This mode is used when creating a new sub perspective grid
        MODE_DRAGGING_EDITOR_WIDGET // This mode is used when dragging/moving the little editor widget
    };

Constructor & Destructor Documentation

◆ KisAssistantTool()

KisAssistantTool::KisAssistantTool ( KoCanvasBase * canvas )

Definition at line 53 of file kis_assistant_tool.cc.

    : KisTool(canvas, KisCursor::arrowCursor())
    , m_canvas(dynamic_cast<KisCanvas2*>(canvas))
    , m_assistantDrag(0)
    , m_newAssistant(0)
    , m_optionsWidget(0)
    , m_unitManager(new KisDocumentAwareSpinBoxUnitManager(this))
{
    Q_ASSERT(m_canvas);
    setObjectName("tool_assistanttool");
}

References m_canvas.

◆ ~KisAssistantTool()

KisAssistantTool::~KisAssistantTool ( )

override

Definition at line 65 of file kis_assistant_tool.cc.

66{

67}

Member Function Documentation

◆ activate

void KisAssistantTool::activate ( const QSet< KoShape * > & shapes )

overrideslot

Definition at line 69 of file kis_assistant_tool.cc.

{
 
    KisTool::activate(shapes);
 
    m_canvas->paintingAssistantsDecoration()->activateAssistantsEditor();
    m_handles = m_canvas->paintingAssistantsDecoration()->handles();
 
    m_internalMode = MODE_CREATION;
    m_canvas->paintingAssistantsDecoration()->setHandleSize(m_handleSize);
 
 
    if (m_optionsWidget) {
        m_canvas->paintingAssistantsDecoration()->deselectAssistant();
        updateToolOptionsUI();
    }
    
    m_canvas->updateCanvas();
    
}

References KisTool::activate(), m_canvas, m_handles, m_handleSize, m_internalMode, m_optionsWidget, MODE_CREATION, and updateToolOptionsUI().

◆ addAssistant()

void KisAssistantTool::addAssistant ( )

private

Definition at line 791 of file kis_assistant_tool.cc.

{
    m_canvas->paintingAssistantsDecoration()->addAssistant(m_newAssistant);
 
    // generate the side handles for the Two Point assistant
    if (m_newAssistant->id() == "two point"){
        QList<KisPaintingAssistantHandleSP> handles = m_newAssistant->handles();
        QSharedPointer<TwoPointAssistant> assis = qSharedPointerCast<TwoPointAssistant>(m_newAssistant);
 
        if (*handles[0] == *handles[1] || *handles[1] == *handles[2]) {
            // Place handles in sensible default position if any of
            // them are overlapping (maybe because user
            // double-clicked)
            const QTransform transform = m_canvas->coordinatesConverter()->documentToWidgetTransform();
            const QTransform inverted = transform.inverted();
            const int size = inverted.map(QPointF(m_canvas->canvasWidget()->width(),0)).x();
            *handles[0] = *handles[2] - QPointF(-size/3,0);
            *handles[1] = *handles[2] - QPointF(size/3,0);
        }
 
        const QPointF p1 = *handles[0];
        const QPointF p2 = *handles[1];
        const QPointF p3 = *handles[2];
 
        qreal size = 0;
        QTransform t = assis->localTransform(p1,p2,p3,&size);
        QTransform inv = t.inverted();
 
        if (t.map(p1).x() * t.map(p2).x() > 0) {
            // Put third handle between first and second if user
            // placed it outside of them, then re-define the transform
            const QLineF horizon = QLineF(t.map(p1),t.map(p2));
            const QPointF origin = QPointF(horizon.center().x(),0);
            *handles[2] = inv.map(origin);
            t = assis->localTransform(p1,p2,*handles[2],&size);
            inv = t.inverted();
        }
 
        const QPointF above = inv.map(QPointF(0,t.map(p1).y()+size));
        const QPointF below = inv.map(QPointF(0,t.map(p1).y()-size));
 
        Q_FOREACH (QPointF side, QList<QPointF>({above,below})) {
            Q_FOREACH (QPointF vp, QList<QPointF>({p1, p2})) {
                QLineF bar = QLineF(side, vp);
                m_newAssistant->addHandle(new KisPaintingAssistantHandle(bar.pointAt(0.8)), HandleType::SIDE);
                m_newAssistant->addHandle(new KisPaintingAssistantHandle(bar.pointAt(0.4)), HandleType::SIDE);
            }
        }
    }
 
 
    QList<KisPaintingAssistantSP> assistants = m_canvas->paintingAssistantsDecoration()->assistants();
    KUndo2Command *addAssistantCmd = new EditAssistantsCommand(m_canvas, m_origAssistantList, KisPaintingAssistant::cloneAssistantList(assistants), EditAssistantsCommand::ADD, assistants.indexOf(m_newAssistant));
    m_canvas->viewManager()->undoAdapter()->addCommand(addAssistantCmd);
 
    m_handles = m_canvas->paintingAssistantsDecoration()->handles();
    m_canvas->paintingAssistantsDecoration()->setSelectedAssistant(m_newAssistant);
    updateToolOptionsUI(); // vanishing point assistant will get an extra option
 
    m_newAssistant.clear();
}

References EditAssistantsCommand::ADD, KisPaintingAssistant::cloneAssistantList(), m_canvas, m_handles, m_newAssistant, m_origAssistantList, p1, p2, p3, SIDE, and updateToolOptionsUI().

◆ assistantSelected()

void KisAssistantTool::assistantSelected ( KisPaintingAssistantSP assistant )

private

Definition at line 970 of file kis_assistant_tool.cc.

{
     m_canvas->paintingAssistantsDecoration()->setSelectedAssistant(assistant);
     updateToolOptionsUI();
}

References m_canvas, and updateToolOptionsUI().

◆ beginActionImpl()

void KisAssistantTool::beginActionImpl ( KoPointerEvent * event )

private

Definition at line 97 of file kis_assistant_tool.cc.

{
    setMode(KisTool::PAINT_MODE);
    m_origAssistantList = KisPaintingAssistant::cloneAssistantList(m_canvas->paintingAssistantsDecoration()->assistants());
 
    bool newAssistantAllowed = true;
 
    KisPaintingAssistantsDecorationSP canvasDecoration = m_canvas->paintingAssistantsDecoration();
 
    if (m_newAssistant) {
        m_internalMode = MODE_CREATION;
 
        if (!snap(event)) {
            *m_newAssistant->handles().back() = canvasDecoration->snapToGuide(event, QPointF(), false);
        }
 
        if (m_newAssistant->handles().size() == m_newAssistant->numHandles()) {
            addAssistant();
        } else {
            m_newAssistant->addHandle(new KisPaintingAssistantHandle(canvasDecoration->snapToGuide(event, QPointF(), false)), HandleType::NORMAL);
        }
        m_canvas->updateCanvas();
        return;
    }
    m_handleDrag = 0;
    double minDist = m_handleMaxDist;
 
 
    QPointF mousePos = m_canvas->viewConverter()->documentToView(canvasDecoration->snapToGuide(event, QPointF(), false));//m_canvas->viewConverter()->documentToView(event->point);
 
    // syncs the assistant handles to the handles reference we store in this tool
    // they can get out of sync with the way the actions and paintevents occur
    // we probably need to stop storing a reference in m_handles and call the assistants directly
    m_handles = m_canvas->paintingAssistantsDecoration()->handles();
 
 
    Q_FOREACH (KisPaintingAssistantSP assistant, m_canvas->paintingAssistantsDecoration()->assistants()) {
 
        if (assistant->isLocked()) {
            continue; // let's not modify an assistant that is locked
        }
 
 
        // find out which handle on all assistants is closest to the mouse position
        // vanishing points have "side handles", so make sure to include that
        {
            QList<KisPaintingAssistantHandleSP> allAssistantHandles;
            allAssistantHandles.append(assistant->handles());
            allAssistantHandles.append(assistant->sideHandles());
 
            Q_FOREACH (const KisPaintingAssistantHandleSP handle, allAssistantHandles) {
 
                double dist = KisPaintingAssistant::norm2(mousePos - m_canvas->viewConverter()->documentToView(*handle));
                if (dist < minDist) {
                    minDist = dist;
                    m_handleDrag = handle;
 
                    assistantSelected(assistant); // whatever handle is the closest contains the selected assistant
                    m_canvas->paintingAssistantsDecoration()->raiseAssistant(assistant);
                }
            }
        }
 
 
 
 
        if(m_handleDrag && assistant->id() == "perspective") {
            // Look for the handle which was pressed
 
 
            if (m_handleDrag == assistant->topLeft()) {
                double dist = KisPaintingAssistant::norm2(mousePos - m_canvas->viewConverter()->documentToView(*m_handleDrag));
                if (dist < minDist) {
                    minDist = dist;
                }
                m_dragStart = QPointF(assistant->topRight().data()->x(),assistant->topRight().data()->y());
                m_internalMode = MODE_DRAGGING_NODE;
            } else if (m_handleDrag == assistant->topRight()) {
                double dist = KisPaintingAssistant::norm2(mousePos - m_canvas->viewConverter()->documentToView(*m_handleDrag));
                if (dist < minDist) {
                    minDist = dist;
                }
                m_internalMode = MODE_DRAGGING_NODE;
                m_dragStart = QPointF(assistant->topLeft().data()->x(),assistant->topLeft().data()->y());
            } else if (m_handleDrag == assistant->bottomLeft()) {
                double dist = KisPaintingAssistant::norm2(mousePos - m_canvas->viewConverter()->documentToView(*m_handleDrag));
                if (dist < minDist) {
                    minDist = dist;
                }
                m_internalMode = MODE_DRAGGING_NODE;
                m_dragStart = QPointF(assistant->bottomRight().data()->x(),assistant->bottomRight().data()->y());
            } else if (m_handleDrag == assistant->bottomRight()) {
                double dist = KisPaintingAssistant::norm2(mousePos - m_canvas->viewConverter()->documentToView(*m_handleDrag));
                if (dist < minDist) {
                    minDist = dist;
                }
                m_internalMode = MODE_DRAGGING_NODE;
                m_dragStart = QPointF(assistant->bottomLeft().data()->x(),assistant->bottomLeft().data()->y());
            } else if (m_handleDrag == assistant->leftMiddle()) {
                m_internalMode = MODE_DRAGGING_TRANSLATING_TWONODES;
                m_dragStart = QPointF((assistant->bottomLeft().data()->x()+assistant->topLeft().data()->x())*0.5,
                                      (assistant->bottomLeft().data()->y()+assistant->topLeft().data()->y())*0.5);
                m_selectedNode1 = new KisPaintingAssistantHandle(assistant->topLeft().data()->x(),assistant->topLeft().data()->y());
                m_selectedNode2 = new KisPaintingAssistantHandle(assistant->bottomLeft().data()->x(),assistant->bottomLeft().data()->y());
                m_newAssistant = toQShared(KisPaintingAssistantFactoryRegistry::instance()->get("perspective")->createPaintingAssistant());
                m_newAssistant->addHandle(assistant->topLeft(), HandleType::NORMAL );
                m_newAssistant->addHandle(m_selectedNode1, HandleType::NORMAL);
                m_newAssistant->addHandle(m_selectedNode2, HandleType::NORMAL);
                m_newAssistant->addHandle(assistant->bottomLeft(), HandleType::NORMAL);
                m_dragEnd = event->point;
                m_handleDrag = 0;
                m_canvas->updateCanvas(); // TODO update only the relevant part of the canvas
                return;
            } else if (m_handleDrag == assistant->rightMiddle()) {
                m_dragStart = QPointF((assistant->topRight().data()->x()+assistant->bottomRight().data()->x())*0.5,
                                      (assistant->topRight().data()->y()+assistant->bottomRight().data()->y())*0.5);
                m_internalMode = MODE_DRAGGING_TRANSLATING_TWONODES;
                m_selectedNode1 = new KisPaintingAssistantHandle(assistant->topRight().data()->x(),assistant->topRight().data()->y());
                m_selectedNode2 = new KisPaintingAssistantHandle(assistant->bottomRight().data()->x(),assistant->bottomRight().data()->y());
                m_newAssistant = toQShared(KisPaintingAssistantFactoryRegistry::instance()->get("perspective")->createPaintingAssistant());
                m_newAssistant->addHandle(assistant->topRight(), HandleType::NORMAL);
                m_newAssistant->addHandle(m_selectedNode1, HandleType::NORMAL);
                m_newAssistant->addHandle(m_selectedNode2, HandleType::NORMAL);
                m_newAssistant->addHandle(assistant->bottomRight(), HandleType::NORMAL);
                m_dragEnd = event->point;
                m_handleDrag = 0;
                m_canvas->updateCanvas(); // TODO update only the relevant part of the canvas
                return;
            } else if (m_handleDrag == assistant->topMiddle()) {
                m_dragStart = QPointF((assistant->topLeft().data()->x()+assistant->topRight().data()->x())*0.5,
                                      (assistant->topLeft().data()->y()+assistant->topRight().data()->y())*0.5);
                m_internalMode = MODE_DRAGGING_TRANSLATING_TWONODES;
                m_selectedNode1 = new KisPaintingAssistantHandle(assistant->topLeft().data()->x(),assistant->topLeft().data()->y());
                m_selectedNode2 = new KisPaintingAssistantHandle(assistant->topRight().data()->x(),assistant->topRight().data()->y());
                m_newAssistant = toQShared(KisPaintingAssistantFactoryRegistry::instance()->get("perspective")->createPaintingAssistant());
                m_newAssistant->addHandle(m_selectedNode1, HandleType::NORMAL);
                m_newAssistant->addHandle(m_selectedNode2, HandleType::NORMAL);
                m_newAssistant->addHandle(assistant->topRight(), HandleType::NORMAL);
                m_newAssistant->addHandle(assistant->topLeft(), HandleType::NORMAL);
                m_dragEnd = event->point;
                m_handleDrag = 0;
                m_canvas->updateCanvas(); // TODO update only the relevant part of the canvas
                return;
            } else if (m_handleDrag == assistant->bottomMiddle()) {
                m_dragStart = QPointF((assistant->bottomLeft().data()->x()+assistant->bottomRight().data()->x())*0.5,
                                      (assistant->bottomLeft().data()->y()+assistant->bottomRight().data()->y())*0.5);
                m_internalMode = MODE_DRAGGING_TRANSLATING_TWONODES;
                m_selectedNode1 = new KisPaintingAssistantHandle(assistant->bottomLeft().data()->x(),assistant->bottomLeft().data()->y());
                m_selectedNode2 = new KisPaintingAssistantHandle(assistant->bottomRight().data()->x(),assistant->bottomRight().data()->y());
                m_newAssistant = toQShared(KisPaintingAssistantFactoryRegistry::instance()->get("perspective")->createPaintingAssistant());
                m_newAssistant->addHandle(assistant->bottomLeft(), HandleType::NORMAL);
                m_newAssistant->addHandle(assistant->bottomRight(), HandleType::NORMAL);
                m_newAssistant->addHandle(m_selectedNode2, HandleType::NORMAL);
                m_newAssistant->addHandle(m_selectedNode1, HandleType::NORMAL);
                m_dragEnd = event->point;
                m_handleDrag = 0;
                m_canvas->updateCanvas(); // TODO update only the relevant part of the canvas
                return;
            }
            m_snapIsRadial = false;
        }
        else if (m_handleDrag && assistant->handles().size()>1 && (assistant->id() == "ruler" ||
                                                                   assistant->id() == "parallel ruler" ||
                                                                   assistant->id() == "infinite ruler" ||
                                                                   assistant->id() == "spline" ||
                                                                   assistant->id() == "curvilinear-perspective")){
            if (m_handleDrag == assistant->handles()[0]) {
                m_dragStart = *assistant->handles()[1];
            } else if (m_handleDrag == assistant->handles()[1]) {
                m_dragStart = *assistant->handles()[0];
            } else if(assistant->handles().size()==4){
                if (m_handleDrag == assistant->handles()[2]) {
                    m_dragStart = *assistant->handles()[0];
                } else if (m_handleDrag == assistant->handles()[3]) {
                    m_dragStart = *assistant->handles()[1];
                }
            }
            m_snapIsRadial = false;
        } else if (m_handleDrag && assistant->handles().size()>2 && (assistant->id() == "ellipse" ||
                                                                     assistant->id() == "concentric ellipse" ||
                                                                     assistant->id() == "fisheye-point")){
            m_snapIsRadial = false;
            if (m_handleDrag == assistant->handles()[0]) {
                m_dragStart = *assistant->handles()[1];
                m_snapIsRadial = false;
            } else if (m_handleDrag == assistant->handles()[1]) {
                m_dragStart = *assistant->handles()[0];
                m_snapIsRadial = false;
            } else if (m_handleDrag == assistant->handles()[2]) {
                m_dragStart = assistant->getEditorPosition();
                m_radius = QLineF(m_dragStart, *assistant->handles()[0]);
                m_snapIsRadial = true;
            }
        } else if (m_handleDrag && assistant->handles().size()>2 && assistant->id() == "two point") {
 
            // If the user left the assistant's handles in an invalid
            // state (ie 3rd handle isn't between the 1st and 2nd
            // handle), then compute a sensible value for m_dragStart
            // that respects it
            QList<KisPaintingAssistantHandleSP> handles = assistant->handles();
 
            const QPointF p1 = *assistant->handles()[0];
            const QPointF p2 = *assistant->handles()[1];
            const QPointF p3 = *assistant->handles()[2];
 
            qreal size = 0;
            QTransform t = qSharedPointerCast<TwoPointAssistant>(m_newAssistant)->localTransform(p1,p2,p3,&size);
            QTransform inv = t.inverted();
            if (t.map(p1).x() * t.map(p2).x() > 0) {
 
                // We only care about m_dragStart if user is dragging a VP
                if (m_handleDrag == assistant->handles()[0]) {
                    const QPointF safe_start = QPointF(-1.0*t.map(p1).x(),t.map(p1).y());
                    m_dragStart = inv.map(safe_start);
                } else if (m_handleDrag == assistant->handles()[1]) {
                    const QPointF safe_start = QPointF(-1.0*t.map(p2).x(),t.map(p1).y());
                    m_dragStart = inv.map(safe_start);
                }
 
                m_snapIsRadial = false;
            } else {
                m_dragStart = *m_handleDrag;
                m_snapIsRadial = false;
            }
 
        } else if (m_handleDrag && assistant->id() == "vanishing point" &&
                   m_handleDrag == assistant->handles()[0]){
            m_dragStart = assistant->getEditorPosition();
            m_snapIsRadial = false;
        }
    }
 
    m_currentAdjustment = QPointF();
 
    if (m_handleDrag) {
        // TODO: Shift-press should now be handled using the alternate actions
        // if (event->modifiers() & Qt::ShiftModifier) {
        //     m_handleDrag->uncache();
        //     m_handleDrag = m_handleDrag->split()[0];
        //     m_handles = m_canvas->view()->paintingAssistantsDecoration()->handles();
        // }
        m_canvas->updateCanvas(); // TODO update only the relevant part of the canvas
        return;
    }
 
    m_assistantDrag.clear();
    
    // list will contain the assistants whose control widgets are affected by the click event...
    QList<KisPaintingAssistantSP> assistantsPressed;
 
    // data for calculating mouse intersection with control widget.
    AssistantEditorData &globalEditorWidgetData = m_canvas->paintingAssistantsDecoration()->globalEditorWidgetData;
    const KisCoordinatesConverter *converter = m_canvas->coordinatesConverter();
    QTransform initialTransform = converter->documentToWidgetTransform();
    // for UI control widget options with move, show, and delete -- disregard document transforms like rotating and mirroring.
    // otherwise the UI controls get awkward to use when they are at 45 degree angles or the order of controls gets flipped backwards
    QPointF uiMousePosition = initialTransform.map(canvasDecoration->snapToGuide(event, QPointF(), false));
    
    // find control widgets pressed...
    Q_FOREACH (KisPaintingAssistantSP assistant, m_canvas->paintingAssistantsDecoration()->assistants()) {
        
        QPointF actionsPosition = initialTransform.map(assistant->viewportConstrainedEditorPosition(converter, globalEditorWidgetData.boundingSize));
                
        // first we must find if the click event intersects any assistant control widget rectangles.
        // as it is possible for control widgets to overlap, we must then determine which control widget is actually being clicked based on the 
        // order of the assistants, which represent the z position hierarchy of their respective control widgets.
      
        // calculate widget rect bound
        QPointF actionsBGRectangle(actionsPosition + QPointF(globalEditorWidgetData.widgetOffset,globalEditorWidgetData.widgetOffset));
        QRectF editorWidget = QRectF(actionsBGRectangle.x(), actionsBGRectangle.y(), globalEditorWidgetData.boundingSize.width(), globalEditorWidgetData.boundingSize.height());
        // add all assistants that intersect the mouse to a list.
        if (editorWidget.contains(uiMousePosition)) {
            assistantsPressed.push_back(assistant);
        }
     
    }
    
    // get assistant pressed...
    if (!assistantsPressed.isEmpty()) {
        // get closest assistant
        KisPaintingAssistantSP assistant = assistantsPressed.last();
        // move assistant to front of assistants list.
        m_canvas->paintingAssistantsDecoration()->raiseAssistant(assistant);
 
        assistantSelected(assistant);
 
        QPointF actionsPosition = initialTransform.map(assistant->viewportConstrainedEditorPosition(converter, globalEditorWidgetData.boundingSize));
 
        // loop through all activated buttons and see if any are being clicked
        if(globalEditorWidgetData.moveButtonActivated) {
            QPointF iconMovePosition(actionsPosition + globalEditorWidgetData.moveIconPosition);
            QRectF moveRect(iconMovePosition, QSizeF(globalEditorWidgetData.buttonSize, globalEditorWidgetData.buttonSize));
 
            if (moveRect.contains(uiMousePosition) && !assistant->isLocked()) {
                m_assistantDrag = assistant;
                m_cursorStart = event->point;
                m_internalMode = MODE_EDITING;
 
                assistantSelected(assistant); // whatever handle is the closest contains the selected assistant
 
                return;
            }
        }
        if(globalEditorWidgetData.snapButtonActivated) {
            QPointF iconSnapPosition(actionsPosition + globalEditorWidgetData.snapIconPosition);
            QRectF visibleRect(iconSnapPosition, QSizeF(globalEditorWidgetData.buttonSize, globalEditorWidgetData.buttonSize));
            if (visibleRect.contains(uiMousePosition)) {
                newAssistantAllowed = false;
                assistant->setSnappingActive(!assistant->isSnappingActive()); // toggle
                assistant->uncache();//this updates the cache of the assistant, very important.
 
                assistantSelected(assistant); // whatever handle is the closest contains the selected assistant
            }
        }
        if(globalEditorWidgetData.lockButtonActivated) {
            QPointF iconLockPosition(actionsPosition + globalEditorWidgetData.lockedIconPosition);
            QRectF lockRect(iconLockPosition, QSizeF(globalEditorWidgetData.buttonSize, globalEditorWidgetData.buttonSize));
            if (lockRect.contains(uiMousePosition)) {
 
                assistant->setLocked(!assistant->isLocked());
                assistantSelected(assistant); // whatever handle is the closest contains the selected assistant
                m_internalMode = MODE_EDITING;
 
                return;
            }
        }
        if(globalEditorWidgetData.duplicateButtonActivated) {
            QPointF iconDuplicatePosition(actionsPosition + globalEditorWidgetData.duplicateIconPosition);
            QRectF duplicateRect(iconDuplicatePosition,QSizeF(globalEditorWidgetData.buttonSize,globalEditorWidgetData.buttonSize));
            
            if (duplicateRect.contains(uiMousePosition)) {
                //create new assistant from old one
                QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> handleMap;
                m_newAssistant = assistant->clone(handleMap);
                m_newAssistant->copySharedData(assistant);
                m_newAssistant->setDuplicating(true);
                //add assistant to global list and register UNDO/REDO object
                m_canvas->paintingAssistantsDecoration()->addAssistant(m_newAssistant);
                QList<KisPaintingAssistantSP> assistants = m_canvas->paintingAssistantsDecoration()->assistants();
                KUndo2Command *addAssistantCmd = new EditAssistantsCommand(m_canvas, m_origAssistantList, KisPaintingAssistant::cloneAssistantList(assistants), EditAssistantsCommand::ADD, assistants.indexOf(m_newAssistant));
                m_canvas->viewManager()->undoAdapter()->addCommand(addAssistantCmd);
                m_origAssistantList = KisPaintingAssistant::cloneAssistantList(m_canvas->paintingAssistantsDecoration()->assistants());
                m_handles = m_canvas->paintingAssistantsDecoration()->handles();
                m_canvas->paintingAssistantsDecoration()->setSelectedAssistant(m_newAssistant);
                assistantDuplicatingFlag = true;
                
                // if assistant is locked simply move the control widget, not the entire assistant
                if(assistant->isLocked()) {
                    newAssistantAllowed = false;
                    m_internalMode = MODE_DRAGGING_EDITOR_WIDGET;
                    m_dragStart = event->point;
                    m_dragEnd = event->point;
                    m_newAssistant.clear();
                } else {
                    m_assistantDrag = m_newAssistant;
                    m_newAssistant.clear();
                    m_cursorStart = event->point;
                    m_internalMode = MODE_EDITING;
                    m_dragStart = event->point;
                    m_dragEnd = event->point;
                }
                
                updateToolOptionsUI(); 
                m_canvas->updateCanvas();
                return;
            }
 
        }
        if(globalEditorWidgetData.deleteButtonActivated) {
            QPointF iconDeletePosition(actionsPosition + globalEditorWidgetData.deleteIconPosition);
            QRectF deleteRect(iconDeletePosition, QSizeF(globalEditorWidgetData.buttonSize, globalEditorWidgetData.buttonSize));
            if (deleteRect.contains(uiMousePosition) && !assistant->isLocked()) {
                removeAssistant(assistant);
                if(m_canvas->paintingAssistantsDecoration()->assistants().isEmpty()) {
                    m_internalMode = MODE_CREATION;
                } else m_internalMode = MODE_EDITING;
                m_canvas->updateCanvas();
                return;
            }
 
        }
        // if user clicking control widget background.
        if((QRectF(actionsPosition + QPointF(10, 10), globalEditorWidgetData.boundingSize).adjusted(-2, -2, 2, 2).contains(uiMousePosition))) {
            newAssistantAllowed = false;
            m_internalMode = MODE_DRAGGING_EDITOR_WIDGET;
            assistantSelected(assistant);
            m_dragStart = event->point;
            m_dragEnd = event->point;
            
        } 
 
 
    }
 
    if (newAssistantAllowed==true) {//don't make a new assistant when I'm just toggling visibility//
        QString key = m_options.availableAssistantsComboBox->model()->index( m_options.availableAssistantsComboBox->currentIndex(), 0 ).data(Qt::UserRole).toString();
        KConfigGroup cfg = KSharedConfig::openConfig()->group(toolId());
        cfg.writeEntry("AssistantType", key);
        m_newAssistant = toQShared(KisPaintingAssistantFactoryRegistry::instance()->get(key)->createPaintingAssistant());
        if (m_newAssistant->canBeLocal()) {
            m_newAssistant->setLocal(m_options.localAssistantCheckbox->isChecked());
        }
        m_internalMode = MODE_CREATION;
        m_newAssistant->addHandle(new KisPaintingAssistantHandle(canvasDecoration->snapToGuide(event, QPointF(), false)), HandleType::NORMAL);
        if (m_newAssistant->numHandles() <= 1) {
            addAssistant();
        } else {
            m_newAssistant->addHandle(new KisPaintingAssistantHandle(canvasDecoration->snapToGuide(event, QPointF(), false)), HandleType::NORMAL);
        }
    }
 
    if (m_newAssistant) {
        m_newAssistant->setAssistantGlobalColorCache(m_canvas->paintingAssistantsDecoration()->globalAssistantsColor());
    }
 
    m_canvas->updateCanvas();
}

◆ beginAlternateAction()

void KisAssistantTool::beginAlternateAction	(	KoPointerEvent *	event,
		KisTool::AlternateAction	action )

overridevirtual

Reimplemented from KisTool.

Definition at line 1965 of file kis_assistant_tool.cc.

{
    Q_UNUSED(action);
    beginActionImpl(event);
}

References KoToolBase::action(), and beginActionImpl().

◆ beginPrimaryAction()

void KisAssistantTool::beginPrimaryAction ( KoPointerEvent * event )

overridevirtual

Called by KisToolProxy when a primary action for the tool is started. The event stores the original event that started the stroke. The event is accepted by default. If the tool decides to ignore this particular action (e.g. when the node is not editable), it should call event->ignore(). Then no further continuePrimaryAction() or endPrimaryAction() will be called until the next user action.

Reimplemented from KisTool.

Definition at line 1983 of file kis_assistant_tool.cc.

{
    beginActionImpl(event);
}

References beginActionImpl().

◆ continueActionImpl()

void KisAssistantTool::continueActionImpl ( KoPointerEvent * event )

private

Definition at line 515 of file kis_assistant_tool.cc.

{
    KisPaintingAssistantsDecorationSP canvasDecoration = m_canvas->paintingAssistantsDecoration();
 
    if (m_handleDrag) {
        m_previousHandlePos = *m_handleDrag;
        *m_handleDrag = event->point;
 
        KisPaintingAssistantSP selectedAssistant = m_canvas->paintingAssistantsDecoration()->selectedAssistant();
 
        if (!snap(event)) {
            *m_handleDrag = canvasDecoration->snapToGuide(event, QPointF(), false);
        }
        m_handleDrag->uncache();
 
        m_handleCombine = 0;
        if (!(event->modifiers() & Qt::ShiftModifier)) {
            double minDist = 49.0;
            QPointF mousePos = m_canvas->viewConverter()->documentToView(event->point);
            Q_FOREACH (const KisPaintingAssistantHandleSP handle, m_handles) {
                if (handle == m_handleDrag)
                    continue;
 
 
                double dist = KisPaintingAssistant::norm2(mousePos - m_canvas->viewConverter()->documentToView(*handle));
                if (dist < minDist) {
                    minDist = dist;
                    m_handleCombine = handle;
                }
            }
        }
        m_canvas->updateCanvas();
    } else if (m_assistantDrag) {
        QPointF newAdjustment = canvasDecoration->snapToGuide(event, QPointF(), false) - m_cursorStart;
        if (event->modifiers() & Qt::ShiftModifier ) {
            newAdjustment = snapToClosestNiceAngle(newAdjustment, QPointF(0, 0), M_PI / 4);
        }
        Q_FOREACH (KisPaintingAssistantHandleSP handle, m_assistantDrag->handles()) {
            *handle += (newAdjustment - m_currentAdjustment);
        }
        if (m_assistantDrag->id()== "vanishing point" || m_assistantDrag->id()== "two point"){
            Q_FOREACH (KisPaintingAssistantHandleSP handle, m_assistantDrag->sideHandles()) {
                *handle += (newAdjustment - m_currentAdjustment);
            }
        }
        m_assistantDrag->uncache();
        m_currentAdjustment = newAdjustment;
        m_canvas->updateCanvas();
        m_dragEnd = event->point;
 
    } else if (m_internalMode == MODE_DRAGGING_EDITOR_WIDGET) {
 
        KisPaintingAssistantSP selectedAssistant = m_canvas->paintingAssistantsDecoration()->selectedAssistant();
        QPointF currentOffset = selectedAssistant->editorWidgetOffset();
        selectedAssistant->setEditorWidgetOffset(currentOffset + (event->point - m_dragEnd));
        m_dragEnd = event->point;
 
    } else {
        event->ignore();
    }
 
    bool wasHighlightedNode = m_highlightedNode != 0;
    QPointF mousep = m_canvas->viewConverter()->documentToView(event->point);
    QList <KisPaintingAssistantSP> pAssistant= m_canvas->paintingAssistantsDecoration()->assistants();
 
    Q_FOREACH (KisPaintingAssistantSP assistant, pAssistant) {
        if(assistant->id() == "perspective") {
            if ((m_highlightedNode = assistant->closestCornerHandleFromPoint(mousep))) {
                if (m_highlightedNode == m_selectedNode1 || m_highlightedNode == m_selectedNode2) {
                    m_highlightedNode = 0;
                } else {
                    m_canvas->updateCanvas(); // TODO update only the relevant part of the canvas
                    break;
                }
            }
        }
 
        //this following bit sets the translations for the vanishing-point handles.
        if(m_handleDrag && assistant->id() == "vanishing point" && assistant->sideHandles().size()==4) {
            //for inner handles, the outer handle gets translated.
            if (m_handleDrag == assistant->sideHandles()[0]) {
                QLineF perspectiveline = QLineF(*assistant->handles()[0],
                                                *assistant->sideHandles()[0]);
 
                qreal length = QLineF(*assistant->sideHandles()[0],
                                      *assistant->sideHandles()[1]).length();
 
                if (length < 2.0){
                    length = 2.0;
                }
 
                length += perspectiveline.length();
                perspectiveline.setLength(length);
                *assistant->sideHandles()[1] = perspectiveline.p2();
            }
            else if (m_handleDrag == assistant->sideHandles()[2]){
                QLineF perspectiveline = QLineF(*assistant->handles()[0], *assistant->sideHandles()[2]);
                qreal length = QLineF(*assistant->sideHandles()[2], *assistant->sideHandles()[3]).length();
 
                if (length<2.0){
                    length=2.0;
                }
 
                length += perspectiveline.length();
                perspectiveline.setLength(length);
                *assistant->sideHandles()[3] = perspectiveline.p2();
            } // for outer handles, only the vanishing point is translated, but only if there's an intersection.
            else if (m_handleDrag == assistant->sideHandles()[1]|| m_handleDrag == assistant->sideHandles()[3]){
                QPointF vanishingpoint(0,0);
                QLineF perspectiveline = QLineF(*assistant->sideHandles()[0], *assistant->sideHandles()[1]);
                QLineF perspectiveline2 = QLineF(*assistant->sideHandles()[2], *assistant->sideHandles()[3]);
 
                if (QLineF(perspectiveline2).intersects(QLineF(perspectiveline), &vanishingpoint) != QLineF::NoIntersection){
                    *assistant->handles()[0] = vanishingpoint;
                }
            }// and for the vanishing point itself, only the outer handles get translated.
            else if (m_handleDrag == assistant->handles()[0]){
                QLineF perspectiveline = QLineF(*assistant->handles()[0], *assistant->sideHandles()[0]);
                QLineF perspectiveline2 = QLineF(*assistant->handles()[0], *assistant->sideHandles()[2]);
                qreal length =  QLineF(*assistant->sideHandles()[0], *assistant->sideHandles()[1]).length();
                qreal length2 = QLineF(*assistant->sideHandles()[2], *assistant->sideHandles()[3]).length();
 
                if (length < 2.0) {
                    length = 2.0;
                }
 
                if (length2 < 2.0) {
                    length2=2.0;
                }
 
                length += perspectiveline.length();
                length2 += perspectiveline2.length();
                perspectiveline.setLength(length);
                perspectiveline2.setLength(length2);
                *assistant->sideHandles()[1] = perspectiveline.p2();
                *assistant->sideHandles()[3] = perspectiveline2.p2();
            }
 
        }
        if (m_handleDrag && assistant->id() == "two point" && assistant->handles().size() >= 3 &&
            assistant->sideHandles().size() == 8) {
 
          QList<KisPaintingAssistantHandleSP> hndl = assistant->handles();
          QList<KisPaintingAssistantHandleSP> side_hndl = assistant->sideHandles();
 
          const bool far_handle_is_dragged =
              m_handleDrag == side_hndl[1] || m_handleDrag == side_hndl[3] ||
              m_handleDrag == side_hndl[5] || m_handleDrag == side_hndl[7];
 
            if (far_handle_is_dragged) {
                QLineF perspective_line_a, perspective_line_b;
                QPointF vp_new_pos(0,0);
                KisPaintingAssistantHandleSP vp_moved;
                if (m_handleDrag == side_hndl[1] || m_handleDrag == side_hndl[5]) {
                    vp_moved = hndl[0];
                    perspective_line_a = QLineF(*side_hndl[0],*side_hndl[1]);
                    perspective_line_b = QLineF(*side_hndl[4],*side_hndl[5]);
                } else {
                    vp_moved = hndl[1];
                    perspective_line_a = QLineF(*side_hndl[3],*side_hndl[2]);
                    perspective_line_b = QLineF(*side_hndl[6],*side_hndl[7]);
                }
                if (perspective_line_a.intersects(perspective_line_b, &vp_new_pos) != QLineF::NoIntersection) {
                    *vp_moved = vp_new_pos;
                }
            } else {
                QLineF perspective_line_a1;
                QLineF perspective_line_b1;
                QLineF perspective_line_a2;
                QLineF perspective_line_b2;
 
                perspective_line_a1 = QLineF(*hndl[0], *side_hndl[0]);
                perspective_line_a1.setLength(QLineF(*side_hndl[0],*side_hndl[1]).length());
                perspective_line_a1.translate(*side_hndl[0] - perspective_line_a1.p1());
                *side_hndl[1] = perspective_line_a1.p2();
 
                perspective_line_b1 = QLineF(*hndl[0], *side_hndl[4]);
                perspective_line_b1.setLength(QLineF(*side_hndl[4],*side_hndl[5]).length());
                perspective_line_b1.translate(*side_hndl[4] - perspective_line_b1.p1());
                *side_hndl[5] = perspective_line_b1.p2();
 
                perspective_line_a2 = QLineF(*hndl[1], *side_hndl[2]);
                perspective_line_a2.setLength(QLineF(*side_hndl[2],*side_hndl[3]).length());
                perspective_line_a2.translate(*side_hndl[2] - perspective_line_a2.p1());
                *side_hndl[3] = perspective_line_a2.p2();
 
                perspective_line_b2 = QLineF(*hndl[1], *side_hndl[6]);
                perspective_line_b2.setLength(QLineF(*side_hndl[6],*side_hndl[7]).length());
                perspective_line_b2.translate(*side_hndl[6] - perspective_line_b2.p1());
                *side_hndl[7] = perspective_line_b2.p2();
            }
        }
        // The following section handles rulers that have been set to a
        // constant length
        if (m_handleDrag && (assistant->id() == "ruler" || assistant->id() == "infinite ruler")
            && qSharedPointerCast<RulerAssistant>(assistant)->hasFixedLength()
            && assistant->isAssistantComplete()) {
            
            QSharedPointer<RulerAssistant> ruler = qSharedPointerCast<RulerAssistant>(assistant);
          
            if (m_handleDrag == ruler->handles()[0]) {
                // Dragging handle 1 moves the ruler
                *ruler->handles()[1] += *ruler->handles()[0] - m_previousHandlePos;
            }
            else if (m_handleDrag == ruler->handles()[1]) {
                // Dragging handle 2 only allows rotation
                QPointF center = *ruler->handles()[0];
                QPointF handle = *ruler->handles()[1];
                
                QPointF direction = handle - center;
                qreal distance = sqrt(KisPaintingAssistant::norm2(direction));
                QPointF delta = direction / distance * ruler->fixedLength();
                
                *ruler->handles()[1] = center + delta;
            }
        }
    }
    if (wasHighlightedNode && !m_highlightedNode) {
        m_canvas->updateCanvas(); // TODO update only the relevant part of the canvas
    }
}

References distance(), length(), m_assistantDrag, m_canvas, m_currentAdjustment, m_cursorStart, m_dragEnd, m_handleCombine, m_handleDrag, m_handles, m_highlightedNode, m_internalMode, M_PI, m_previousHandlePos, m_selectedNode1, m_selectedNode2, MODE_DRAGGING_EDITOR_WIDGET, KoPointerEvent::modifiers(), KisPaintingAssistant::norm2(), KoPointerEvent::point, snap(), snapToClosestNiceAngle(), KisPaintingAssistantsDecoration::snapToGuide(), and KisPaintingAssistantHandle::uncache().

◆ continueAlternateAction()

void KisAssistantTool::continueAlternateAction	(	KoPointerEvent *	event,
		AlternateAction	action )

overridevirtual

Reimplemented from KisTool.

Definition at line 1971 of file kis_assistant_tool.cc.

{
    Q_UNUSED(action);
    continueActionImpl(event);
}

References KoToolBase::action(), and continueActionImpl().

◆ continuePrimaryAction()

void KisAssistantTool::continuePrimaryAction ( KoPointerEvent * event )

overridevirtual

Called by KisToolProxy when the primary action is in progress of pointer movement. If the tool has ignored the event in beginPrimaryAction(), this method will not be called.

Reimplemented from KisTool.

Definition at line 1988 of file kis_assistant_tool.cc.

{
    continueActionImpl(event);
}

References continueActionImpl().

◆ createOptionWidget()

QWidget * KisAssistantTool::createOptionWidget ( )

overridevirtual

Reimplement this if your tool actually has an option widget. Sets the option widget to 0 by default.

Reimplemented from KoToolBase.

Definition at line 1686 of file kis_assistant_tool.cc.

{
    if (!m_optionsWidget) {
        m_optionsWidget = new QWidget;
        m_options.setupUi(m_optionsWidget);
 
        KConfigGroup cfg = KSharedConfig::openConfig()->group(toolId());
 
        // See https://bugs.kde.org/show_bug.cgi?id=316896
        QWidget *specialSpacer = new QWidget(m_optionsWidget);
        specialSpacer->setObjectName("SpecialSpacer");
        specialSpacer->setFixedSize(0, 0);
        m_optionsWidget->layout()->addWidget(specialSpacer);
 
        m_options.loadAssistantButton->setIcon(KisIconUtils::loadIcon("folder"));
        m_options.loadAssistantButton->setIconSize(QSize(16, 16));
        m_options.saveAssistantButton->setIcon(KisIconUtils::loadIcon("document-save-16"));
        m_options.saveAssistantButton->setIconSize(QSize(16, 16));
        m_options.deleteAllAssistantsButton->setIcon(KisIconUtils::loadIcon("edit-delete"));
        m_options.deleteAllAssistantsButton->setIconSize(QSize(16, 16));
 
        m_options.showDockerOptionsButton->setIcon(KisIconUtils::loadIcon("arrow-right"));
        m_options.showDockerOptionsButton->setIconSize(QSize(16, 16));
 
        QList<KoID> assistants;
        Q_FOREACH (const QString& key, KisPaintingAssistantFactoryRegistry::instance()->keys()) {
            QString name = KisPaintingAssistantFactoryRegistry::instance()->get(key)->name();
            assistants << KoID(key, name);
        }
        std::sort(assistants.begin(), assistants.end(), KoID::compareNames);
 
        QString currentAssistantType = cfg.readEntry("AssistantType", "two point");
        int i = 0;
        int currentAssistantIndex = 0;
        Q_FOREACH(const KoID &id, assistants) {
            m_options.availableAssistantsComboBox->addItem(id.name(), id.id());
            if (id.id() == currentAssistantType) {
                currentAssistantIndex = i;
            }
            i++;
        }
        m_options.availableAssistantsComboBox->setCurrentIndex(currentAssistantIndex);
 
        connect(m_options.availableAssistantsComboBox, SIGNAL(currentIndexChanged(int)), SLOT(slotSelectedAssistantTypeChanged()));
 
        connect(m_options.saveAssistantButton, SIGNAL(clicked()), SLOT(saveAssistants()));
        connect(m_options.loadAssistantButton, SIGNAL(clicked()), SLOT(loadAssistants()));
        connect(m_options.deleteAllAssistantsButton, SIGNAL(clicked()), SLOT(removeAllAssistants()));
 
        connect(m_options.assistantsColor, SIGNAL(changed(QColor)), SLOT(slotGlobalAssistantsColorChanged(QColor)));
        connect(m_options.assistantsGlobalOpacitySlider, SIGNAL(valueChanged(int)), SLOT(slotGlobalAssistantOpacityChanged()));
 
        connect(m_options.vanishingPointAngleSpinbox, SIGNAL(valueChanged(double)), this, SLOT(slotChangeVanishingPointAngle(double)));
        connect(m_options.twoPointDensitySpinbox, SIGNAL(valueChanged(double)), this, SLOT(slotChangeTwoPointDensity(double)));
        connect(m_options.twoPointUseVerticalCheckbox, SIGNAL(stateChanged(int)), this, SLOT(slotChangeTwoPointUseVertical(int)));
        
        connect(m_options.subdivisionsSpinbox, SIGNAL(valueChanged(int)), this, SLOT(slotChangeSubdivisions(int)));
        connect(m_options.minorSubdivisionsSpinbox, SIGNAL(valueChanged(int)), this, SLOT(slotChangeMinorSubdivisions(int)));
        connect(m_options.fixedLengthCheckbox, SIGNAL(stateChanged(int)), this, SLOT(slotEnableFixedLength(int)));
        connect(m_options.fixedLengthSpinbox, SIGNAL(valueChangedPt(double)), this, SLOT(slotChangeFixedLength(double)));
        
        //update EditorWidgetData when checkbox clicked
        connect(m_options.showMove, SIGNAL(stateChanged(int)), this, SLOT(slotToggleMoveButton(int)));
        connect(m_options.showSnap, SIGNAL(stateChanged(int)), this, SLOT(slotToggleSnapButton(int)));
        connect(m_options.showLock, SIGNAL(stateChanged(int)), this, SLOT(slotToggleLockButton(int)));
        connect(m_options.showDuplicate, SIGNAL(stateChanged(int)), this, SLOT(slotToggleDuplicateButton(int)));
        connect(m_options.showDelete, SIGNAL(stateChanged(int)), this, SLOT(slotToggleDeleteButton(int)));
        
        // initialize UI elements with existing data if possible
        if (m_canvas && m_canvas->paintingAssistantsDecoration()) {
            const QColor color = m_canvas->paintingAssistantsDecoration()->globalAssistantsColor();
 
            QColor opaqueColor = color;
            opaqueColor.setAlpha(255);
 
            m_options.assistantsColor->setColor(opaqueColor);
            m_options.customAssistantColorButton->setColor(opaqueColor);
            m_options.assistantsGlobalOpacitySlider->setValue(color.alphaF() * 100.0);
 
        } else {
            m_options.assistantsColor->setColor(QColor(176, 176, 176, 255)); // grey default for all assistants
            m_options.assistantsGlobalOpacitySlider->setValue(100); // 100%
        }
 
        m_options.assistantsGlobalOpacitySlider->setPrefix(i18n("Opacity: "));
        m_options.assistantsGlobalOpacitySlider->setSuffix(" %");
 
 
        // custom color of selected assistant
        m_options.customColorOpacitySlider->setValue(100); // 100%
        m_options.customColorOpacitySlider->setPrefix(i18n("Opacity: "));
        m_options.customColorOpacitySlider->setSuffix(" %");
 
        connect(m_options.useCustomAssistantColor, SIGNAL(clicked(bool)), this, SLOT(slotUpdateCustomColor()));
        connect(m_options.customAssistantColorButton, SIGNAL(changed(QColor)), this, SLOT(slotUpdateCustomColor()));
        connect(m_options.customColorOpacitySlider, SIGNAL(valueChanged(int)), SLOT(slotCustomOpacityChanged()));
 
        m_options.twoPointDensitySpinbox->setPrefix(i18n("Density: "));
        m_options.twoPointDensitySpinbox->setRange(0.1, 4.0, 2);
        m_options.twoPointDensitySpinbox->setSingleStep(0.1);
 
        m_options.vanishingPointAngleSpinbox->setPrefix(i18n("Density: "));
        m_options.vanishingPointAngleSpinbox->setSuffix(QStringLiteral("°"));
        m_options.vanishingPointAngleSpinbox->setRange(1.0, 180.0);
        m_options.vanishingPointAngleSpinbox->setSingleStep(1.0);
        
        m_options.subdivisionsSpinbox->setPrefix(i18n("Subdivisions: "));
        m_options.subdivisionsSpinbox->setRange(0, 100);
        m_options.subdivisionsSpinbox->setSoftRange(0, 20);
        
        m_options.minorSubdivisionsSpinbox->setPrefix(i18n("Minor Subdivisions: "));
        m_options.minorSubdivisionsSpinbox->setRange(1, 5);
        
        m_unitManager->setUnitDimension(KisSpinBoxUnitManager::LENGTH);
        m_options.fixedLengthSpinbox->setUnitManager(m_unitManager);
        m_options.fixedLengthSpinbox->setDisplayUnit(false);
        m_options.fixedLengthSpinbox->setMinimum(0);
        m_options.fixedLengthUnit->setModel(m_unitManager);
        m_unitManager->setApparentUnitFromSymbol("px");
        connect(m_options.fixedLengthUnit, SIGNAL(currentIndexChanged(int)), this, SLOT(slotChangeFixedLengthUnit(int)));
        connect(m_unitManager, SIGNAL(unitChanged(int)), m_options.fixedLengthUnit, SLOT(setCurrentIndex(int)));
        
        m_options.vanishingPointAngleSpinbox->setVisible(false);
        m_options.twoPointDensitySpinbox->setVisible(false);
        m_options.subdivisionsSpinbox->setVisible(false);
        m_options.minorSubdivisionsSpinbox->setVisible(false);
        m_options.fixedLengthCheckbox->setVisible(false);
        m_options.fixedLengthSpinbox->setVisible(false);
        m_options.fixedLengthUnit->setVisible(false);
        
 
        m_options.localAssistantCheckbox->setChecked(cfg.readEntry("LimitAssistantToArea", false));
 
        connect(m_options.localAssistantCheckbox, SIGNAL(stateChanged(int)), SLOT(slotLocalAssistantCheckboxChanged()));
 
        // show panel for docker tool option visibility
        connect(m_options.showDockerOptionsButton, SIGNAL(clicked()), this, SLOT(slotToggleDockToolOptionsVisible()));
        // set control widget buttons on first startup.
        AssistantEditorData &globalEditorWidgetData = m_canvas->paintingAssistantsDecoration()->globalEditorWidgetData;
 
 
        if (globalEditorWidgetData.moveButtonActivated) {
            m_options.showMove->setChecked(true);
        }
        if (globalEditorWidgetData.snapButtonActivated) {
            m_options.showSnap->setChecked(true);
        }
        if (globalEditorWidgetData.lockButtonActivated) {
        m_options.showLock->setChecked(true);
        }
        if (globalEditorWidgetData.duplicateButtonActivated) {
            m_options.showDuplicate->setChecked(true);
        }
        if (globalEditorWidgetData.deleteButtonActivated) {
            m_options.showDelete->setChecked(true);
        }
    }
 
    updateToolOptionsUI();
 
    return m_optionsWidget;
}

References KoID::compareNames(), AssistantEditorData::deleteButtonActivated, AssistantEditorData::duplicateButtonActivated, KoGenericRegistry< T >::get(), KisPaintingAssistantFactoryRegistry::instance(), KisSpinBoxUnitManager::LENGTH, loadAssistants(), KisIconUtils::loadIcon(), AssistantEditorData::lockButtonActivated, m_canvas, m_options, m_optionsWidget, m_unitManager, AssistantEditorData::moveButtonActivated, KisPaintingAssistantFactory::name(), removeAllAssistants(), saveAssistants(), KisSpinBoxUnitManager::setApparentUnitFromSymbol(), KisSpinBoxUnitManager::setUnitDimension(), slotChangeFixedLength(), slotChangeFixedLengthUnit(), slotChangeMinorSubdivisions(), slotChangeSubdivisions(), slotChangeTwoPointDensity(), slotChangeTwoPointUseVertical(), slotChangeVanishingPointAngle(), slotCustomOpacityChanged(), slotEnableFixedLength(), slotGlobalAssistantOpacityChanged(), slotGlobalAssistantsColorChanged(), slotLocalAssistantCheckboxChanged(), slotSelectedAssistantTypeChanged(), slotToggleDeleteButton(), slotToggleDockToolOptionsVisible(), slotToggleDuplicateButton(), slotToggleLockButton(), slotToggleMoveButton(), slotToggleSnapButton(), slotUpdateCustomColor(), AssistantEditorData::snapButtonActivated, KoToolBase::toolId(), and updateToolOptionsUI().

◆ deactivate

void KisAssistantTool::deactivate ( )

overrideslot

Definition at line 90 of file kis_assistant_tool.cc.

{
    m_canvas->paintingAssistantsDecoration()->deactivateAssistantsEditor();
    m_canvas->updateCanvas();
    KisTool::deactivate();
}

References KisTool::deactivate(), and m_canvas.

◆ drawEditorWidget()

void KisAssistantTool::drawEditorWidget	(	KisPaintingAssistantSP	assistant,
		QPainter &	_gc )

private

◆ endActionImpl()

void KisAssistantTool::endActionImpl ( KoPointerEvent * event )

private

Definition at line 737 of file kis_assistant_tool.cc.

{
    setMode(KisTool::HOVER_MODE);
    // release duplication button flag
    if(assistantDuplicatingFlag) {
        KisPaintingAssistantSP selectedAssistant = m_canvas->paintingAssistantsDecoration()->selectedAssistant();
        selectedAssistant->setDuplicating(false);
        assistantDuplicatingFlag = false;
            
        // offset control widget if user simple click-releases duplication button
        if (m_dragEnd == m_dragStart) {
            // calculate offset independent from canvas resolution and zoom
            const KisCoordinatesConverter *converter = m_canvas->coordinatesConverter();
            // create offset unit, considering canvas resolution
            const int offset = 20;
            const float offsetUnit = offset / m_canvas->image()->xRes();
            // use unit to calculate final offset, considering canvas zoom
            QPointF widgetDuplicationOffset = QPointF(offsetUnit / converter->effectiveZoom(),offsetUnit / converter->effectiveZoom());
            // apply offset to control widget
            QPointF currentOffset = selectedAssistant->editorWidgetOffset();
            selectedAssistant->setEditorWidgetOffset(currentOffset + widgetDuplicationOffset);
        }
    }
 
    if (m_handleDrag || m_assistantDrag) {
        if (m_handleDrag) {
            if (!(event->modifiers() & Qt::ShiftModifier) && m_handleCombine) {
                m_handleCombine->mergeWith(m_handleDrag);
                m_handleCombine->uncache();
                m_handles = m_canvas->paintingAssistantsDecoration()->handles();
            }
            m_handleDrag = m_handleCombine = 0;
        } else {
            m_assistantDrag.clear();
        }
        dbgUI << "creating undo command...";
        KUndo2Command *command = new EditAssistantsCommand(m_canvas, m_origAssistantList, KisPaintingAssistant::cloneAssistantList(m_canvas->paintingAssistantsDecoration()->assistants()));
        m_canvas->viewManager()->undoAdapter()->addCommand(command);
        dbgUI << "done";
    } else if(m_internalMode == MODE_DRAGGING_TRANSLATING_TWONODES) {
        addAssistant();
        m_internalMode = MODE_CREATION;
    } else if (m_internalMode == MODE_DRAGGING_EDITOR_WIDGET) {
        KisPaintingAssistantSP selectedAssistant = m_canvas->paintingAssistantsDecoration()->selectedAssistant();
        QPointF currentOffset = selectedAssistant->editorWidgetOffset();
        selectedAssistant->setEditorWidgetOffset(currentOffset + (event->point - m_dragEnd));
    }
    else {
        event->ignore();
    }
 
    m_canvas->updateCanvas(); // TODO update only the relevant part of the canvas
}

References addAssistant(), assistantDuplicatingFlag, KisPaintingAssistant::cloneAssistantList(), dbgUI, KisCoordinatesConverter::effectiveZoom(), KisTool::HOVER_MODE, m_assistantDrag, m_canvas, m_dragEnd, m_dragStart, m_handleCombine, m_handleDrag, m_handles, m_internalMode, m_origAssistantList, KisPaintingAssistantHandle::mergeWith(), MODE_CREATION, MODE_DRAGGING_EDITOR_WIDGET, MODE_DRAGGING_TRANSLATING_TWONODES, KoPointerEvent::modifiers(), KoPointerEvent::point, KisTool::setMode(), and KisPaintingAssistantHandle::uncache().

◆ endAlternateAction()

void KisAssistantTool::endAlternateAction	(	KoPointerEvent *	event,
		AlternateAction	action )

overridevirtual

Reimplemented from KisTool.

Definition at line 1977 of file kis_assistant_tool.cc.

{
    Q_UNUSED(action);
    endActionImpl(event);
}

References KoToolBase::action(), and endActionImpl().

◆ endPrimaryAction()

void KisAssistantTool::endPrimaryAction ( KoPointerEvent * event )

overridevirtual

Called by KisToolProxy when the primary action is being finished, that is while mouseRelease or tabletRelease event. If the tool has ignored the event in beginPrimaryAction(), this method will not be called.

Reimplemented from KisTool.

Definition at line 1993 of file kis_assistant_tool.cc.

{
    endActionImpl(event);
}

References endActionImpl().

◆ keyPressEvent()

void KisAssistantTool::keyPressEvent ( QKeyEvent * event )

overridevirtual

Called when a key is pressed. Implementors should call event->ignore() if they do not actually use the event. Default implementation ignores this event.

Parameters

event state and reason of this key press

Reimplemented from KoToolBase.

Definition at line 1357 of file kis_assistant_tool.cc.

{
    // When the user is in the middle of creating a new
    // assistant the escape key can be used to cancel this process.
    if (event->key()==Qt::Key_Escape && (m_newAssistant)) {
        // Clear shared pointer to the assistant being created so
        // it gets cleaned-up
        m_newAssistant.clear();
        m_canvas->updateCanvas();
        event->accept();
    } else {
        event->ignore();
    }
}

References m_canvas, and m_newAssistant.

◆ loadAssistants

void KisAssistantTool::loadAssistants ( )

privateslot

Definition at line 1435 of file kis_assistant_tool.cc.

{
    KoFileDialog dialog(m_canvas->viewManager()->mainWindowAsQWidget(), KoFileDialog::OpenFile, "OpenAssistant");
    dialog.setCaption(i18n("Select an Assistant"));
    dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
    dialog.setMimeTypeFilters(QStringList() << "application/x-krita-assistant", "application/x-krita-assistant");
    QString filename = dialog.filename();
 
    QFile file(filename);
    if (!file.open(QIODevice::ReadOnly)) { return; }
 
    QByteArray data = file.readAll();
    QXmlStreamReader xml(data);
    QMap<int, KisPaintingAssistantHandleSP> handleMap;
    QMap<int, KisPaintingAssistantHandleSP> sideHandleMap;
    KisPaintingAssistantSP assistant;
    bool errors = false;
 
    m_origAssistantList = KisPaintingAssistant::cloneAssistantList(m_canvas->paintingAssistantsDecoration()->assistants());
 
 
    while (!xml.atEnd()) {
        switch (xml.readNext()) {
        case QXmlStreamReader::StartElement:
            if (xml.name() == "handle") {
                if (assistant && !xml.attributes().value("ref").isEmpty()) {
                    KisPaintingAssistantHandleSP handle = handleMap.value(xml.attributes().value("ref").toString().toInt());
                    if (handle) {
                       assistant->addHandle(handle, HandleType::NORMAL);
                    } else {
                        errors = true;
                    }
                } else {
                    QString strId = xml.attributes().value("id").toString(),
                            strX = xml.attributes().value("x").toString(),
                            strY = xml.attributes().value("y").toString();
 
 
 
                    if (!strId.isEmpty() && !strX.isEmpty() && !strY.isEmpty()) {
                        int id = strId.toInt();
                        double x = strX.toDouble(),
                                y = strY.toDouble();
                        if (!handleMap.contains(id)) {
                            handleMap.insert(id, new KisPaintingAssistantHandle(x, y));
                        } else {
                            errors = true;
                        }
                    } else {
                        errors = true;
                    }
                }
            // for vanishing point assistant
            } else if (xml.name() == "sidehandle"){
 
              // read in sidehandles
              if (!xml.attributes().value("id").isEmpty()) {
                  QString strId = xml.attributes().value("id").toString(),
                          strX = xml.attributes().value("x").toString(),
                          strY = xml.attributes().value("y").toString();
                  if (!strId.isEmpty() && !strX.isEmpty() && !strY.isEmpty()) {
                      int id = strId.toInt();
                      double x = strX.toDouble();
                      double y = strY.toDouble();
                      if (!sideHandleMap.contains(id)) {
                          sideHandleMap.insert(id, new KisPaintingAssistantHandle(x,y));
                      }}
              }
              // addHandle to assistant
              if (!xml.attributes().value("ref").isEmpty() && assistant) {
                  KisPaintingAssistantHandleSP handle = sideHandleMap.value(xml.attributes().value("ref").toString().toInt());
                  if (handle) {
                      assistant->addHandle(handle, HandleType::SIDE);
                  }
              }
 
            } else if (xml.name() == "assistant") {
                const KisPaintingAssistantFactory* factory = KisPaintingAssistantFactoryRegistry::instance()->get(xml.attributes().value("type").toString());
 
                if (factory) {
                    if (assistant) {
                        errors = true;
                        assistant.clear();
                    }
                    assistant = toQShared(factory->createPaintingAssistant());
                } else {
                    errors = true;
                }
 
                if (assistant) {
                    // load custom shared assistant properties
                    if (xml.attributes().hasAttribute("useCustomColor")) {
                        auto useCustomColor = xml.attributes().value("useCustomColor");
 
                        bool usingColor = false;
                        if (useCustomColor.toString() == "1") {
                            usingColor = true;
                        }
                        assistant->setUseCustomColor(usingColor);
                    }
 
                    if ( xml.attributes().hasAttribute("useCustomColor")) {
                        auto customColor = xml.attributes().value("customColor");
                        assistant->setAssistantCustomColor( KisDomUtils::qStringToQColor(customColor.toString()) );
 
                    }
                }
           }
 
            if (assistant) {
                assistant->loadCustomXml(&xml);
            }
 
 
           break;
        case QXmlStreamReader::EndElement:
            if (xml.name() == "assistant") {
                if (assistant) {
                    if (assistant->handles().size() == assistant->numHandles()) {
                        if (assistant->id() == "vanishing point" && sideHandleMap.empty()){
                        // Create side handles if the saved vp assistant doesn't have any.
                            QPointF pos = *assistant->handles()[0];
                            assistant->addHandle(new KisPaintingAssistantHandle(pos+QPointF(-70,0)), HandleType::SIDE);
                            assistant->addHandle(new KisPaintingAssistantHandle(pos+QPointF(-140,0)), HandleType::SIDE);
                            assistant->addHandle(new KisPaintingAssistantHandle(pos+QPointF(70,0)), HandleType::SIDE);
                            assistant->addHandle(new KisPaintingAssistantHandle(pos+QPointF(140,0)), HandleType::SIDE);
                        }
                        m_canvas->paintingAssistantsDecoration()->addAssistant(assistant);
                    } else {
                        errors = true;
                    }
                    assistant.clear();
                }
            }
 
            break;
        default:
            break;
        }
 
    }
    if (assistant) {
        errors = true;
        assistant.clear();
    }
    if (xml.hasError()) {
        QMessageBox::warning(qApp->activeWindow(), i18nc("@title:window", "Krita"), xml.errorString());
    }
    if (errors) {
        QMessageBox::warning(qApp->activeWindow(), i18nc("@title:window", "Krita"), i18n("Errors were encountered. Not all assistants were successfully loaded."));
    }
 
    KUndo2Command *command = new EditAssistantsCommand(m_canvas, m_origAssistantList, KisPaintingAssistant::cloneAssistantList(m_canvas->paintingAssistantsDecoration()->assistants()));
    m_canvas->viewManager()->undoAdapter()->addCommand(command);
 
    m_handles = m_canvas->paintingAssistantsDecoration()->handles();
    m_canvas->updateCanvas();
}

References KisPaintingAssistant::cloneAssistantList(), KoToolBase::factory(), KoGenericRegistry< T >::get(), KisPaintingAssistantFactoryRegistry::instance(), m_canvas, m_handles, m_origAssistantList, NORMAL, KoFileDialog::OpenFile, KisDomUtils::qStringToQColor(), SIDE, and toQShared().

◆ mouseMoveEvent()

void KisAssistantTool::mouseMoveEvent ( KoPointerEvent * event )

overridevirtual

Called when the mouse or stylus moved over the canvas. Implementors should call event->ignore() if they do not actually use the event.

Parameters

event state and reason of this mouse or stylus move

Implements KoToolBase.

Definition at line 1314 of file kis_assistant_tool.cc.

{
    m_handleHover = 0;
    if (m_newAssistant && m_internalMode == MODE_CREATION) {
 
        KisPaintingAssistantHandleSP new_handle = m_newAssistant->handles().back();
        if (!snap(event)) {
            KisPaintingAssistantsDecorationSP canvasDecoration = m_canvas->paintingAssistantsDecoration();
            *new_handle = canvasDecoration->snapToGuide(event, QPointF(), false);
        }
 
    } else if (m_newAssistant && m_internalMode == MODE_DRAGGING_TRANSLATING_TWONODES) {
        QPointF translate = event->point - m_dragEnd;
        m_dragEnd = event->point;
        m_selectedNode1.data()->operator = (QPointF(m_selectedNode1.data()->x(),m_selectedNode1.data()->y()) + translate);
        m_selectedNode2.data()->operator = (QPointF(m_selectedNode2.data()->x(),m_selectedNode2.data()->y()) + translate);
    } else if (mode() == KisTool::HOVER_MODE) {
 
        // find a handle underneath...
        double minDist = m_handleMaxDist;
 
        QPointF mousePos = m_canvas->viewConverter()->documentToView(event->point);
 
        Q_FOREACH (KisPaintingAssistantSP assistant, m_canvas->paintingAssistantsDecoration()->assistants()) {
            QList<KisPaintingAssistantHandleSP> allAssistantHandles;
            allAssistantHandles.append(assistant->handles());
            allAssistantHandles.append(assistant->sideHandles());
 
            Q_FOREACH (const KisPaintingAssistantHandleSP handle, allAssistantHandles) {
 
                double dist = KisPaintingAssistant::norm2(mousePos - m_canvas->viewConverter()->documentToView(*handle));
                if (dist < minDist) {
                    minDist = dist;
                    m_handleHover = handle;
                }
            }
        }
    }
 
    m_canvas->updateCanvasDecorations();
}

References KisSharedPtr< T >::data(), KisTool::HOVER_MODE, m_canvas, m_dragEnd, m_handleHover, m_handleMaxDist, m_internalMode, m_newAssistant, m_selectedNode1, m_selectedNode2, KisTool::mode(), MODE_CREATION, MODE_DRAGGING_TRANSLATING_TWONODES, KisPaintingAssistant::norm2(), KoPointerEvent::point, snap(), and KisPaintingAssistantsDecoration::snapToGuide().

◆ paint()

void KisAssistantTool::paint	(	QPainter &	gc,
		const KoViewConverter &	converter )

overrideprotectedvirtual

Draws the editor widget controls with move, activate, and delete This also creates a lot of assistant specific stuff for vanishing points and perspective grids Whatever is painted here will be underneath the content painted in the kis_painting_assistant_decoration The kis_painting_assistant_decoration paints the final assistant, so this is more of just editor controls

Implements KoToolBase.

Definition at line 1372 of file kis_assistant_tool.cc.

{
    QRectF canvasSize = QRectF(QPointF(0, 0), QSizeF(m_canvas->image()->size()));
 
    // show special display while a new assistant is in the process of being created
    if (m_newAssistant) {
 
        QColor assistantColor = m_canvas->displayRendererInterface()->convertColorToDisplayColorSpace(KoColor(m_newAssistant->effectiveAssistantColor(), KoColorSpaceRegistry::instance()->rgb8()));
        assistantColor.setAlpha(80);
 
        m_newAssistant->drawAssistant(_gc, canvasSize, m_canvas->coordinatesConverter(), m_canvas->displayRendererInterface(), false, m_canvas, true, false);
        Q_FOREACH (const KisPaintingAssistantHandleSP handle, m_newAssistant->handles()) {
            QPainterPath path;
            path.addEllipse(QRectF(_converter.documentToView(*handle) -  QPointF(m_handleSize * 0.5, m_handleSize * 0.5), QSizeF(m_handleSize, m_handleSize)));
 
            _gc.save();
            _gc.setPen(Qt::NoPen);
            _gc.setBrush(assistantColor);
            _gc.drawPath(path);
            _gc.restore();
        }
    }
 
 
    Q_FOREACH (KisPaintingAssistantSP assistant, m_canvas->paintingAssistantsDecoration()->assistants()) {
 
        QColor assistantColor = m_canvas->displayRendererInterface()->convertColorToDisplayColorSpace(KoColor(assistant->effectiveAssistantColor(), KoColorSpaceRegistry::instance()->rgb8()));
        assistantColor.setAlpha(80);
 
        Q_FOREACH (const KisPaintingAssistantHandleSP handle, m_handles) {
            QRectF ellipse(_converter.documentToView(*handle) -  QPointF(m_handleSize * 0.5, m_handleSize * 0.5),
                           QSizeF(m_handleSize, m_handleSize));
 
            // render handles differently if it is the one being dragged.
            if (handle == m_handleDrag || handle == m_handleCombine || (handle == m_handleHover && !handle->chiefAssistant()->isLocked())) {
                QPen stroke(assistantColor, 4);
                _gc.save();
                _gc.setPen(stroke);
                _gc.setBrush(Qt::NoBrush);
                _gc.drawEllipse(ellipse);
                _gc.restore();
            }
 
        }
    }
}

References KisPaintingAssistantHandle::chiefAssistant(), KoViewConverter::documentToView(), KoColorSpaceRegistry::instance(), KisPaintingAssistant::isLocked(), m_canvas, m_handleCombine, m_handleDrag, m_handleHover, m_handles, m_handleSize, m_newAssistant, and KoColorSpaceRegistry::rgb8().

◆ priority()

virtual quint32 KisAssistantTool::priority ( )

inlinevirtual

Definition at line 48 of file kis_assistant_tool.h.

                               {
        return 3;
    }

◆ removeAllAssistants

void KisAssistantTool::removeAllAssistants ( )

privateslot

Definition at line 1419 of file kis_assistant_tool.cc.

{
    m_origAssistantList = m_canvas->paintingAssistantsDecoration()->assistants();
 
    m_canvas->paintingAssistantsDecoration()->removeAll();
 
    KUndo2Command *removeAssistantCmd = new EditAssistantsCommand(m_canvas, m_origAssistantList, KisPaintingAssistant::cloneAssistantList(m_canvas->paintingAssistantsDecoration()->assistants()));
    m_canvas->viewManager()->undoAdapter()->addCommand(removeAssistantCmd);
 
    m_handles = m_canvas->paintingAssistantsDecoration()->handles();
    m_canvas->updateCanvas();
 
    m_canvas->paintingAssistantsDecoration()->deselectAssistant();
    updateToolOptionsUI();
}

References KisPaintingAssistant::cloneAssistantList(), m_canvas, m_handles, m_origAssistantList, and updateToolOptionsUI().

◆ removeAssistant()

void KisAssistantTool::removeAssistant ( KisPaintingAssistantSP assistant )

private

Definition at line 956 of file kis_assistant_tool.cc.

{
    QList<KisPaintingAssistantSP> assistants = m_canvas->paintingAssistantsDecoration()->assistants();
 
    m_canvas->paintingAssistantsDecoration()->removeAssistant(assistant);
 
    KUndo2Command *removeAssistantCmd = new EditAssistantsCommand(m_canvas, m_origAssistantList, KisPaintingAssistant::cloneAssistantList(m_canvas->paintingAssistantsDecoration()->assistants()), EditAssistantsCommand::REMOVE, assistants.indexOf(assistant));
    m_canvas->viewManager()->undoAdapter()->addCommand(removeAssistantCmd);
 
    m_handles = m_canvas->paintingAssistantsDecoration()->handles();
    m_canvas->paintingAssistantsDecoration()->deselectAssistant();
    updateToolOptionsUI();
}

References KisPaintingAssistant::cloneAssistantList(), m_canvas, m_handles, m_origAssistantList, EditAssistantsCommand::REMOVE, and updateToolOptionsUI().

◆ saveAssistants

void KisAssistantTool::saveAssistants ( )

privateslot

Definition at line 1594 of file kis_assistant_tool.cc.

{
 
    if (m_handles.isEmpty()) return;
 
    QByteArray data;
    QXmlStreamWriter xml(&data);
    xml.writeStartDocument();
    xml.writeStartElement("paintingassistant");
    xml.writeAttribute("color",
                       KisDomUtils::qColorToQString(
                           m_canvas->paintingAssistantsDecoration()->globalAssistantsColor())); // global color if no custom color used
 
 
    xml.writeStartElement("handles");
    QMap<KisPaintingAssistantHandleSP, int> handleMap;
    Q_FOREACH (const KisPaintingAssistantHandleSP handle, m_handles) {
        int id = handleMap.size();
        handleMap.insert(handle, id);
        xml.writeStartElement("handle");
        //xml.writeAttribute("type", handle->handleType());
        xml.writeAttribute("id", QString::number(id));
        xml.writeAttribute("x", QString::number(double(handle->x()), 'f', 3));
        xml.writeAttribute("y", QString::number(double(handle->y()), 'f', 3));
        xml.writeEndElement();
    }
    xml.writeEndElement();
    xml.writeStartElement("sidehandles");
    QMap<KisPaintingAssistantHandleSP, int> sideHandleMap;
    Q_FOREACH (KisPaintingAssistantSP assistant, m_canvas->paintingAssistantsDecoration()->assistants()) {
        Q_FOREACH (KisPaintingAssistantHandleSP handle, assistant->sideHandles()) {
            int id = sideHandleMap.size();
            sideHandleMap.insert(handle, id);
            xml.writeStartElement("sidehandle");
            xml.writeAttribute("id", QString::number(id));
            xml.writeAttribute("x", QString::number(double(handle->x()), 'f', 3));
            xml.writeAttribute("y", QString::number(double(handle->y()), 'f', 3));
            xml.writeEndElement();
        }
    }
    xml.writeStartElement("assistants");
 
 
    Q_FOREACH (const KisPaintingAssistantSP assistant, m_canvas->paintingAssistantsDecoration()->assistants()) {
        xml.writeStartElement("assistant");
        xml.writeAttribute("type", assistant->id());
        xml.writeAttribute("useCustomColor", QString::number(assistant->useCustomColor()));
        xml.writeAttribute("customColor",  KisDomUtils::qColorToQString(assistant->assistantCustomColor()));
 
 
 
        // custom assistant properties like angle density on vanishing point
        assistant->saveCustomXml(&xml);
 
        // handle information
        xml.writeStartElement("handles");
        Q_FOREACH (const KisPaintingAssistantHandleSP handle, assistant->handles()) {
            xml.writeStartElement("handle");
            xml.writeAttribute("ref", QString::number(handleMap.value(handle)));
            xml.writeEndElement();
        }
        xml.writeEndElement();
        if (!sideHandleMap.empty()) {
            xml.writeStartElement("sidehandles");
            Q_FOREACH (const KisPaintingAssistantHandleSP handle, assistant->sideHandles()) {
                xml.writeStartElement("sidehandle");
                xml.writeAttribute("ref", QString::number(sideHandleMap.value(handle)));
                xml.writeEndElement();
            }
            xml.writeEndElement();
        }
        xml.writeEndElement();
    }
    xml.writeEndElement();
    xml.writeEndElement();
    xml.writeEndDocument();
 
    KoFileDialog dialog(m_canvas->viewManager()->mainWindowAsQWidget(), KoFileDialog::SaveFile, "OpenAssistant");
    dialog.setCaption(i18n("Save Assistant"));
    dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
    dialog.setMimeTypeFilters(QStringList() << "application/x-krita-assistant", "application/x-krita-assistant");
    QString filename = dialog.filename();
    if (filename.isEmpty()) return;
 
    QFile file(filename);
    if (file.open(QIODevice::WriteOnly)) {
        file.write(data);
    } else {
        qWarning() << "Couldn't open file" << file.fileName() << "for writing:" << file.errorString();
    }
}

References m_canvas, m_handles, KisDomUtils::qColorToQString(), and KoFileDialog::SaveFile.

◆ slotChangeFixedLength

void KisAssistantTool::slotChangeFixedLength ( double value )

slot

Definition at line 1240 of file kis_assistant_tool.cc.

                                                   {
    // This slot should only be called when the user actually changes the
    // value, not when it is changed through unit conversions. Use
    // QSignalBlocker on the spin box when converting units to achieve this.
  
    if (m_canvas->paintingAssistantsDecoration()->assistants().length() == 0) {
        return;
    }
    
    // get the selected assistant and change the angle value
    KisPaintingAssistantSP m_selectedAssistant =  m_canvas->paintingAssistantsDecoration()->selectedAssistant();
    if (m_selectedAssistant) {
        bool isRulerAssistant = m_selectedAssistant->id() == "ruler"
                             || m_selectedAssistant->id() == "infinite ruler";
        
        if (isRulerAssistant) {
            QSharedPointer <RulerAssistant> assis = qSharedPointerCast<RulerAssistant>(m_selectedAssistant);
            // Stores the newly entered data (length & unit) in the assistant
            assis->setFixedLengthUnit(m_unitManager->getApparentUnitSymbol());
            assis->setFixedLength(m_options.fixedLengthSpinbox->value());
            assis->ensureLength();
            m_options.fixedLengthSpinbox->setPrefix("");
        }
    }
    
    m_canvas->updateCanvasDecorations();
}

References KisSpinBoxUnitManager::getApparentUnitSymbol(), m_canvas, m_options, and m_unitManager.

◆ slotChangeFixedLengthUnit

void KisAssistantTool::slotChangeFixedLengthUnit ( int index )

privateslot

Definition at line 1268 of file kis_assistant_tool.cc.

                                                          {
    if (m_canvas->paintingAssistantsDecoration()->assistants().length() == 0) {
        return;
    }
  
    // get the selected assistant and change the angle value
    KisPaintingAssistantSP m_selectedAssistant =
            m_canvas->paintingAssistantsDecoration()->selectedAssistant();
    if (m_selectedAssistant) {
        bool isRulerAssistant = m_selectedAssistant->id() == "ruler" ||
                                m_selectedAssistant->id() == "infinite ruler";
  
        if (isRulerAssistant) {
            QSharedPointer<RulerAssistant> assis = qSharedPointerCast<RulerAssistant>(m_selectedAssistant);
            
            // Saving and restoring the actual length manually, since the
            // unit manager rounds without warning during conversion
            qreal current_length = assis->fixedLength();
            {
                // Block signals from the spinbox while changing the unit to
                // avoid edits via valueChanged() in the meantime
                QSignalBlocker b(m_options.fixedLengthSpinbox);
                m_unitManager->selectApparentUnitFromIndex(index);
                m_options.fixedLengthSpinbox->changeValue(current_length);
            }
            
            QString unit = m_unitManager->getApparentUnitSymbol();
            
            if (unit == assis->fixedLengthUnit()) {
                // If the previous unit is selected, show no prefix: perfect match
                m_options.fixedLengthSpinbox->setPrefix("");
            }
            else {
                if (abs(m_options.fixedLengthSpinbox->value() - current_length) > 1e-3) {
                    // If the units don't match, show the approximate symbol as prefix
                    m_options.fixedLengthSpinbox->setPrefix(u8"\u2248");
                } else {
                    // If the units don't match but converted perfectly
                    // (close enough: +- 0.001 pt), show equals instead
                    m_options.fixedLengthSpinbox->setPrefix("=");
                }
            }
        }
    }
}

References KisSpinBoxUnitManager::getApparentUnitSymbol(), m_canvas, m_options, m_unitManager, and KisSpinBoxUnitManager::selectApparentUnitFromIndex().

◆ slotChangeMinorSubdivisions

void KisAssistantTool::slotChangeMinorSubdivisions ( int value )

slot

Definition at line 1187 of file kis_assistant_tool.cc.

                                                            {
    if (m_canvas->paintingAssistantsDecoration()->assistants().length() == 0) {
        return;
    }
    
    // get the selected assistant and change the angle value
    KisPaintingAssistantSP m_selectedAssistant =  m_canvas->paintingAssistantsDecoration()->selectedAssistant();
    if (m_selectedAssistant) {
        bool isRulerAssistant = m_selectedAssistant->id() == "ruler"
                             || m_selectedAssistant->id() == "infinite ruler";
        
        if (isRulerAssistant) {
            QSharedPointer <RulerAssistant> assis = qSharedPointerCast<RulerAssistant>(m_selectedAssistant);
            assis->setMinorSubdivisions(value);
        }
    }
    
    m_canvas->updateCanvasDecorations();
}

References m_canvas, and value().

◆ slotChangeSubdivisions

void KisAssistantTool::slotChangeSubdivisions ( int value )

slot

Definition at line 1159 of file kis_assistant_tool.cc.

                                                       {
    if (m_canvas->paintingAssistantsDecoration()->assistants().length() == 0) {
        return;
    }
    
    // get the selected assistant and change the angle value
    KisPaintingAssistantSP m_selectedAssistant =  m_canvas->paintingAssistantsDecoration()->selectedAssistant();
    if (m_selectedAssistant) {
        bool isRulerAssistant = m_selectedAssistant->id() == "ruler"
                             || m_selectedAssistant->id() == "infinite ruler";
        bool isPerspectiveAssistant = m_selectedAssistant->id() == "perspective";
        
        if (isRulerAssistant) {
            QSharedPointer <RulerAssistant> assis = qSharedPointerCast<RulerAssistant>(m_selectedAssistant);
            assis->setSubdivisions(value);
            
            m_options.minorSubdivisionsSpinbox->setEnabled(value > 0);
        }
        
        else if (isPerspectiveAssistant) {
            QSharedPointer <PerspectiveAssistant> assis = qSharedPointerCast<PerspectiveAssistant>(m_selectedAssistant);
            assis->setSubdivisions(value);
        }
    }
    
    m_canvas->updateCanvasDecorations();
}

References m_canvas, m_options, and value().

◆ slotChangeTwoPointDensity

void KisAssistantTool::slotChangeTwoPointDensity ( double value )

slot

Definition at line 1119 of file kis_assistant_tool.cc.

{
    if ( m_canvas->paintingAssistantsDecoration()->assistants().length() == 0) {
        return;
    }
 
    // get the selected assistant and change the angle value
    KisPaintingAssistantSP m_selectedAssistant =  m_canvas->paintingAssistantsDecoration()->selectedAssistant();
    if (m_selectedAssistant) {
        bool isTwoPointAssistant = m_selectedAssistant->id() == "two point";
 
        if (isTwoPointAssistant) {
            QSharedPointer <TwoPointAssistant> assis = qSharedPointerCast<TwoPointAssistant>(m_selectedAssistant);
            assis->setGridDensity((float)value);
        }
    }
 
    m_canvas->updateCanvasDecorations();
}

References m_canvas, and value().

◆ slotChangeTwoPointUseVertical

void KisAssistantTool::slotChangeTwoPointUseVertical ( int value )

slot

Definition at line 1139 of file kis_assistant_tool.cc.

{
    if ( m_canvas->paintingAssistantsDecoration()->assistants().length() == 0) {
        return;
    }
 
    // get the selected assistant and change the angle value
    KisPaintingAssistantSP m_selectedAssistant =  m_canvas->paintingAssistantsDecoration()->selectedAssistant();
    if (m_selectedAssistant) {
        bool isTwoPointAssistant = m_selectedAssistant->id() == "two point";
 
        if (isTwoPointAssistant) {
            QSharedPointer <TwoPointAssistant> assis = qSharedPointerCast<TwoPointAssistant>(m_selectedAssistant);
            assis->setUseVertical(value == Qt::Checked);
        }
    }
 
    m_canvas->updateCanvasDecorations();
}

References m_canvas, and value().

◆ slotChangeVanishingPointAngle

void KisAssistantTool::slotChangeVanishingPointAngle ( double value )

slot

Definition at line 1099 of file kis_assistant_tool.cc.

{
    if ( m_canvas->paintingAssistantsDecoration()->assistants().length() == 0) {
        return;
    }
 
    // get the selected assistant and change the angle value
    KisPaintingAssistantSP m_selectedAssistant =  m_canvas->paintingAssistantsDecoration()->selectedAssistant();
    if (m_selectedAssistant) {
        bool isVanishingPointAssistant = m_selectedAssistant->id() == "vanishing point";
 
        if (isVanishingPointAssistant) {
            QSharedPointer <VanishingPointAssistant> assis = qSharedPointerCast<VanishingPointAssistant>(m_selectedAssistant);
            assis->setReferenceLineDensity((float)value);
        }
    }
 
    m_canvas->updateCanvasDecorations();
}

References m_canvas, and value().

◆ slotCustomOpacityChanged

void KisAssistantTool::slotCustomOpacityChanged ( )

privateslot

Definition at line 1893 of file kis_assistant_tool.cc.

{
    KisPaintingAssistantSP m_selectedAssistant =  m_canvas->paintingAssistantsDecoration()->selectedAssistant();
    if (m_selectedAssistant) {
        QColor newColor = m_selectedAssistant->assistantCustomColor();
        qreal newOpacity = m_options.customColorOpacitySlider->value() * 0.01 * 255.0;
        newColor.setAlpha(int(newOpacity));
        m_selectedAssistant->setAssistantCustomColor(newColor);
        m_selectedAssistant->uncache();
    }
 
    // this forces the canvas to refresh to see the changes immediately
    m_canvas->paintingAssistantsDecoration()->uncache();
    m_canvas->updateCanvasDecorations();
}

References m_canvas, and m_options.

◆ slotEnableFixedLength

void KisAssistantTool::slotEnableFixedLength ( int enabled )

slot

Definition at line 1207 of file kis_assistant_tool.cc.

                                                        {
    if (m_canvas->paintingAssistantsDecoration()->assistants().length() == 0) {
        return;
    }
    
    // get the selected assistant and change the angle value
    KisPaintingAssistantSP m_selectedAssistant =  m_canvas->paintingAssistantsDecoration()->selectedAssistant();
    if (m_selectedAssistant) {
        bool isRulerAssistant = m_selectedAssistant->id() == "ruler"
                             || m_selectedAssistant->id() == "infinite ruler";
        
        if (isRulerAssistant) {
            QSharedPointer <RulerAssistant> assis = qSharedPointerCast<RulerAssistant>(m_selectedAssistant);
            
            m_options.fixedLengthSpinbox->setVisible(enabled);
            m_options.fixedLengthUnit->setVisible(enabled);
            
            if (enabled && !assis->hasFixedLength() && assis->handles().size() >= 2) {
                // When enabling, set the length to the current length.
                QPointF a = *assis->handles()[0];
                QPointF b = *assis->handles()[1];
                qreal length = sqrt(KisPaintingAssistant::norm2(b - a));
                assis->setFixedLength(length);
                m_options.fixedLengthSpinbox->changeValue(length);
            }
  
            assis->enableFixedLength(enabled);
        }
    }
    
    m_canvas->updateCanvasDecorations();
}

References length(), m_canvas, m_options, and KisPaintingAssistant::norm2().

◆ slotGlobalAssistantOpacityChanged

void KisAssistantTool::slotGlobalAssistantOpacityChanged ( )

privateslot

Definition at line 1863 of file kis_assistant_tool.cc.

{
    QColor newColor = m_canvas->paintingAssistantsDecoration()->globalAssistantsColor();
    qreal newOpacity = m_options.assistantsGlobalOpacitySlider->value() * 0.01 * 255.0;
    newColor.setAlpha(int(newOpacity));
    m_canvas->paintingAssistantsDecoration()->setGlobalAssistantsColor(newColor);
 
    m_canvas->paintingAssistantsDecoration()->uncache();
    m_canvas->updateCanvasDecorations();
}

References m_canvas, and m_options.

◆ slotGlobalAssistantsColorChanged

void KisAssistantTool::slotGlobalAssistantsColorChanged ( const QColor & setColor )

privateslot

send the color and opacity information from the UI to the kis_painting_decoration which manages the assistants

Definition at line 1849 of file kis_assistant_tool.cc.

{
    // color and alpha are stored separately, so we need to merge the values before sending it on
    int oldAlpha = m_canvas->paintingAssistantsDecoration()->globalAssistantsColor().alpha();
 
    QColor newColor = setColor;
    newColor.setAlpha(oldAlpha);
 
    m_canvas->paintingAssistantsDecoration()->setGlobalAssistantsColor(newColor);
 
    m_canvas->paintingAssistantsDecoration()->uncache();
    m_canvas->updateCanvasDecorations();
}

References m_canvas.

◆ slotLocalAssistantCheckboxChanged

void KisAssistantTool::slotLocalAssistantCheckboxChanged ( )

privateslot

Definition at line 1909 of file kis_assistant_tool.cc.

{
    KConfigGroup cfg = KSharedConfig::openConfig()->group(toolId());
    cfg.writeEntry("LimitAssistantToArea", m_options.localAssistantCheckbox->isChecked());
}

References m_options, and KoToolBase::toolId().

◆ slotSelectedAssistantTypeChanged

void KisAssistantTool::slotSelectedAssistantTypeChanged ( )

privateslot

Definition at line 1915 of file kis_assistant_tool.cc.

{
    updateToolOptionsUI();
}

References updateToolOptionsUI().

◆ slotToggleDeleteButton

void KisAssistantTool::slotToggleDeleteButton ( int index )

privateslot

Definition at line 1958 of file kis_assistant_tool.cc.

{
    AssistantEditorData &globalEditorWidgetData = m_canvas->paintingAssistantsDecoration()->globalEditorWidgetData;
    globalEditorWidgetData.deleteButtonActivated  = (index > 0) ? true:false;
    updateEditorWidgetData();
}

References AssistantEditorData::deleteButtonActivated, m_canvas, and updateEditorWidgetData().

◆ slotToggleDockToolOptionsVisible

void KisAssistantTool::slotToggleDockToolOptionsVisible ( )

privateslot

Definition at line 1919 of file kis_assistant_tool.cc.

                                                       {
 
    ToggleDockToolOptionsVisible = ToggleDockToolOptionsVisible ? false:true;
    m_options.showDockerOptionsPanel->setVisible(ToggleDockToolOptionsVisible);
 
    if (ToggleDockToolOptionsVisible){
        m_options.showDockerOptionsButton->setIcon(KisIconUtils::loadIcon("arrow-down"));
    }
    else{
        m_options.showDockerOptionsButton->setIcon(KisIconUtils::loadIcon("arrow-right"));
    }
    
    m_options.showDockerOptionsButton->setIconSize(QSize(16, 16));
   
}

References KisIconUtils::loadIcon(), m_options, and ToggleDockToolOptionsVisible.

◆ slotToggleDuplicateButton

void KisAssistantTool::slotToggleDuplicateButton ( int index )

privateslot

Definition at line 1952 of file kis_assistant_tool.cc.

{
    AssistantEditorData &globalEditorWidgetData = m_canvas->paintingAssistantsDecoration()->globalEditorWidgetData;
    globalEditorWidgetData.duplicateButtonActivated  = (index > 0) ? true:false;
    updateEditorWidgetData();
}

References AssistantEditorData::duplicateButtonActivated, m_canvas, and updateEditorWidgetData().

◆ slotToggleLockButton

void KisAssistantTool::slotToggleLockButton ( int index )

privateslot

Definition at line 1946 of file kis_assistant_tool.cc.

{
    AssistantEditorData &globalEditorWidgetData = m_canvas->paintingAssistantsDecoration()->globalEditorWidgetData;
    globalEditorWidgetData.lockButtonActivated  = (index > 0) ? true:false;
    updateEditorWidgetData();
}

References AssistantEditorData::lockButtonActivated, m_canvas, and updateEditorWidgetData().

◆ slotToggleMoveButton

void KisAssistantTool::slotToggleMoveButton ( int index )

privateslot

Definition at line 1934 of file kis_assistant_tool.cc.

{
    AssistantEditorData &globalEditorWidgetData = m_canvas->paintingAssistantsDecoration()->globalEditorWidgetData;
    globalEditorWidgetData.moveButtonActivated  = (index > 0) ? true:false;
    updateEditorWidgetData();
}

References m_canvas, AssistantEditorData::moveButtonActivated, and updateEditorWidgetData().

◆ slotToggleSnapButton

void KisAssistantTool::slotToggleSnapButton ( int index )

privateslot

Definition at line 1940 of file kis_assistant_tool.cc.

{
    AssistantEditorData &globalEditorWidgetData = m_canvas->paintingAssistantsDecoration()->globalEditorWidgetData;
    globalEditorWidgetData.snapButtonActivated  = (index > 0) ? true:false;
    updateEditorWidgetData();
}

References m_canvas, AssistantEditorData::snapButtonActivated, and updateEditorWidgetData().

◆ slotUpdateCustomColor

void KisAssistantTool::slotUpdateCustomColor ( )

privateslot

Definition at line 1874 of file kis_assistant_tool.cc.

{
    // get the selected assistant and change the angle value
    KisPaintingAssistantSP m_selectedAssistant =  m_canvas->paintingAssistantsDecoration()->selectedAssistant();
    if (m_selectedAssistant) {
        m_selectedAssistant->setUseCustomColor(m_options.useCustomAssistantColor->isChecked());
 
        // changing color doesn't keep alpha, so update that before we send it on
        QColor newColor = m_options.customAssistantColorButton->color();
        newColor.setAlpha(m_selectedAssistant->assistantCustomColor().alpha());
 
        m_selectedAssistant->setAssistantCustomColor(newColor);
        m_selectedAssistant->uncache();
    }
 
    updateToolOptionsUI();
    m_canvas->updateCanvasDecorations();
}

References m_canvas, m_options, and updateToolOptionsUI().

◆ snap()

bool KisAssistantTool::snap ( KoPointerEvent * event )

private

Definition at line 1998 of file kis_assistant_tool.cc.

{
    if (event->modifiers() == Qt::NoModifier) {
        return false;
    }
 
    if (m_handleDrag) {
        KisPaintingAssistantsDecorationSP canvasDecoration = m_canvas->paintingAssistantsDecoration();
        KisPaintingAssistantSP selectedAssistant = canvasDecoration->selectedAssistant();
        QList<KisPaintingAssistantHandleSP> handles = selectedAssistant->handles();
 
        if (selectedAssistant->id() == "two point" && m_handleDrag != handles[2] &&
            event->modifiers() != Qt::ShiftModifier) {
            // Snapping interactions that are specific to the two point assistant.
            // Skip this code block when only Shift is pressed, as
            // Shift means we only need closest-axis snapping.
 
            QSharedPointer<TwoPointAssistant> assis = qSharedPointerCast<TwoPointAssistant>(selectedAssistant);
            KisPaintingAssistantHandleSP handleOpp = m_handleDrag == handles[0] ? handles[1] : handles[0];
            const QPointF prevPoint = m_currentAdjustment.isNull() ? m_dragStart : m_currentAdjustment;
 
            qreal size = 0;
            const QTransform t = assis->localTransform(prevPoint,*handleOpp,*handles[2],&size);
            const QTransform inv = t.inverted();
 
            // Exact alignment matters here, so fudge horizon line
            // to be perfectly horizontal instead of trusting the
            // QTransform calculation to do it
            const QLineF horizon = QLineF(t.map(prevPoint), QPointF(t.map(*handleOpp).x(),t.map(prevPoint).y()));
            const QPointF sp = QPointF(0,horizon.p1().y()+size);
 
            const bool preserve_distortion_snap = event->modifiers() == Qt::ControlModifier;
            const bool preserve_left_right_ratio_snap = event->modifiers() == (Qt::ControlModifier|Qt::ShiftModifier);
            const bool preserve_horizon_snap = event->modifiers() == Qt::AltModifier;
 
            QPointF snap_point;
            QPointF opp_snap_point;
            QLineF sp_to_opp_vp;
 
            if (preserve_distortion_snap) {
                const QLineF sp_to_vp = QLineF(sp, t.map(*m_handleDrag));
                sp_to_opp_vp = sp_to_vp.normalVector();
                sp_to_vp.intersects(horizon,&snap_point);
            } else if (preserve_left_right_ratio_snap) {
                const QLineF prev_sp_to_vp = QLineF(sp, horizon.p1());
                QLineF new_sp_to_vp = prev_sp_to_vp.translated(t.map(*m_handleDrag)-sp);
                QPointF new_sp;
                new_sp_to_vp.intersects(QLineF(QPoint(0,0),QPointF(0,1)),&new_sp);
                sp_to_opp_vp = new_sp_to_vp.normalVector().translated(new_sp-new_sp_to_vp.p1());
                new_sp_to_vp.intersects(horizon,&snap_point);
            } else if (preserve_horizon_snap) {
                snap_point = QPointF(t.map(*m_handleDrag).x(),horizon.p1().y());
                sp_to_opp_vp = QLineF(sp,QPointF(t.map(prevPoint).x(),horizon.p1().y())).normalVector();
            }
 
            // The snapping modes must be robust against falling into
            // invalid configurations, so test if the new snap points
            // actually do make sense
            const bool no_intersection =
                // NB: opp_snap_point is initialized here
                sp_to_opp_vp.intersects(horizon, &opp_snap_point) == QLineF::NoIntersection;
            const bool origin_is_between =
                (snap_point.x() < 0 && opp_snap_point.x() > 0) ||
                (snap_point.x() > 0 && opp_snap_point.x() < 0);
            const bool null_opp_point =
                qFuzzyIsNull(opp_snap_point.x()) ||
                qFuzzyIsNull(opp_snap_point.y());
            const bool overlapping_snap_points =
                qFuzzyCompare(opp_snap_point.x(),snap_point.x());
 
            // Revert to original state if new points are invalid
            if (!origin_is_between || no_intersection || null_opp_point || overlapping_snap_points) {
                *m_handleDrag = m_dragStart;
                QPointF oppStart;
                // Use different recovery method for different
                // snapping modes
                if (preserve_distortion_snap) {
                    sp_to_opp_vp = QLineF(sp, t.map(m_dragStart)).normalVector();
                    sp_to_opp_vp.intersects(horizon, &oppStart);
                } else {
                    const QPointF p1 = t.map(m_dragStart);
                    const qreal p2x = preserve_horizon_snap ? t.map(*handleOpp).x() : -p1.x();
                    const QPointF p2 = QPointF(p2x,p1.y());
                    const QLineF new_horizon = QLineF(p1,p2);
                    const qreal new_size = sqrt(pow(new_horizon.length()/2.0,2) -
                                                pow(abs(new_horizon.center().x()),2));
                    const QPointF new_sp = QPointF(0,horizon.p1().y()+new_size);
                    sp_to_opp_vp = QLineF(new_sp, t.map(m_dragStart)).normalVector();
                }
                sp_to_opp_vp.intersects(horizon, &oppStart);
                *handleOpp=inv.map(oppStart);
                m_currentAdjustment = QPointF(0,0); // clear
            } else {
                // otherwise use the new configuration if it's valid
                *m_handleDrag = inv.map(snap_point);
                *handleOpp = inv.map(opp_snap_point);
                m_currentAdjustment = *m_handleDrag;
            }
        } else if (m_snapIsRadial == true) {
            QLineF dragRadius = QLineF(m_dragStart, event->point);
            dragRadius.setLength(m_radius.length());
            *m_handleDrag = dragRadius.p2();
        } else {
            QPointF snap_point = snapToClosestNiceAngle(event->point, m_dragStart);
            *m_handleDrag = snap_point;
        }
    } else {
        if (m_newAssistant && m_internalMode == MODE_CREATION) {
            QList<KisPaintingAssistantHandleSP> handles = m_newAssistant->handles();
            KisPaintingAssistantHandleSP handle_snap = handles.back();
            // for any assistant, snap 2nd handle to x or y axis relative to first handle
            if (handles.size() == 2) {
                QPointF snap_point = snapToClosestNiceAngle(event->point, (QPointF)(*handles[0]));
                *handle_snap =  snap_point;
            } else {
                bool was_snapped = false;
                if (m_newAssistant->id() == "spline") {
                    KisPaintingAssistantHandleSP start;
                    handles.size() == 3 ? start = handles[0] : start = handles[1];
                    QPointF snap_point = snapToClosestNiceAngle(event->point, (QPointF)(*start));
                    *handle_snap =  snap_point;
                    was_snapped = true;
                }
 
                if (m_newAssistant->id() == "ellipse" ||
                    m_newAssistant->id() == "concentric ellipse" ||
                    m_newAssistant->id() == "fisheye-point") {
                    QPointF center = QLineF(*handles[0], *handles[1]).center();
                    QLineF radius = QLineF(center,*handles[0]);
                    QLineF dragRadius = QLineF(center, event->point);
                    dragRadius.setLength(radius.length());
                    *handle_snap = dragRadius.p2();
                    was_snapped = true;
                }
 
                if (m_newAssistant->id() == "perspective") {
                    KisPaintingAssistantHandleSP start;
                    handles.size() == 3 ? start = handles[1] : start = handles[2];
                    QPointF snap_point = snapToClosestNiceAngle(event->point, (QPointF)(*start));
                    *handle_snap = snap_point;
                    was_snapped = true;
                }
                return was_snapped;
            }
        }
    }
    return true;
}

References m_canvas, m_currentAdjustment, m_dragStart, m_handleDrag, m_internalMode, m_newAssistant, m_radius, m_snapIsRadial, MODE_CREATION, KoPointerEvent::modifiers(), p1, p2, KoPointerEvent::point, qFuzzyCompare(), qFuzzyIsNull(), KisPaintingAssistantsDecoration::selectedAssistant(), and snapToClosestNiceAngle().

◆ updateEditorWidgetData()

void KisAssistantTool::updateEditorWidgetData ( )

private

Definition at line 853 of file kis_assistant_tool.cc.

{
 
    AssistantEditorData &globalEditorWidgetData = m_canvas->paintingAssistantsDecoration()->globalEditorWidgetData;
    if( !globalEditorWidgetData.moveButtonActivated && !globalEditorWidgetData.snapButtonActivated && !globalEditorWidgetData.lockButtonActivated && 
        !globalEditorWidgetData.duplicateButtonActivated && !globalEditorWidgetData.deleteButtonActivated) {
        globalEditorWidgetData.widgetActivated = false;
    } else globalEditorWidgetData.widgetActivated = true;
 
    int horizontalButtonLimit = globalEditorWidgetData.horizontalButtonLimit;
    int buttonCount = 0;
    int horizontalButtonCount = 0;
    int positionX = 15;
    int positionY = 15;
 
    //loop through all buttons and calculate positions
    if(globalEditorWidgetData.moveButtonActivated) {
        
        buttonCount++;
        horizontalButtonCount++;
        if(horizontalButtonCount > horizontalButtonLimit)
        {
            horizontalButtonCount = 1;
            positionX = 15;
            positionY += globalEditorWidgetData.buttonSize + globalEditorWidgetData.buttonPadding;
        }
        //the size icon is a little smaller than the others visually, so the icon is scaled
        //and the positioin is adjusted by -5 to compinsate
        globalEditorWidgetData.moveIconPosition.setX(positionX-5);
        globalEditorWidgetData.moveIconPosition.setY(positionY-5);
        positionX += globalEditorWidgetData.buttonSize + globalEditorWidgetData.buttonPadding;
    }
    if(globalEditorWidgetData.snapButtonActivated) {
        buttonCount++;
        horizontalButtonCount++;
        if(horizontalButtonCount > horizontalButtonLimit)
        {
            horizontalButtonCount = 1;
            positionX = 15;
            positionY += globalEditorWidgetData.buttonSize + globalEditorWidgetData.buttonPadding;
        }
        globalEditorWidgetData.snapIconPosition.setX(positionX);
        globalEditorWidgetData.snapIconPosition.setY(positionY);
        positionX += globalEditorWidgetData.buttonSize + globalEditorWidgetData.buttonPadding;
    }
    if(globalEditorWidgetData.lockButtonActivated) {
        buttonCount++;
        horizontalButtonCount++;
        if(horizontalButtonCount > horizontalButtonLimit)
        {
            horizontalButtonCount = 1;
            positionX = 15;
            positionY += globalEditorWidgetData.buttonSize + globalEditorWidgetData.buttonPadding;
        }
        globalEditorWidgetData.lockedIconPosition.setX(positionX);
        globalEditorWidgetData.lockedIconPosition.setY(positionY);
        positionX += globalEditorWidgetData.buttonSize + globalEditorWidgetData.buttonPadding;
    }
    if(globalEditorWidgetData.duplicateButtonActivated) {
        buttonCount++;
        horizontalButtonCount++;
        if(horizontalButtonCount > horizontalButtonLimit)
        {
            horizontalButtonCount = 0;
            positionX = 15;
            positionY += globalEditorWidgetData.buttonSize + globalEditorWidgetData.buttonPadding;
        }
        globalEditorWidgetData.duplicateIconPosition.setX(positionX);
        globalEditorWidgetData.duplicateIconPosition.setY(positionY);
        positionX += globalEditorWidgetData.buttonSize + globalEditorWidgetData.buttonPadding;
    }
    if(globalEditorWidgetData.deleteButtonActivated) {
        buttonCount++;
        horizontalButtonCount++;
        if(horizontalButtonCount > horizontalButtonLimit)
        {
            horizontalButtonCount = 1;
            positionX = 15;
            positionY += globalEditorWidgetData.buttonSize + globalEditorWidgetData.buttonPadding;
        }
        globalEditorWidgetData.deleteIconPosition.setX(positionX);
        globalEditorWidgetData.deleteIconPosition.setY(positionY);
        positionX += globalEditorWidgetData.buttonSize + globalEditorWidgetData.buttonPadding;
    }
    
    int buttonSection = globalEditorWidgetData.buttonSize+globalEditorWidgetData.buttonPadding;
    int boundingWidgetWidth = (buttonCount < horizontalButtonLimit) ? buttonCount*buttonSection:horizontalButtonLimit*buttonSection;
    boundingWidgetWidth += 5;
    globalEditorWidgetData.boundingSize.setWidth(boundingWidgetWidth+globalEditorWidgetData.dragDecorationWidth);
 
    int buttonToWidthRatio = (buttonCount/horizontalButtonLimit);
    if(buttonCount%horizontalButtonLimit != 0) {
        buttonToWidthRatio++;
    }
 
    int boundingWidgetHeight = buttonToWidthRatio*buttonSection;
    boundingWidgetHeight += 5;
    globalEditorWidgetData.boundingSize.setHeight(boundingWidgetHeight);
    
    
    m_canvas->updateCanvasDecorations();
}

◆ updateToolOptionsUI

void KisAssistantTool::updateToolOptionsUI ( )

privateslot

Definition at line 976 of file kis_assistant_tool.cc.

{
     KisPaintingAssistantSP m_selectedAssistant =  m_canvas->paintingAssistantsDecoration()->selectedAssistant();
 
     bool hasActiveAssistant = m_selectedAssistant ? true : false;
    AssistantEditorData &globalEditorWidgetData = m_canvas->paintingAssistantsDecoration()->globalEditorWidgetData;
 
    if(globalEditorWidgetData.moveButtonActivated) {
        m_options.showMove->setChecked(true);
    }
    if(globalEditorWidgetData.snapButtonActivated) {
        m_options.showSnap->setChecked(true);
    }
    if(globalEditorWidgetData.lockButtonActivated) {
        m_options.showLock->setChecked(true);
    }
    if(globalEditorWidgetData.duplicateButtonActivated) {
        m_options.showDuplicate->setChecked(true);
    }
    if(globalEditorWidgetData.deleteButtonActivated) {
        m_options.showDelete->setChecked(true);
    }
 
    if (m_selectedAssistant) {
         bool isVanishingPointAssistant = m_selectedAssistant->id() == "vanishing point";
         bool isTwoPointAssistant = m_selectedAssistant->id() == "two point";
         bool isRulerAssistant = m_selectedAssistant->id() == "ruler"
                              || m_selectedAssistant->id() == "infinite ruler";
         bool isPerspectiveAssistant = m_selectedAssistant->id() == "perspective";
 
         m_options.vanishingPointAngleSpinbox->setVisible(isVanishingPointAssistant);
         m_options.twoPointDensitySpinbox->setVisible(isTwoPointAssistant);
         m_options.twoPointUseVerticalCheckbox->setVisible(isTwoPointAssistant);
         m_options.subdivisionsSpinbox->setVisible(isRulerAssistant || isPerspectiveAssistant);
         m_options.minorSubdivisionsSpinbox->setVisible(isRulerAssistant);
         m_options.fixedLengthCheckbox->setVisible(isRulerAssistant);
         // show checkboxes for controlling which control widget buttons are visible
         m_options.showMove->setVisible(true);
         m_options.showSnap->setVisible(true);
         m_options.showLock->setVisible(true);
         m_options.showDuplicate->setVisible(true);
         m_options.showDelete->setVisible(true);
         
         
 
         if (isVanishingPointAssistant) {
             QSharedPointer <VanishingPointAssistant> assis = qSharedPointerCast<VanishingPointAssistant>(m_selectedAssistant);
             m_options.vanishingPointAngleSpinbox->setValue(assis->referenceLineDensity());
         }
 
         if (isTwoPointAssistant) {
             QSharedPointer <TwoPointAssistant> assis = qSharedPointerCast<TwoPointAssistant>(m_selectedAssistant);
             m_options.twoPointDensitySpinbox->setValue(assis->gridDensity());
             m_options.twoPointUseVerticalCheckbox->setChecked(assis->useVertical());
         }
 
         if (isRulerAssistant) {
             QSharedPointer <RulerAssistant> assis = qSharedPointerCast<RulerAssistant>(m_selectedAssistant);
             m_options.subdivisionsSpinbox->setValue(assis->subdivisions());
             m_options.minorSubdivisionsSpinbox->setValue(assis->minorSubdivisions());
             m_options.fixedLengthCheckbox->setChecked(assis->hasFixedLength());
             
             m_options.fixedLengthSpinbox->setVisible(assis->hasFixedLength());
             m_options.fixedLengthUnit->setVisible(assis->hasFixedLength());
             {
                // Block valueChanged signals during unit switch
                QSignalBlocker b(m_options.fixedLengthSpinbox);
                m_unitManager->setApparentUnitFromSymbol(assis->fixedLengthUnit());
                m_options.fixedLengthUnit->setCurrentIndex(m_unitManager->getApparentUnitId());
                m_options.fixedLengthSpinbox->changeValue(assis->fixedLength());
             }
             m_options.fixedLengthSpinbox->setPrefix("");
         } else {
             m_options.fixedLengthSpinbox->setVisible(false);
             m_options.fixedLengthUnit->setVisible(false);
         }
         
         if (isPerspectiveAssistant) {
             QSharedPointer <PerspectiveAssistant> assis = qSharedPointerCast<PerspectiveAssistant>(m_selectedAssistant);
             m_options.subdivisionsSpinbox->setValue(assis->subdivisions());
         }
         
         // load custom color settings from assistant (this happens when changing assistant
         m_options.useCustomAssistantColor->setChecked(m_selectedAssistant->useCustomColor());
         m_options.customAssistantColorButton->setColor(m_selectedAssistant->assistantCustomColor());
 
 
         double opacity = (double)m_selectedAssistant->assistantCustomColor().alpha()/(double)255.00 * (double)100.00 ;
         opacity = ceil(opacity); // helps keep the 0-100% slider from shifting
 
         m_options.customColorOpacitySlider->blockSignals(true);
         m_options.customColorOpacitySlider->setValue((double)opacity);
         m_options.customColorOpacitySlider->blockSignals(false);
 
     } else {
         m_options.vanishingPointAngleSpinbox->setVisible(false);
         m_options.twoPointDensitySpinbox->setVisible(false);
         m_options.twoPointUseVerticalCheckbox->setVisible(false);
         m_options.subdivisionsSpinbox->setVisible(false);
         m_options.minorSubdivisionsSpinbox->setVisible(false);
         m_options.fixedLengthCheckbox->setVisible(false);
         m_options.fixedLengthSpinbox->setVisible(false);
         m_options.fixedLengthUnit->setVisible(false);
     }
 
     // show/hide elements if an assistant is selected or not
      m_options.useCustomAssistantColor->setVisible(hasActiveAssistant);
 
      // hide custom color options if use custom color is not selected
      bool showCustomColorSettings = m_options.useCustomAssistantColor->isChecked() && hasActiveAssistant;
      m_options.customColorOpacitySlider->setVisible(showCustomColorSettings);
      m_options.customAssistantColorButton->setVisible(showCustomColorSettings);
      
      // disable global color settings if we are using the custom color
      m_options.assistantsGlobalOpacitySlider->setEnabled(!showCustomColorSettings);
      m_options.assistantsColor->setEnabled(!showCustomColorSettings);
      m_options.globalColorLabel->setEnabled(!showCustomColorSettings);
 
      QString key = m_options.availableAssistantsComboBox->model()->index( m_options.availableAssistantsComboBox->currentIndex(), 0 ).data(Qt::UserRole).toString();
      m_options.localAssistantCheckbox->setVisible(key == "two point" || key == "vanishing point" || key == "parallel ruler");
 
}

References AssistantEditorData::deleteButtonActivated, AssistantEditorData::duplicateButtonActivated, KisSpinBoxUnitManager::getApparentUnitId(), AssistantEditorData::lockButtonActivated, m_canvas, m_options, m_unitManager, AssistantEditorData::moveButtonActivated, KisSpinBoxUnitManager::setApparentUnitFromSymbol(), and AssistantEditorData::snapButtonActivated.

Member Data Documentation

◆ assistantDuplicatingFlag

bool KisAssistantTool::assistantDuplicatingFlag {false}

protected

Definition at line 172 of file kis_assistant_tool.h.

172{false}; // this flag is set during an assistant duplication

◆ m_assistantDrag

KisPaintingAssistantSP KisAssistantTool::m_assistantDrag

protected

Definition at line 155 of file kis_assistant_tool.h.

◆ m_assistantHelperYOffset

int KisAssistantTool::m_assistantHelperYOffset {10}

private

Definition at line 178 of file kis_assistant_tool.h.

178{10}; // used by the assistant editor icons for placement on the canvas.

◆ m_canvas

QPointer<KisCanvas2> KisAssistantTool::m_canvas

protected

this class manipulates the kis_painting_assistant_decorations a lot, so this class is a helper to get a reference to it and call "updateCanvas" which refreshes the display

Definition at line 146 of file kis_assistant_tool.h.

◆ m_currentAdjustment

QPointF KisAssistantTool::m_currentAdjustment

protected

Definition at line 162 of file kis_assistant_tool.h.

◆ m_cursorStart

QPointF KisAssistantTool::m_cursorStart

protected

Definition at line 161 of file kis_assistant_tool.h.

◆ m_dragEnd

QPointF KisAssistantTool::m_dragEnd

protected

Definition at line 169 of file kis_assistant_tool.h.

◆ m_dragStart

QPointF KisAssistantTool::m_dragStart

protected

Definition at line 166 of file kis_assistant_tool.h.

◆ m_handleCombine

KisPaintingAssistantHandleSP KisAssistantTool::m_handleCombine

protected

Definition at line 153 of file kis_assistant_tool.h.

◆ m_handleDrag

KisPaintingAssistantHandleSP KisAssistantTool::m_handleDrag

protected

Definition at line 152 of file kis_assistant_tool.h.

◆ m_handleHover

KisPaintingAssistantHandleSP KisAssistantTool::m_handleHover

protected

Definition at line 154 of file kis_assistant_tool.h.

◆ m_handleMaxDist

int KisAssistantTool::m_handleMaxDist {81}

protected

Definition at line 171 of file kis_assistant_tool.h.

171{81}; // how far away the user can click and still select a handle

◆ m_handles

QList<KisPaintingAssistantHandleSP> KisAssistantTool::m_handles

protected

the handles are retrieved from the kis_painting_decoration originally They are used here to generate and manipulate editor handles with the tool's primary action

Definition at line 150 of file kis_assistant_tool.h.

◆ m_handleSize

int KisAssistantTool::m_handleSize {17}

protected

Definition at line 170 of file kis_assistant_tool.h.

170{17}; // how large the editor handles will appear

◆ m_highlightedNode

KisPaintingAssistantHandleSP KisAssistantTool::m_highlightedNode

private

Definition at line 177 of file kis_assistant_tool.h.

◆ m_internalMode

PerspectiveAssistantEditionMode KisAssistantTool::m_internalMode { MODE_CREATION }

private

Definition at line 176 of file kis_assistant_tool.h.

176{ MODE_CREATION };

◆ m_newAssistant

KisPaintingAssistantSP KisAssistantTool::m_newAssistant

protected

Used while a new assistant is being created. Most assistants need multiple points to exist so this helps manage the visual state while this creation process is going on

Definition at line 159 of file kis_assistant_tool.h.

◆ m_options

Ui::AssistantsToolOptions KisAssistantTool::m_options

protected

Definition at line 164 of file kis_assistant_tool.h.

◆ m_optionsWidget

QWidget* KisAssistantTool::m_optionsWidget {0}

protected

Definition at line 165 of file kis_assistant_tool.h.

165{0};

◆ m_origAssistantList

QList<KisPaintingAssistantSP> KisAssistantTool::m_origAssistantList

private

Definition at line 179 of file kis_assistant_tool.h.

◆ m_previousHandlePos

QPointF KisAssistantTool::m_previousHandlePos

protected

Definition at line 163 of file kis_assistant_tool.h.

◆ m_radius

QLineF KisAssistantTool::m_radius

protected

Definition at line 167 of file kis_assistant_tool.h.

◆ m_selectedNode1

KisPaintingAssistantHandleSP KisAssistantTool::m_selectedNode1

private

Definition at line 177 of file kis_assistant_tool.h.

◆ m_selectedNode2

KisPaintingAssistantHandleSP KisAssistantTool::m_selectedNode2

private

Definition at line 177 of file kis_assistant_tool.h.

◆ m_sideHandles

QList<KisPaintingAssistantHandleSP> KisAssistantTool::m_sideHandles

protected

Definition at line 151 of file kis_assistant_tool.h.

◆ m_snapIsRadial

bool KisAssistantTool::m_snapIsRadial {false}

protected

Definition at line 168 of file kis_assistant_tool.h.

168{false};

◆ m_unitManager

KisSpinBoxUnitManager* KisAssistantTool::m_unitManager {0}

private

Definition at line 180 of file kis_assistant_tool.h.

180{0};

◆ ToggleDockToolOptionsVisible

bool KisAssistantTool::ToggleDockToolOptionsVisible = false

private

Definition at line 89 of file kis_assistant_tool.h.

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

plugins/assistants/Assistants/kis_assistant_tool.h
plugins/assistants/Assistants/kis_assistant_tool.cc

Public Slots

Public Member Functions

Protected Member Functions

Protected Attributes

Private Types

Private Slots

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ PerspectiveAssistantEditionMode

Constructor & Destructor Documentation

◆ KisAssistantTool()

◆ ~KisAssistantTool()

Member Function Documentation

◆ activate

◆ addAssistant()

◆ assistantSelected()

◆ beginActionImpl()

◆ beginAlternateAction()

◆ beginPrimaryAction()

◆ continueActionImpl()

◆ continueAlternateAction()

◆ continuePrimaryAction()

◆ createOptionWidget()

◆ deactivate

◆ drawEditorWidget()

◆ endActionImpl()

◆ endAlternateAction()

◆ endPrimaryAction()

◆ keyPressEvent()

◆ loadAssistants

◆ mouseMoveEvent()

◆ paint()

◆ priority()

◆ removeAllAssistants

◆ removeAssistant()

◆ saveAssistants

◆ slotChangeFixedLength

◆ slotChangeFixedLengthUnit

◆ slotChangeMinorSubdivisions

◆ slotChangeSubdivisions

◆ slotChangeTwoPointDensity

◆ slotChangeTwoPointUseVertical

◆ slotChangeVanishingPointAngle

◆ slotCustomOpacityChanged

◆ slotEnableFixedLength

◆ slotGlobalAssistantOpacityChanged

◆ slotGlobalAssistantsColorChanged

◆ slotLocalAssistantCheckboxChanged

◆ slotSelectedAssistantTypeChanged

◆ slotToggleDeleteButton

◆ slotToggleDockToolOptionsVisible

◆ slotToggleDuplicateButton

◆ slotToggleLockButton

◆ slotToggleMoveButton

◆ slotToggleSnapButton

◆ slotUpdateCustomColor

◆ snap()

◆ updateEditorWidgetData()

◆ updateToolOptionsUI

Member Data Documentation

◆ assistantDuplicatingFlag

◆ m_assistantDrag

◆ m_assistantHelperYOffset

◆ m_canvas

◆ m_currentAdjustment

◆ m_cursorStart

◆ m_dragEnd

◆ m_dragStart

◆ m_handleCombine

◆ m_handleDrag

◆ m_handleHover

◆ m_handleMaxDist

◆ m_handles

◆ m_handleSize

◆ m_highlightedNode

◆ m_internalMode

◆ m_newAssistant