#include <kis_tool_paint.h>

Inheritance diagram for KisToolPaint:

Classes
struct	Private

Public Slots
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
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)

Public Member Functions
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	beginPrimaryAction (KoPointerEvent *event)

virtual void	beginPrimaryDoubleClickAction (KoPointerEvent *event)

virtual void	continuePrimaryAction (KoPointerEvent *event)

void	deleteSelection () override

virtual void	endPrimaryAction (KoPointerEvent *event)

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

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

virtual bool	wantsAutoScroll () const

	~KoToolBase () override

Protected Member Functions
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

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

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)

Protected Attributes
KisOptimizedBrushOutline	m_currentOutline

QRectF	m_oldColorPreviewUpdateRect

QRectF	m_oldOutlineRect

QPointF	m_outlineDocPoint

bool	m_paintOutline {false}

Protected Attributes inherited from KoToolBase
KoToolBasePrivate *	d_ptr

Private Slots
void	decreaseBrushSize ()

void	increaseBrushSize ()

void	rotateBrushTipClockwise ()

void	rotateBrushTipClockwisePrecise ()

void	rotateBrushTipCounterClockwise ()

void	rotateBrushTipCounterClockwisePrecise ()

void	showBrushSize ()

void	slotColorPickerRequestedCursor (const QCursor &cursor)

void	slotColorPickerRequestedCursorReset ()

void	slotColorPickerRequestedOutlineUpdate ()

void	slotPopupQuickHelp ()

Private Member Functions
bool	isSamplingAction (AlternateAction action)

KisOptimizedBrushOutline	tryFixBrushOutline (const KisOptimizedBrushOutline &originalOutline)

void	tryRestoreOpacitySnapshot ()

Private Attributes
KisAsyncColorSamplerHelper	m_colorSamplerHelper

QScopedPointer< Private >	m_d

bool	m_isOutlineEnabled

bool	m_isOutlineVisible

qreal	m_oldOpacity {1.0}

KisPaintOpPresetSP	m_oldPreset

bool	m_oldPresetIsDirty {false}

int	m_oldPresetVersion {-1}

QGridLayout *	m_optionsWidgetLayout {nullptr}

bool	m_specialHoverModifier {false}

std::vector< int >	m_standardBrushSizes

bool	m_supportOutline {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 }

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 33 of file kis_tool_paint.h.

Constructor & Destructor Documentation

◆ KisToolPaint()

KisToolPaint::KisToolPaint	(	KoCanvasBase *	canvas,
		const QCursor &	cursor )

Definition at line 78 of file kis_tool_paint.cc.

    : KisTool(canvas, cursor),
      m_isOutlineEnabled(true),
      m_isOutlineVisible(true),
      m_colorSamplerHelper(dynamic_cast<KisCanvas2*>(canvas)),
      m_d(new Private())
{
 
    {
        const int maxSize = KisImageConfig(true).maxBrushSize();
 
        int brushSize = 1;
        do {
            m_standardBrushSizes.push_back(brushSize);
            int increment = qMax(1, int(std::ceil(qreal(brushSize) / 15)));
            brushSize += increment;
        } while (brushSize < maxSize);
 
        m_standardBrushSizes.push_back(maxSize);
    }
 
    KisCanvas2 *kiscanvas = dynamic_cast<KisCanvas2*>(canvas);
    KIS_ASSERT(kiscanvas);
    connect(this, SIGNAL(sigPaintingFinished()), kiscanvas->viewManager()->canvasResourceProvider(), SLOT(slotPainting()));
 
    connect(&m_colorSamplerHelper, SIGNAL(sigRequestCursor(QCursor)), this, SLOT(slotColorPickerRequestedCursor(QCursor)));
    connect(&m_colorSamplerHelper, SIGNAL(sigRequestCursorReset()), this, SLOT(slotColorPickerRequestedCursorReset()));
    connect(&m_colorSamplerHelper, SIGNAL(sigRequestUpdateOutline()), this, SLOT(slotColorPickerRequestedOutlineUpdate()));
}

References Private::canvas, KisViewManager::canvasResourceProvider(), connect(), KIS_ASSERT, m_colorSamplerHelper, m_standardBrushSizes, KisImageConfig::maxBrushSize(), sigPaintingFinished(), slotColorPickerRequestedCursor(), slotColorPickerRequestedCursorReset(), slotColorPickerRequestedOutlineUpdate(), and KisCanvas2::viewManager().

◆ ~KisToolPaint()

KisToolPaint::~KisToolPaint ( )

override

Definition at line 109 of file kis_tool_paint.cc.

110{

111}

Member Function Documentation

◆ activate

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

overrideslot

Definition at line 171 of file kis_tool_paint.cc.

{
    if (currentPaintOpPreset()) {
        const QString formattedBrushName = currentPaintOpPreset() ? currentPaintOpPreset()->name().replace("_", " ") : QString();
        Q_EMIT statusTextChanged(formattedBrushName);
    }
 
    KisTool::activate(shapes);
    if (flags() & KisTool::FLAG_USES_CUSTOM_SIZE) {
        connect(action("increase_brush_size"), SIGNAL(triggered()), SLOT(increaseBrushSize()), Qt::UniqueConnection);
        connect(action("decrease_brush_size"), SIGNAL(triggered()), SLOT(decreaseBrushSize()), Qt::UniqueConnection);
        connect(action("increase_brush_size"), SIGNAL(triggered()), this, SLOT(showBrushSize()));
        connect(action("decrease_brush_size"), SIGNAL(triggered()), this, SLOT(showBrushSize()));
 
    }
 
    connect(action("rotate_brush_tip_clockwise"), SIGNAL(triggered()), SLOT(rotateBrushTipClockwise()), Qt::UniqueConnection);
    connect(action("rotate_brush_tip_clockwise_precise"), SIGNAL(triggered()), SLOT(rotateBrushTipClockwisePrecise()), Qt::UniqueConnection);
    connect(action("rotate_brush_tip_counter_clockwise"), SIGNAL(triggered()), SLOT(rotateBrushTipCounterClockwise()), Qt::UniqueConnection);
    connect(action("rotate_brush_tip_counter_clockwise_precise"), SIGNAL(triggered()), SLOT(rotateBrushTipCounterClockwisePrecise()), Qt::UniqueConnection);
 
    tryRestoreOpacitySnapshot();
}

References KoToolBase::action(), KisTool::activate(), connect(), KisTool::currentPaintOpPreset(), decreaseBrushSize(), KisTool::FLAG_USES_CUSTOM_SIZE, flags(), increaseBrushSize(), rotateBrushTipClockwise(), rotateBrushTipClockwisePrecise(), rotateBrushTipCounterClockwise(), rotateBrushTipCounterClockwisePrecise(), showBrushSize(), KoToolBase::statusTextChanged(), and tryRestoreOpacitySnapshot().

