#include <KisToolSelectMagnetic.h>

Inheritance diagram for KisToolSelectMagnetic:

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

void	deactivate () override

void	slotCalculateEdge ()

void	slotSetAnchorGap (int)

void	slotSetFilterRadius (qreal)

void	slotSetSearchRadius (int)

void	slotSetThreshold (int)

void	undoPoints ()

Signals
void	setButtonsEnabled (bool)

Public Member Functions
void	beginPrimaryAction (KoPointerEvent *event) override

void	continuePrimaryAction (KoPointerEvent *event) override

QWidget *	createOptionWidget () override

void	endPrimaryAction (KoPointerEvent *event) override

void	keyPressEvent (QKeyEvent *event) override

void	keyReleaseEvent (QKeyEvent *event) override

	KisToolSelectMagnetic (KoCanvasBase *canvas)

void	mouseMoveEvent (KoPointerEvent *event) override

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

void	requestStrokeCancellation () override

void	requestStrokeEnd () override

void	resetCursorStyle () override

	~KisToolSelectMagnetic () override=default

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

void	activateAlternateAction (KisTool::AlternateAction action) override

SelectionAction	alternateSelectionAction () const

bool	antiAliasSelection () const

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

bool	beginMoveContentInteraction ()

bool	beginMoveSelectionInteraction ()

void	beginPrimaryAction (KoPointerEvent *event) override

bool	beginSelectInteraction ()

bool	canBeginNewAction (KoPointerEvent *event, const QPointF &pos, CursorHit hit)

void	cancelMoveSelectionStroke ()

CursorHit	checkCursorHit (const QPointF &pos, Qt::KeyboardModifiers modifiers) const

QList< int >	colorLabelsSelected () const

void	commitMoveSelectionStroke ()

void	commitMoveSelectionStrokeImpl (bool cancel)

void	continueAlternateAction (KoPointerEvent *event, KisTool::AlternateAction action) override

void	continuePrimaryAction (KoPointerEvent *event) override

QWidget *	createOptionWidget () override

void	deactivate () override

void	deactivateAlternateAction (KisTool::AlternateAction action) override

void	endAlternateAction (KoPointerEvent *event, KisTool::AlternateAction action) override

bool	endMoveContentInteraction ()

bool	endMoveSelectionInteraction ()

void	endPrimaryAction (KoPointerEvent *event) override

bool	endSelectInteraction ()

void	explicitUserStrokeEndRequest () override

int	featherSelection () const

int	growSelection () const

void	initializeStrokeAttributes (const QPointF &pos, KisStrokeStrategy *strategy, bool moved)

bool	isMovingContent () const

bool	isMovingSelection () const

bool	isSelecting () const

void	keyPressEvent (QKeyEvent *event) override

void	keyReleaseEvent (QKeyEvent *event) override

	KisToolSelectBase (KoCanvasBase *canvas, const QCursor cursor, const QString toolName)

	KisToolSelectBase (KoCanvasBase *canvas, const QString toolName)

	KisToolSelectBase (KoCanvasBase canvas, QCursor cursor, QString toolName, KoToolBase delegateTool)

KisNodeSP	locateSelectionMaskUnderCursor (const QPointF &pos, Qt::KeyboardModifiers modifiers)

void	mouseMoveEvent (KoPointerEvent *event) override

bool	moveSelectedContent () const

QMenu *	popupActionsMenu () override

KisPopupWidgetInterface *	popupWidget () override

void	requestStrokeCancellation () override

SampleLayersMode	sampleLayersMode () const

SelectionAction	selectionAction () const

bool	selectionDidMove () const

SelectionMode	selectionMode () const

KisSelectionOptions *	selectionOptionWidget ()

virtual void	setAlternateSelectionAction (SelectionAction action)

bool	stopGrowingAtDarkestPixel () const

void	updateActionShortcutToolTips ()

void	updateCursor ()

void	updateCursorDelayed ()

Protected Attributes
KisSelectionToolConfigWidgetHelper	m_widgetHelper

Protected Attributes inherited from KisToolSelectBase< BaseClass >
SelectionAction	m_selectionActionAlternate

KisSelectionToolConfigWidgetHelper	m_widgetHelper

Private Member Functions
void	calculateCheckPoints (vQPointF points)

void	checkIfAnchorIsSelected (QPointF pt)

vQPointF	computeEdgeWrapper (QPoint a, QPoint b)

void	deleteSelectedAnchor ()

void	drawAnchors (QPainter &gc)

void	finishSelectionAction ()

void	reEvaluatePoints ()

void	resetVariables ()

void	updateCanvas ()

void	updateContinuedMode ()

void	updateFeedback ()

int	updateInitialAnchorBounds (QPoint pt)

void	updatePaintPath ()

void	updateSelectedAnchor ()

Private Attributes
int	m_anchorGap {30}

QVector< QPoint >	m_anchorPoints

bool	m_complete {false}

KConfigGroup	m_configGroup

bool	m_continuedMode {false}

QPointF	m_cursorOnPress

qreal	m_filterRadius {3.0}

bool	m_finished {false}

QPoint	m_lastAnchor

QPointF	m_lastCursorPos

KisSignalCompressor	m_mouseHoverCompressor

QPainterPath	m_paintPath

QVector< vQPointF >	m_pointCollection

QVector< QPointF >	m_points

int	m_searchRadius {30}

bool	m_selected {false}

int	m_selectedAnchor {0}

QRectF	m_snapBound

int	m_threshold {70}

QScopedPointer< KisMagneticWorker >	m_worker

Additional Inherited Members
Public Types inherited from KisToolSelectBase< BaseClass >
enum	CursorHit { CursorHit_None , CursorHit_Border , CursorHit_Inside , CursorHit_Outside }

enum	SampleLayersMode { SampleAllLayers , SampleCurrentLayer , SampleColorLabeledLayers }

Protected Member Functions inherited from KisToolSelectBase< BaseClass >
virtual bool	isPixelOnly () const

virtual bool	usesColorLabels () const

Detailed Description

Definition at line 19 of file KisToolSelectMagnetic.h.

Constructor & Destructor Documentation

◆ KisToolSelectMagnetic()

KisToolSelectMagnetic::KisToolSelectMagnetic ( KoCanvasBase * canvas )

