#include <kis_tool_line.h>

Inheritance diagram for KisToolLine:

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

void	beginPrimaryAction (KoPointerEvent *event) override

void	continuePrimaryAction (KoPointerEvent *event) override

void	deactivate () override

void	endPrimaryAction (KoPointerEvent *event) override

	KisToolLine (KoCanvasBase *canvas)

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

bool	primaryActionSupportsHiResEvents () const override

QString	quickHelp () const override

void	requestStrokeCancellation () override

void	requestStrokeEnd () override

bool	supportsPaintingAssistants () const override

	~KisToolLine () override

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

	KisToolShape (KoCanvasBase *canvas, const QCursor &cursor)

	~KisToolShape () override

Public Member Functions inherited from KisToolPaint
	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

virtual bool	wantsAutoScroll () const

	~KoToolBase () override

Protected Slots
void	resetCursorStyle () override

Protected Slots inherited from KisTool
virtual void	resetCursorStyle ()

Private Slots
void	setShowGuideline (bool value)

void	setShowPreview (bool value)

void	setSnapEraser (bool value)

void	setSnapToAssistants (bool value)

void	setUseSensors (bool value)

void	updateStroke ()

Private Member Functions
void	cancelStroke ()

QWidget *	createOptionWidget () override

void	endStroke ()

void	paintLine (QPainter &gc, const QRect &rc)

void	showSize ()

QPointF	snapToAssistants (QPointF point)

QPointF	straightLine (QPointF point)

void	updateGuideline ()

void	updatePreviewTimer (bool showGuide)

Private Attributes
KConfigGroup	configGroup

QCheckBox *	m_chkShowGuideline {nullptr}

QCheckBox *	m_chkShowPreview {nullptr}

QCheckBox *	m_chkSnapEraser {nullptr}

QCheckBox *	m_chkSnapToAssistants {nullptr}

QCheckBox *	m_chkUseSensors {nullptr}

QPointF	m_endPoint

QScopedPointer< KisToolLineHelper >	m_helper

QScopedPointer< KisPaintingInformationBuilder >	m_infoBuilder

QPointF	m_lastUpdatedPoint

KisSignalCompressor	m_longStrokeUpdateCompressor

QPointF	m_originalStartPoint

bool	m_showGuideline {true}

QPointF	m_startPoint

bool	m_strokeIsRunning {false}

KisSignalCompressor	m_strokeUpdateCompressor

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 KisToolShape
void	activate (const QSet< KoShape * > &shapes) override

virtual void	fillSettingChanged (int value)

virtual void	outlineSettingChanged (int value)

virtual void	patternRotationSettingChanged (qreal value)

virtual void	patternScaleSettingChanged (qreal value)

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	documentResourceChanged (int key, const QVariant &res)

virtual void	repaintDecorations ()

virtual void	requestRedoDuringStroke ()

virtual void	requestUndoDuringStroke ()

void	setStatusText (const QString &statusText)

void	updateOptionsWidgetIcons ()

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 KisToolShape
WdgGeometryOptions *	m_shapeOptionsWidget

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 Member Functions inherited from KisToolShape
void	addPathShape (KoPathShape *pathShape, const KUndo2MagicString &name)

void	addShape (KoShape *shape)

virtual void	beginShape ()

QWidget *	createOptionWidget () override

qreal	currentStrokeWidth () const

virtual void	endShape ()

KisToolShapeUtils::FillStyle	fillStyle ()

QTransform	fillTransform ()

ShapeAddInfo	shouldAddShape (KisNodeSP currentNode) const

KisToolShapeUtils::StrokeStyle	strokeStyle ()

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

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 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 inherited from KisToolShape
KConfigGroup	m_configGroup

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 KisTool
bool	isActive

Detailed Description

Definition at line 34 of file kis_tool_line.h.

Constructor & Destructor Documentation

◆ KisToolLine()

KisToolLine::KisToolLine ( KoCanvasBase * canvas )