◆ activateAlternateAction()

void KisToolPaint::activateAlternateAction ( AlternateAction action )

overrideprotectedvirtual

Reimplemented from KisTool.

Reimplemented in KisToolSelectBase< __KisToolSelectEllipticalLocal >, KisToolSelectBase< __KisToolSelectOutlineLocal >, KisToolSelectBase< __KisToolSelectPolygonalLocal >, and KisToolSelectBase< __KisToolSelectRectangularLocal >.

Definition at line 297 of file kis_tool_paint.cc.

{
    if (!isSamplingAction(action)) {
        KisTool::activateAlternateAction(action);
        return;
    }
 
    const bool sampleCurrentLayer = action == SampleFgNode || action == SampleBgNode;
    const bool sampleFgColor = action == SampleFgNode || action == SampleFgImage;
    m_colorSamplerHelper.activate(sampleCurrentLayer, sampleFgColor);
}

References KoToolBase::action(), KisAsyncColorSamplerHelper::activate(), KisTool::activateAlternateAction(), isSamplingAction(), m_colorSamplerHelper, KisTool::SampleBgNode, KisTool::SampleFgImage, and KisTool::SampleFgNode.

◆ activatePrimaryAction()

void KisToolPaint::activatePrimaryAction ( )

overrideprotectedvirtual

Called by KisToolProxy when the primary action of the tool is going to be started now, that is when all the modifiers are pressed and the only thing left is just to press the mouse button. On coming of this callback the tool is supposed to prepare the cursor and/or the outline to show the user shat is going to happen next

Reimplemented from KisTool.

Reimplemented in KisToolSmartPatch.

Definition at line 502 of file kis_tool_paint.cc.

{
    setOutlineVisible(true);
    KisTool::activatePrimaryAction();
}

References KisTool::activatePrimaryAction(), and setOutlineVisible().

◆ addOptionWidgetLayout()

void KisToolPaint::addOptionWidgetLayout ( QLayout * layout )

protected

Add the tool-specific layout to the default option widget layout.

Definition at line 476 of file kis_tool_paint.cc.

{
    Q_ASSERT(m_optionsWidgetLayout != 0);
    int rowCount = m_optionsWidgetLayout->rowCount();
    m_optionsWidgetLayout->addLayout(layout, rowCount, 0, 1, 2);
}

References m_optionsWidgetLayout.

◆ addOptionWidgetOption()

void KisToolPaint::addOptionWidgetOption	(	QWidget *	control,
		QWidget *	label = nullptr )

protectedvirtual

Add a widget and a label to the current option widget layout.

Definition at line 484 of file kis_tool_paint.cc.

{
    Q_ASSERT(m_optionsWidgetLayout != 0);
    if (label) {
        m_optionsWidgetLayout->addWidget(label, m_optionsWidgetLayout->rowCount(), 0);
        m_optionsWidgetLayout->addWidget(control, m_optionsWidgetLayout->rowCount() - 1, 1);
    }
    else {
        m_optionsWidgetLayout->addWidget(control, m_optionsWidgetLayout->rowCount(), 0, 1, 2);
    }
}

References m_optionsWidgetLayout.

◆ beginAlternateAction()

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

overrideprotectedvirtual

Reimplemented from KisTool.

Reimplemented in KisToolPolylineBase, KisToolSelectBase< __KisToolSelectEllipticalLocal >, KisToolSelectBase< __KisToolSelectOutlineLocal >, KisToolSelectBase< __KisToolSelectPolygonalLocal >, and KisToolSelectBase< __KisToolSelectRectangularLocal >.

Definition at line 326 of file kis_tool_paint.cc.

{
    if (isSamplingAction(action)) {
        setMode(SECONDARY_PAINT_MODE);
 
        KisToolUtils::ColorSamplerConfig config;
        config.load();
 
        m_colorSamplerHelper.startAction(event->point, config.radius, config.blend);
        requestUpdateOutline(event->point, event);
    } else {
        KisTool::beginAlternateAction(event, action);
    }
}

References KoToolBase::action(), KisTool::beginAlternateAction(), KisToolUtils::ColorSamplerConfig::blend, isSamplingAction(), KisToolUtils::ColorSamplerConfig::load(), m_colorSamplerHelper, KoPointerEvent::point, KisToolUtils::ColorSamplerConfig::radius, requestUpdateOutline(), KisTool::SECONDARY_PAINT_MODE, setMode(), and KisAsyncColorSamplerHelper::startAction().

◆ canvasResourceChanged()

void KisToolPaint::canvasResourceChanged	(	int	key,
		const QVariant &	res )

overrideprotectedvirtual

This method is called whenever a property in the resource provider associated with the canvas this tool belongs to changes. An example is currently selected foreground color.

Reimplemented from KoToolBase.

Definition at line 118 of file kis_tool_paint.cc.

{
    KisTool::canvasResourceChanged(key, v);
 
    switch(key) {
    case(KoCanvasResource::Opacity):
        break;
    case(KoCanvasResource::CurrentPaintOpPreset): {
        if (isActive()) {
            requestUpdateOutline(m_outlineDocPoint, 0);
        }
        break;
    }
    case KoCanvasResource::CurrentPaintOpPresetName: {
        if (isActive()) {
            const QString formattedBrushName = v.toString().replace("_", " ");
            Q_EMIT statusTextChanged(formattedBrushName);
        }
        break;
    }
    default: //nothing
        break;
    }
 
    connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(resetCursorStyle()), Qt::UniqueConnection);
 
}

References KisTool::canvasResourceChanged(), connect(), KoCanvasResource::CurrentPaintOpPreset, KoCanvasResource::CurrentPaintOpPresetName, KisConfigNotifier::instance(), KisTool::isActive, m_outlineDocPoint, KoCanvasResource::Opacity, requestUpdateOutline(), KisTool::resetCursorStyle(), KoToolBase::statusTextChanged(), and v.

◆ continueAlternateAction()

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

overrideprotectedvirtual

Reimplemented from KisTool.

Reimplemented in KisToolSelectBase< __KisToolSelectEllipticalLocal >, KisToolSelectBase< __KisToolSelectOutlineLocal >, KisToolSelectBase< __KisToolSelectPolygonalLocal >, and KisToolSelectBase< __KisToolSelectRectangularLocal >.

Definition at line 341 of file kis_tool_paint.cc.

{
    if (isSamplingAction(action)) {
        m_colorSamplerHelper.continueAction(event->point);
        requestUpdateOutline(event->point, event);
    } else {
        KisTool::continueAlternateAction(event, action);
    }
}

