#include <kis_tool_multihand.h>

Inheritance diagram for KisToolMultihand:

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

void	beginPrimaryAction (KoPointerEvent *event) override

void	continueAlternateAction (KoPointerEvent *event, AlternateAction action) override

void	continuePrimaryAction (KoPointerEvent *event) override

void	endAlternateAction (KoPointerEvent *event, AlternateAction action) override

void	endPrimaryAction (KoPointerEvent *event) override

	KisToolMultihand (KoCanvasBase *canvas)

void	mouseMoveEvent (KoPointerEvent *event) override

	~KisToolMultihand () override

Public Member Functions inherited from KisToolBrush
qreal	delayDistance () const

bool	finishStabilizedCurve () const

	KisToolBrush (KoCanvasBase *canvas)

int	smoothingType () const

qreal	smoothnessFactor () const

int	smoothnessQualityMax () const

int	smoothnessQualityMin () const

bool	smoothPressure () const

bool	stabilizeSensors () const

bool	useDelayDistance () const

bool	useScalableDistance () const

	~KisToolBrush () override

Public Member Functions inherited from KisToolFreehand
int	flags () const override

	KisToolFreehand (KoCanvasBase *canvas, const QCursor &cursor, const KUndo2MagicString &transactionText, bool useSavedSmoothing=true)

	~KisToolFreehand () override

Public Member Functions inherited from KisToolPaint
int	flags () const override

	KisToolPaint (KoCanvasBase *canvas, const QCursor &cursor)

void	mouseMoveEvent (KoPointerEvent *event) override

void	mousePressEvent (KoPointerEvent *event) override

void	mouseReleaseEvent (KoPointerEvent *event) override

KisPopupWidgetInterface *	popupWidget () override

	~KisToolPaint () override

Public Member Functions inherited from KisTool
virtual bool	alternateActionSupportsHiResEvents (AlternateAction action) const

virtual void	beginAlternateDoubleClickAction (KoPointerEvent *event, AlternateAction action)

virtual void	beginPrimaryDoubleClickAction (KoPointerEvent *event)

void	deleteSelection () override

bool	isActive () const

	KisTool (KoCanvasBase *canvas, const QCursor &cursor)

void	mouseDoubleClickEvent (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 ()

	~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 Enter key or any equivalent. 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	keyPressEvent (QKeyEvent *event)

virtual void	keyReleaseEvent (QKeyEvent *event)

	KoToolBase (KoCanvasBase *canvas)

bool	maskSyntheticEvents () const

QList< QPointer< QWidget > >	optionWidgets ()

virtual bool	paste ()

virtual QMenu *	popupActionsMenu ()

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

virtual KoToolSelection *	selection ()

Q_INVOKABLE QString	toolId () const

	~KoToolBase () override

Protected Member Functions
QWidget *	createOptionWidget () override

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

Protected Member Functions inherited from KisToolFreehand
void	activateAlternateAction (AlternateAction action) override

void	deactivateAlternateAction (AlternateAction action) override

virtual void	doStroke (KoPointerEvent *event)

virtual void	endStroke ()

KisOptimizedBrushOutline	getOutlinePath (const QPointF &documentPos, const KoPointerEvent *event, KisPaintOpSettings::OutlineMode outlineMode) override

virtual void	initStroke (KoPointerEvent *event)

KisPaintingInformationBuilder *	paintingInformationBuilder () const

bool	primaryActionSupportsHiResEvents () const override

void	resetHelper (KisToolFreehandHelper *helper)

KisSmoothingOptionsSP	smoothingOptions () const

bool	supportsPaintingAssistants () const override

bool	trySampleByPaintOp (KoPointerEvent *event, AlternateAction action)

bool	wantsAutoScroll () const override

Protected Member Functions inherited from KisToolPaint
void	activateAlternateAction (AlternateAction action) override

void	activatePrimaryAction () override

void	addOptionWidgetLayout (QLayout *layout)
	Add the tool-specific layout to the default option widget layout.

virtual void	addOptionWidgetOption (QWidget control, QWidget label=nullptr)
	Add a widget and a label to the current option widget layout.

void	beginAlternateAction (KoPointerEvent *event, AlternateAction action) override

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

void	continueAlternateAction (KoPointerEvent *event, AlternateAction action) override

QWidget *	createOptionWidget () override

void	deactivateAlternateAction (AlternateAction action) override

void	deactivatePrimaryAction () override

void	enableControl (QWidget *control, bool value)

void	endAlternateAction (KoPointerEvent *event, AlternateAction action) override

bool	isEraser () const

bool	isOutlineEnabled () const

bool	isOutlineVisible () const

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

virtual QString	quickHelp () const

virtual void	requestUpdateOutline (const QPointF &outlineDocPoint, const KoPointerEvent *event)

void	setMode (ToolMode mode) override

void	setOutlineEnabled (bool enabled)

void	setOutlineVisible (bool visible)

void	setSupportOutline (bool supportOutline)

void	showControl (QWidget *control, bool value)

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)

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)

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)

Private Types
enum	enumTransformModes : int { SYMMETRY =0 , MIRROR , TRANSLATE , SNOWFLAKE , COPYTRANSLATE , COPYTRANSLATEINTERVALS }

Private Slots
void	activateAxesPointModeSetup ()

void	resetAxes ()

void	slotAddSubbrushesMode (bool checked)

void	slotRemoveAllSubbrushes ()

void	slotSetAxesAngle (qreal angle)

void	slotSetAxesVisible (bool vis)

void	slotSetHandsCount (int count)

void	slotSetIntervals ()

void	slotSetKeepAspect ()

void	slotSetMirrorHorizontally (bool mirror)

void	slotSetMirrorVertically (bool mirror)

void	slotSetTransformMode (int qcomboboxIndex)

void	slotSetTranslateRadius (int radius)

Private Member Functions
void	finishAxesSetup ()

void	initTransformations ()

QVector< QPoint >	intervalLocations ()

void	updateCanvas ()

Private Attributes
KisToolMultiHandConfigWidget *	customUI

bool	m_addSubbrushesMode

qreal	m_angle

QPointF	m_axesPoint

int	m_handsCount

KisToolMultihandHelper *	m_helper

int	m_intervalX

int	m_intervalY

QPointF	m_lastToolPos

bool	m_mirrorHorizontally

bool	m_mirrorVertically

QRandomGenerator	m_randomGenerator

bool	m_setupAxesFlag

bool	m_showAxes

QVector< QPointF >	m_subbrOriginalLocations

enumTransformModes	m_transformMode

int	m_translateRadius

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 }

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

void	deactivate () override