Definition at line 49 of file KisToolSelectMagnetic.cc.

    : KisToolSelect(canvas,
                    KisCursor::loadWithSize("tool_magnetic_selection_cursor.svg", 32, 32, 6, 6),
                    i18n("Magnetic Selection"))
  , m_worker(nullptr)
  , m_mouseHoverCompressor(100, KisSignalCompressor::FIRST_ACTIVE)
{ }

◆ ~KisToolSelectMagnetic()

KisToolSelectMagnetic::~KisToolSelectMagnetic ( )

overridedefault

Member Function Documentation

◆ activate

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

overrideslot

Definition at line 672 of file KisToolSelectMagnetic.cc.

{
    m_worker.reset(new KisMagneticWorker(image()->projection()));
    m_configGroup = KSharedConfig::openConfig()->group(toolId());
    connect(action("undo_polygon_selection"), SIGNAL(triggered()), SLOT(undoPoints()), Qt::UniqueConnection);
    connect(&m_mouseHoverCompressor, SIGNAL(timeout()), this, SLOT(slotCalculateEdge()));
    KisToolSelect::activate(shapes);
}

References KisToolSelectBase< BaseClass >::activate(), m_configGroup, m_mouseHoverCompressor, m_worker, slotCalculateEdge(), and undoPoints().

◆ beginPrimaryAction()

void KisToolSelectMagnetic::beginPrimaryAction ( KoPointerEvent * event )

override

Definition at line 208 of file KisToolSelectMagnetic.cc.

{
    KisToolSelectBase::beginPrimaryAction(event);
    if (isMovingSelection()) {
        return;
    }
 
    setMode(KisTool::PAINT_MODE);
    QPointF temp(convertToPixelCoord(event));
 
    if (!image()->bounds().contains(temp.toPoint())) {
        return;
    }
 
    m_cursorOnPress = temp;
 
    checkIfAnchorIsSelected(temp);
 
    if (m_complete || m_selected) {
        return;
    }
 
    if (m_anchorPoints.count() != 0) {
        vQPointF edge = computeEdgeWrapper(m_anchorPoints.last(), temp.toPoint());
        m_points.append(edge);
        m_pointCollection.push_back(edge);
    } else {
        beginSelectInteraction();
        updateInitialAnchorBounds(temp.toPoint());
        Q_EMIT setButtonsEnabled(true);
    }
 
    m_lastAnchor = temp.toPoint();
    m_anchorPoints.push_back(m_lastAnchor);
    m_lastCursorPos = temp;
    reEvaluatePoints();
    updateCanvasPixelRect(image()->bounds());
} // KisToolSelectMagnetic::beginPrimaryAction

References KisToolSelectBase< BaseClass >::beginPrimaryAction(), KisToolSelectBase< BaseClass >::beginSelectInteraction(), bounds, checkIfAnchorIsSelected(), computeEdgeWrapper(), KisToolSelectBase< BaseClass >::isMovingSelection(), m_anchorPoints, m_complete, m_cursorOnPress, m_lastAnchor, m_lastCursorPos, m_pointCollection, m_points, m_selected, KisTool::PAINT_MODE, reEvaluatePoints(), setButtonsEnabled(), and updateInitialAnchorBounds().

◆ calculateCheckPoints()

void KisToolSelectMagnetic::calculateCheckPoints ( vQPointF points )

private

Definition at line 73 of file KisToolSelectMagnetic.cc.

{
    qreal totalDistance = 0.0;
    int checkPoint      = 0;
    int finalPoint      = 2;
    int midPoint        = 1;
    int minPoint        = 0;
    qreal maxFactor     = 2;
 
    for (; finalPoint < points.count(); finalPoint++) {
        totalDistance += kisDistance(points[finalPoint], points[finalPoint - 1]);
 
        if (totalDistance <= m_anchorGap / 3.0) {
            minPoint = finalPoint;
        }
 
        if (totalDistance <= m_anchorGap) {
            midPoint = finalPoint;
        }
 
        if (totalDistance > maxFactor * m_anchorGap) {
            break;
        }
    }
 
    if (totalDistance > maxFactor * m_anchorGap) {
        bool foundSomething = false;
 
        for (int i = midPoint; i < finalPoint; i++) {
            if (m_worker->intensity(points.at(i).toPoint()) >= m_threshold) {
                m_lastAnchor = points.at(i).toPoint();
                m_anchorPoints.push_back(m_lastAnchor);
 
                vQPointF temp;
                for (int j = 0; j <= i; j++) {
                    temp.push_back(points[j]);
                }
 
                m_pointCollection.push_back(temp);
                foundSomething = true;
                checkPoint     = i;
                break;
            }
        }
 
        if (!foundSomething) {
            for (int i = midPoint - 1; i >= minPoint; i--) {
                if (m_worker->intensity(points.at(i).toPoint()) >= m_threshold) {
                    m_lastAnchor = points.at(i).toPoint();
                    m_anchorPoints.push_back(m_lastAnchor);
                    vQPointF temp;
                    for (int j = midPoint - 1; j >= i; j--) {
                        temp.push_front(points[j]);
                    }
 
                    m_pointCollection.push_back(temp);
                    foundSomething = true;
                    checkPoint     = i;
                    break;
                }
            }
        }
 
        if (!foundSomething) {
            m_lastAnchor = points[midPoint].toPoint();
            m_anchorPoints.push_back(m_lastAnchor);
            vQPointF temp;
 
            for (int j = 0; j <= midPoint; j++) {
                temp.push_back(points[j]);
            }
 
            m_pointCollection.push_back(temp);
            checkPoint     = midPoint;
            foundSomething = true;
        }
    }
 
    totalDistance = 0.0;
    reEvaluatePoints();
 
    for (; finalPoint < points.count(); finalPoint++) {
        totalDistance += kisDistance(points[finalPoint], points[checkPoint]);
        if (totalDistance > maxFactor * m_anchorGap) {
            points.remove(0, checkPoint + 1);
            calculateCheckPoints(points);
            break;
        }
    }
} // KisToolSelectMagnetic::calculateCheckPoints

References calculateCheckPoints(), kisDistance(), m_anchorGap, m_anchorPoints, m_lastAnchor, m_pointCollection, m_threshold, m_worker, and reEvaluatePoints().

◆ checkIfAnchorIsSelected()

void KisToolSelectMagnetic::checkIfAnchorIsSelected ( QPointF pt )

private

Definition at line 247 of file KisToolSelectMagnetic.cc.