References KoToolBase::action(), KisAsyncColorSamplerHelper::continueAction(), KisTool::continueAlternateAction(), isSamplingAction(), m_colorSamplerHelper, KoPointerEvent::point, and requestUpdateOutline().

◆ createOptionWidget()

QWidget * KisToolPaint::createOptionWidget ( )

overrideprotectedvirtual

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

Reimplemented from KisTool.

Reimplemented in KisToolSelectBase< __KisToolSelectEllipticalLocal >, KisToolSelectBase< __KisToolSelectOutlineLocal >, KisToolSelectBase< __KisToolSelectPolygonalLocal >, KisToolSelectBase< __KisToolSelectRectangularLocal >, KisToolShape, KisToolPolyline, and KisToolSmartPatch.

Definition at line 398 of file kis_tool_paint.cc.

{
    QWidget *optionWidget = new QWidget();
    optionWidget->setObjectName(toolId());
 
    QVBoxLayout *verticalLayout = new QVBoxLayout(optionWidget);
    verticalLayout->setObjectName("KisToolPaint::OptionWidget::VerticalLayout");
    verticalLayout->setContentsMargins(0,0,0,0);
    verticalLayout->setSpacing(5);
 
    // See https://bugs.kde.org/show_bug.cgi?id=316896
    QWidget *specialSpacer = new QWidget(optionWidget);
    specialSpacer->setObjectName("SpecialSpacer");
    specialSpacer->setFixedSize(0, 0);
    verticalLayout->addWidget(specialSpacer);
    verticalLayout->addWidget(specialSpacer);
 
    m_optionsWidgetLayout = new QGridLayout();
    m_optionsWidgetLayout->setColumnStretch(1, 1);
    verticalLayout->addLayout(m_optionsWidgetLayout);
    m_optionsWidgetLayout->setContentsMargins(0,0,0,0);
    m_optionsWidgetLayout->setSpacing(5);
 
    if (!quickHelp().isEmpty()) {
        QPushButton *push = new QPushButton(KisIconUtils::loadIcon("help-contents"), QString(), optionWidget);
        connect(push, SIGNAL(clicked()), this, SLOT(slotPopupQuickHelp()));
        QHBoxLayout *hLayout = new QHBoxLayout();
        hLayout->addWidget(push);
        hLayout->addItem(new QSpacerItem(0, 0, QSizePolicy::Expanding, QSizePolicy::Fixed));
        verticalLayout->addLayout(hLayout);
    }
 
    return optionWidget;
}

References connect(), KisIconUtils::loadIcon(), m_optionsWidgetLayout, KisTool::optionWidget, quickHelp(), slotPopupQuickHelp(), and KoToolBase::toolId().

◆ deactivate

void KisToolPaint::deactivate ( )

overrideslot

Definition at line 195 of file kis_tool_paint.cc.

{
    if (flags() & KisTool::FLAG_USES_CUSTOM_SIZE) {
        disconnect(action("increase_brush_size"), 0, this, 0);
        disconnect(action("decrease_brush_size"), 0, this, 0);
    }
 
    disconnect(action("rotate_brush_tip_clockwise"), 0, this, 0);
    disconnect(action("rotate_brush_tip_clockwise_precise"), 0, this, 0);
    disconnect(action("rotate_brush_tip_counter_clockwise"), 0, this, 0);
    disconnect(action("rotate_brush_tip_counter_clockwise_precise"), 0, this, 0);
 
    tryRestoreOpacitySnapshot();
    Q_EMIT statusTextChanged(QString());
 
    KisTool::deactivate();
}

References KoToolBase::action(), KisTool::deactivate(), KisTool::FLAG_USES_CUSTOM_SIZE, flags(), KoToolBase::statusTextChanged(), and tryRestoreOpacitySnapshot().

◆ deactivateAlternateAction()

void KisToolPaint::deactivateAlternateAction ( AlternateAction action )

overrideprotectedvirtual

Reimplemented from KisTool.

Reimplemented in KisToolSelectBase< __KisToolSelectEllipticalLocal >, KisToolSelectBase< __KisToolSelectOutlineLocal >, KisToolSelectBase< __KisToolSelectPolygonalLocal >, and KisToolSelectBase< __KisToolSelectRectangularLocal >.

Definition at line 309 of file kis_tool_paint.cc.

{
    if (!isSamplingAction(action)) {
        KisTool::deactivateAlternateAction(action);
        return;
    }
 
    m_colorSamplerHelper.deactivate();
}

References KoToolBase::action(), KisAsyncColorSamplerHelper::deactivate(), KisTool::deactivateAlternateAction(), isSamplingAction(), and m_colorSamplerHelper.

◆ deactivatePrimaryAction()

void KisToolPaint::deactivatePrimaryAction ( )

overrideprotectedvirtual

Called by KisToolProxy when the primary is no longer possible to be started now, e.g. when its modifiers and released. The tool is supposed to revert all the preparations it has done in activatePrimaryAction().

Reimplemented from KisTool.

Reimplemented in KisToolSmartPatch.

Definition at line 508 of file kis_tool_paint.cc.

{
    setOutlineVisible(false);
    KisTool::deactivatePrimaryAction();
}

References KisTool::deactivatePrimaryAction(), and setOutlineVisible().

◆ decreaseBrushSize

void KisToolPaint::decreaseBrushSize ( )

privateslot

Definition at line 551 of file kis_tool_paint.cc.

{
    qreal paintopSize = currentPaintOpPreset()->settings()->paintOpSize();
 
    std::vector<int>::reverse_iterator result =
        std::upper_bound(m_standardBrushSizes.rbegin(),
                         m_standardBrushSizes.rend(),
                         qRound(paintopSize),
                         std::greater<int>());
 
    int newValue = result != m_standardBrushSizes.rend() ? *result : m_standardBrushSizes.front();
 
    currentPaintOpPreset()->settings()->setPaintOpSize(newValue);
    requestUpdateOutline(m_outlineDocPoint, 0);
}

References KisTool::currentPaintOpPreset(), m_outlineDocPoint, m_standardBrushSizes, and requestUpdateOutline().

◆ enableControl()

void KisToolPaint::enableControl	(	QWidget *	control,
		bool	value )

protected

Definition at line 467 of file kis_tool_paint.cc.

{
    control->setEnabled(value);
    QWidget *label = findLabelWidget(m_optionsWidgetLayout, control);
    if (label) {
        label->setEnabled(value);
    }
}

References findLabelWidget(), m_optionsWidgetLayout, and value().

◆ endAlternateAction()

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

overrideprotectedvirtual

Reimplemented from KisTool.

Reimplemented in KisToolSelectBase< __KisToolSelectEllipticalLocal >, KisToolSelectBase< __KisToolSelectOutlineLocal >, KisToolSelectBase< __KisToolSelectPolygonalLocal >, and KisToolSelectBase< __KisToolSelectRectangularLocal >.