Definition at line 46 of file kis_tool_line.cc.

    : KisToolShape(canvas, KisCursor::load("tool_line_cursor.png", 6, 6)),
      m_showGuideline(true),
      m_strokeIsRunning(false),
      m_infoBuilder(new KisConverterPaintingInformationBuilder(getCoordinatesConverter(canvas))),
      m_helper(new KisToolLineHelper(m_infoBuilder.data(),
                                     canvas->resourceManager(),
                                     kundo2_i18n("Draw Line"))),
      m_strokeUpdateCompressor(200, KisSignalCompressor::POSTPONE),
      m_longStrokeUpdateCompressor(750, KisSignalCompressor::FIRST_INACTIVE)
{
    setObjectName("tool_line");
 
    setSupportOutline(true);
 
    setIsOpacityPresetMode(true);
 
    connect(&m_strokeUpdateCompressor, SIGNAL(timeout()), SLOT(updateStroke()));
    connect(&m_longStrokeUpdateCompressor, SIGNAL(timeout()), SLOT(updateStroke()));
 
    KisCanvas2 *kritaCanvas = dynamic_cast<KisCanvas2*>(canvas);
 
    connect(kritaCanvas->viewManager()->canvasResourceProvider(), SIGNAL(sigEffectiveCompositeOpChanged()), SLOT(resetCursorStyle()));
}

References Private::canvas, KisViewManager::canvasResourceProvider(), connect(), m_longStrokeUpdateCompressor, m_strokeUpdateCompressor, resetCursorStyle(), KoToolBase::setIsOpacityPresetMode(), KisToolPaint::setSupportOutline(), updateStroke(), and KisCanvas2::viewManager().

◆ ~KisToolLine()

KisToolLine::~KisToolLine ( )

override

Definition at line 71 of file kis_tool_line.cc.

72{

73}

Member Function Documentation

◆ activate()

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

overridevirtual

This method is called when this tool instance is activated. For any main window there is only one tool active at a time, which then gets all user input. Switching between tools will call deactivate on one and activate on the new tool allowing the tool to flush items (like a selection) when it is not in use.

Parameters

shapes the set of shapes that are selected or suggested for editing by a selected shape for the tool to work on. Not all shapes will be meant for this tool.

See also: deactivate()

Reimplemented from KoToolBase.

Definition at line 86 of file kis_tool_line.cc.

{
   KisToolPaint::activate(shapes);
   configGroup =  KSharedConfig::openConfig()->group(toolId());
}

References KisToolPaint::activate(), configGroup, and KoToolBase::toolId().

◆ beginPrimaryAction()

void KisToolLine::beginPrimaryAction ( KoPointerEvent * event )

overridevirtual

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

Reimplemented from KisTool.

Definition at line 202 of file kis_tool_line.cc.

{
    NodePaintAbility nodeAbility = nodePaintAbility();
    if (nodeAbility == UNPAINTABLE || !nodeEditable()) {
        event->ignore();
        return;
    }
 
    if (nodeAbility == MYPAINTBRUSH_UNPAINTABLE) {
        KisCanvas2 * kiscanvas = static_cast<KisCanvas2*>(canvas());
        QString message = i18n("The MyPaint Brush Engine is not available for this colorspace");
        kiscanvas->viewManager()->showFloatingMessage(message, koIcon("object-locked"));
        event->ignore();
        return;
    }
 
    setMode(KisTool::PAINT_MODE);
 
    const KisToolShape::ShapeAddInfo info =
        shouldAddShape(currentNode());
 
    // Always show guideline on vector layers
    m_showGuideline = m_chkShowGuideline->isChecked() || nodeAbility != PAINT;
    updatePreviewTimer(m_showGuideline);
    m_helper->setEnabled((nodeAbility == PAINT && !info.shouldAddShape) || info.shouldAddSelectionShape);
    m_helper->setUseSensors(m_chkUseSensors->isChecked());
    m_helper->start(event, canvas()->resourceManager());
 
    m_startPoint = convertToPixelCoordAndSnap(event);
    m_endPoint = m_startPoint;
    m_lastUpdatedPoint = m_startPoint;
    m_originalStartPoint = m_startPoint;
 
    m_strokeIsRunning = true;
 
    showSize();
}