{
    Q_FOREACH (const QPoint pt, m_anchorPoints) {
        qreal zoomLevel = canvas()->viewConverter()->zoom();
        int sides       = (int) std::ceil(10.0 / zoomLevel);
        QRect r         = QRect(QPoint(0, 0), QSize(sides, sides));
        r.moveCenter(pt);
        if (r.contains(temp.toPoint())) {
            m_selected       = true;
            m_selectedAnchor = m_anchorPoints.lastIndexOf(pt);
            return;
        }
    }
}

References m_anchorPoints, m_selected, and m_selectedAnchor.

◆ computeEdgeWrapper()

vQPointF KisToolSelectMagnetic::computeEdgeWrapper	(	QPoint	a,
		QPoint	b )

private

Definition at line 187 of file KisToolSelectMagnetic.cc.

{
    return m_worker->computeEdge(m_searchRadius, a, b, m_filterRadius);
}

References m_filterRadius, m_searchRadius, and m_worker.

◆ continuePrimaryAction()

void KisToolSelectMagnetic::continuePrimaryAction ( KoPointerEvent * event )

override

Definition at line 311 of file KisToolSelectMagnetic.cc.

{
    if (isMovingSelection()) {
        KisToolSelectBase::continuePrimaryAction(event);
        return;
    }
 
    if (m_selected) {
        m_anchorPoints[m_selectedAnchor] = convertToPixelCoord(event).toPoint();
    } else if (!m_complete) {
        m_lastCursorPos = convertToPixelCoord(event);
        if(kisDistance(m_lastCursorPos, m_cursorOnPress) >= m_anchorGap)
            m_mouseHoverCompressor.start();
    }
}

References KisToolSelectBase< BaseClass >::continuePrimaryAction(), KisToolSelectBase< BaseClass >::isMovingSelection(), kisDistance(), m_anchorGap, m_anchorPoints, m_complete, m_cursorOnPress, m_lastCursorPos, m_mouseHoverCompressor, m_selected, m_selectedAnchor, and KisSignalCompressor::start().

◆ createOptionWidget()

QWidget * KisToolSelectMagnetic::createOptionWidget ( )

override

Definition at line 724 of file KisToolSelectMagnetic.cc.

{
    KisToolSelectBase::createOptionWidget();
    KisSelectionOptions *selectionWidget = selectionOptionWidget();
 
    // Create widgets
    KisDoubleSliderSpinBox *sliderRadius = new KisDoubleSliderSpinBox;
    sliderRadius->setObjectName("radius");
    sliderRadius->setRange(2.5, 100.0, 2);
    sliderRadius->setSingleStep(0.5);
    sliderRadius->setPrefix(
        i18nc("Filter radius in Magnetic Select Tool settings",
              "Filter Radius: "));
 
    KisSliderSpinBox *sliderThreshold = new KisSliderSpinBox;
    sliderThreshold->setObjectName("threshold");
    sliderThreshold->setRange(1, 255);
    sliderThreshold->setSingleStep(10);
    sliderThreshold->setPrefix(
        i18nc("Threshold in Magnetic Selection's Tool options", "Threshold: "));
 
    KisSliderSpinBox *sliderSearchRadius = new KisSliderSpinBox;
    sliderSearchRadius->setObjectName("frequency");
    sliderSearchRadius->setRange(20, 200);
    sliderSearchRadius->setSingleStep(10);
    sliderSearchRadius->setPrefix(
        i18nc("Search Radius in Magnetic Selection's Tool options",
              "Search Radius: "));
    sliderSearchRadius->setSuffix(" px");
 
    KisSliderSpinBox *sliderAnchorGap = new KisSliderSpinBox;
    sliderAnchorGap->setObjectName("anchorgap");
    sliderAnchorGap->setRange(20, 200);
    sliderAnchorGap->setSingleStep(10);
    sliderAnchorGap->setPrefix(
        i18nc("Anchor Gap in Magnetic Selection's Tool options",
              "Anchor Gap: "));
    sliderAnchorGap->setSuffix(" px");
 
    QPushButton *buttonCompleteSelection =
        new QPushButton(i18nc("Complete the selection", "Complete"),
                        selectionWidget);
    buttonCompleteSelection->setEnabled(false);
 
    QPushButton *buttonDiscardSelection =
        new QPushButton(i18nc("Discard the selection", "Discard"),
                        selectionWidget);
    buttonDiscardSelection->setEnabled(false);
 
    // Set the tooltips
    sliderRadius->setToolTip(i18nc("@info:tooltip",
                                   "Radius of the filter for the detecting "
                                   "edges, might take some time to calculate"));
    sliderThreshold->setToolTip(
        i18nc("@info:tooltip",
              "Threshold for determining the minimum intensity of the edges"));
    sliderSearchRadius->setToolTip(
        i18nc("@info:tooltip", "Extra area to be searched"));
    sliderAnchorGap->setToolTip(
        i18nc("@info:tooltip", "Gap between 2 anchors in interactive mode"));
    buttonCompleteSelection->setToolTip(
        i18nc("@info:tooltip", "Complete Selection"));
    buttonDiscardSelection->setToolTip(
        i18nc("@info:tooltip", "Discard Selection"));
 
    // Construct the option widget
    KisOptionCollectionWidgetWithHeader *sectionPathOptions =
        new KisOptionCollectionWidgetWithHeader(
            i18nc("The 'path options' section label in magnetic selection's "
                  "tool options",
                  "Path options"));
    sectionPathOptions->appendWidget("sliderRadius", sliderRadius);
    sectionPathOptions->appendWidget("sliderThreshold", sliderThreshold);
    sectionPathOptions->appendWidget("sliderSearchRadius", sliderSearchRadius);
    sectionPathOptions->appendWidget("sliderAnchorGap", sliderAnchorGap);
    sectionPathOptions->appendWidget("buttonCompleteSelection",
                                     buttonCompleteSelection);
    sectionPathOptions->appendWidget("buttonDiscardSelection",
                                     buttonDiscardSelection);
    selectionWidget->appendWidget("sectionPathOptions", sectionPathOptions);
 
    // Load configuration settings into tool options
    m_filterRadius = m_configGroup.readEntry("filterradius", 3.0);
    m_threshold = m_configGroup.readEntry("threshold", 100);
    m_searchRadius = m_configGroup.readEntry("searchradius", 30);
    m_anchorGap = m_configGroup.readEntry("anchorgap", 20);
 
    sliderRadius->setValue(m_filterRadius);
    sliderThreshold->setValue(m_threshold);
    sliderSearchRadius->setValue(m_searchRadius);
    sliderAnchorGap->setValue(m_anchorGap);
 
    // Make connections
    connect(sliderRadius,
            SIGNAL(valueChanged(qreal)),
            this,
            SLOT(slotSetFilterRadius(qreal)));
    connect(sliderThreshold,
            SIGNAL(valueChanged(int)),
            this,
            SLOT(slotSetThreshold(int)));
    connect(sliderSearchRadius,
            SIGNAL(valueChanged(int)),
            this,
            SLOT(slotSetSearchRadius(int)));
    connect(sliderAnchorGap,
            SIGNAL(valueChanged(int)),
            this,
            SLOT(slotSetAnchorGap(int)));
    connect(buttonCompleteSelection,
            SIGNAL(clicked()),
            this,
            SLOT(requestStrokeEnd()));
    connect(this,
            SIGNAL(setButtonsEnabled(bool)),
            buttonCompleteSelection,
            SLOT(setEnabled(bool)));
    connect(buttonDiscardSelection,
            SIGNAL(clicked()),
            this,
            SLOT(requestStrokeCancellation()));
    connect(this,
            SIGNAL(setButtonsEnabled(bool)),
            buttonDiscardSelection,
            SLOT(setEnabled(bool)));
 
    return selectionWidget;
 
} // KisToolSelectMagnetic::createOptionWidget