Definition at line 351 of file kis_tool_paint.cc.

{
    if (isSamplingAction(action)) {
        m_colorSamplerHelper.endAction();
        requestUpdateOutline(event->point, event);
        setMode(HOVER_MODE);
    } else {
        KisTool::endAlternateAction(event, action);
    }
}

References KoToolBase::action(), KisAsyncColorSamplerHelper::endAction(), KisTool::endAlternateAction(), KisTool::HOVER_MODE, isSamplingAction(), m_colorSamplerHelper, KoPointerEvent::point, requestUpdateOutline(), and setMode().

◆ flags()

int KisToolPaint::flags ( ) const

overridevirtual

Reimplemented from KisTool.

Reimplemented in KisToolShape, and KisToolSmartPatch.

Definition at line 113 of file kis_tool_paint.cc.

{
    return KisTool::FLAG_USES_CUSTOM_COMPOSITEOP;
}

References KisTool::FLAG_USES_CUSTOM_COMPOSITEOP.

◆ getOutlinePath()

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

protectedvirtual

Reimplemented in KisToolFreehand, and KisToolBasicBrushBase.

Definition at line 750 of file kis_tool_paint.cc.

{
    KisCanvas2 *canvas2 = dynamic_cast<KisCanvas2 *>(canvas());
    KIS_ASSERT(canvas2);
    const KisCoordinatesConverter *converter = canvas2->coordinatesConverter();
 
    const QPointF pixelPos = convertToPixelCoord(documentPos);
    // When touch drawing, a "hover" event means the finger was just pressed
    // down. The last cursor position is invalid with regards to distance and
    // speed, since it isn't updated while the finger isn't down, so reset it.
    if (event && event->isTouchEvent() && mode() == HOVER_MODE) {
        m_d->lastCursorPos.reset(pixelPos);
    }
 
    KisPaintInformation info(pixelPos);
    info.setCanvasMirroredH(canvas2->coordinatesConverter()->xAxisMirrored());
    info.setCanvasMirroredV(canvas2->coordinatesConverter()->yAxisMirrored());
    info.setCanvasRotation(canvas2->coordinatesConverter()->rotationAngle());
    info.setRandomSource(new KisRandomSource());
    info.setPerStrokeRandomSource(new KisPerStrokeRandomSource());
 
    const qreal currentZoom = canvas2->resourceManager() ? canvas2->resourceManager()->resource(KoCanvasResource::EffectiveZoom).toReal() : 1.0;
 
    QPointF prevPoint = m_d->lastCursorPos.pushThroughHistory(pixelPos, currentZoom);
    qreal startAngle = KisAlgebra2D::directionBetweenPoints(prevPoint, pixelPos, 0);
    KisDistanceInformation distanceInfo(prevPoint, startAngle);
 
    KisPaintInformation::DistanceInformationRegistrar registrar =
        info.registerDistanceInformation(&distanceInfo);
 
    KisOptimizedBrushOutline path = currentPaintOpPreset()->settings()->
        brushOutline(info,
                     outlineMode, converter->effectivePhysicalZoom());
 
    return path;
}

References Private::canvas, KisTool::convertToPixelCoord(), KisCanvas2::coordinatesConverter, KisTool::currentPaintOpPreset(), KisAlgebra2D::directionBetweenPoints(), KisCoordinatesConverter::effectivePhysicalZoom(), KoCanvasResource::EffectiveZoom, KisTool::HOVER_MODE, KoPointerEvent::isTouchEvent(), KIS_ASSERT, m_d, KisTool::mode(), KisPaintInformation::registerDistanceInformation(), KoCanvasBase::resourceManager, KisCoordinatesConverter::rotationAngle(), KisPaintInformation::setCanvasMirroredH(), KisPaintInformation::setCanvasMirroredV(), KisPaintInformation::setCanvasRotation(), KisPaintInformation::setPerStrokeRandomSource(), KisPaintInformation::setRandomSource(), KisCoordinatesConverter::xAxisMirrored(), and KisCoordinatesConverter::yAxisMirrored().

◆ increaseBrushSize

void KisToolPaint::increaseBrushSize ( )

privateslot

Definition at line 536 of file kis_tool_paint.cc.

{
    qreal paintopSize = currentPaintOpPreset()->settings()->paintOpSize();
 
    std::vector<int>::iterator result =
        std::upper_bound(m_standardBrushSizes.begin(),
                         m_standardBrushSizes.end(),
                         qRound(paintopSize));
 
    int newValue = result != m_standardBrushSizes.end() ? *result : m_standardBrushSizes.back();
 
    currentPaintOpPreset()->settings()->setPaintOpSize(newValue);
    requestUpdateOutline(m_outlineDocPoint, 0);
}

References KisTool::currentPaintOpPreset(), m_outlineDocPoint, m_standardBrushSizes, and requestUpdateOutline().

◆ isEraser()

bool KisToolPaint::isEraser ( ) const

protected

Definition at line 746 of file kis_tool_paint.cc.

                                  {
    return canvas()->resourceManager()->resource(KoCanvasResource::CurrentEffectiveCompositeOp).toString() == COMPOSITE_ERASE;
}

References Private::canvas, COMPOSITE_ERASE, KoCanvasResource::CurrentEffectiveCompositeOp, and KoCanvasBase::resourceManager.

◆ isOutlineEnabled()

bool KisToolPaint::isOutlineEnabled ( ) const

protected

Definition at line 514 of file kis_tool_paint.cc.

{
    return m_isOutlineEnabled;
}

References m_isOutlineEnabled.

◆ isOutlineVisible()

bool KisToolPaint::isOutlineVisible ( ) const

protected

Definition at line 525 of file kis_tool_paint.cc.

{
    return m_isOutlineVisible;
}

References m_isOutlineVisible.

◆ isSamplingAction()

bool KisToolPaint::isSamplingAction ( AlternateAction action )

private

Definition at line 319 of file kis_tool_paint.cc.

                                                          {
    return action == SampleFgNode ||
        action == SampleBgNode ||
        action == SampleFgImage ||
        action == SampleBgImage;
}

References KoToolBase::action(), KisTool::SampleBgImage, KisTool::SampleBgNode, KisTool::SampleFgImage, and KisTool::SampleFgNode.

◆ mouseMoveEvent()

void KisToolPaint::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 KisTool.

Reimplemented in KisToolPolylineBase, KisToolSelectBase< __KisToolSelectEllipticalLocal >, KisToolSelectBase< __KisToolSelectOutlineLocal >, KisToolSelectBase< __KisToolSelectPolygonalLocal >, and KisToolSelectBase< __KisToolSelectRectangularLocal >.