References Private::canvas, KisTool::convertToPixelCoordAndSnap(), KisTool::currentNode(), koIcon, m_chkShowGuideline, m_chkUseSensors, m_endPoint, m_helper, m_lastUpdatedPoint, m_originalStartPoint, m_showGuideline, m_startPoint, m_strokeIsRunning, KisTool::MYPAINTBRUSH_UNPAINTABLE, KisTool::nodeEditable(), KisTool::nodePaintAbility(), KisTool::PAINT, KisTool::PAINT_MODE, KisToolPaint::setMode(), KisToolShape::ShapeAddInfo::shouldAddSelectionShape, KisToolShape::ShapeAddInfo::shouldAddShape, KisToolShape::shouldAddShape(), KisViewManager::showFloatingMessage(), showSize(), KisTool::UNPAINTABLE, updatePreviewTimer(), and KisCanvas2::viewManager().

◆ cancelStroke()

void KisToolLine::cancelStroke ( )

private

The actual stroke is run by the timer so it is a legal situation when m_strokeIsRunning is true, but the actual redraw stroke is not running.

Definition at line 366 of file kis_tool_line.cc.

{
    if (!m_strokeIsRunning) return;
    if (m_startPoint == m_endPoint) return;
 
    if (m_helper->isRunning()) {
        m_helper->cancel();
    }
 
    m_strokeIsRunning = false;
    m_endPoint = m_startPoint;
}

References m_endPoint, m_helper, m_startPoint, and m_strokeIsRunning.

◆ continuePrimaryAction()

void KisToolLine::continuePrimaryAction ( KoPointerEvent * event )

overridevirtual

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

Reimplemented from KisTool.

Definition at line 249 of file kis_tool_line.cc.

{
    CHECK_MODE_SANITY_OR_RETURN(KisTool::PAINT_MODE);
    if (!m_strokeIsRunning) return;
 
    // First ensure the old guideline is deleted
    updateGuideline();
 
    QPointF pos = convertToPixelCoordAndSnap(event);
 
    if (event->modifiers() == Qt::AltModifier) {
        QPointF trans = pos - m_endPoint;
        m_helper->translatePoints(trans);
        m_startPoint += trans;
        m_endPoint += trans;
        m_originalStartPoint += trans; // original start point is only original in terms of snapping to assistants
    } else if (event->modifiers() == Qt::ShiftModifier) {
        pos = straightLine(pos);
        m_helper->addPoint(event, pos);
    } else {
        pos = snapToAssistants(pos);
        m_helper->addPoint(event, pos);
        m_helper->movePointsTo(m_startPoint, pos);
    }
    m_endPoint = pos;
 
    // Draw preview if requested
    if (m_chkShowPreview->isChecked()) {
        // If the cursor has moved a significant amount, immediately clear the
        // current preview and redraw. Otherwise, do slow redraws periodically.
        auto updateDistance = (pixelToView(m_lastUpdatedPoint) - pixelToView(pos)).manhattanLength();
        if (updateDistance > 10) {
            m_helper->clearPaint();
            m_longStrokeUpdateCompressor.stop();
            m_strokeUpdateCompressor.start();
            m_lastUpdatedPoint = pos;
        } else if (updateDistance > 1 &&  !m_strokeUpdateCompressor.isActive() && !m_longStrokeUpdateCompressor.isActive()) {
            m_longStrokeUpdateCompressor.start();
            m_lastUpdatedPoint = pos;
        }
    }
 
    if(event->modifiers() == Qt::AltModifier) {
        KisCanvas2 *kisCanvas =dynamic_cast<KisCanvas2*>(canvas());
        KIS_ASSERT(kisCanvas);
        kisCanvas->viewManager()->showFloatingMessage(i18n("X: %1 px\nY: %2 px", QString::number(m_startPoint.x(), 'f',1)
                                                           , QString::number(m_startPoint.y(), 'f',1))
                                                           , QIcon(), 1000, KisFloatingMessage::High,  Qt::AlignLeft | Qt::TextWordWrap | Qt::AlignVCenter);
    }
    else {
        showSize();
    }
 
    updateGuideline();
    KisToolPaint::requestUpdateOutline(event->point, event);
}