void	setDelayDistance (qreal value)

void	setFinishStabilizedCurve (bool value)

void	setSmoothPressure (bool value)

void	setStabilizeSensors (bool value)

void	setUseDelayDistance (bool value)

void	setUseScalableDistance (bool value)

void	slotSetMagnetism (int magnetism)

void	slotSetSmoothingType (int index)

void	slotSetSmoothnessDistanceKeepAspectRatio (bool value)

void	slotSetSmoothnessDistanceMax (qreal distance)

void	slotSetSmoothnessDistanceMin (qreal distance)

void	slotSetTailAggressiveness (qreal argh_rhhrr)

void	updateSettingsViews () override

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

void	deactivate () override

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

void	deactivate () override

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

Signals inherited from KisToolBrush
void	delayDistanceChanged ()

void	finishStabilizedCurveChanged ()

void	smoothingTypeChanged ()

void	smoothnessFactorChanged ()

void	smoothnessQualityChanged ()

void	smoothPressureChanged ()

void	stabilizeSensorsChanged ()

void	useDelayDistanceChanged ()

void	useScalableDistanceChanged ()

Signals inherited from KisToolPaint
void	sigPaintingFinished ()

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 KisToolBrush
void	resetCursorStyle () override

Protected Slots inherited from KisToolFreehand
void	explicitUpdateOutline ()

void	resetCursorStyle () override

void	setAssistant (bool assistant)

void	setOnlyOneAssistantSnap (bool assistant)

void	setSnapEraser (bool assistant)

void	slotDoResizeBrush (qreal newSize)

Protected Slots inherited from KisTool
virtual void	resetCursorStyle ()

Protected Attributes inherited from KisToolBrush
KConfigGroup	m_configGroup

Protected Attributes inherited from KisToolFreehand
bool	m_assistant {false}

bool	m_eraser_snapping {false}

double	m_magnetism {1.0}

bool	m_only_one_assistant {true}

Protected Attributes inherited from KisToolPaint
KisOptimizedBrushOutline	m_currentOutline

QRectF	m_oldColorPreviewUpdateRect

QRectF	m_oldOutlineRect

QPointF	m_outlineDocPoint

bool	m_paintOutline {false}

Protected Attributes inherited from KoToolBase
KoToolBasePrivate *	d_ptr

Properties inherited from KisToolBrush
qreal	delayDistance

bool	finishStabilizedCurve

int	smoothingType

qreal	smoothnessFactor

int	smoothnessQualityMax

int	smoothnessQualityMin

bool	smoothPressure

bool	stabilizeSensors

bool	useDelayDistance

bool	useScalableDistance

Properties inherited from KisTool
bool	isActive

Detailed Description

Definition at line 23 of file kis_tool_multihand.h.

Member Enumeration Documentation

◆ enumTransformModes

enum KisToolMultihand::enumTransformModes : int

private

Enumerator
SYMMETRY
MIRROR
TRANSLATE
SNOWFLAKE
COPYTRANSLATE
COPYTRANSLATEINTERVALS

Definition at line 69 of file kis_tool_multihand.h.

69:int { SYMMETRY=0, MIRROR, TRANSLATE, SNOWFLAKE, COPYTRANSLATE, COPYTRANSLATEINTERVALS };

KisToolMultihand::COPYTRANSLATEINTERVALS

@ COPYTRANSLATEINTERVALS

Definition kis_tool_multihand.h:69

KisToolMultihand::SNOWFLAKE

@ SNOWFLAKE

Definition kis_tool_multihand.h:69

KisToolMultihand::MIRROR

@ MIRROR

Definition kis_tool_multihand.h:69

KisToolMultihand::SYMMETRY

@ SYMMETRY

Definition kis_tool_multihand.h:69

KisToolMultihand::COPYTRANSLATE

@ COPYTRANSLATE

Definition kis_tool_multihand.h:69

KisToolMultihand::TRANSLATE

@ TRANSLATE

Definition kis_tool_multihand.h:69

Constructor & Destructor Documentation

◆ KisToolMultihand()

KisToolMultihand::KisToolMultihand ( KoCanvasBase * canvas )

Definition at line 28 of file kis_tool_multihand.cpp.

    : KisToolBrush(canvas),
      m_transformMode(SYMMETRY),
      m_angle(0),
      m_handsCount(6),
      m_mirrorVertically(false),
      m_mirrorHorizontally(false),
      m_showAxes(false),
      m_translateRadius(100),
      m_setupAxesFlag(false),
      m_addSubbrushesMode(false),
      m_intervalX(0),
      m_intervalY(0)
    , m_randomGenerator(QRandomGenerator::global()->generate())
    , customUI(0)
{
 
 
    m_helper =
        new KisToolMultihandHelper(paintingInformationBuilder(),
                                   canvas->resourceManager(),
                                   kundo2_i18n("Multibrush Stroke"));
    resetHelper(m_helper);
    if (image()) {
        m_axesPoint = QPointF(0.5 * image()->width(), 0.5 * image()->height());
    }
 
}

References Private::canvas, KisTool::image(), kundo2_i18n(), m_axesPoint, m_helper, KisToolFreehand::paintingInformationBuilder(), KisToolFreehand::resetHelper(), and KoCanvasBase::resourceManager.

◆ ~KisToolMultihand()

KisToolMultihand::~KisToolMultihand ( )

override

Definition at line 57 of file kis_tool_multihand.cpp.

58{

59}

Member Function Documentation

◆ activateAxesPointModeSetup

void KisToolMultihand::activateAxesPointModeSetup ( )

privateslot

Definition at line 512 of file kis_tool_multihand.cpp.

{
    if (customUI->moveOriginButton->isChecked()){
        m_setupAxesFlag = true;
        useCursor(KisCursor::crossCursor());
        updateCanvas();
    } else {
        finishAxesSetup();
    }
}

References KisCursor::crossCursor(), customUI, finishAxesSetup(), m_setupAxesFlag, updateCanvas(), and KoToolBase::useCursor().

◆ beginAlternateAction()

void KisToolMultihand::beginAlternateAction	(	KoPointerEvent *	event,
		AlternateAction	action )

overridevirtual

Reimplemented from KisToolFreehand.

Definition at line 111 of file kis_tool_multihand.cpp.

{
    if ((action != ChangeSize && action != ChangeSizeSnap) ||
            m_transformMode != COPYTRANSLATE ||
            !m_addSubbrushesMode) {
        KisToolBrush::beginAlternateAction(event, action);
        return;
    }
    setMode(KisTool::OTHER_1);
    m_axesPoint = convertToPixelCoord(event->point);
    requestUpdateOutline(event->point, 0);
    updateCanvas();
}