Definition at line 370 of file kis_tool_paint.cc.

{
    KisTool::mouseMoveEvent(event);
    if (mode() == KisTool::HOVER_MODE) {
        requestUpdateOutline(event->point, event);
    }
}

References KisTool::HOVER_MODE, KisTool::mode(), KisTool::mouseMoveEvent(), KoPointerEvent::point, and requestUpdateOutline().

◆ mousePressEvent()

void KisToolPaint::mousePressEvent ( KoPointerEvent * event )

overridevirtual

Called when (one of) the mouse or stylus buttons is pressed. Implementors should call event->ignore() if they do not actually use the event.

Parameters

event state and reason of this mouse or stylus press

Reimplemented from KisTool.

Definition at line 362 of file kis_tool_paint.cc.

{
    KisTool::mousePressEvent(event);
    if (mode() == KisTool::HOVER_MODE) {
        requestUpdateOutline(event->point, event);
    }
}

References KisTool::HOVER_MODE, KisTool::mode(), KisTool::mousePressEvent(), KoPointerEvent::point, and requestUpdateOutline().

◆ mouseReleaseEvent()

void KisToolPaint::mouseReleaseEvent ( KoPointerEvent * event )

overridevirtual

Called when (one of) the mouse or stylus buttons is released. Implementors should call event->ignore() if they do not actually use the event.

Parameters

event state and reason of this mouse or stylus release

Reimplemented from KisTool.

Definition at line 390 of file kis_tool_paint.cc.

{
    KisTool::mouseReleaseEvent(event);
    if (mode() == KisTool::HOVER_MODE) {
        requestUpdateOutline(event->point, event);
    }
}

References KisTool::HOVER_MODE, KisTool::mode(), KisTool::mouseReleaseEvent(), KoPointerEvent::point, and requestUpdateOutline().

◆ paint()

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

Reimplemented in KisToolPolylineBase, KisToolRectangleBase, and KisToolSmartPatch.

Definition at line 275 of file kis_tool_paint.cc.

{
    Q_UNUSED(converter);
 
    KisOptimizedBrushOutline path = tryFixBrushOutline(pixelToView(m_currentOutline));
    paintToolOutline(&gc, path);
 
    m_colorSamplerHelper.paint(gc, converter);
}

References m_colorSamplerHelper, m_currentOutline, KisAsyncColorSamplerHelper::paint(), KisTool::paintToolOutline(), KisTool::pixelToView(), and tryFixBrushOutline().

◆ popupWidget()

KisPopupWidgetInterface * KisToolPaint::popupWidget ( )

overridevirtual

Returns: a widget with useful controls to be popped up on top of the canvas. Will not be called if popupActionsMenu() does not return null.

Reimplemented from KoToolBase.

Reimplemented in KisToolPolylineBase, KisToolSelectBase< __KisToolSelectEllipticalLocal >, KisToolSelectBase< __KisToolSelectOutlineLocal >, KisToolSelectBase< __KisToolSelectPolygonalLocal >, and KisToolSelectBase< __KisToolSelectRectangularLocal >.

Definition at line 378 of file kis_tool_paint.cc.

{
    KisCanvas2 *kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
 
    if (!kisCanvas) {
        return nullptr;
    }
 
    KisPopupWidgetInterface* popupWidget = kisCanvas->popupPalette();
    return popupWidget;
}

References Private::canvas, KisCanvas2::popupPalette, and popupWidget().

◆ quickHelp()

virtual QString KisToolPaint::quickHelp ( ) const

inlineprotectedvirtual

Quick help is a short help text about the way the tool functions.

Reimplemented in KisToolLine.

Definition at line 102 of file kis_tool_paint.h.

                                      {
        return QString();
    }

◆ requestUpdateOutline()

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

protectedvirtual

A simple "update-ahead" implementation that issues an update a little bigger to accommodate the possible following outline.

The point is that canvas rendering comes through two stages of compression and the canvas may request outline update when the outline itself has already been changed. It causes visual tearing on the screen (see https://bugs.kde.org/show_bug.cgi?id=476300).

We can solve that in two ways:

1) Pass the actual outline with the update rect itself, which is a bit complicated and may result in the outline being a bit delayed visually. We don't implement this method (yet).

2) Just pass the update rect a bit bigger than the actual outline to accommodate a possible change in the outline. We calculate this bigger rect by offsetting the rect by the previous cursor offset.

Don't try to update-ahead if the offset is bigger than 50% of the brush outline

10% of extra move is added to offset

Reimplemented in KisDynamicDelegatedTool< KisToolShape >, and KisToolSmartPatch.

Definition at line 603 of file kis_tool_paint.cc.