References Private::canvas, CHECK_MODE_SANITY_OR_RETURN, KisTool::convertToPixelCoordAndSnap(), KisFloatingMessage::High, KisSignalCompressor::isActive(), KIS_ASSERT, m_chkShowPreview, m_endPoint, m_helper, m_lastUpdatedPoint, m_longStrokeUpdateCompressor, m_originalStartPoint, m_startPoint, m_strokeIsRunning, m_strokeUpdateCompressor, KoPointerEvent::modifiers(), KisTool::PAINT_MODE, KisTool::pixelToView(), KoPointerEvent::point, KisToolPaint::requestUpdateOutline(), KisViewManager::showFloatingMessage(), showSize(), snapToAssistants(), KisSignalCompressor::start(), KisSignalCompressor::stop(), straightLine(), updateGuideline(), and KisCanvas2::viewManager().

◆ createOptionWidget()

QWidget * KisToolLine::createOptionWidget ( )

overrideprivatevirtual

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

Reimplemented from KisTool.

Definition at line 98 of file kis_tool_line.cc.

{
    QWidget* widget = KisToolPaint::createOptionWidget();
 
    m_chkUseSensors = new QCheckBox(i18n("Use sensors"));
    addOptionWidgetOption(m_chkUseSensors);
 
    m_chkShowPreview = new QCheckBox(i18n("Show Preview"));
    addOptionWidgetOption(m_chkShowPreview);
 
    m_chkShowGuideline = new QCheckBox(i18n("Show Guideline"));
    addOptionWidgetOption(m_chkShowGuideline);
 
    m_chkSnapToAssistants = new QCheckBox(i18n("Snap to Assistants"));
    addOptionWidgetOption(m_chkSnapToAssistants);
 
    m_chkSnapEraser = new QCheckBox(i18n("Snap Eraser"));
    addOptionWidgetOption(m_chkSnapEraser);
 
 
 
 
    // hook up connections for value changing
    connect(m_chkUseSensors, SIGNAL(clicked(bool)), this, SLOT(setUseSensors(bool)) );
    connect(m_chkShowPreview, SIGNAL(clicked(bool)), this, SLOT(setShowPreview(bool)) );
    connect(m_chkShowGuideline, SIGNAL(clicked(bool)), this, SLOT(setShowGuideline(bool)) );
    connect(m_chkSnapToAssistants, SIGNAL(clicked(bool)), this, SLOT(setSnapToAssistants(bool)) );
 
 
    // read values in from configuration
    m_chkUseSensors->setChecked(configGroup.readEntry("useSensors", true));
    m_chkShowPreview->setChecked(configGroup.readEntry("showPreview", true));
    m_chkShowGuideline->setChecked(configGroup.readEntry("showGuideline", true));
    m_chkSnapToAssistants->setChecked(configGroup.readEntry("snapToAssistants", false));
    m_chkSnapEraser->setChecked(configGroup.readEntry("snapEraser", false));
    if (!m_chkSnapToAssistants->isChecked()) {
        m_chkSnapEraser->setEnabled(false);
    }
 
    return widget;
}

References KisToolPaint::addOptionWidgetOption(), configGroup, connect(), KisToolPaint::createOptionWidget(), m_chkShowGuideline, m_chkShowPreview, m_chkSnapEraser, m_chkSnapToAssistants, m_chkUseSensors, setShowGuideline(), setShowPreview(), setSnapToAssistants(), and setUseSensors().

◆ deactivate()

void KisToolLine::deactivate ( )

overridevirtual

This method is called whenever this tool is no longer the active tool

See also: activate()

Reimplemented from KoToolBase.

Definition at line 92 of file kis_tool_line.cc.

{
    KisToolPaint::deactivate();
    cancelStroke();
}

References cancelStroke(), and KisToolPaint::deactivate().

◆ endPrimaryAction()

void KisToolLine::endPrimaryAction ( KoPointerEvent * event )

overridevirtual

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

Reimplemented from KisTool.

Definition at line 306 of file kis_tool_line.cc.

{
    Q_UNUSED(event);
    CHECK_MODE_SANITY_OR_RETURN(KisTool::PAINT_MODE);
    setMode(KisTool::HOVER_MODE);
 
    updateGuideline();
    endStroke();
 
    if (static_cast<KisCanvas2*>(canvas())->paintingAssistantsDecoration()) {
        static_cast<KisCanvas2*>(canvas())->paintingAssistantsDecoration()->endStroke();
    }
}

References Private::canvas, CHECK_MODE_SANITY_OR_RETURN, endStroke(), KisTool::HOVER_MODE, KisTool::PAINT_MODE, KisToolPaint::setMode(), and updateGuideline().