References KoToolBase::action(), KisTool::beginAlternateAction(), KisTool::ChangeSize, KisTool::ChangeSizeSnap, KisTool::convertToPixelCoord(), COPYTRANSLATE, m_addSubbrushesMode, m_axesPoint, m_transformMode, KisTool::OTHER_1, KoPointerEvent::point, KisToolPaint::requestUpdateOutline(), KisToolPaint::setMode(), and updateCanvas().

◆ beginPrimaryAction()

void KisToolMultihand::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 KisToolFreehand.

Definition at line 61 of file kis_tool_multihand.cpp.

{
    if(m_setupAxesFlag) {
        setMode(KisTool::OTHER);
        m_axesPoint = convertToPixelCoord(event->point);
        requestUpdateOutline(event->point, 0);
        updateCanvas();
    }
    else if (m_addSubbrushesMode &&  m_transformMode == COPYTRANSLATE){
        QPointF newPoint = convertToPixelCoord(event->point);
        m_subbrOriginalLocations << newPoint;
        requestUpdateOutline(event->point, 0);
        updateCanvas();
    }
    else if (m_transformMode == COPYTRANSLATEINTERVALS) {
        m_axesPoint = convertToPixelCoord(event->point);
        initTransformations();
        KisToolFreehand::beginPrimaryAction(event);
    }
    else {
        initTransformations();
        KisToolFreehand::beginPrimaryAction(event);
    }
}

References KisToolFreehand::beginPrimaryAction(), KisTool::convertToPixelCoord(), COPYTRANSLATE, COPYTRANSLATEINTERVALS, initTransformations(), m_addSubbrushesMode, m_axesPoint, m_setupAxesFlag, m_subbrOriginalLocations, m_transformMode, KisTool::OTHER, KoPointerEvent::point, KisToolPaint::requestUpdateOutline(), KisToolPaint::setMode(), and updateCanvas().

◆ continueAlternateAction()

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

overridevirtual

Reimplemented from KisToolFreehand.

Definition at line 125 of file kis_tool_multihand.cpp.

{
    if ((action != ChangeSize && action != ChangeSizeSnap) ||
            m_transformMode != COPYTRANSLATE ||
            !m_addSubbrushesMode) {
        KisToolBrush::continueAlternateAction(event, action);
        return;
    }
    if (mode() == KisTool::OTHER_1) {
        m_axesPoint = convertToPixelCoord(event->point);
        requestUpdateOutline(event->point, 0);
        updateCanvas();
    }
}

References KoToolBase::action(), KisTool::ChangeSize, KisTool::ChangeSizeSnap, KisTool::continueAlternateAction(), KisTool::convertToPixelCoord(), COPYTRANSLATE, m_addSubbrushesMode, m_axesPoint, m_transformMode, KisTool::mode(), KisTool::OTHER_1, KoPointerEvent::point, KisToolPaint::requestUpdateOutline(), and updateCanvas().

◆ continuePrimaryAction()

void KisToolMultihand::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.

Actual painting

Reimplemented from KisToolFreehand.

Definition at line 86 of file kis_tool_multihand.cpp.

{
    if(mode() == KisTool::OTHER) {
        m_axesPoint = convertToPixelCoord(event->point);
        requestUpdateOutline(event->point, 0);
        updateCanvas();
    }
    else {
        requestUpdateOutline(event->point, 0);
        KisToolFreehand::continuePrimaryAction(event);
    }
}

References KisToolFreehand::continuePrimaryAction(), KisTool::convertToPixelCoord(), m_axesPoint, KisTool::mode(), KisTool::OTHER, KoPointerEvent::point, KisToolPaint::requestUpdateOutline(), and updateCanvas().

◆ createOptionWidget()

QWidget * KisToolMultihand::createOptionWidget ( )

overrideprotectedvirtual

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

Reimplemented from KisToolBrush.

Definition at line 427 of file kis_tool_multihand.cpp.