{
    QRectF outlinePixelRect;
    QRectF outlineDocRect;
 
    QRectF colorPreviewDocUpdateRect;
 
    QPointF outlineMoveVector;
 
    if (m_supportOutline) {
        KisConfig cfg(true);
        KisPaintOpSettings::OutlineMode outlineMode;
 
        bool useSeparateEraserCursor = cfg.separateEraserCursor() && isEraser();
 
        const OutlineStyle currentOutlineStyle = !useSeparateEraserCursor ? cfg.newOutlineStyle() : cfg.eraserOutlineStyle();
        const auto outlineStyleIsVisible = [&]() {
            return currentOutlineStyle == OUTLINE_FULL ||
                   currentOutlineStyle == OUTLINE_CIRCLE ||
                   currentOutlineStyle == OUTLINE_TILT;
        };
        const auto shouldShowOutlineWhilePainting = [&]() {
            return !useSeparateEraserCursor ? cfg.showOutlineWhilePainting() : cfg.showEraserOutlineWhilePainting();
        };
        if (isOutlineEnabled() && isOutlineVisible() &&
                (mode() == KisTool::GESTURE_MODE ||
                    (outlineStyleIsVisible() &&
                        (mode() == HOVER_MODE ||
                         (mode() == PAINT_MODE && shouldShowOutlineWhilePainting()))))) { // lisp forever!
 
            outlineMode.isVisible = true;
 
            switch (!useSeparateEraserCursor ? cfg.newOutlineStyle() : cfg.eraserOutlineStyle()) {
            case OUTLINE_CIRCLE:
                outlineMode.forceCircle = true;
                break;
            case OUTLINE_TILT:
                outlineMode.forceCircle = true;
                outlineMode.showTiltDecoration = true;
                break;
            default:
                break;
            }
        }
 
        outlineMode.forceFullSize = !useSeparateEraserCursor ? cfg.forceAlwaysFullSizedOutline() : cfg.forceAlwaysFullSizedEraserOutline();
 
        outlineMoveVector = outlineDocPoint - m_outlineDocPoint;
 
        m_outlineDocPoint = outlineDocPoint;
        m_currentOutline = getOutlinePath(m_outlineDocPoint, event, outlineMode);
 
        outlinePixelRect = tryFixBrushOutline(m_currentOutline).boundingRect();
        outlineDocRect = currentImage()->pixelToDocument(outlinePixelRect);
 
        // This adjusted call is needed as we paint with a 3 pixel wide brush and the pen is outside the bounds of the path
        // Pen uses view coordinates so we have to zoom the document value to match 2 pixel in view coordinates
        // See BUG 275829
        qreal zoomX;
        qreal zoomY;
        canvas()->viewConverter()->zoom(&zoomX, &zoomY);
        qreal xoffset = 2.0/zoomX;
        qreal yoffset = 2.0/zoomY;
 
        if (!outlineDocRect.isEmpty()) {
            outlineDocRect.adjust(-xoffset,-yoffset,xoffset,yoffset);
        }
 
        colorPreviewDocUpdateRect = m_colorSamplerHelper.colorPreviewDocRect(m_outlineDocPoint);
 
        if (!colorPreviewDocUpdateRect.isEmpty()) {
            colorPreviewDocUpdateRect = colorPreviewDocUpdateRect.adjusted(-xoffset,-yoffset,xoffset,yoffset);
        }
 
    }
 
    // DIRTY HACK ALERT: we should fetch the assistant's dirty rect when requesting
    //                   the update, instead of just dumbly update the entire canvas!
 
    // WARNING: assistants code is also duplicated in KisDelegatedSelectPathWrapper::mouseMoveEvent
 
    KisCanvas2 *kiscanvas = qobject_cast<KisCanvas2*>(canvas());
    KisPaintingAssistantsDecorationSP decoration = kiscanvas->paintingAssistantsDecoration();
    if (decoration && decoration->visible() && decoration->hasPaintableAssistants()) {
        kiscanvas->updateCanvasDecorations();
    }
 
    if (!m_oldColorPreviewUpdateRect.isEmpty()) {
        kiscanvas->updateCanvasToolOutlineDoc(m_oldColorPreviewUpdateRect);
    }
 
    if (!m_oldOutlineRect.isEmpty()) {
        kiscanvas->updateCanvasToolOutlineDoc(m_oldOutlineRect);
    }
 
    if (!outlineDocRect.isEmpty()) {
        const qreal maxUpdateAheadOutlinePortion = 0.5;
 
        const qreal offsetFuzzyExtension = 0.1;
 
        const qreal moveDistance = KisAlgebra2D::norm(outlineMoveVector);
 
        QRectF offsetRect;
 
        if (moveDistance < maxUpdateAheadOutlinePortion * KisAlgebra2D::maxDimension(outlineDocRect)) {
            offsetRect = outlineDocRect.translated((1.0 + offsetFuzzyExtension) * outlineMoveVector);
        }
 
        kiscanvas->updateCanvasToolOutlineDoc(outlineDocRect | offsetRect);
    }
 
    if (!colorPreviewDocUpdateRect.isEmpty()) {
        kiscanvas->updateCanvasToolOutlineDoc(colorPreviewDocUpdateRect);
    }
 
    m_oldOutlineRect = outlineDocRect;
    m_oldColorPreviewUpdateRect = colorPreviewDocUpdateRect;
}

References KisOptimizedBrushOutline::boundingRect(), Private::canvas, KisAsyncColorSamplerHelper::colorPreviewDocRect(), KisTool::currentImage(), KisConfig::eraserOutlineStyle(), KisConfig::forceAlwaysFullSizedEraserOutline(), KisConfig::forceAlwaysFullSizedOutline(), KisPaintOpSettings::OutlineMode::forceCircle, KisPaintOpSettings::OutlineMode::forceFullSize, KisTool::GESTURE_MODE, getOutlinePath(), KisPaintingAssistantsDecoration::hasPaintableAssistants(), KisTool::HOVER_MODE, isEraser(), isOutlineEnabled(), isOutlineVisible(), KisPaintOpSettings::OutlineMode::isVisible, m_colorSamplerHelper, m_currentOutline, m_oldColorPreviewUpdateRect, m_oldOutlineRect, m_outlineDocPoint, m_supportOutline, KisAlgebra2D::maxDimension(), KisTool::mode(), KisConfig::newOutlineStyle(), KisAlgebra2D::norm(), OUTLINE_CIRCLE, OUTLINE_FULL, OUTLINE_TILT, KisTool::PAINT_MODE, KisCanvas2::paintingAssistantsDecoration(), KisImage::pixelToDocument(), KisConfig::separateEraserCursor(), KisConfig::showEraserOutlineWhilePainting(), KisConfig::showOutlineWhilePainting(), KisPaintOpSettings::OutlineMode::showTiltDecoration, tryFixBrushOutline(), KisCanvas2::updateCanvasDecorations(), KisCanvas2::updateCanvasToolOutlineDoc(), KisCanvas2::viewConverter(), KisCanvasDecoration::visible(), and KoViewConverter::zoom().

◆ rotateBrushTipClockwise

void KisToolPaint::rotateBrushTipClockwise ( )

privateslot

Definition at line 575 of file kis_tool_paint.cc.

{
    const qreal angle = currentPaintOpPreset()->settings()->paintOpAngle();
    currentPaintOpPreset()->settings()->setPaintOpAngle(angle - 15);
    requestUpdateOutline(m_outlineDocPoint, 0);
}

References KisTool::currentPaintOpPreset(), m_outlineDocPoint, and requestUpdateOutline().

◆ rotateBrushTipClockwisePrecise

void KisToolPaint::rotateBrushTipClockwisePrecise ( )

privateslot

Definition at line 582 of file kis_tool_paint.cc.

{
    const qreal angle = currentPaintOpPreset()->settings()->paintOpAngle();
    currentPaintOpPreset()->settings()->setPaintOpAngle(angle - 1);
    requestUpdateOutline(m_outlineDocPoint, 0);
}

References KisTool::currentPaintOpPreset(), m_outlineDocPoint, and requestUpdateOutline().

◆ rotateBrushTipCounterClockwise

void KisToolPaint::rotateBrushTipCounterClockwise ( )

privateslot

Definition at line 589 of file kis_tool_paint.cc.

{
    const qreal angle = currentPaintOpPreset()->settings()->paintOpAngle();
    currentPaintOpPreset()->settings()->setPaintOpAngle(angle + 15);
    requestUpdateOutline(m_outlineDocPoint, 0);
}

References KisTool::currentPaintOpPreset(), m_outlineDocPoint, and requestUpdateOutline().

◆ rotateBrushTipCounterClockwisePrecise

void KisToolPaint::rotateBrushTipCounterClockwisePrecise ( )