References KisOptionCollectionWidget::appendWidget(), KisOptionCollectionWidgetWithHeader::appendWidget(), KisToolSelectBase< BaseClass >::createOptionWidget(), m_anchorGap, m_configGroup, m_filterRadius, m_searchRadius, m_threshold, requestStrokeCancellation(), requestStrokeEnd(), KisToolSelectBase< BaseClass >::selectionOptionWidget(), setButtonsEnabled(), KisSliderSpinBox::setRange(), KisDoubleSliderSpinBox::setRange(), KisSliderSpinBox::setValue(), KisDoubleSliderSpinBox::setValue(), slotSetAnchorGap(), slotSetFilterRadius(), slotSetSearchRadius(), and slotSetThreshold().

◆ deactivate

void KisToolSelectMagnetic::deactivate ( )

overrideslot

Definition at line 681 of file KisToolSelectMagnetic.cc.

{
    KisCanvas2 *kisCanvas = dynamic_cast<KisCanvas2 *>(canvas());
    KIS_ASSERT_RECOVER_RETURN(kisCanvas);
    kisCanvas->updateCanvas();
    resetVariables();
    m_continuedMode = false;
    disconnect(action("undo_polygon_selection"), nullptr, this, nullptr);
 
    KisTool::deactivate();
}

References KisTool::deactivate(), KIS_ASSERT_RECOVER_RETURN, m_continuedMode, resetVariables(), and KisCanvas2::updateCanvas().

◆ deleteSelectedAnchor()

void KisToolSelectMagnetic::deleteSelectedAnchor ( )

private

Definition at line 379 of file KisToolSelectMagnetic.cc.

{
    if (m_anchorPoints.isEmpty())
        return;
 
    if (m_anchorPoints.size() <= 1) {
        resetVariables();
 
    } else if (m_selectedAnchor == 0) { // if it is the initial anchor
        m_anchorPoints.pop_front();
        m_pointCollection.pop_front();
 
        if (m_complete) {
            m_pointCollection[m_pointCollection.size() - 1] = computeEdgeWrapper(m_anchorPoints.last(), m_anchorPoints.first());
        }
 
    } else if (m_selectedAnchor == m_anchorPoints.count() - 1) { // if it is the last anchor
        m_anchorPoints.pop_back();
        m_pointCollection.pop_back();
 
        if (m_complete) {
            m_pointCollection[m_pointCollection.size() - 1] = computeEdgeWrapper(m_anchorPoints.last(), m_anchorPoints.first());
        }
 
    } else { // it is in the middle
        m_anchorPoints.remove(m_selectedAnchor);
        m_pointCollection.remove(m_selectedAnchor);
        m_pointCollection[m_selectedAnchor - 1] =
            computeEdgeWrapper(m_anchorPoints[m_selectedAnchor - 1],
                               m_anchorPoints[m_selectedAnchor]);
    }
 
    if (m_complete && m_anchorPoints.size() < 3) {
        m_complete = false;
        m_pointCollection.pop_back();
    }
 
    reEvaluatePoints();
 
} // KisToolSelectMagnetic::deleteSelectedAnchor

References computeEdgeWrapper(), m_anchorPoints, m_complete, m_pointCollection, m_selectedAnchor, reEvaluatePoints(), and resetVariables().

◆ drawAnchors()

void KisToolSelectMagnetic::drawAnchors ( QPainter & gc )

private

Definition at line 631 of file KisToolSelectMagnetic.cc.

{
    const KisHandlePalette palette = canvas()->displayRendererInterface()->handlePaletteForDisplayColorSpace();
    int sides = updateInitialAnchorBounds(m_anchorPoints.first());
    Q_FOREACH (const QPoint pt, m_anchorPoints) {
        KisHandlePainterHelper helper(&gc, handleRadius(), decorationThickness());
        QRect r(QPoint(0, 0), QSize(sides, sides));
        r.moveCenter(pt);
        if (r.contains(m_lastCursorPos.toPoint())) {
            helper.setHandleStyle(KisHandleStyle::highlightedPrimaryHandles(palette));
        } else {
            helper.setHandleStyle(KisHandleStyle::primarySelection(palette));
        }
        helper.drawHandleRect(pixelToView(pt), 4, QPoint(0, 0));
    }
}

References KisHandlePainterHelper::drawHandleRect(), KisHandleStyle::highlightedPrimaryHandles(), m_anchorPoints, m_lastCursorPos, palette, KisHandleStyle::primarySelection(), KisHandlePainterHelper::setHandleStyle(), and updateInitialAnchorBounds().

◆ endPrimaryAction()

void KisToolSelectMagnetic::endPrimaryAction ( KoPointerEvent * event )

override

Definition at line 341 of file KisToolSelectMagnetic.cc.