{
    QWidget *widget = KisToolBrush::createOptionWidget();
 
    customUI = new KisToolMultiHandConfigWidget();
 
    // brush smoothing option.
    //customUI->layout()->addWidget(widget);
    customUI->smoothingOptionsLayout->addWidget(widget);
 
 
    // setup common parameters that all of the modes will see
    connect(customUI->showAxesCheckbox, SIGNAL(toggled(bool)), this, SLOT(slotSetAxesVisible(bool)));
    customUI->showAxesCheckbox->setChecked((bool)m_configGroup.readEntry("showAxes", false));
 
    connect(image(), SIGNAL(sigSizeChanged(QPointF,QPointF)), this, SLOT(resetAxes()));
 
    customUI->moveOriginButton->setCheckable(true);
    connect(customUI->moveOriginButton, SIGNAL(clicked(bool)),this, SLOT(activateAxesPointModeSetup()));
 
    connect(customUI->resetOriginButton, SIGNAL(released()), this, SLOT(resetAxes()));
 
    customUI->multihandTypeCombobox->addItem(i18n("Symmetry"),int(SYMMETRY));  // axis mode
    customUI->multihandTypeCombobox->addItem(i18nc("Label of Mirror in Multihand brush tool options", "Mirror"),int(MIRROR));
    customUI->multihandTypeCombobox->addItem(i18n("Translate"),int(TRANSLATE));
    customUI->multihandTypeCombobox->addItem(i18n("Snowflake"),int(SNOWFLAKE));
    customUI->multihandTypeCombobox->addItem(i18n("Copy Translate"),int(COPYTRANSLATE));
    customUI->multihandTypeCombobox->addItem(i18n("Copy Translate at Intervals"),int(COPYTRANSLATEINTERVALS));
    connect(customUI->multihandTypeCombobox,SIGNAL(currentIndexChanged(int)),this, SLOT(slotSetTransformMode(int)));
    customUI->multihandTypeCombobox->setCurrentIndex(m_configGroup.readEntry("transformMode", 0));
 
 
    customUI->axisRotationAngleSelector->setRange(0.0, 90.0);
    customUI->axisRotationAngleSelector->setDecimals(1);
    customUI->axisRotationAngleSelector->setWrapping(false);
    customUI->axisRotationAngleSelector->setFlipOptionsMode(KisAngleSelector::FlipOptionsMode_NoFlipOptions);
    connect(customUI->axisRotationAngleSelector, SIGNAL(angleChanged(qreal)), this, SLOT(slotSetAxesAngle(qreal)));
    customUI->axisRotationAngleSelector->setAngle(m_configGroup.readEntry("axesAngle", 0.0));
 
 
    // symmetry mode options
    customUI->brushCountSpinBox->setRange(1, MAXIMUM_BRUSHES);
    connect(customUI->brushCountSpinBox, SIGNAL(valueChanged(int)),this, SLOT(slotSetHandsCount(int)));
    customUI->brushCountSpinBox->setValue(m_configGroup.readEntry("handsCount", 4));
 
    // mirror mode specific options
    connect(customUI->horizontalCheckbox, SIGNAL(toggled(bool)), this, SLOT(slotSetMirrorHorizontally(bool)));
    customUI->horizontalCheckbox->setChecked((bool)m_configGroup.readEntry("mirrorHorizontally", false));
 
    connect(customUI->verticalCheckbox, SIGNAL(toggled(bool)), this, SLOT(slotSetMirrorVertically(bool)));
    customUI->verticalCheckbox->setChecked((bool)m_configGroup.readEntry("mirrorVertically", false));
 
    // translate mode options
    customUI->translationRadiusSpinbox->setRange(0, 200);
    customUI->translationRadiusSpinbox->setSuffix(i18n(" px"));
 
    connect(customUI->translationRadiusSpinbox,SIGNAL(valueChanged(int)),this,SLOT(slotSetTranslateRadius(int)));
    customUI->translationRadiusSpinbox->setValue(m_configGroup.readEntry("translateRadius", 0));
 
    // Copy translate mode options and actions
    connect(customUI->addSubbrushButton, &QPushButton::clicked, this, &KisToolMultihand::slotAddSubbrushesMode);
    connect(customUI->removeSubbrushButton, &QPushButton::clicked, this, &KisToolMultihand::slotRemoveAllSubbrushes);
 
    // Copy translate at intervals mode options and actions
    customUI->intervalXSpinBox->setRange(0, 2000);
    customUI->intervalXSpinBox->setSuffix(i18n(" px"));
    customUI->intervalYSpinBox->setRange(0, 2000);
    customUI->intervalYSpinBox->setSuffix(i18n(" px"));
 
    KisAspectRatioLocker *intervalAspectLocker = new KisAspectRatioLocker(this);
    intervalAspectLocker->connectSpinBoxes(customUI->intervalXSpinBox, customUI->intervalYSpinBox, customUI->intervalAspectButton);
 
    customUI->intervalXSpinBox->setValue(m_configGroup.readEntry("intervalX", 0));
    customUI->intervalYSpinBox->setValue(m_configGroup.readEntry("intervalY", 0));
    connect(intervalAspectLocker, SIGNAL(sliderValueChanged()), this, SLOT(slotSetIntervals()));
    slotSetIntervals(); // X and Y need to be set at the same time.
    connect(intervalAspectLocker, SIGNAL(aspectButtonChanged()), this, SLOT(slotSetKeepAspect()));
    customUI->intervalAspectButton->setKeepAspectRatio(m_configGroup.readEntry("intervalKeepAspect", false));
 
    // snowflake re-uses the existing options, so there is no special parameters for that...
 
 
    return static_cast<QWidget*>(customUI); // keeping it in the native class until the end allows us to access the UI components
}

References activateAxesPointModeSetup(), connect(), KisAspectRatioLocker::connectSpinBoxes(), COPYTRANSLATE, COPYTRANSLATEINTERVALS, KisToolBrush::createOptionWidget(), customUI, KisAngleSelector::FlipOptionsMode_NoFlipOptions, KisTool::image(), KisToolBrush::m_configGroup, MAXIMUM_BRUSHES, MIRROR, resetAxes(), slotAddSubbrushesMode(), slotRemoveAllSubbrushes(), slotSetAxesAngle(), slotSetAxesVisible(), slotSetHandsCount(), slotSetIntervals(), slotSetKeepAspect(), slotSetMirrorHorizontally(), slotSetMirrorVertically(), slotSetTransformMode(), slotSetTranslateRadius(), SNOWFLAKE, SYMMETRY, and TRANSLATE.

◆ endAlternateAction()

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

overridevirtual

Reimplemented from KisToolFreehand.

Definition at line 140 of file kis_tool_multihand.cpp.

{
    if ((action != ChangeSize && action != ChangeSizeSnap) ||
            m_transformMode != COPYTRANSLATE ||
            !m_addSubbrushesMode) {
        KisToolBrush::endAlternateAction(event, action);
        return;
    }
    if (mode() == KisTool::OTHER_1) {
        setMode(KisTool::HOVER_MODE);
    }
}

References KoToolBase::action(), KisTool::ChangeSize, KisTool::ChangeSizeSnap, COPYTRANSLATE, KisTool::endAlternateAction(), KisTool::HOVER_MODE, m_addSubbrushesMode, m_transformMode, KisTool::mode(), KisTool::OTHER_1, and KisToolPaint::setMode().

◆ endPrimaryAction()

void KisToolMultihand::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 KisToolFreehand.

Definition at line 99 of file kis_tool_multihand.cpp.

{
    if(mode() == KisTool::OTHER) {
        setMode(KisTool::HOVER_MODE);
        requestUpdateOutline(event->point, 0);
        finishAxesSetup();
    }
    else {
        KisToolFreehand::endPrimaryAction(event);
    }
}

References KisToolFreehand::endPrimaryAction(), finishAxesSetup(), KisTool::HOVER_MODE, KisTool::mode(), KisTool::OTHER, KoPointerEvent::point, KisToolPaint::requestUpdateOutline(), and KisToolPaint::setMode().

◆ finishAxesSetup()

void KisToolMultihand::finishAxesSetup ( )

private

Definition at line 530 of file kis_tool_multihand.cpp.

{
    m_setupAxesFlag = false;
    customUI->moveOriginButton->setChecked(false);
    resetCursorStyle();
    updateCanvas();
}

References customUI, m_setupAxesFlag, KisToolBrush::resetCursorStyle(), and updateCanvas().

◆ initTransformations()

void KisToolMultihand::initTransformations ( )

private

TODO: currently, the seed is the same for all the strokes

Definition at line 294 of file kis_tool_multihand.cpp.