◆ endStroke()

void KisToolLine::endStroke ( )

private

Definition at line 326 of file kis_tool_line.cc.

{
    NodePaintAbility nodeAbility = nodePaintAbility();
 
    if (!m_strokeIsRunning || m_startPoint == m_endPoint || nodeAbility == UNPAINTABLE) {
        m_helper->clearPoints();
        return;
    }
 
    const KisToolShape::ShapeAddInfo info =
        shouldAddShape(currentNode());
 
    if ((nodeAbility == PAINT && !info.shouldAddShape) || info.shouldAddSelectionShape) {
        updateStroke();
        m_helper->end();
    }
    else {
        KisResourcesSnapshot resources(image(),
                                       currentNode(),
                                       canvas()->resourceManager());
        KoPathShape* path = new KoPathShape();
        path->setShapeId(KoPathShapeId);
 
        QTransform resolutionMatrix;
        resolutionMatrix.scale(1 / currentImage()->xRes(), 1 / currentImage()->yRes());
        path->moveTo(resolutionMatrix.map(m_startPoint));
        path->lineTo(resolutionMatrix.map(m_endPoint));
        path->normalize();
 
        KoShapeStrokeSP border(new KoShapeStroke(currentStrokeWidth(), resources.currentFgColor().toQColor()));
        path->setStroke(border);
 
        KUndo2Command * cmd = canvas()->shapeController()->addShape(path, nullptr);
        canvas()->addCommand(cmd);
    }
 
    m_strokeIsRunning = false;
    m_endPoint = m_startPoint;
}

References KisCanvas2::addCommand(), Private::canvas, KisResourcesSnapshot::currentFgColor(), KisTool::currentImage(), KisTool::currentNode(), KisToolShape::currentStrokeWidth(), KisTool::image(), KoPathShapeId, m_endPoint, m_helper, m_startPoint, m_strokeIsRunning, KisTool::nodePaintAbility(), KisTool::PAINT, KoCanvasBase::shapeController, KisToolShape::ShapeAddInfo::shouldAddSelectionShape, KisToolShape::ShapeAddInfo::shouldAddShape, KisToolShape::shouldAddShape(), KoColor::toQColor(), KisTool::UNPAINTABLE, and updateStroke().

◆ paint()

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

overridevirtual

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 192 of file kis_tool_line.cc.

{
    Q_UNUSED(converter);
 
    if(mode() == KisTool::PAINT_MODE) {
        paintLine(gc,QRect());
    }
    KisToolPaint::paint(gc,converter);
}

References KisTool::mode(), KisToolPaint::paint(), KisTool::PAINT_MODE, and paintLine().

◆ paintLine()

void KisToolLine::paintLine	(	QPainter &	gc,
		const QRect &	rc )

private

Definition at line 449 of file kis_tool_line.cc.

{
    QPointF viewStartPos = pixelToView(m_startPoint);
    QPointF viewStartEnd = pixelToView(m_endPoint);
 
    if (m_showGuideline && canvas()) {
        QPainterPath path;
        path.moveTo(viewStartPos);
        path.lineTo(viewStartEnd);
        paintToolOutline(&gc, path);
    }
}

References Private::canvas, m_endPoint, m_showGuideline, m_startPoint, KisTool::paintToolOutline(), and KisTool::pixelToView().

◆ primaryActionSupportsHiResEvents()

bool KisToolLine::primaryActionSupportsHiResEvents ( ) const

overridevirtual

Returns true if the tool can handle (and wants to handle) a very tight flow of input events from the tablet

Reimplemented from KisTool.

Definition at line 320 of file kis_tool_line.cc.

{
    return true;
}

◆ quickHelp()

QString KisToolLine::quickHelp ( ) const

overridevirtual

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

Reimplemented from KisToolPaint.

Definition at line 462 of file kis_tool_line.cc.

{
    return i18n("Alt+Drag will move the origin of the currently displayed line around, Shift+Drag will force you to draw straight lines");
}

◆ requestStrokeCancellation()

void KisToolLine::requestStrokeCancellation ( )

overridevirtual

Called when the user requested the cancellation of the current stroke. If you tool supports cancelling, override this method and do the needed work there

Reimplemented from KoToolBase.