{
    if (isMovingSelection()) {
        KisToolSelectBase::endPrimaryAction(event);
        return;
    }
 
    if (m_selected && convertToPixelCoord(event) != m_cursorOnPress) {
        if (!image()->bounds().contains(m_anchorPoints[m_selectedAnchor])) {
            deleteSelectedAnchor();
        } else {
            updateSelectedAnchor();
        }
    } else if (m_selected) {
        QPointF temp(convertToPixelCoord(event));
 
        if (!image()->bounds().contains(temp.toPoint())) {
            return;
        }
 
        if (m_snapBound.contains(temp) && m_anchorPoints.count() > 1) {
            if(m_complete){
                finishSelectionAction();
                return;
            }
            vQPointF edge = computeEdgeWrapper(m_anchorPoints.last(), temp.toPoint());
            m_points.append(edge);
            m_pointCollection.push_back(edge);
            m_complete = true;
        }
    }
    if (m_mouseHoverCompressor.isActive()) {
        m_mouseHoverCompressor.stop();
        slotCalculateEdge();
    }
    m_selected = false;
} // KisToolSelectMagnetic::endPrimaryAction

References bounds, computeEdgeWrapper(), deleteSelectedAnchor(), KisToolSelectBase< BaseClass >::endPrimaryAction(), finishSelectionAction(), KisSignalCompressor::isActive(), KisToolSelectBase< BaseClass >::isMovingSelection(), m_anchorPoints, m_complete, m_cursorOnPress, m_mouseHoverCompressor, m_pointCollection, m_points, m_selected, m_selectedAnchor, m_snapBound, slotCalculateEdge(), KisSignalCompressor::stop(), and updateSelectedAnchor().

◆ finishSelectionAction()

void KisToolSelectMagnetic::finishSelectionAction ( )

private

Definition at line 474 of file KisToolSelectMagnetic.cc.

{
    KisCanvas2 *kisCanvas = dynamic_cast<KisCanvas2 *>(canvas());
    KIS_ASSERT_RECOVER_RETURN(kisCanvas);
    kisCanvas->updateCanvas();
    setMode(KisTool::HOVER_MODE);
    m_complete = false;
    m_finished = true;
 
    // just for testing out
    // m_worker.saveTheImage(m_points);
 
    QRectF boundingViewRect =
        pixelToView(KisAlgebra2D::accumulateBounds(m_points));
 
    KisSelectionToolHelper helper(kisCanvas, kundo2_i18n("Magnetic Selection"));
 
    if (m_points.count() > 2 &&
        !helper.tryDeselectCurrentSelection(boundingViewRect, selectionAction()))
    {
        KisCursorOverrideLock cursorLock(KisCursor::waitCursor());
 
        const SelectionMode mode =
            helper.tryOverrideSelectionMode(kisCanvas->viewManager()->selection(),
                                            selectionMode(),
                                            selectionAction());
        if (mode == PIXEL_SELECTION) {
            KisProcessingApplicator applicator(
                currentImage(),
                currentNode(),
                KisProcessingApplicator::NONE,
                KisImageSignalVector(),
                kundo2_i18n("Magnetic Selection"));
 
            KisPixelSelectionSP tmpSel =
                new KisPixelSelection(new KisDefaultBounds(currentImage()));
 
            const bool antiAlias = antiAliasSelection();
            const int grow = growSelection();
            const int feather = featherSelection();
 
            QPainterPath path;
            path.addPolygon(m_points);
            path.closeSubpath();
 
            KUndo2Command *cmd = new KisCommandUtils::LambdaCommand(
                [tmpSel, antiAlias, grow, feather, path]() mutable
                -> KUndo2Command * {
                    KisPainter painter(tmpSel);
                    painter.setPaintColor(
                        KoColor(Qt::black, tmpSel->colorSpace()));
                    // Since the feathering already smooths the selection, the
                    // antiAlias is not applied if we must feather
                    painter.setAntiAliasPolygonFill(antiAlias && feather == 0);
                    painter.setFillStyle(KisPainter::FillStyleForegroundColor);
                    painter.setStrokeStyle(KisPainter::StrokeStyleNone);
 
                    painter.paintPainterPath(path);
 
                    if (grow > 0) {
                        KisGrowSelectionFilter biggy(grow, grow);
                        biggy.process(tmpSel,
                                      tmpSel->selectedRect().adjusted(-grow,
                                                                      -grow,
                                                                      grow,
                                                                      grow));
                    } else if (grow < 0) {
                        KisShrinkSelectionFilter tiny(-grow, -grow, false);
                        tiny.process(tmpSel, tmpSel->selectedRect());
                    }
                    if (feather > 0) {
                        KisFeatherSelectionFilter feathery(feather);
                        feathery.process(
                            tmpSel,
                            tmpSel->selectedRect().adjusted(-feather,
                                                            -feather,
                                                            feather,
                                                            feather));
                    }
 
                    if (grow == 0 && feather == 0) {
                        tmpSel->setOutlineCache(path);
                    } else {
                        tmpSel->invalidateOutlineCache();
                    }
 
                    return 0;
                });
 
            applicator.applyCommand(cmd, KisStrokeJobData::SEQUENTIAL);
            helper.selectPixelSelection(applicator, tmpSel, selectionAction());
            applicator.end();
 
        } else {
            KoPathShape *path = new KoPathShape();
            path->setShapeId(KoPathShapeId);
 
            QTransform resolutionMatrix;
            resolutionMatrix.scale(1 / currentImage()->xRes(), 1 / currentImage()->yRes());
            path->moveTo(resolutionMatrix.map(m_points[0]));
            for (int i = 1; i < m_points.count(); i++)
                path->lineTo(resolutionMatrix.map(m_points[i]));
            path->close();
            path->normalize();
            helper.addSelectionShape(path, selectionAction());
        }
    }
 
    resetVariables();
 
    endSelectInteraction();
} // KisToolSelectMagnetic::finishSelectionAction

References KisAlgebra2D::accumulateBounds(), KisSelectionToolHelper::addSelectionShape(), KisToolSelectBase< BaseClass >::antiAliasSelection(), KisProcessingApplicator::applyCommand(), KisPaintDevice::colorSpace(), KisProcessingApplicator::end(), KisToolSelectBase< BaseClass >::endSelectInteraction(), KisToolSelectBase< BaseClass >::featherSelection(), KisPainter::FillStyleForegroundColor, KisToolSelectBase< BaseClass >::growSelection(), KisTool::HOVER_MODE, KisPixelSelection::invalidateOutlineCache(), KIS_ASSERT_RECOVER_RETURN, KoPathShapeId, kundo2_i18n(), m_complete, m_finished, m_points, KisProcessingApplicator::NONE, KisPainter::paintPainterPath(), PIXEL_SELECTION, KisFeatherSelectionFilter::process(), KisGrowSelectionFilter::process(), KisShrinkSelectionFilter::process(), resetVariables(), KisPixelSelection::selectedRect(), KisViewManager::selection(), KisToolSelectBase< BaseClass >::selectionAction(), KisToolSelectBase< BaseClass >::selectionMode(), KisSelectionToolHelper::selectPixelSelection(), KisStrokeJobData::SEQUENTIAL, KisPainter::setAntiAliasPolygonFill(), KisPainter::setFillStyle(), KisPixelSelection::setOutlineCache(), KisPainter::setPaintColor(), KisPainter::setStrokeStyle(), KisPainter::StrokeStyleNone, KisSelectionToolHelper::tryDeselectCurrentSelection(), KisSelectionToolHelper::tryOverrideSelectionMode(), KisCanvas2::updateCanvas(), KisCanvas2::viewManager(), and KisCursor::waitCursor().