{
    QVector<QTransform> transformations;
    QTransform m;
 
    if(m_transformMode == SYMMETRY) {
        qreal angle = 0;
        const qreal angleStep = (2 * M_PI) / m_handsCount;
 
        for(int i = 0; i < m_handsCount; i++) {
            m.translate(m_axesPoint.x(), m_axesPoint.y());
            m.rotateRadians(angle);
            m.translate(-m_axesPoint.x(), -m_axesPoint.y());
 
            transformations << m;
            m.reset();
            angle += angleStep;
        }
    }
    else if(m_transformMode == MIRROR) {
        transformations << m;
 
        if (m_mirrorHorizontally) {
            m.translate(m_axesPoint.x(),m_axesPoint.y());
            m.rotateRadians(m_angle);
            m.scale(-1,1);
            m.rotateRadians(-m_angle);
            m.translate(-m_axesPoint.x(), -m_axesPoint.y());
            transformations << m;
            m.reset();
        }
 
        if (m_mirrorVertically) {
            m.translate(m_axesPoint.x(),m_axesPoint.y());
            m.rotateRadians(m_angle);
            m.scale(1,-1);
            m.rotateRadians(-m_angle);
            m.translate(-m_axesPoint.x(), -m_axesPoint.y());
            transformations << m;
            m.reset();
        }
 
        if (m_mirrorVertically && m_mirrorHorizontally){
            m.translate(m_axesPoint.x(),m_axesPoint.y());
            m.rotateRadians(m_angle);
            m.scale(-1,-1);
            m.rotateRadians(-m_angle);
            m.translate(-m_axesPoint.x(), -m_axesPoint.y());
            transformations << m;
            m.reset();
        }
 
    }
    else if(m_transformMode == SNOWFLAKE) {
        qreal angle = 0;
        const qreal angleStep = (2 * M_PI) / m_handsCount/4;
 
        for(int i = 0; i < m_handsCount*4; i++) {
           if ((i%2)==1) {
 
               m.translate(m_axesPoint.x(), m_axesPoint.y());
               m.rotateRadians(m_angle-angleStep);
               m.rotateRadians(angle);
               m.scale(-1,1);
               m.rotateRadians(-m_angle+angleStep);
               m.translate(-m_axesPoint.x(), -m_axesPoint.y());
 
               transformations << m;
               m.reset();
               angle += angleStep*2;
           } else {
               m.translate(m_axesPoint.x(), m_axesPoint.y());
               m.rotateRadians(m_angle-angleStep);
               m.rotateRadians(angle);
               m.rotateRadians(-m_angle+angleStep);
               m.translate(-m_axesPoint.x(), -m_axesPoint.y());
 
               transformations << m;
               m.reset();
               angle += angleStep*2;
            }
        }
    }
    else if(m_transformMode == TRANSLATE) {
        for (int i = 0; i < m_handsCount; i++){
            const qreal angle = m_randomGenerator.bounded(2.0 * M_PI);
            const qreal length = m_randomGenerator.bounded(1.0);
 
            // convert the Polar coordinates to Cartesian coordinates
            qreal nx = (m_translateRadius * cos(angle) * length);
            qreal ny = (m_translateRadius * sin(angle) * length);
 
            m.translate(m_axesPoint.x(),m_axesPoint.y());
            m.rotateRadians(m_angle);
            m.translate(nx,ny);
            m.rotateRadians(-m_angle);
            m.translate(-m_axesPoint.x(), -m_axesPoint.y());
            transformations << m;
            m.reset();
        }
    } else if (m_transformMode == COPYTRANSLATE) {
        transformations << m;
        Q_FOREACH (QPointF dPos, m_subbrOriginalLocations) {
            const QPointF resPos = dPos-m_axesPoint; // Calculate the difference between subbrush reference position and "origin" reference
            m.translate(resPos.x(), resPos.y());
            transformations << m;
            m.reset();
        }
    } else if (m_transformMode == COPYTRANSLATEINTERVALS) {
        KisCanvas2 *kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
        Q_ASSERT(kisCanvas);
        const QRect bounds = kisCanvas->viewManager()->selection() ?
            kisCanvas->viewManager()->selection()->selectedExactRect() :
            kisCanvas->currentImage()->bounds();
        const QPoint dPos = bounds.topLeft() +
                      QPoint(m_intervalX ? m_intervalX * floor((m_axesPoint.x() - bounds.left()) / m_intervalX) : 0,
                             m_intervalY ? m_intervalY * floor((m_axesPoint.y() - bounds.top()) / m_intervalY) : 0);
 
        Q_FOREACH (QPoint pos, intervalLocations()) {
                const QPointF resPos = pos - dPos;
                m.translate(resPos.x(), resPos.y());
                transformations << m;
                m.reset();
        }
    }
 
    m_helper->setupTransformations(transformations);
}

References KisImage::bounds(), bounds, Private::canvas, COPYTRANSLATE, COPYTRANSLATEINTERVALS, KisCanvas2::currentImage(), intervalLocations(), length(), m_angle, m_axesPoint, m_handsCount, m_helper, m_intervalX, m_intervalY, m_mirrorHorizontally, m_mirrorVertically, M_PI, m_randomGenerator, m_subbrOriginalLocations, m_transformMode, m_translateRadius, MIRROR, KisSelection::selectedExactRect(), KisViewManager::selection(), KisToolMultihandHelper::setupTransformations(), SNOWFLAKE, SYMMETRY, TRANSLATE, and KisCanvas2::viewManager().

◆ intervalLocations()

QVector< QPoint > KisToolMultihand::intervalLocations ( )

private

Definition at line 551 of file kis_tool_multihand.cpp.

{
    QVector<QPoint> intervalLocations;
 
    KisCanvas2 *kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
    Q_ASSERT(kisCanvas);
    const QRect bounds = kisCanvas->viewManager()->selection() ?
        kisCanvas->viewManager()->selection()->selectedExactRect() :
        kisCanvas->currentImage()->bounds();
 
    const int intervals = m_intervalX ? (bounds.width() / m_intervalX) : 0 +
                    m_intervalY ? (bounds.height() / m_intervalY) : 0;
    if (intervals > MAXIMUM_BRUSHES) {
        kisCanvas->viewManager()->showFloatingMessage(
            i18n("Multibrush Tool does not support more than %1 brushes; use a larger interval.",
            QString::number(MAXIMUM_BRUSHES)), QIcon());
        return intervalLocations;
    }
 
    for (int x = bounds.left(); x <= bounds.right(); x += m_intervalX) {
        for (int y = bounds.top(); y <= bounds.bottom(); y += m_intervalY) {
            intervalLocations << QPoint(x,y);
 
            if (m_intervalY == 0) { break; }
        }
        if (m_intervalX == 0) { break; }
    }
 
    return intervalLocations;
}

References KisImage::bounds(), bounds, Private::canvas, KisCanvas2::currentImage(), intervalLocations(), m_intervalX, m_intervalY, MAXIMUM_BRUSHES, KisSelection::selectedExactRect(), KisViewManager::selection(), KisViewManager::showFloatingMessage(), and KisCanvas2::viewManager().