Definition at line 167 of file kis_tool_line.cc.

{
    cancelStroke();
}

References cancelStroke().

◆ requestStrokeEnd()

void KisToolLine::requestStrokeEnd ( )

overridevirtual

Called when the image decided that the stroke should better be ended. If you tool supports long strokes, override this method and do the needed work there

Reimplemented from KoToolBase.

Definition at line 172 of file kis_tool_line.cc.

{
    // Terminate any in-progress strokes
    if (nodePaintAbility() == PAINT && m_helper->isRunning()) {
        endStroke();
    }
}

References endStroke(), m_helper, KisTool::nodePaintAbility(), and KisTool::PAINT.

◆ resetCursorStyle

void KisToolLine::resetCursorStyle ( )

overrideprotectedslot

Definition at line 75 of file kis_tool_line.cc.

{
    if (isEraser() && (nodePaintAbility() == PAINT)) {
        useCursor(KisCursor::load("tool_line_eraser_cursor.png", 6, 6));
    } else {
        KisToolPaint::resetCursorStyle();
    }
 
    overrideCursorIfNotEditable();
}

References KisToolPaint::isEraser(), KisCursor::load(), KisTool::nodePaintAbility(), KisTool::overrideCursorIfNotEditable(), KisTool::PAINT, KisTool::resetCursorStyle(), and KoToolBase::useCursor().

◆ setShowGuideline

void KisToolLine::setShowGuideline ( bool value )

privateslot

Definition at line 145 of file kis_tool_line.cc.

{
    m_showGuideline = value;
    configGroup.writeEntry("showGuideline", value);
}

References configGroup, m_showGuideline, and value().

◆ setShowPreview

void KisToolLine::setShowPreview ( bool value )

privateslot

Definition at line 151 of file kis_tool_line.cc.

{
    configGroup.writeEntry("showPreview", value);
}

References configGroup, and value().

◆ setSnapEraser

void KisToolLine::setSnapEraser ( bool value )

privateslot

Definition at line 162 of file kis_tool_line.cc.

{
    configGroup.writeEntry("snapEraser", value);
}

References configGroup, and value().

◆ setSnapToAssistants

void KisToolLine::setSnapToAssistants ( bool value )

privateslot

Definition at line 156 of file kis_tool_line.cc.

{
    configGroup.writeEntry("snapToAssistants", value);
    m_chkSnapEraser->setEnabled(value);
}

References configGroup, m_chkSnapEraser, and value().

◆ setUseSensors

void KisToolLine::setUseSensors ( bool value )

privateslot

Definition at line 140 of file kis_tool_line.cc.

{
    configGroup.writeEntry("useSensors", value);
}

References configGroup, and value().

◆ showSize()

void KisToolLine::showSize ( )

private

Definition at line 442 of file kis_tool_line.cc.

{
    KisCanvas2 *kisCanvas =dynamic_cast<KisCanvas2*>(canvas());
    KIS_ASSERT(kisCanvas);
    kisCanvas->viewManager()->showFloatingMessage(i18n("Length: %1 px", QString::number(QLineF(m_startPoint,m_endPoint).length(), 'f',1))
                                                        , QIcon(), 1000, KisFloatingMessage::High,  Qt::AlignLeft | Qt::TextWordWrap | Qt::AlignVCenter);
}

References Private::canvas, KisFloatingMessage::High, KIS_ASSERT, length(), m_endPoint, m_startPoint, KisViewManager::showFloatingMessage(), and KisCanvas2::viewManager().

◆ snapToAssistants()

QPointF KisToolLine::snapToAssistants ( QPointF point )

private

Definition at line 407 of file kis_tool_line.cc.