◆ keyPressEvent()

void KisToolSelectMagnetic::keyPressEvent ( QKeyEvent * event )

override

Definition at line 57 of file KisToolSelectMagnetic.cc.

{
    if (isSelecting()) {
        if (event->key() == Qt::Key_Control) {
            m_continuedMode = true;
        }
    }
    KisToolSelect::keyPressEvent(event);
}

References KisToolSelectBase< BaseClass >::isSelecting(), KisToolSelectBase< BaseClass >::keyPressEvent(), and m_continuedMode.

◆ keyReleaseEvent()

void KisToolSelectMagnetic::keyReleaseEvent ( QKeyEvent * event )

override

Definition at line 164 of file KisToolSelectMagnetic.cc.

{
    if (isSelecting()) {
        if (event->key() == Qt::Key_Control ||
            !(event->modifiers() & Qt::ControlModifier)) {
 
            m_continuedMode = false;
            if (mode() != PAINT_MODE) {
                // Prevent finishing the selection if there is only one point, since
                // finishSelectionAction will deselect the current selection. That
                // is fine if the user just clicks, but not if we are in continued
                // mode
                if (m_points.count() > 1) {
                    finishSelectionAction();
                }
                m_points.clear(); // ensure points are always cleared
            }
        }
    }
 
    KisToolSelect::keyReleaseEvent(event);
}

References finishSelectionAction(), KisToolSelectBase< BaseClass >::isSelecting(), KisToolSelectBase< BaseClass >::keyReleaseEvent(), m_continuedMode, and m_points.

◆ mouseMoveEvent()

void KisToolSelectMagnetic::mouseMoveEvent ( KoPointerEvent * event )

override

Definition at line 193 of file KisToolSelectMagnetic.cc.

{
    if (isMovingSelection()) {
        KisToolSelect::mouseMoveEvent(event);
        return;
    }
 
    m_lastCursorPos = convertToPixelCoord(event);
    if (isSelecting()) {
        updatePaintPath();
    }
    KisToolSelect::mouseMoveEvent(event);
} // KisToolSelectMagnetic::mouseMoveEvent

References KisToolSelectBase< BaseClass >::isMovingSelection(), KisToolSelectBase< BaseClass >::isSelecting(), m_lastCursorPos, KisToolSelectBase< BaseClass >::mouseMoveEvent(), and updatePaintPath().

◆ paint()

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

override

Definition at line 615 of file KisToolSelectMagnetic.cc.

{
    Q_UNUSED(converter);
    updatePaintPath();
    if ((mode() == KisTool::PAINT_MODE || m_continuedMode) &&
        !m_anchorPoints.isEmpty())
    {
        QPainterPath outline = m_paintPath;
        if (m_continuedMode && mode() != KisTool::PAINT_MODE) {
            outline.lineTo(pixelToView(m_lastCursorPos));
        }
        paintToolOutline(&gc, outline);
        drawAnchors(gc);
    }
}

References drawAnchors(), m_anchorPoints, m_continuedMode, m_lastCursorPos, m_paintPath, KisTool::PAINT_MODE, and updatePaintPath().

◆ reEvaluatePoints()

void KisToolSelectMagnetic::reEvaluatePoints ( )

private

Definition at line 464 of file KisToolSelectMagnetic.cc.

{
    m_points.clear();
    Q_FOREACH (const vQPointF vec, m_pointCollection) {
        m_points.append(vec);
    }
 
    updatePaintPath();
}

References m_pointCollection, m_points, and updatePaintPath().

◆ requestStrokeCancellation()

void KisToolSelectMagnetic::requestStrokeCancellation ( )

override

Definition at line 716 of file KisToolSelectMagnetic.cc.

{
    m_complete = false;
    m_finished = false;
    setButtonsEnabled(false);
    resetVariables();
}

References m_complete, m_finished, resetVariables(), and setButtonsEnabled().

◆ requestStrokeEnd()

void KisToolSelectMagnetic::requestStrokeEnd ( )

override

Definition at line 707 of file KisToolSelectMagnetic.cc.

{
    if (m_finished || m_anchorPoints.count() < 2) return;
 
    setButtonsEnabled(false);
    finishSelectionAction();
    m_finished = false;
}

References finishSelectionAction(), m_anchorPoints, m_finished, and setButtonsEnabled().

◆ resetCursorStyle()

void KisToolSelectMagnetic::resetCursorStyle ( )

override

Definition at line 878 of file KisToolSelectMagnetic.cc.

{
    if (selectionAction() == SELECTION_ADD) {
        useCursor(KisCursor::loadWithSize("tool_magnetic_selection_cursor_add.svg", 32, 32, 6, 6));
    } else if (selectionAction() == SELECTION_SUBTRACT) {
        useCursor(KisCursor::loadWithSize("tool_magnetic_selection_cursor_sub.svg", 32, 32, 6, 6));
    } else if (selectionAction() == SELECTION_INTERSECT) {
        useCursor(KisCursor::loadWithSize("tool_magnetic_selection_cursor_inter.svg", 32, 32, 6, 6));
    } else if (selectionAction() == SELECTION_SYMMETRICDIFFERENCE) {
        useCursor(KisCursor::loadWithSize("tool_magnetic_selection_cursor_symdiff.svg", 32, 32, 6, 6));
    } else {
        KisToolSelect::resetCursorStyle();
    }
}

References KisCursor::loadWithSize(), SELECTION_ADD, SELECTION_INTERSECT, SELECTION_SUBTRACT, SELECTION_SYMMETRICDIFFERENCE, and KisToolSelectBase< BaseClass >::selectionAction().

◆ resetVariables()

void KisToolSelectMagnetic::resetVariables ( )