◆ mouseMoveEvent()

void KisToolMultihand::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

Reimplemented from KisToolFreehand.

Definition at line 153 of file kis_tool_multihand.cpp.

{
    if (mode() == HOVER_MODE) {
        m_lastToolPos=convertToPixelCoord(event->point);
    }
    KisToolBrush::mouseMoveEvent(event);
}

References KisTool::convertToPixelCoord(), KisTool::HOVER_MODE, m_lastToolPos, KisTool::mode(), KoToolBase::mouseMoveEvent(), and KoPointerEvent::point.

◆ paint()

void KisToolMultihand::paint	(	QPainter &	painter,
		const KoViewConverter &	converter )

overrideprotectedvirtual

Called by the canvas to paint any decorations that the tool deems needed. The painter has the top left of the canvas as its origin.

Parameters

painter	used for painting the shape
converter	to convert between internal and view coordinates.

Implements KoToolBase.

Definition at line 161 of file kis_tool_multihand.cpp.

{
    QPainterPath path;
 
    if (m_showAxes) {
        const int axisLength = currentImage()->height() + currentImage()->width();
 
        // add division guide lines if using multiple brushes
        if ((m_handsCount > 1 && m_transformMode == SYMMETRY) ||
            (m_handsCount > 1 && m_transformMode == SNOWFLAKE) ) {
            int axesCount;
            if (m_transformMode == SYMMETRY){
                 axesCount = m_handsCount;
            }
            else {
                axesCount = m_handsCount*2;
            }
            const qreal axesAngle = 360.0 / float(axesCount);
            float currentAngle = 0.0;
            const float startingInsetLength = 20; // don't start each line at the origin so we can see better when all points converge
 
            // draw lines radiating from the origin
            for( int i=0; i < axesCount; i++) {
 
                currentAngle = i*axesAngle;
 
                // convert angles to radians since cos and sin need that
                currentAngle = currentAngle * 0.017453 + m_angle; // m_angle is current rotation set on UI
 
                const QPoint startingSpot = QPoint(m_axesPoint.x()+ (sin(currentAngle)*startingInsetLength), m_axesPoint.y()- (cos(currentAngle))*startingInsetLength );
                path.moveTo(startingSpot.x(), startingSpot.y());
                QPointF symmetryLinePoint(m_axesPoint.x()+ (sin(currentAngle)*axisLength), m_axesPoint.y()- (cos(currentAngle))*axisLength );
                path.lineTo(symmetryLinePoint);
            }
 
        }
        else if(m_transformMode == MIRROR) {
 
            if (m_mirrorHorizontally) {
                path.moveTo(m_axesPoint.x()-axisLength*cos(m_angle+M_PI_2), m_axesPoint.y()-axisLength*sin(m_angle+M_PI_2));
                path.lineTo(m_axesPoint.x()+axisLength*cos(m_angle+M_PI_2), m_axesPoint.y()+axisLength*sin(m_angle+M_PI_2));
            }
 
            if(m_mirrorVertically) {
                path.moveTo(m_axesPoint.x()-axisLength*cos(m_angle), m_axesPoint.y()-axisLength*sin(m_angle));
                path.lineTo(m_axesPoint.x()+axisLength*cos(m_angle), m_axesPoint.y()+axisLength*sin(m_angle));
            }
        }
        else if (m_transformMode == COPYTRANSLATE) {
 
            const int ellipsePreviewSize = 10;
            // draw ellipse at origin to emphasize this is a drawing point
            path.addEllipse(m_axesPoint.x()-(ellipsePreviewSize),
                            m_axesPoint.y()-(ellipsePreviewSize),
                            ellipsePreviewSize*2,
                            ellipsePreviewSize*2);
 
            Q_FOREACH (QPointF dPos, m_subbrOriginalLocations) {
                path.addEllipse(dPos, ellipsePreviewSize, ellipsePreviewSize);  // Show subbrush reference locations while in add mode
            }
 
            // draw the horiz/vertical line for axis  origin
            path.moveTo(m_axesPoint.x()-axisLength*cos(m_angle), m_axesPoint.y()-axisLength*sin(m_angle));
            path.lineTo(m_axesPoint.x()+axisLength*cos(m_angle), m_axesPoint.y()+axisLength*sin(m_angle));
            path.moveTo(m_axesPoint.x()-axisLength*cos(m_angle+M_PI_2), m_axesPoint.y()-axisLength*sin(m_angle+M_PI_2));
            path.lineTo(m_axesPoint.x()+axisLength*cos(m_angle+M_PI_2), m_axesPoint.y()+axisLength*sin(m_angle+M_PI_2));
 
        }
        else if (m_transformMode == COPYTRANSLATEINTERVALS) {
            const int ellipsePreviewSize = 10;
 
            Q_FOREACH (QPointF dPos, intervalLocations()) {
                path.addEllipse(dPos, ellipsePreviewSize, ellipsePreviewSize);
            }
        }
        else {
 
            // draw the horiz/vertical line for axis  origin
            path.moveTo(m_axesPoint.x()-axisLength*cos(m_angle), m_axesPoint.y()-axisLength*sin(m_angle));
            path.lineTo(m_axesPoint.x()+axisLength*cos(m_angle), m_axesPoint.y()+axisLength*sin(m_angle));
            path.moveTo(m_axesPoint.x()-axisLength*cos(m_angle+M_PI_2), m_axesPoint.y()-axisLength*sin(m_angle+M_PI_2));
            path.lineTo(m_axesPoint.x()+axisLength*cos(m_angle+M_PI_2), m_axesPoint.y()+axisLength*sin(m_angle+M_PI_2));
        }
 
    } else {
 
        // not showing axis
        if (m_transformMode == COPYTRANSLATE) {
 
            Q_FOREACH (QPointF dPos, m_subbrOriginalLocations) {
                // Show subbrush reference locations while in add mode
                if (m_addSubbrushesMode) {
                    path.addEllipse(dPos, 10, 10);
                }
            }
        }
    }
 
    KisToolFreehand::paint(gc, converter);
 
    // origin point preview line/s
    gc.save();
    QPen outlinePen;
    outlinePen.setColor(QColor(100,100,100,150));
    outlinePen.setStyle(Qt::PenStyle::SolidLine);
    gc.setPen(outlinePen);
    paintToolOutline(&gc, pixelToView(path));
    gc.restore();
 
 
    // fill in a dot for the origin if showing axis
    if (m_showAxes && m_transformMode != COPYTRANSLATEINTERVALS) {
        // draw a dot at the origin point to help with precisely moving
        QPainterPath dotPath;
        const int dotRadius = 4;
        dotPath.moveTo(m_axesPoint.x(), m_axesPoint.y());
        dotPath.addEllipse(m_axesPoint.x()- dotRadius*0.25, m_axesPoint.y()- dotRadius*0.25, dotRadius, dotRadius); // last 2 parameters are dot's size
 
        QBrush fillBrush;
        fillBrush.setColor(QColor(255, 255, 255, 255));
        fillBrush.setStyle(Qt::SolidPattern);
        gc.fillPath(pixelToView(dotPath), fillBrush);
 
 
        // add slight offset circle for contrast to help show it on
        dotPath = QPainterPath(); // resets path
        dotPath.addEllipse(m_axesPoint.x() - dotRadius*0.75, m_axesPoint.y()- dotRadius*0.75, dotRadius, dotRadius); // last 2 parameters are dot's size
        fillBrush.setColor(QColor(120, 120, 120, 255));
        gc.fillPath(pixelToView(dotPath), fillBrush);
    }
 
}