{
    if (m_chkSnapToAssistants->isChecked() && static_cast<KisCanvas2*>(canvas())->paintingAssistantsDecoration()) {
        KisCanvas2* c = static_cast<KisCanvas2*>(canvas());
        c->paintingAssistantsDecoration()->setOnlyOneAssistantSnap(true);
        c->paintingAssistantsDecoration()->setEraserSnap(m_chkSnapEraser->isChecked());
        QPointF startPoint = m_originalStartPoint;
 
        // startPoint etc. are in image coordinates system (pixels)
        // but assistants work in document coordinates system ("points")
        QPointF startPointInDoc = getCoordinatesConverter(canvas())->imageToDocument(startPoint);
        QPointF pointInDoc = getCoordinatesConverter(canvas())->imageToDocument(point);
 
        c->paintingAssistantsDecoration()->adjustLine(pointInDoc, startPointInDoc);
        c->paintingAssistantsDecoration()->setAdjustedBrushPosition(pointInDoc);
 
        startPoint = getCoordinatesConverter(canvas())->documentToImage(startPointInDoc);
        point = getCoordinatesConverter(canvas())->documentToImage(pointInDoc);
 
        m_startPoint = startPoint;
        return point;
    }
    return point;
}

References KisPaintingAssistantsDecoration::adjustLine(), Private::canvas, KisCoordinatesConverter::documentToImage(), getCoordinatesConverter(), KisCoordinatesConverter::imageToDocument(), m_chkSnapEraser, m_chkSnapToAssistants, m_originalStartPoint, m_startPoint, KisCanvas2::paintingAssistantsDecoration(), KisPaintingAssistantsDecoration::setAdjustedBrushPosition(), KisPaintingAssistantsDecoration::setEraserSnap(), and KisPaintingAssistantsDecoration::setOnlyOneAssistantSnap().

◆ straightLine()

QPointF KisToolLine::straightLine ( QPointF point )

private

Definition at line 384 of file kis_tool_line.cc.

{
    const QPointF lineVector = point - m_startPoint;
    qreal lineAngle = std::atan2(lineVector.y(), lineVector.x());
 
    if (lineAngle < 0) {
        lineAngle += 2 * M_PI;
    }
 
    const qreal ANGLE_BETWEEN_CONSTRAINED_LINES = (2 * M_PI) / 24;
 
    const quint32 constrainedLineIndex = static_cast<quint32>((lineAngle / ANGLE_BETWEEN_CONSTRAINED_LINES) + 0.5);
    const qreal constrainedLineAngle = constrainedLineIndex * ANGLE_BETWEEN_CONSTRAINED_LINES;
 
    const qreal lineLength = std::sqrt((lineVector.x() * lineVector.x()) + (lineVector.y() * lineVector.y()));
 
    const QPointF constrainedLineVector(lineLength * std::cos(constrainedLineAngle), lineLength * std::sin(constrainedLineAngle));
 
    const QPointF result = m_startPoint + constrainedLineVector;
 
    return result;
}

References M_PI, and m_startPoint.

◆ supportsPaintingAssistants()

bool KisToolLine::supportsPaintingAssistants ( ) const

overridevirtual

Reimplemented from KisTool.

Definition at line 467 of file kis_tool_line.cc.

{
    return true;
}

◆ updateGuideline()

void KisToolLine::updateGuideline ( )

private

Definition at line 433 of file kis_tool_line.cc.

{
    if (canvas()) {
        QRectF bound(m_startPoint, m_endPoint);
        canvas()->updateCanvas(convertToPt(bound.normalized().adjusted(-3, -3, 3, 3)));
    }
}

References Private::canvas, KisTool::convertToPt(), m_endPoint, m_startPoint, and KisCanvas2::updateCanvas().

◆ updatePreviewTimer()

void KisToolLine::updatePreviewTimer ( bool showGuide )

private

Definition at line 180 of file kis_tool_line.cc.

{
    // If the user disables the guideline, we will want to try to draw some
    // preview lines even if they're slow, so set the timer to FIRST_ACTIVE.
    if (showGuideline) {
        m_strokeUpdateCompressor.setMode(KisSignalCompressor::POSTPONE);
    } else {
        m_strokeUpdateCompressor.setMode(KisSignalCompressor::FIRST_ACTIVE);
    }
}

References KisSignalCompressor::FIRST_ACTIVE, m_strokeUpdateCompressor, KisSignalCompressor::POSTPONE, and KisSignalCompressor::setMode().

◆ updateStroke

void KisToolLine::updateStroke ( )

privateslot

Definition at line 240 of file kis_tool_line.cc.

{
    if (!m_strokeIsRunning) return;
 
    m_helper->repaintLine(image(),
                          currentNode(),
                          image().data());
}

References KisTool::currentNode(), KisTool::image(), m_helper, and m_strokeIsRunning.