private

Definition at line 587 of file KisToolSelectMagnetic.cc.

{
    m_points.clear();
    m_anchorPoints.clear();
    m_pointCollection.clear();
    m_paintPath = QPainterPath();
    m_complete = false;
}

References m_anchorPoints, m_complete, m_paintPath, m_pointCollection, and m_points.

◆ setButtonsEnabled

void KisToolSelectMagnetic::setButtonsEnabled ( bool )

signal

◆ slotCalculateEdge

void KisToolSelectMagnetic::slotCalculateEdge ( )

slot

Definition at line 327 of file KisToolSelectMagnetic.cc.

{
    QPoint current    = m_lastCursorPos.toPoint();
    if (!image()->bounds().contains(current))
        return;
 
    if(kisDistance(m_lastAnchor, current) < m_anchorGap)
        return;
 
    vQPointF pointSet = computeEdgeWrapper(m_lastAnchor, current);
    calculateCheckPoints(pointSet);
}

References bounds, calculateCheckPoints(), computeEdgeWrapper(), kisDistance(), m_anchorGap, m_lastAnchor, and m_lastCursorPos.

◆ slotSetAnchorGap

void KisToolSelectMagnetic::slotSetAnchorGap ( int g )

slot

Definition at line 872 of file KisToolSelectMagnetic.cc.

{
    m_anchorGap = g;
    m_configGroup.writeEntry("anchorgap", g);
}

References m_anchorGap, and m_configGroup.

◆ slotSetFilterRadius

void KisToolSelectMagnetic::slotSetFilterRadius ( qreal r )

slot

Definition at line 854 of file KisToolSelectMagnetic.cc.

{
    m_filterRadius = r;
    m_configGroup.writeEntry("filterradius", r);
}

References m_configGroup, and m_filterRadius.

◆ slotSetSearchRadius

void KisToolSelectMagnetic::slotSetSearchRadius ( int r )

slot

Definition at line 866 of file KisToolSelectMagnetic.cc.

{
    m_searchRadius = r;
    m_configGroup.writeEntry("searchradius", r);
}

References m_configGroup, and m_searchRadius.

◆ slotSetThreshold

void KisToolSelectMagnetic::slotSetThreshold ( int t )

slot

Definition at line 860 of file KisToolSelectMagnetic.cc.

{
    m_threshold = t;
    m_configGroup.writeEntry("threshold", t);
}

References m_configGroup, and m_threshold.

◆ undoPoints

void KisToolSelectMagnetic::undoPoints ( )

slot

Definition at line 693 of file KisToolSelectMagnetic.cc.

{
    if (m_complete) return;
 
    if(m_anchorPoints.count() <= 1){
        resetVariables();
        return;
    }
 
    m_anchorPoints.pop_back();
    m_pointCollection.pop_back();
    reEvaluatePoints();
}

References m_anchorPoints, m_complete, m_pointCollection, reEvaluatePoints(), and resetVariables().

◆ updateCanvas()

void KisToolSelectMagnetic::updateCanvas ( )

private

◆ updateContinuedMode()

void KisToolSelectMagnetic::updateContinuedMode ( )

private

Definition at line 660 of file KisToolSelectMagnetic.cc.

{
    if (!m_points.isEmpty()) {
        qint32 lastPointIndex = m_points.count() - 1;
 
        QRectF updateRect = QRectF(m_points[lastPointIndex - 1], m_lastCursorPos).normalized();
        updateRect = kisGrowRect(updateRect, FEEDBACK_LINE_WIDTH);
 
        updateCanvasPixelRect(updateRect);
    }
}

References FEEDBACK_LINE_WIDTH, kisGrowRect(), m_lastCursorPos, and m_points.

◆ updateFeedback()

void KisToolSelectMagnetic::updateFeedback ( )

private

Definition at line 648 of file KisToolSelectMagnetic.cc.

{
    if (m_points.count() > 1) {
        qint32 lastPointIndex = m_points.count() - 1;
 
        QRectF updateRect = QRectF(m_points[lastPointIndex - 1], m_points[lastPointIndex]).normalized();
        updateRect = kisGrowRect(updateRect, FEEDBACK_LINE_WIDTH);
 
        updateCanvasPixelRect(updateRect);
    }
}

References FEEDBACK_LINE_WIDTH, kisGrowRect(), and m_points.

◆ updateInitialAnchorBounds()

int KisToolSelectMagnetic::updateInitialAnchorBounds ( QPoint pt )

private

Definition at line 455 of file KisToolSelectMagnetic.cc.

{
    qreal zoomLevel = canvas()->viewConverter()->zoom();
    int sides       = (int) std::ceil(10.0 / zoomLevel);
    m_snapBound = QRectF(QPoint(0, 0), QSize(sides, sides));
    m_snapBound.moveCenter(pt);
    return sides;
}

References m_snapBound.

◆ updatePaintPath()

void KisToolSelectMagnetic::updatePaintPath ( )

private

Definition at line 596 of file KisToolSelectMagnetic.cc.

{
    m_paintPath = QPainterPath();
    if (m_points.size() > 0) {
        m_paintPath.moveTo(pixelToView(m_points[0]));
    }
    for (int i = 1; i < m_points.count(); i++) {
        m_paintPath.lineTo(pixelToView(m_points[i]));
    }
 
    updateFeedback();
 
    if (m_continuedMode && mode() != PAINT_MODE) {
        updateContinuedMode();
    }
 
    updateCanvasPixelRect(image()->bounds());
}

References bounds, m_continuedMode, m_paintPath, m_points, updateContinuedMode(), and updateFeedback().

◆ updateSelectedAnchor()

void KisToolSelectMagnetic::updateSelectedAnchor ( )

private

Definition at line 420 of file KisToolSelectMagnetic.cc.