References COPYTRANSLATE, COPYTRANSLATEINTERVALS, KisTool::currentImage(), KisImage::height(), intervalLocations(), m_addSubbrushesMode, m_angle, m_axesPoint, m_handsCount, m_mirrorHorizontally, m_mirrorVertically, m_showAxes, m_subbrOriginalLocations, m_transformMode, MIRROR, KoToolBase::paint(), KisTool::paintToolOutline(), KisTool::pixelToView(), SNOWFLAKE, SYMMETRY, and KisImage::width().

◆ resetAxes

void KisToolMultihand::resetAxes ( )

privateslot

Definition at line 523 of file kis_tool_multihand.cpp.

{
    m_axesPoint = QPointF(0.5 * image()->width(), 0.5 * image()->height());
    finishAxesSetup();
}

References finishAxesSetup(), KisTool::image(), and m_axesPoint.

◆ slotAddSubbrushesMode

void KisToolMultihand::slotAddSubbrushesMode ( bool checked )

privateslot

Definition at line 668 of file kis_tool_multihand.cpp.

{
    m_addSubbrushesMode = checked;
    updateCanvas();
}

References m_addSubbrushesMode, and updateCanvas().

◆ slotRemoveAllSubbrushes

void KisToolMultihand::slotRemoveAllSubbrushes ( )

privateslot

Definition at line 674 of file kis_tool_multihand.cpp.

{
    m_subbrOriginalLocations.clear();
    updateCanvas();
}

References m_subbrOriginalLocations, and updateCanvas().

◆ slotSetAxesAngle

void KisToolMultihand::slotSetAxesAngle ( qreal angle )

privateslot

Definition at line 589 of file kis_tool_multihand.cpp.

{
    //negative so axes rotates counter clockwise
    m_angle = -angle*M_PI/180;
    updateCanvas();
    m_configGroup.writeEntry("axesAngle", angle);
}

References m_angle, KisToolBrush::m_configGroup, M_PI, and updateCanvas().

◆ slotSetAxesVisible

void KisToolMultihand::slotSetAxesVisible ( bool vis )

privateslot

Definition at line 640 of file kis_tool_multihand.cpp.

{
    m_showAxes = vis;
    updateCanvas();
    m_configGroup.writeEntry("showAxes", vis);
}

References KisToolBrush::m_configGroup, m_showAxes, and updateCanvas().

◆ slotSetHandsCount

void KisToolMultihand::slotSetHandsCount ( int count )

privateslot

Definition at line 582 of file kis_tool_multihand.cpp.

{
    m_handsCount = count;
    m_configGroup.writeEntry("handsCount", count);
    updateCanvas();
}

References KisToolBrush::m_configGroup, m_handsCount, and updateCanvas().

◆ slotSetIntervals

void KisToolMultihand::slotSetIntervals ( )

privateslot

Definition at line 680 of file kis_tool_multihand.cpp.

{
    m_intervalX = customUI->intervalXSpinBox->value();
    m_configGroup.writeEntry("intervalX", m_intervalX);
 
    m_intervalY = customUI->intervalYSpinBox->value();
    m_configGroup.writeEntry("intervalY", m_intervalY);
 
    updateCanvas();
}

References customUI, KisToolBrush::m_configGroup, m_intervalX, m_intervalY, and updateCanvas().

◆ slotSetKeepAspect

void KisToolMultihand::slotSetKeepAspect ( )

privateslot

Definition at line 691 of file kis_tool_multihand.cpp.

{
    m_configGroup.writeEntry("intervalKeepAspect", customUI->intervalAspectButton->keepAspectRatio());
}

References customUI, and KisToolBrush::m_configGroup.

◆ slotSetMirrorHorizontally

void KisToolMultihand::slotSetMirrorHorizontally ( bool mirror )

privateslot

Definition at line 655 of file kis_tool_multihand.cpp.

{
    m_mirrorHorizontally = mirror;
    updateCanvas();
    m_configGroup.writeEntry("mirrorHorizontally", mirror);
}

References KisToolBrush::m_configGroup, m_mirrorHorizontally, and updateCanvas().

◆ slotSetMirrorVertically

void KisToolMultihand::slotSetMirrorVertically ( bool mirror )

privateslot

Definition at line 648 of file kis_tool_multihand.cpp.

{
    m_mirrorVertically = mirror;
    updateCanvas();
    m_configGroup.writeEntry("mirrorVertically", mirror);
}

References KisToolBrush::m_configGroup, m_mirrorVertically, and updateCanvas().

◆ slotSetTransformMode

void KisToolMultihand::slotSetTransformMode ( int qcomboboxIndex )

privateslot

Definition at line 597 of file kis_tool_multihand.cpp.

{
    m_transformMode = enumTransformModes(customUI->multihandTypeCombobox->itemData(index).toInt());
    m_configGroup.writeEntry("transformMode", index);
 
    // turn on or off what we need
 
    bool vis = index == MIRROR;
    customUI->horizontalCheckbox->setVisible(vis);
    customUI->verticalCheckbox->setVisible(vis);
 
    vis = index == TRANSLATE;
    customUI->translationRadiusSpinbox->setVisible(vis);
    customUI->radiusLabel->setVisible(vis);
    customUI->brushCountSpinBox->setVisible(vis);
    customUI->brushesLabel->setVisible(vis);
 
    vis = index == SYMMETRY || index == SNOWFLAKE || index == TRANSLATE;
    customUI->brushCountSpinBox->setVisible(vis);
    customUI->brushesLabel->setVisible(vis);
    
    vis = index == COPYTRANSLATE;
    customUI->subbrushLabel->setVisible(vis);
    customUI->addSubbrushButton->setVisible(vis);
    customUI->addSubbrushButton->setChecked(m_addSubbrushesMode);
    customUI->removeSubbrushButton->setVisible(vis);
 
    vis = index == COPYTRANSLATEINTERVALS;
    customUI->intervalXLabel->setVisible(vis);
    customUI->intervalYLabel->setVisible(vis);
    customUI->intervalXSpinBox->setVisible(vis);
    customUI->intervalYSpinBox->setVisible(vis);
    customUI->intervalAspectButton->setVisible(vis);
 
    vis = index != COPYTRANSLATEINTERVALS;
    customUI->label->setVisible(vis); // the origin label
    customUI->moveOriginButton->setVisible(vis);
    customUI->resetOriginButton->setVisible(vis);
    customUI->axisRotationLabel->setVisible(vis);
    customUI->axisRotationAngleSelector->setVisible(vis);
 
}