Member Data Documentation

◆ configGroup

KConfigGroup KisToolLine::configGroup

private

Definition at line 104 of file kis_tool_line.h.

◆ m_chkShowGuideline

QCheckBox* KisToolLine::m_chkShowGuideline {nullptr}

private

Definition at line 95 of file kis_tool_line.h.

95{nullptr};

◆ m_chkShowPreview

QCheckBox* KisToolLine::m_chkShowPreview {nullptr}

private

Definition at line 94 of file kis_tool_line.h.

94{nullptr};

◆ m_chkSnapEraser

QCheckBox* KisToolLine::m_chkSnapEraser {nullptr}

private

Definition at line 97 of file kis_tool_line.h.

97{nullptr};

◆ m_chkSnapToAssistants

QCheckBox* KisToolLine::m_chkSnapToAssistants {nullptr}

private

Definition at line 96 of file kis_tool_line.h.

96{nullptr};

◆ m_chkUseSensors

QCheckBox* KisToolLine::m_chkUseSensors {nullptr}

private

Definition at line 93 of file kis_tool_line.h.

93{nullptr};

◆ m_endPoint

QPointF KisToolLine::m_endPoint

private

Definition at line 86 of file kis_tool_line.h.

◆ m_helper

QScopedPointer<KisToolLineHelper> KisToolLine::m_helper

private

Definition at line 100 of file kis_tool_line.h.

◆ m_infoBuilder

QScopedPointer<KisPaintingInformationBuilder> KisToolLine::m_infoBuilder

private

Definition at line 99 of file kis_tool_line.h.

◆ m_lastUpdatedPoint

QPointF KisToolLine::m_lastUpdatedPoint

private

Definition at line 88 of file kis_tool_line.h.

◆ m_longStrokeUpdateCompressor

KisSignalCompressor KisToolLine::m_longStrokeUpdateCompressor

private

Definition at line 102 of file kis_tool_line.h.

◆ m_originalStartPoint

QPointF KisToolLine::m_originalStartPoint

private

Definition at line 87 of file kis_tool_line.h.

◆ m_showGuideline

bool KisToolLine::m_showGuideline {true}

private

Definition at line 83 of file kis_tool_line.h.

83{true};

◆ m_startPoint

QPointF KisToolLine::m_startPoint

private

Definition at line 85 of file kis_tool_line.h.

◆ m_strokeIsRunning

bool KisToolLine::m_strokeIsRunning {false}

private

Definition at line 90 of file kis_tool_line.h.

90{false};

◆ m_strokeUpdateCompressor

KisSignalCompressor KisToolLine::m_strokeUpdateCompressor

private

Definition at line 101 of file kis_tool_line.h.

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

plugins/tools/basictools/kis_tool_line.h
plugins/tools/basictools/kis_tool_line.cc

Public Member Functions

Protected Slots

Private Slots

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ KisToolLine()

◆ ~KisToolLine()

Member Function Documentation

◆ activate()

◆ beginPrimaryAction()

◆ cancelStroke()

◆ continuePrimaryAction()

◆ createOptionWidget()

◆ deactivate()

◆ endPrimaryAction()

◆ endStroke()

◆ paint()

◆ paintLine()

◆ primaryActionSupportsHiResEvents()

◆ quickHelp()

◆ requestStrokeCancellation()

◆ requestStrokeEnd()

◆ resetCursorStyle

◆ setShowGuideline

◆ setShowPreview

◆ setSnapEraser

◆ setSnapToAssistants

◆ setUseSensors

◆ showSize()

◆ snapToAssistants()

◆ straightLine()

◆ supportsPaintingAssistants()

◆ updateGuideline()

◆ updatePreviewTimer()

◆ updateStroke

Member Data Documentation

◆ configGroup

◆ m_chkShowGuideline

◆ m_chkShowPreview

◆ m_chkSnapEraser

◆ m_chkSnapToAssistants

◆ m_chkUseSensors

◆ m_endPoint

◆ m_helper

◆ m_infoBuilder

◆ m_lastUpdatedPoint

◆ m_longStrokeUpdateCompressor

◆ m_originalStartPoint

◆ m_showGuideline

◆ m_startPoint

◆ m_strokeIsRunning

◆ m_strokeUpdateCompressor