privateslot

Definition at line 596 of file kis_tool_paint.cc.

{
    const qreal angle = currentPaintOpPreset()->settings()->paintOpAngle();
    currentPaintOpPreset()->settings()->setPaintOpAngle(angle + 1);
    requestUpdateOutline(m_outlineDocPoint, 0);
}

References KisTool::currentPaintOpPreset(), m_outlineDocPoint, and requestUpdateOutline().

◆ setMode()

void KisToolPaint::setMode ( ToolMode mode )

overrideprotectedvirtual

Reimplemented from KisTool.

Definition at line 285 of file kis_tool_paint.cc.

{
    if(this->mode() == KisTool::PAINT_MODE &&
            mode != KisTool::PAINT_MODE) {
 
        // Let's add history information about recently used colors
        Q_EMIT sigPaintingFinished();
    }
 
    KisTool::setMode(mode);
}

References KisTool::mode(), KisTool::PAINT_MODE, KisTool::setMode(), and sigPaintingFinished().

◆ setOutlineEnabled()

void KisToolPaint::setOutlineEnabled ( bool enabled )

protected

Definition at line 519 of file kis_tool_paint.cc.

{
    m_isOutlineEnabled = enabled;
    requestUpdateOutline(m_outlineDocPoint, lastDeliveredPointerEvent());
}

References KoToolBase::lastDeliveredPointerEvent(), m_isOutlineEnabled, m_outlineDocPoint, and requestUpdateOutline().

◆ setOutlineVisible()

void KisToolPaint::setOutlineVisible ( bool visible )

protected

Definition at line 530 of file kis_tool_paint.cc.

{
    m_isOutlineVisible = visible;
    requestUpdateOutline(m_outlineDocPoint, lastDeliveredPointerEvent());
}

References KoToolBase::lastDeliveredPointerEvent(), m_isOutlineVisible, m_outlineDocPoint, and requestUpdateOutline().

◆ setSupportOutline()

void KisToolPaint::setSupportOutline ( bool supportOutline )

inlineprotected

If the paint tool support outline like brushes, set to true. If not (e.g. gradient tool), set to false. Default is false.

Definition at line 72 of file kis_tool_paint.h.

                                                {
        m_supportOutline = supportOutline;
    }

◆ showBrushSize

void KisToolPaint::showBrushSize ( )

privateslot

Definition at line 567 of file kis_tool_paint.cc.

{
     KisCanvas2 *kisCanvas =dynamic_cast<KisCanvas2*>(canvas());
     KIS_SAFE_ASSERT_RECOVER_RETURN(kisCanvas);
     kisCanvas->viewManager()->showFloatingMessage(i18n("Brush Size: %1 px", currentPaintOpPreset()->settings()->paintOpSize())
                                                   , QIcon(), 1000, KisFloatingMessage::High,  Qt::AlignLeft | Qt::TextWordWrap | Qt::AlignVCenter);
}

References Private::canvas, KisTool::currentPaintOpPreset(), KisFloatingMessage::High, KIS_SAFE_ASSERT_RECOVER_RETURN, KisViewManager::showFloatingMessage(), and KisCanvas2::viewManager().

◆ showControl()

void KisToolPaint::showControl	(	QWidget *	control,
		bool	value )

protected

Definition at line 458 of file kis_tool_paint.cc.

{
    control->setVisible(value);
    QWidget *label = findLabelWidget(m_optionsWidgetLayout, control);
    if (label) {
        label->setVisible(value);
    }
}

References findLabelWidget(), m_optionsWidgetLayout, and value().

◆ sigPaintingFinished

void KisToolPaint::sigPaintingFinished ( )

signal

◆ slotColorPickerRequestedCursor

void KisToolPaint::slotColorPickerRequestedCursor ( const QCursor & cursor )

privateslot

Definition at line 213 of file kis_tool_paint.cc.

{
    useCursor(cursor);
}

References KisTool::cursor, and KoToolBase::useCursor().

◆ slotColorPickerRequestedCursorReset

void KisToolPaint::slotColorPickerRequestedCursorReset ( )

privateslot

Definition at line 218 of file kis_tool_paint.cc.

{
    resetCursorStyle();
}

References KisTool::resetCursorStyle().

◆ slotColorPickerRequestedOutlineUpdate

void KisToolPaint::slotColorPickerRequestedOutlineUpdate ( )

privateslot

Definition at line 223 of file kis_tool_paint.cc.

{
    requestUpdateOutline(m_outlineDocPoint, 0);
}

References m_outlineDocPoint, and requestUpdateOutline().

◆ slotPopupQuickHelp

void KisToolPaint::slotPopupQuickHelp ( )

privateslot

Definition at line 497 of file kis_tool_paint.cc.

{
    QWhatsThis::showText(QCursor::pos(), quickHelp());
}

References quickHelp().

◆ tryFixBrushOutline()

KisOptimizedBrushOutline KisToolPaint::tryFixBrushOutline ( const KisOptimizedBrushOutline & originalOutline )

private

If the brush outline is bigger than the canvas itself (which would make it invisible for a user in most of the cases) just add a cross in the center of it

Definition at line 228 of file kis_tool_paint.cc.

{
    KisConfig cfg(true);
 
    bool useSeparateEraserCursor = cfg.separateEraserCursor() && isEraser();
 
    const OutlineStyle currentOutlineStyle = !useSeparateEraserCursor ? cfg.newOutlineStyle() : cfg.eraserOutlineStyle();
    if (currentOutlineStyle == OUTLINE_NONE) return originalOutline;
 
    const qreal minThresholdSize = cfg.outlineSizeMinimum();
 
    QSize widgetSize = canvas()->canvasWidget()->size();
    const int maxThresholdSum = widgetSize.width() + widgetSize.height();
 
    KisOptimizedBrushOutline outline = originalOutline;
    QRectF boundingRect = outline.boundingRect();
    const qreal sum = boundingRect.width() + boundingRect.height();
 
    QPointF center = boundingRect.center();
 
    if (sum > maxThresholdSum) {
        const int hairOffset = 7;
 
        QPainterPath crossIcon;
 
        crossIcon.moveTo(center.x(), center.y() - hairOffset);
        crossIcon.lineTo(center.x(), center.y() + hairOffset);
 
        crossIcon.moveTo(center.x() - hairOffset, center.y());
        crossIcon.lineTo(center.x() + hairOffset, center.y());
 
        outline.addPath(crossIcon);
 
    } else if (sum < minThresholdSize && !outline.isEmpty()) {
        outline = QPainterPath();
        outline.addEllipse(center, 0.5 * minThresholdSize, 0.5 * minThresholdSize);
    }
 
    return outline;
}