References COPYTRANSLATE, COPYTRANSLATEINTERVALS, customUI, m_addSubbrushesMode, KisToolBrush::m_configGroup, m_transformMode, MIRROR, SNOWFLAKE, SYMMETRY, and TRANSLATE.

◆ slotSetTranslateRadius

void KisToolMultihand::slotSetTranslateRadius ( int radius )

privateslot

Definition at line 662 of file kis_tool_multihand.cpp.

{
    m_translateRadius = radius;
    m_configGroup.writeEntry("translateRadius", radius);
}

References KisToolBrush::m_configGroup, and m_translateRadius.

◆ updateCanvas()

void KisToolMultihand::updateCanvas ( )

private

Definition at line 538 of file kis_tool_multihand.cpp.

{
    KisCanvas2 *kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
    Q_ASSERT(kisCanvas);
    kisCanvas->updateCanvas();
    if(customUI->moveOriginButton->isChecked())
    {
        kisCanvas->viewManager()->showFloatingMessage(i18n("X: %1 px\nY: %2 px"
                , QString::number(this->m_axesPoint.x(),'f',1),QString::number(this->m_axesPoint.y(),'f',1))
                , QIcon(), 1000, KisFloatingMessage::High, Qt::AlignLeft | Qt::TextWordWrap | Qt::AlignVCenter);
    }
}

References Private::canvas, customUI, KisFloatingMessage::High, m_axesPoint, KisViewManager::showFloatingMessage(), KisCanvas2::updateCanvas(), and KisCanvas2::viewManager().

Member Data Documentation

◆ customUI

KisToolMultiHandConfigWidget* KisToolMultihand::customUI

private

Definition at line 88 of file kis_tool_multihand.h.

◆ m_addSubbrushesMode

bool KisToolMultihand::m_addSubbrushesMode

private

Definition at line 80 of file kis_tool_multihand.h.

◆ m_angle

qreal KisToolMultihand::m_angle

private

Definition at line 72 of file kis_tool_multihand.h.

◆ m_axesPoint

QPointF KisToolMultihand::m_axesPoint

private

Definition at line 71 of file kis_tool_multihand.h.

◆ m_handsCount

int KisToolMultihand::m_handsCount

private

Definition at line 73 of file kis_tool_multihand.h.

◆ m_helper

KisToolMultihandHelper* KisToolMultihand::m_helper

private

Definition at line 67 of file kis_tool_multihand.h.

◆ m_intervalX

int KisToolMultihand::m_intervalX

private

Definition at line 84 of file kis_tool_multihand.h.

◆ m_intervalY

int KisToolMultihand::m_intervalY

private

Definition at line 85 of file kis_tool_multihand.h.

◆ m_lastToolPos

QPointF KisToolMultihand::m_lastToolPos

private

Definition at line 81 of file kis_tool_multihand.h.

◆ m_mirrorHorizontally

bool KisToolMultihand::m_mirrorHorizontally

private

Definition at line 75 of file kis_tool_multihand.h.

◆ m_mirrorVertically

bool KisToolMultihand::m_mirrorVertically

private

Definition at line 74 of file kis_tool_multihand.h.

◆ m_randomGenerator

QRandomGenerator KisToolMultihand::m_randomGenerator

private

Definition at line 86 of file kis_tool_multihand.h.

◆ m_setupAxesFlag

bool KisToolMultihand::m_setupAxesFlag

private

Definition at line 79 of file kis_tool_multihand.h.

◆ m_showAxes

bool KisToolMultihand::m_showAxes

private

Definition at line 76 of file kis_tool_multihand.h.

◆ m_subbrOriginalLocations

QVector<QPointF> KisToolMultihand::m_subbrOriginalLocations

private

Definition at line 82 of file kis_tool_multihand.h.

◆ m_transformMode

enumTransformModes KisToolMultihand::m_transformMode

private

Definition at line 70 of file kis_tool_multihand.h.

◆ m_translateRadius

int KisToolMultihand::m_translateRadius

private

Definition at line 77 of file kis_tool_multihand.h.

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

plugins/tools/basictools/kis_tool_multihand.h
plugins/tools/basictools/kis_tool_multihand.cpp

Public Member Functions

Protected Member Functions

Private Types

Private Slots

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ enumTransformModes

Constructor & Destructor Documentation

◆ KisToolMultihand()

◆ ~KisToolMultihand()

Member Function Documentation

◆ activateAxesPointModeSetup

◆ beginAlternateAction()

◆ beginPrimaryAction()

◆ continueAlternateAction()

◆ continuePrimaryAction()

◆ createOptionWidget()

◆ endAlternateAction()

◆ endPrimaryAction()

◆ finishAxesSetup()

◆ initTransformations()

◆ intervalLocations()

◆ mouseMoveEvent()

◆ paint()

◆ resetAxes

◆ slotAddSubbrushesMode

◆ slotRemoveAllSubbrushes

◆ slotSetAxesAngle

◆ slotSetAxesVisible

◆ slotSetHandsCount

◆ slotSetIntervals

◆ slotSetKeepAspect

◆ slotSetMirrorHorizontally

◆ slotSetMirrorVertically

◆ slotSetTransformMode

◆ slotSetTranslateRadius

◆ updateCanvas()

Member Data Documentation

◆ customUI

◆ m_addSubbrushesMode

◆ m_angle

◆ m_axesPoint

◆ m_handsCount

◆ m_helper

◆ m_intervalX

◆ m_intervalY

◆ m_lastToolPos

◆ m_mirrorHorizontally

◆ m_mirrorVertically

◆ m_randomGenerator

◆ m_setupAxesFlag

◆ m_showAxes

◆ m_subbrOriginalLocations

◆ m_transformMode

◆ m_translateRadius