{
    //the only anchor
    if (m_anchorPoints.count() <= 1) {
        return;
    }
 
    if (m_selectedAnchor == 0) {
        m_pointCollection[m_selectedAnchor] = computeEdgeWrapper(m_anchorPoints[0], m_anchorPoints[1]);
        if (m_complete) {
            m_pointCollection[m_pointCollection.count() - 1] =
                computeEdgeWrapper(m_anchorPoints.last(),
                                   m_anchorPoints.first());
        }
    } else if (m_selectedAnchor == m_anchorPoints.count() - 1) {
        m_pointCollection[m_selectedAnchor - 1] =
            computeEdgeWrapper(m_anchorPoints[m_anchorPoints.count() - 2],
                               m_anchorPoints[m_anchorPoints.count() - 1]);
        if (m_complete) {
            m_pointCollection[m_selectedAnchor] =
                computeEdgeWrapper(m_anchorPoints.last(), m_anchorPoints.first());
        }
    } else {
        m_pointCollection[m_selectedAnchor - 1] =
            computeEdgeWrapper(m_anchorPoints[m_selectedAnchor - 1],
                               m_anchorPoints[m_selectedAnchor]);
 
        m_pointCollection[m_selectedAnchor] =
            computeEdgeWrapper(m_anchorPoints[m_selectedAnchor],
                               m_anchorPoints[m_selectedAnchor + 1]);
    }
 
    reEvaluatePoints();
}

References computeEdgeWrapper(), m_anchorPoints, m_complete, m_pointCollection, m_selectedAnchor, and reEvaluatePoints().

Member Data Documentation

◆ m_anchorGap

int KisToolSelectMagnetic::m_anchorGap {30}

private

Definition at line 88 of file KisToolSelectMagnetic.h.

88{30};

◆ m_anchorPoints

QVector<QPoint> KisToolSelectMagnetic::m_anchorPoints

private

Definition at line 77 of file KisToolSelectMagnetic.h.

◆ m_complete

bool KisToolSelectMagnetic::m_complete {false}

private

Definition at line 81 of file KisToolSelectMagnetic.h.

81{false};

◆ m_configGroup

KConfigGroup KisToolSelectMagnetic::m_configGroup

private

Definition at line 91 of file KisToolSelectMagnetic.h.

◆ m_continuedMode

bool KisToolSelectMagnetic::m_continuedMode {false}

private

Definition at line 78 of file KisToolSelectMagnetic.h.

78{false};

◆ m_cursorOnPress

QPointF KisToolSelectMagnetic::m_cursorOnPress

private

Definition at line 79 of file KisToolSelectMagnetic.h.

◆ m_filterRadius

qreal KisToolSelectMagnetic::m_filterRadius {3.0}

private

Definition at line 89 of file KisToolSelectMagnetic.h.

89{3.0};

◆ m_finished

bool KisToolSelectMagnetic::m_finished {false}

private

Definition at line 83 of file KisToolSelectMagnetic.h.

83{false};

◆ m_lastAnchor

QPoint KisToolSelectMagnetic::m_lastAnchor

private

Definition at line 80 of file KisToolSelectMagnetic.h.

◆ m_lastCursorPos

QPointF KisToolSelectMagnetic::m_lastCursorPos

private

Definition at line 79 of file KisToolSelectMagnetic.h.

◆ m_mouseHoverCompressor

KisSignalCompressor KisToolSelectMagnetic::m_mouseHoverCompressor

private

Definition at line 93 of file KisToolSelectMagnetic.h.

◆ m_paintPath

QPainterPath KisToolSelectMagnetic::m_paintPath

private

Definition at line 75 of file KisToolSelectMagnetic.h.

◆ m_pointCollection

QVector<vQPointF> KisToolSelectMagnetic::m_pointCollection

private

Definition at line 92 of file KisToolSelectMagnetic.h.

◆ m_points

QVector<QPointF> KisToolSelectMagnetic::m_points

private

Definition at line 76 of file KisToolSelectMagnetic.h.

◆ m_searchRadius

int KisToolSelectMagnetic::m_searchRadius {30}

private

Definition at line 86 of file KisToolSelectMagnetic.h.

86{30};

◆ m_selected

bool KisToolSelectMagnetic::m_selected {false}

private

Definition at line 82 of file KisToolSelectMagnetic.h.

82{false};

◆ m_selectedAnchor

int KisToolSelectMagnetic::m_selectedAnchor {0}

private

Definition at line 87 of file KisToolSelectMagnetic.h.

87{0};

◆ m_snapBound

QRectF KisToolSelectMagnetic::m_snapBound

private

Definition at line 90 of file KisToolSelectMagnetic.h.

◆ m_threshold

int KisToolSelectMagnetic::m_threshold {70}

private

Definition at line 85 of file KisToolSelectMagnetic.h.

85{70};

◆ m_widgetHelper

KisSelectionToolConfigWidgetHelper KisToolSelectBase< BaseClass >::m_widgetHelper

protected

Definition at line 731 of file kis_tool_select_base.h.

◆ m_worker

QScopedPointer<KisMagneticWorker> KisToolSelectMagnetic::m_worker

private

Definition at line 84 of file KisToolSelectMagnetic.h.

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

plugins/tools/selectiontools/KisToolSelectMagnetic.h
plugins/tools/selectiontools/KisToolSelectMagnetic.cc

Public Slots

Signals

Public Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ KisToolSelectMagnetic()

◆ ~KisToolSelectMagnetic()

Member Function Documentation

◆ activate

◆ beginPrimaryAction()

◆ calculateCheckPoints()

◆ checkIfAnchorIsSelected()

◆ computeEdgeWrapper()

◆ continuePrimaryAction()

◆ createOptionWidget()

◆ deactivate

◆ deleteSelectedAnchor()

◆ drawAnchors()

◆ endPrimaryAction()

◆ finishSelectionAction()

◆ keyPressEvent()

◆ keyReleaseEvent()

◆ mouseMoveEvent()

◆ paint()

◆ reEvaluatePoints()

◆ requestStrokeCancellation()

◆ requestStrokeEnd()

◆ resetCursorStyle()

◆ resetVariables()

◆ setButtonsEnabled

◆ slotCalculateEdge

◆ slotSetAnchorGap

◆ slotSetFilterRadius

◆ slotSetSearchRadius

◆ slotSetThreshold

◆ undoPoints

◆ updateCanvas()

◆ updateContinuedMode()

◆ updateFeedback()

◆ updateInitialAnchorBounds()

◆ updatePaintPath()

◆ updateSelectedAnchor()

Member Data Documentation

◆ m_anchorGap

◆ m_anchorPoints

◆ m_complete

◆ m_configGroup

◆ m_continuedMode

◆ m_cursorOnPress

◆ m_filterRadius

◆ m_finished

◆ m_lastAnchor

◆ m_lastCursorPos

◆ m_mouseHoverCompressor

◆ m_paintPath

◆ m_pointCollection

◆ m_points

◆ m_searchRadius

◆ m_selected

◆ m_selectedAnchor

◆ m_snapBound

◆ m_threshold

◆ m_widgetHelper

◆ m_worker