References KisOptimizedBrushOutline::addEllipse(), KisOptimizedBrushOutline::addPath(), KisOptimizedBrushOutline::boundingRect(), Private::canvas, KisCanvas2::canvasWidget, KisConfig::eraserOutlineStyle(), KisOptimizedBrushOutline::isEmpty(), isEraser(), KisConfig::newOutlineStyle(), OUTLINE_NONE, KisConfig::outlineSizeMinimum(), and KisConfig::separateEraserCursor().

◆ tryRestoreOpacitySnapshot()

void KisToolPaint::tryRestoreOpacitySnapshot ( )

private

Here is a weird heuristics on when to restore brush opacity and when not. Basically, we should restore opacity to its saved if the brush preset hasn't changed too much, that is, its version is the same and it hasn't been reset into a clean state since then. The latter condition is checked in a fuzzy manner by just mangling the isDirty state before and after.

Definition at line 146 of file kis_tool_paint.cc.

{
    KisCanvasResourceProvider *provider = qobject_cast<KisCanvas2*>(canvas())->viewManager()->canvasResourceProvider();
 
    KisPaintOpPresetSP newPreset = provider->currentPreset();
 
    if (newPreset) {
        m_oldPreset = newPreset;
        m_oldPresetIsDirty = newPreset->isDirty();
        m_oldPresetVersion = newPreset->version();
    }
}

References Private::canvas, KisCanvasResourceProvider::currentPreset(), m_oldPreset, m_oldPresetIsDirty, and m_oldPresetVersion.

Member Data Documentation

◆ m_colorSamplerHelper

KisAsyncColorSamplerHelper KisToolPaint::m_colorSamplerHelper

private

Definition at line 156 of file kis_tool_paint.h.

◆ m_currentOutline

KisOptimizedBrushOutline KisToolPaint::m_currentOutline

protected

Definition at line 130 of file kis_tool_paint.h.

◆ m_d

QScopedPointer<Private> KisToolPaint::m_d

private

Definition at line 161 of file kis_tool_paint.h.

◆ m_isOutlineEnabled

bool KisToolPaint::m_isOutlineEnabled

private

Used as a switch for sampleColor

Definition at line 148 of file kis_tool_paint.h.

◆ m_isOutlineVisible

bool KisToolPaint::m_isOutlineVisible

private

Definition at line 149 of file kis_tool_paint.h.

◆ m_oldColorPreviewUpdateRect

QRectF KisToolPaint::m_oldColorPreviewUpdateRect

protected

Definition at line 132 of file kis_tool_paint.h.

◆ m_oldOpacity

qreal KisToolPaint::m_oldOpacity {1.0}

private

Definition at line 153 of file kis_tool_paint.h.

153{1.0};

◆ m_oldOutlineRect

QRectF KisToolPaint::m_oldOutlineRect

protected

Definition at line 131 of file kis_tool_paint.h.

◆ m_oldPreset

KisPaintOpPresetSP KisToolPaint::m_oldPreset

private

Definition at line 152 of file kis_tool_paint.h.

◆ m_oldPresetIsDirty

bool KisToolPaint::m_oldPresetIsDirty {false}

private

Definition at line 154 of file kis_tool_paint.h.

154{false};

◆ m_oldPresetVersion

int KisToolPaint::m_oldPresetVersion {-1}

private

Definition at line 155 of file kis_tool_paint.h.

155{-1};

◆ m_optionsWidgetLayout

QGridLayout* KisToolPaint::m_optionsWidgetLayout {nullptr}

private

Definition at line 140 of file kis_tool_paint.h.

140{nullptr};

◆ m_outlineDocPoint

QPointF KisToolPaint::m_outlineDocPoint

protected

Definition at line 129 of file kis_tool_paint.h.

◆ m_paintOutline

bool KisToolPaint::m_paintOutline {false}

protected

Definition at line 128 of file kis_tool_paint.h.

128{false};

◆ m_specialHoverModifier

bool KisToolPaint::m_specialHoverModifier {false}

private

Definition at line 139 of file kis_tool_paint.h.

139{false};

◆ m_standardBrushSizes

std::vector<int> KisToolPaint::m_standardBrushSizes

private

Definition at line 150 of file kis_tool_paint.h.

◆ m_supportOutline

bool KisToolPaint::m_supportOutline {false}

private

Definition at line 142 of file kis_tool_paint.h.

142{false};

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

libs/ui/tool/kis_tool_paint.h
libs/ui/tool/kis_tool_paint.cc

Classes

Public Slots

Signals

Public Member Functions

Protected Member Functions

Protected Attributes

Private Slots

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ KisToolPaint()

◆ ~KisToolPaint()

Member Function Documentation

◆ activate

◆ activateAlternateAction()

◆ activatePrimaryAction()

◆ addOptionWidgetLayout()

◆ addOptionWidgetOption()

◆ beginAlternateAction()

◆ canvasResourceChanged()

◆ continueAlternateAction()

◆ createOptionWidget()

◆ deactivate

◆ deactivateAlternateAction()

◆ deactivatePrimaryAction()

◆ decreaseBrushSize

◆ enableControl()

◆ endAlternateAction()

◆ flags()

◆ getOutlinePath()

◆ increaseBrushSize

◆ isEraser()

◆ isOutlineEnabled()

◆ isOutlineVisible()

◆ isSamplingAction()

◆ mouseMoveEvent()

◆ mousePressEvent()

◆ mouseReleaseEvent()

◆ paint()

◆ popupWidget()

◆ quickHelp()

◆ requestUpdateOutline()

◆ rotateBrushTipClockwise

◆ rotateBrushTipClockwisePrecise

◆ rotateBrushTipCounterClockwise

◆ rotateBrushTipCounterClockwisePrecise

◆ setMode()

◆ setOutlineEnabled()

◆ setOutlineVisible()

◆ setSupportOutline()

◆ showBrushSize

◆ showControl()

◆ sigPaintingFinished

◆ slotColorPickerRequestedCursor

◆ slotColorPickerRequestedCursorReset

◆ slotColorPickerRequestedOutlineUpdate

◆ slotPopupQuickHelp

◆ tryFixBrushOutline()

◆ tryRestoreOpacitySnapshot()

Member Data Documentation

◆ m_colorSamplerHelper

◆ m_currentOutline

◆ m_d

◆ m_isOutlineEnabled

◆ m_isOutlineVisible

◆ m_oldColorPreviewUpdateRect

◆ m_oldOpacity

◆ m_oldOutlineRect

◆ m_oldPreset

◆ m_oldPresetIsDirty

◆ m_oldPresetVersion

◆ m_optionsWidgetLayout

◆ m_outlineDocPoint

◆ m_paintOutline

◆ m_specialHoverModifier

◆ m_standardBrushSizes

◆ m_supportOutline