KisToolSelectBase< BaseClass > Class Template Reference

#include <kis_tool_select_base.h>

Inheritance diagram for KisToolSelectBase< BaseClass >:

Public Types
enum	CursorHit { CursorHit_None , CursorHit_Border , CursorHit_Inside , CursorHit_Outside }
enum	SampleLayersMode { SampleAllLayers , SampleCurrentLayer , SampleColorLabeledLayers }

Public Member Functions
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 Member Functions
virtual bool	isPixelOnly () const
virtual bool	usesColorLabels () const

Protected Attributes
SelectionAction	m_selectionActionAlternate
KisSelectionToolConfigWidgetHelper	m_widgetHelper

Private Types
enum	Interaction { Interaction_None , Interaction_Select , Interaction_MoveSelection , Interaction_MoveContent }

Private Member Functions
Interaction	currentInteraction () const

Private Attributes
QPoint	m_accumulatedOffset
Interaction	m_currentInteraction {Interaction_None}
Qt::KeyboardModifiers	m_currentModifiers
QPointF	m_currentPos
bool	m_didMove = false
QPoint	m_dragStartOffset
QPointF	m_dragStartPos
KisSignalAutoConnectionsStore	m_modeConnections
KisStrokeId	m_moveStrokeId

Detailed Description

template<class BaseClass>
class KisToolSelectBase< BaseClass >

This is a basic template to create selection tools from basic path based drawing tools. The template overrides the ability to execute alternate actions correctly. The default behavior for the modifier keys is as follows:

Shift: add to selection Alt: subtract from selection Shift+Alt: intersect current selection Ctrl+Alt: symmetric difference Ctrl: replace selection

The mapping itself is done in KisSelectionModifierMapper.

Certain tools also use modifier keys to alter their behavior, e.g. forcing square proportions with the rectangle tool. The template enables the following rules for forwarding keys:

1) If the user is not selecting, then changing the modifier combination changes the selection method.

2) If the user is selecting then the modifier keys are forwarded to the specific tool, so that it can do with them whatever it wants. The selection method is not changed in this stage and it will be the same as just before the user started selecting.

3) Once the user finishes selecting, the selection method is updated to reflect the current modifier combination

4) If the user is moving the selection, then changing the modifiers

Definition at line 62 of file kis_tool_select_base.h.

Member Enumeration Documentation

CursorHit

template<class BaseClass >

enum KisToolSelectBase::CursorHit

Enumerator
CursorHit_None
CursorHit_Border
CursorHit_Inside
CursorHit_Outside

Definition at line 91 of file kis_tool_select_base.h.

    {
        CursorHit_None,
        CursorHit_Border,
        CursorHit_Inside,
        CursorHit_Outside
    };

Interaction

template<class BaseClass >

enum KisToolSelectBase::Interaction

private

Enumerator
Interaction_None
Interaction_Select
Interaction_MoveSelection
Interaction_MoveContent

Definition at line 743 of file kis_tool_select_base.h.

    {
        Interaction_None,
        Interaction_Select,
        Interaction_MoveSelection,
        Interaction_MoveContent
    };

SampleLayersMode

template<class BaseClass >

enum KisToolSelectBase::SampleLayersMode

Enumerator
SampleAllLayers
SampleCurrentLayer
SampleColorLabeledLayers

Definition at line 99 of file kis_tool_select_base.h.

    {
        SampleAllLayers,
        SampleCurrentLayer,
        SampleColorLabeledLayers,
    };

Constructor & Destructor Documentation

KisToolSelectBase() [1/3]

template<class BaseClass >

KisToolSelectBase< BaseClass >::KisToolSelectBase ( KoCanvasBase * canvas, const QString toolName )

inline

Definition at line 67 of file kis_tool_select_base.h.

        : BaseClass(canvas)
        , m_widgetHelper(toolName)
        , m_selectionActionAlternate(SELECTION_DEFAULT)
    {
        KisSelectionModifierMapper::instance();
    }

References KisSelectionModifierMapper::instance().

KisToolSelectBase() [2/3]

template<class BaseClass >

KisToolSelectBase< BaseClass >::KisToolSelectBase ( KoCanvasBase * canvas, const QCursor cursor, const QString toolName )

inline

Definition at line 75 of file kis_tool_select_base.h.

        : BaseClass(canvas, cursor)
        , m_widgetHelper(toolName)
        , m_selectionActionAlternate(SELECTION_DEFAULT)
    {
        KisSelectionModifierMapper::instance();
    }

References KisSelectionModifierMapper::instance().

KisToolSelectBase() [3/3]

template<class BaseClass >

KisToolSelectBase< BaseClass >::KisToolSelectBase ( KoCanvasBase * canvas, QCursor cursor, QString toolName, KoToolBase * delegateTool )

inline

Definition at line 83 of file kis_tool_select_base.h.

        : BaseClass(canvas, cursor, delegateTool)
        , m_widgetHelper(toolName)
        , m_selectionActionAlternate(SELECTION_DEFAULT)
    {
        KisSelectionModifierMapper::instance();
    }

References KisSelectionModifierMapper::instance().

Member Function Documentation

activate()

template<class BaseClass >

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

inlineoverride

Definition at line 124 of file kis_tool_select_base.h.

    {
        BaseClass::activate(shapes);
 
        m_modeConnections.addUniqueConnection(
            this->action("selection_tool_mode_replace"), SIGNAL(triggered()),
            &m_widgetHelper, SLOT(slotReplaceModeRequested()));
 
        m_modeConnections.addUniqueConnection(
            this->action("selection_tool_mode_add"), SIGNAL(triggered()),
            &m_widgetHelper, SLOT(slotAddModeRequested()));
 
        m_modeConnections.addUniqueConnection(
            this->action("selection_tool_mode_subtract"), SIGNAL(triggered()),
            &m_widgetHelper, SLOT(slotSubtractModeRequested()));
 
        m_modeConnections.addUniqueConnection(
            this->action("selection_tool_mode_intersect"), SIGNAL(triggered()),
            &m_widgetHelper, SLOT(slotIntersectModeRequested()));
 
        updateActionShortcutToolTips();
 
        if (m_widgetHelper.optionWidget()) {
            if (isPixelOnly()) {
                m_widgetHelper.optionWidget()->setModeSectionVisible(false);
                m_widgetHelper.optionWidget()->setAdjustmentsSectionVisible(
                    true);
            }
            m_widgetHelper.optionWidget()->setReferenceSectionVisible(
                usesColorLabels());
        }
    }

References KisSignalAutoConnectionsStore::addUniqueConnection(), KisToolSelectBase< BaseClass >::isPixelOnly(), KisToolSelectBase< BaseClass >::m_modeConnections, KisToolSelectBase< BaseClass >::m_widgetHelper, KisSelectionToolConfigWidgetHelper::optionWidget(), KisSelectionOptions::setAdjustmentsSectionVisible(), KisSelectionOptions::setModeSectionVisible(), KisSelectionOptions::setReferenceSectionVisible(), KisToolSelectBase< BaseClass >::updateActionShortcutToolTips(), and KisToolSelectBase< BaseClass >::usesColorLabels().

activateAlternateAction()

template<class BaseClass >

void KisToolSelectBase< BaseClass >::activateAlternateAction ( KisTool::AlternateAction action )

inlineoverride

Definition at line 263 of file kis_tool_select_base.h.

    {
        Q_UNUSED(action);
        BaseClass::activatePrimaryAction();
    }

alternateSelectionAction()

template<class BaseClass >

SelectionAction KisToolSelectBase< BaseClass >::alternateSelectionAction ( ) const

inline

Definition at line 248 of file kis_tool_select_base.h.

    {
        return m_selectionActionAlternate;
    }

References KisToolSelectBase< BaseClass >::m_selectionActionAlternate.

antiAliasSelection()

template<class BaseClass >

bool KisToolSelectBase< BaseClass >::antiAliasSelection ( ) const

inline

Definition at line 208 of file kis_tool_select_base.h.

    {
        return m_widgetHelper.antiAliasSelection();
    }

References KisSelectionToolConfigWidgetHelper::antiAliasSelection(), and KisToolSelectBase< BaseClass >::m_widgetHelper.

beginAlternateAction()

template<class BaseClass >

void KisToolSelectBase< BaseClass >::beginAlternateAction ( KoPointerEvent * event, KisTool::AlternateAction action )

inlineoverride

Definition at line 275 of file kis_tool_select_base.h.

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

References KisToolSelectBase< BaseClass >::beginPrimaryAction().

beginMoveContentInteraction()

template<class BaseClass >

bool KisToolSelectBase< BaseClass >::beginMoveContentInteraction ( )

inline

Definition at line 611 of file kis_tool_select_base.h.

                                       {
        if (m_currentInteraction != Interaction_None) {
            return false;
        }
        m_currentInteraction = Interaction_MoveContent;
        return true;
    }

References KisToolSelectBase< BaseClass >::Interaction_MoveContent, KisToolSelectBase< BaseClass >::Interaction_None, and KisToolSelectBase< BaseClass >::m_currentInteraction.

beginMoveSelectionInteraction()

template<class BaseClass >

bool KisToolSelectBase< BaseClass >::beginMoveSelectionInteraction ( )

inline

Definition at line 594 of file kis_tool_select_base.h.

                                         {
        if (m_currentInteraction != Interaction_None) {
            return false;
        }
        m_currentInteraction = Interaction_MoveSelection;
        return true;
    }

References KisToolSelectBase< BaseClass >::Interaction_MoveSelection, KisToolSelectBase< BaseClass >::Interaction_None, and KisToolSelectBase< BaseClass >::m_currentInteraction.

beginPrimaryAction()

template<class BaseClass >

void KisToolSelectBase< BaseClass >::beginPrimaryAction ( KoPointerEvent * event )

inlineoverride

Definition at line 483 of file kis_tool_select_base.h.

    {
        const QPointF pos = this->convertToPixelCoord(event->point);
        const CursorHit hit = checkCursorHit(pos, event->modifiers());
 
        if (!canBeginNewAction(event, pos, hit)) {
            return;
        }
 
        KisCanvas2* canvas = dynamic_cast<KisCanvas2*>(this->canvas());
        KIS_SAFE_ASSERT_RECOVER_RETURN(canvas);
 
        if (hit == CursorHit_Inside && this->moveSelectedContent()) {
            KisSelectionSP selection = canvas->viewManager()->selection();
            KisPaintLayerSP layer = dynamic_cast<KisPaintLayer*>(this->currentNode().data());
            if (this->beginMoveContentInteraction() && selection && layer) {
                KisStrokeStrategy *strategy =
                    new MoveSelectionStrokeStrategy(layer, selection, this->image().data(), this->image().data());
                initializeStrokeAttributes(pos, strategy, true);
                updateCursor();
            }
            return;
        }
 
        if (m_currentInteraction == Interaction_MoveContent &&
            (hit == CursorHit_Inside || hit == CursorHit_Border)) {
            // we shouldn't pass the control to the parent tool
            // when we have the already started the move content action
            return;
        }
 
        KisNodeSP selectionMask = locateSelectionMaskUnderCursor(pos, event->modifiers());
        if (selectionMask) {
            if (this->beginMoveSelectionInteraction()) {
                KisStrokeStrategy *strategy =
                    new MoveStrokeStrategy({selectionMask}, this->image().data(), this->image().data());
                initializeStrokeAttributes(pos, strategy, true);
                updateCursor();
                return;
            }
        }
 
        m_didMove = false;
        BaseClass::beginPrimaryAction(event);
    }

References KisToolSelectBase< BaseClass >::beginMoveContentInteraction(), KisToolSelectBase< BaseClass >::beginMoveSelectionInteraction(), KisToolSelectBase< BaseClass >::canBeginNewAction(), KisToolSelectBase< BaseClass >::checkCursorHit(), KisToolSelectBase< BaseClass >::CursorHit_Border, KisToolSelectBase< BaseClass >::CursorHit_Inside, KisSharedPtr< T >::data(), KisToolSelectBase< BaseClass >::initializeStrokeAttributes(), KisToolSelectBase< BaseClass >::Interaction_MoveContent, KIS_SAFE_ASSERT_RECOVER_RETURN, KisToolSelectBase< BaseClass >::locateSelectionMaskUnderCursor(), KisToolSelectBase< BaseClass >::m_currentInteraction, KisToolSelectBase< BaseClass >::m_didMove, KoPointerEvent::modifiers(), KisToolSelectBase< BaseClass >::moveSelectedContent(), KoPointerEvent::point, KisViewManager::selection(), KisToolSelectBase< BaseClass >::updateCursor(), and KisCanvas2::viewManager().

beginSelectInteraction()

template<class BaseClass >

bool KisToolSelectBase< BaseClass >::beginSelectInteraction ( )

inline

Definition at line 628 of file kis_tool_select_base.h.

                                  {
        if (m_currentInteraction != Interaction_None) {
            return false;
        }
        m_currentInteraction = Interaction_Select;
        return true;
    }

References KisToolSelectBase< BaseClass >::Interaction_None, KisToolSelectBase< BaseClass >::Interaction_Select, and KisToolSelectBase< BaseClass >::m_currentInteraction.

canBeginNewAction()

template<class BaseClass >

bool KisToolSelectBase< BaseClass >::canBeginNewAction ( KoPointerEvent * event, const QPointF & pos, CursorHit hit )

inline

Definition at line 458 of file kis_tool_select_base.h.

    {
        /* Prevent interrupting while selecting a region */
        if (isSelecting()) {
            BaseClass::beginPrimaryAction(event);
            return false;
        }
 
        /* Prevent interrupting while moving */
        if (isMovingContent()) {
            /* We must update the offsets here, so the offset is sane later */
            m_dragStartPos = pos;
            m_dragStartOffset = m_accumulatedOffset;
            /* User clicked outside? Commit changes and start a new stroke */
            /* This eliminates extra keystrokes to start a new transaction */
            if (hit == CursorHit_Outside) {
                commitMoveSelectionStroke();
                BaseClass::beginPrimaryAction(event);
                return false;
            }
        }
 
        return true;
    }

References KisToolSelectBase< BaseClass >::commitMoveSelectionStroke(), KisToolSelectBase< BaseClass >::CursorHit_Outside, KisToolSelectBase< BaseClass >::isMovingContent(), KisToolSelectBase< BaseClass >::isSelecting(), KisToolSelectBase< BaseClass >::m_accumulatedOffset, KisToolSelectBase< BaseClass >::m_dragStartOffset, and KisToolSelectBase< BaseClass >::m_dragStartPos.

cancelMoveSelectionStroke()

template<class BaseClass >

void KisToolSelectBase< BaseClass >::cancelMoveSelectionStroke ( )

inline

Definition at line 306 of file kis_tool_select_base.h.

                                     {
        commitMoveSelectionStrokeImpl(true);
    }

References KisToolSelectBase< BaseClass >::commitMoveSelectionStrokeImpl().

checkCursorHit()

template<class BaseClass >

CursorHit KisToolSelectBase< BaseClass >::checkCursorHit ( const QPointF & pos, Qt::KeyboardModifiers modifiers ) const

inline

Definition at line 428 of file kis_tool_select_base.h.

    {
        KisCanvas2 *canvas = dynamic_cast<KisCanvas2*>(this->canvas());
        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(canvas, CursorHit_Outside);
        KisSelectionSP selection = canvas->viewManager()->selection();
 
        if (!selection || !selection->outlineCacheValid()) {
            return CursorHit_Outside;
        }
 
        const QPainterPath selectionPath = selection->outlineCache();
 
        if (modifiers == Qt::NoModifier) {
            const qreal handleRadius = qreal(this->handleRadius()) / canvas->coordinatesConverter()->effectiveZoom();
 
            QPainterPath samplePath;
            samplePath.addEllipse(pos, handleRadius, handleRadius);
 
            if (selectionPath.intersects(samplePath) && !selectionPath.contains(samplePath)) {
                    return CursorHit_Border;
                }
        }
 
        if (selectionPath.contains(pos)) {
            return CursorHit_Inside;
        }
 
        return CursorHit_Outside;
    }

References KisCanvas2::coordinatesConverter, KisToolSelectBase< BaseClass >::CursorHit_Border, KisToolSelectBase< BaseClass >::CursorHit_Inside, KisToolSelectBase< BaseClass >::CursorHit_Outside, KisCoordinatesConverter::effectiveZoom(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, KisSelection::outlineCache(), KisSelection::outlineCacheValid(), KisViewManager::selection(), and KisCanvas2::viewManager().

colorLabelsSelected()

template<class BaseClass >

QList< int > KisToolSelectBase< BaseClass >::colorLabelsSelected ( ) const

inline

Definition at line 228 of file kis_tool_select_base.h.

    {
        return m_widgetHelper.selectedColorLabels();
    }

References KisToolSelectBase< BaseClass >::m_widgetHelper, and KisSelectionToolConfigWidgetHelper::selectedColorLabels().

commitMoveSelectionStroke()

template<class BaseClass >

void KisToolSelectBase< BaseClass >::commitMoveSelectionStroke ( )

inline

Definition at line 310 of file kis_tool_select_base.h.

                                     {
        commitMoveSelectionStrokeImpl(false);
    }

References KisToolSelectBase< BaseClass >::commitMoveSelectionStrokeImpl().

commitMoveSelectionStrokeImpl()

template<class BaseClass >

void KisToolSelectBase< BaseClass >::commitMoveSelectionStrokeImpl ( bool cancel )

inline

Definition at line 314 of file kis_tool_select_base.h.

                                                    {
        if (m_moveStrokeId && isMovingContent()) {
            if (!cancel) {
                this->image()->endStroke(m_moveStrokeId);
            } else {
                this->image()->cancelStroke(m_moveStrokeId);
            }
            m_moveStrokeId.clear();
            m_accumulatedOffset = QPoint();
            m_dragStartOffset = QPoint();
            this->endMoveContentInteraction();
            return;
        }
    }

References KisToolSelectBase< BaseClass >::endMoveContentInteraction(), KisToolSelectBase< BaseClass >::isMovingContent(), KisToolSelectBase< BaseClass >::m_accumulatedOffset, KisToolSelectBase< BaseClass >::m_dragStartOffset, and KisToolSelectBase< BaseClass >::m_moveStrokeId.

continueAlternateAction()

template<class BaseClass >

void KisToolSelectBase< BaseClass >::continueAlternateAction ( KoPointerEvent * event, KisTool::AlternateAction action )

inlineoverride

Definition at line 282 of file kis_tool_select_base.h.

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

References KisToolSelectBase< BaseClass >::continuePrimaryAction().

continuePrimaryAction()

template<class BaseClass >

void KisToolSelectBase< BaseClass >::continuePrimaryAction ( KoPointerEvent * event )

inlineoverride

Definition at line 529 of file kis_tool_select_base.h.

    {
        if (isMovingSelection() || isMovingContent()) {
            const QPointF pos = this->convertToPixelCoord(event->point);
            const QPoint delta = (pos - m_dragStartPos).toPoint();
            const QPoint offset = m_dragStartOffset + delta;
            m_accumulatedOffset = offset;
            this->image()->addJob(m_moveStrokeId, new MoveStrokeStrategy::Data(offset));
            return;
    }
 
        BaseClass::continuePrimaryAction(event);
    }

References KisToolSelectBase< BaseClass >::isMovingContent(), KisToolSelectBase< BaseClass >::isMovingSelection(), KisToolSelectBase< BaseClass >::m_accumulatedOffset, KisToolSelectBase< BaseClass >::m_dragStartOffset, KisToolSelectBase< BaseClass >::m_dragStartPos, KisToolSelectBase< BaseClass >::m_moveStrokeId, and KoPointerEvent::point.

createOptionWidget()

template<class BaseClass >

QWidget * KisToolSelectBase< BaseClass >::createOptionWidget ( )

inlineoverride

Definition at line 164 of file kis_tool_select_base.h.

    {
        m_widgetHelper.createOptionWidget(this->toolId());
        m_widgetHelper.setConfigGroupForExactTool(this->toolId());
 
        this->connect(this, SIGNAL(isActiveChanged(bool)), &m_widgetHelper, SLOT(slotToolActivatedChanged(bool)));
        this->connect(&m_widgetHelper,
                      SIGNAL(selectionActionChanged(SelectionAction)),
                      this,
                      SLOT(resetCursorStyle()));
 
        updateActionShortcutToolTips();
        if (m_widgetHelper.optionWidget()) {
            m_widgetHelper.optionWidget()->setContentsMargins(0, 10, 0, 10);
            if (isPixelOnly()) {
                m_widgetHelper.optionWidget()->setModeSectionVisible(false);
                m_widgetHelper.optionWidget()->setAdjustmentsSectionVisible(
                    true);
            }
            m_widgetHelper.optionWidget()->setReferenceSectionVisible(
                usesColorLabels());
        }
 
        return m_widgetHelper.optionWidget();
    }

References KisSelectionToolConfigWidgetHelper::createOptionWidget(), KisToolSelectBase< BaseClass >::isPixelOnly(), KisToolSelectBase< BaseClass >::m_widgetHelper, KisSelectionToolConfigWidgetHelper::optionWidget(), KisSelectionOptions::setAdjustmentsSectionVisible(), KisSelectionToolConfigWidgetHelper::setConfigGroupForExactTool(), KisSelectionOptions::setModeSectionVisible(), KisSelectionOptions::setReferenceSectionVisible(), KisToolSelectBase< BaseClass >::updateActionShortcutToolTips(), and KisToolSelectBase< BaseClass >::usesColorLabels().

currentInteraction()

template<class BaseClass >

Interaction KisToolSelectBase< BaseClass >::currentInteraction ( ) const

inlineprivate

Definition at line 753 of file kis_tool_select_base.h.

                                           {
        return m_currentInteraction;
    }

References KisToolSelectBase< BaseClass >::m_currentInteraction.

deactivate()

template<class BaseClass >

void KisToolSelectBase< BaseClass >::deactivate ( )

inlineoverride

Definition at line 157 of file kis_tool_select_base.h.

    {
        commitMoveSelectionStroke();
        BaseClass::deactivate();
        m_modeConnections.clear();
    }

References KisSignalAutoConnectionsStore::clear(), KisToolSelectBase< BaseClass >::commitMoveSelectionStroke(), and KisToolSelectBase< BaseClass >::m_modeConnections.

deactivateAlternateAction()

template<class BaseClass >

void KisToolSelectBase< BaseClass >::deactivateAlternateAction ( KisTool::AlternateAction action )

inlineoverride

Definition at line 269 of file kis_tool_select_base.h.

    {
        Q_UNUSED(action);
        BaseClass::deactivatePrimaryAction();
    }

endAlternateAction()

template<class BaseClass >

void KisToolSelectBase< BaseClass >::endAlternateAction ( KoPointerEvent * event, KisTool::AlternateAction action )

inlineoverride

Definition at line 289 of file kis_tool_select_base.h.

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

References KisToolSelectBase< BaseClass >::endPrimaryAction().

endMoveContentInteraction()

template<class BaseClass >

bool KisToolSelectBase< BaseClass >::endMoveContentInteraction ( )

inline

Definition at line 619 of file kis_tool_select_base.h.

                                     {
        if (!isMovingContent()) {
            return false;
        }
        m_currentInteraction = Interaction_None;
        updateCursorDelayed();
        return true;
    }

References KisToolSelectBase< BaseClass >::Interaction_None, KisToolSelectBase< BaseClass >::isMovingContent(), KisToolSelectBase< BaseClass >::m_currentInteraction, and KisToolSelectBase< BaseClass >::updateCursorDelayed().

endMoveSelectionInteraction()

template<class BaseClass >

bool KisToolSelectBase< BaseClass >::endMoveSelectionInteraction ( )

inline

Definition at line 602 of file kis_tool_select_base.h.

                                       {
        if (!isMovingSelection()) {
            return false;
        }
        m_currentInteraction = Interaction_None;
        updateCursorDelayed();
        return true;
    }

References KisToolSelectBase< BaseClass >::Interaction_None, KisToolSelectBase< BaseClass >::isMovingSelection(), KisToolSelectBase< BaseClass >::m_currentInteraction, and KisToolSelectBase< BaseClass >::updateCursorDelayed().

endPrimaryAction()

template<class BaseClass >

void KisToolSelectBase< BaseClass >::endPrimaryAction ( KoPointerEvent * event )

inlineoverride

Definition at line 543 of file kis_tool_select_base.h.

    {
        if (isMovingContent()) {
            const QPointF pos = this->convertToPixelCoord(event->point);
            const QPoint delta = (pos - m_dragStartPos).toPoint();
            m_accumulatedOffset = m_dragStartOffset + delta;
            return;
        }
        if (isMovingSelection()) {
            this->image()->endStroke(m_moveStrokeId);
            m_moveStrokeId.clear();
            this->endMoveSelectionInteraction();
            return;
        }
 
        BaseClass::endPrimaryAction(event);
    }

References KisToolSelectBase< BaseClass >::endMoveSelectionInteraction(), KisToolSelectBase< BaseClass >::isMovingContent(), KisToolSelectBase< BaseClass >::isMovingSelection(), KisToolSelectBase< BaseClass >::m_accumulatedOffset, KisToolSelectBase< BaseClass >::m_dragStartOffset, KisToolSelectBase< BaseClass >::m_dragStartPos, KisToolSelectBase< BaseClass >::m_moveStrokeId, and KoPointerEvent::point.

endSelectInteraction()

template<class BaseClass >

bool KisToolSelectBase< BaseClass >::endSelectInteraction ( )

inline

Definition at line 636 of file kis_tool_select_base.h.

                                {
        if (!isSelecting()) {
            return false;
        }
        m_currentInteraction = Interaction_None;
        updateCursorDelayed();
        return true;
    }

References KisToolSelectBase< BaseClass >::Interaction_None, KisToolSelectBase< BaseClass >::isSelecting(), KisToolSelectBase< BaseClass >::m_currentInteraction, and KisToolSelectBase< BaseClass >::updateCursorDelayed().

explicitUserStrokeEndRequest()

template<class BaseClass >

void KisToolSelectBase< BaseClass >::explicitUserStrokeEndRequest ( )

inlineoverride

Definition at line 296 of file kis_tool_select_base.h.

    {
        commitMoveSelectionStroke();
    }

References KisToolSelectBase< BaseClass >::commitMoveSelectionStroke().

featherSelection()

template<class BaseClass >

int KisToolSelectBase< BaseClass >::featherSelection ( ) const

inline

Definition at line 223 of file kis_tool_select_base.h.

    {
        return m_widgetHelper.featherSelection();
    }

References KisSelectionToolConfigWidgetHelper::featherSelection(), and KisToolSelectBase< BaseClass >::m_widgetHelper.

growSelection()

template<class BaseClass >

int KisToolSelectBase< BaseClass >::growSelection ( ) const

inline

Definition at line 213 of file kis_tool_select_base.h.

    {
        return m_widgetHelper.growSelection();
    }

References KisSelectionToolConfigWidgetHelper::growSelection(), and KisToolSelectBase< BaseClass >::m_widgetHelper.

initializeStrokeAttributes()

template<class BaseClass >

void KisToolSelectBase< BaseClass >::initializeStrokeAttributes ( const QPointF & pos, KisStrokeStrategy * strategy, bool moved )

inline

Definition at line 586 of file kis_tool_select_base.h.

                                                                                                        {
        m_moveStrokeId = this->image()->startStroke(strategy);
        m_dragStartPos = pos;
        m_didMove = moved;
        m_accumulatedOffset = QPoint();
        m_dragStartOffset = QPoint();
    }

References KisToolSelectBase< BaseClass >::m_accumulatedOffset, KisToolSelectBase< BaseClass >::m_didMove, KisToolSelectBase< BaseClass >::m_dragStartOffset, KisToolSelectBase< BaseClass >::m_dragStartPos, and KisToolSelectBase< BaseClass >::m_moveStrokeId.

isMovingContent()

template<class BaseClass >

bool KisToolSelectBase< BaseClass >::isMovingContent ( ) const

inline

Definition at line 649 of file kis_tool_select_base.h.

                                 {
        return m_currentInteraction == Interaction_MoveContent;
    }

References KisToolSelectBase< BaseClass >::Interaction_MoveContent, and KisToolSelectBase< BaseClass >::m_currentInteraction.

isMovingSelection()

template<class BaseClass >

bool KisToolSelectBase< BaseClass >::isMovingSelection ( ) const

inline

Definition at line 645 of file kis_tool_select_base.h.

                                   {
        return m_currentInteraction == Interaction_MoveSelection;
    }

References KisToolSelectBase< BaseClass >::Interaction_MoveSelection, and KisToolSelectBase< BaseClass >::m_currentInteraction.

isPixelOnly()

template<class BaseClass >

virtual bool KisToolSelectBase< BaseClass >::isPixelOnly ( ) const

inlineprotectedvirtual

Reimplemented in KisToolSelectContiguous, and KisToolSelectSimilar.

Definition at line 734 of file kis_tool_select_base.h.

                                     {
        return false;
    }

isSelecting()

template<class BaseClass >

bool KisToolSelectBase< BaseClass >::isSelecting ( ) const

inline

Definition at line 653 of file kis_tool_select_base.h.

                             {
        return m_currentInteraction == Interaction_Select;
    }

References KisToolSelectBase< BaseClass >::Interaction_Select, and KisToolSelectBase< BaseClass >::m_currentInteraction.

keyPressEvent()

template<class BaseClass >

void KisToolSelectBase< BaseClass >::keyPressEvent ( QKeyEvent * event )

inlineoverride

Definition at line 356 of file kis_tool_select_base.h.

    {
        const Qt::Key key = KisExtendedModifiersMapper::workaroundShiftAltMetaHell(event);
        // Assume all the modifiers were unpressed...
        m_currentModifiers = Qt::NoModifier;
        // ...and add those which are right now
        if (key == Qt::Key_Control || event->modifiers().testFlag(Qt::ControlModifier)) {
            m_currentModifiers.setFlag(Qt::ControlModifier);
        }
        if (key == Qt::Key_Shift || event->modifiers().testFlag(Qt::ShiftModifier)) {
            m_currentModifiers.setFlag(Qt::ShiftModifier);
        }
        if (key == Qt::Key_Alt || event->modifiers().testFlag(Qt::AltModifier)) {
            m_currentModifiers.setFlag(Qt::AltModifier);
        }
 
        // Avoid changing the cursor if the user is interacting
        if (isSelecting()) {
            BaseClass::keyPressEvent(event);
            return;
        }
        if (isMovingSelection()) {
            return;
        }
 
        setAlternateSelectionAction(KisSelectionModifierMapper::map(m_currentModifiers));
        updateCursor();
    }

References KisToolSelectBase< BaseClass >::isMovingSelection(), KisToolSelectBase< BaseClass >::isSelecting(), KisToolSelectBase< BaseClass >::m_currentModifiers, KisSelectionModifierMapper::map(), KisToolSelectBase< BaseClass >::setAlternateSelectionAction(), KisToolSelectBase< BaseClass >::updateCursor(), and KisExtendedModifiersMapper::workaroundShiftAltMetaHell().

keyReleaseEvent()

template<class BaseClass >

void KisToolSelectBase< BaseClass >::keyReleaseEvent ( QKeyEvent * event )

inlineoverride

Definition at line 385 of file kis_tool_select_base.h.

    {
        const Qt::Key key = KisExtendedModifiersMapper::workaroundShiftAltMetaHell(event);
        // Assume all the modifiers were pressed...
        m_currentModifiers = Qt::ControlModifier | Qt::ShiftModifier | Qt::AltModifier;
        // ...and remove those which aren't right now
        if (key == Qt::Key_Control || !event->modifiers().testFlag(Qt::ControlModifier)) {
            m_currentModifiers.setFlag(Qt::ControlModifier, false);
        }
        if (key == Qt::Key_Shift || !event->modifiers().testFlag(Qt::ShiftModifier)) {
            m_currentModifiers.setFlag(Qt::ShiftModifier, false);
        }
        if (key == Qt::Key_Alt || !event->modifiers().testFlag(Qt::AltModifier)) {
            m_currentModifiers.setFlag(Qt::AltModifier, false);
        }
 
        // Avoid changing the selection mode and cursor if the user is interacting
        if (isSelecting()) {
            BaseClass::keyReleaseEvent(event);
            return;
        }
        if (isMovingSelection()) {
            return;
        }
 
        setAlternateSelectionAction(KisSelectionModifierMapper::map(m_currentModifiers));
        if (m_currentModifiers == Qt::NoModifier) {
            updateCursor();
        }
        else {
            this->resetCursorStyle();
        }
    }

References KisToolSelectBase< BaseClass >::isMovingSelection(), KisToolSelectBase< BaseClass >::isSelecting(), KisToolSelectBase< BaseClass >::m_currentModifiers, KisSelectionModifierMapper::map(), KisToolSelectBase< BaseClass >::setAlternateSelectionAction(), KisToolSelectBase< BaseClass >::updateCursor(), and KisExtendedModifiersMapper::workaroundShiftAltMetaHell().

locateSelectionMaskUnderCursor()

template<class BaseClass >

KisNodeSP KisToolSelectBase< BaseClass >::locateSelectionMaskUnderCursor ( const QPointF & pos, Qt::KeyboardModifiers modifiers )

inline

Definition at line 329 of file kis_tool_select_base.h.

                                                                                                {
        if (modifiers != Qt::NoModifier) return 0;
 
        KisCanvas2* canvas = dynamic_cast<KisCanvas2*>(this->canvas());
        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(canvas, 0);
 
        KisSelectionSP selection = canvas->viewManager()->selection();
        if (selection &&
            selection->outlineCacheValid()) {
 
            const qreal handleRadius = qreal(this->handleRadius()) / canvas->coordinatesConverter()->effectiveZoom();
            QPainterPath samplePath;
            samplePath.addEllipse(pos, handleRadius, handleRadius);
 
            const QPainterPath selectionPath = selection->outlineCache();
 
            if (selectionPath.intersects(samplePath) && !selectionPath.contains(samplePath)) {
                KisNodeSP parent = selection->parentNode();
                if (parent && parent->isEditable()) {
                    return parent;
                }
            }
        }
 
        return 0;
    }

References KisCanvas2::coordinatesConverter, KisCoordinatesConverter::effectiveZoom(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, KisSelection::outlineCache(), KisSelection::outlineCacheValid(), KisSelection::parentNode, KisViewManager::selection(), and KisCanvas2::viewManager().

mouseMoveEvent()

template<class BaseClass >

void KisToolSelectBase< BaseClass >::mouseMoveEvent ( KoPointerEvent * event )

inlineoverride

Definition at line 419 of file kis_tool_select_base.h.

    {
        m_currentPos = this->convertToPixelCoord(event->point);
        m_currentModifiers = event->modifiers();
 
        updateCursor();
        BaseClass::mouseMoveEvent(event);
    }

References KisToolSelectBase< BaseClass >::m_currentModifiers, KisToolSelectBase< BaseClass >::m_currentPos, KoPointerEvent::point, and KisToolSelectBase< BaseClass >::updateCursor().

moveSelectedContent()

template<class BaseClass >

bool KisToolSelectBase< BaseClass >::moveSelectedContent ( ) const

inline

Definition at line 203 of file kis_tool_select_base.h.

    {
        return m_widgetHelper.moveSelectedContent();
    }

References KisToolSelectBase< BaseClass >::m_widgetHelper, and KisSelectionToolConfigWidgetHelper::moveSelectedContent().

popupActionsMenu()

template<class BaseClass >

QMenu * KisToolSelectBase< BaseClass >::popupActionsMenu ( )

inlineoverride

Definition at line 566 of file kis_tool_select_base.h.

    {
        if (isSelecting()) {
            return BaseClass::popupActionsMenu();
        }
 
        KisCanvas2 * kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(kisCanvas, 0);
 
        return KisSelectionToolHelper::getSelectionContextMenu(kisCanvas);
    }

References KisSelectionToolHelper::getSelectionContextMenu(), KisToolSelectBase< BaseClass >::isSelecting(), and KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE.

popupWidget()

template<class BaseClass >

KisPopupWidgetInterface * KisToolSelectBase< BaseClass >::popupWidget ( )

inlineoverride

Definition at line 578 of file kis_tool_select_base.h.

    {
        if (isSelecting()) {
            return BaseClass::popupWidget();
        }
        return nullptr;
    }

References KisToolSelectBase< BaseClass >::isSelecting().

requestStrokeCancellation()

template<class BaseClass >

void KisToolSelectBase< BaseClass >::requestStrokeCancellation ( )

inlineoverride

Definition at line 301 of file kis_tool_select_base.h.

    {
        cancelMoveSelectionStroke();
    }

References KisToolSelectBase< BaseClass >::cancelMoveSelectionStroke().

sampleLayersMode()

template<class BaseClass >

SampleLayersMode KisToolSelectBase< BaseClass >::sampleLayersMode ( ) const

inline

Definition at line 233 of file kis_tool_select_base.h.

    {
        KisSelectionOptions::ReferenceLayers referenceLayers =
            m_widgetHelper.referenceLayers();
        if (referenceLayers == KisSelectionOptions::AllLayers) {
            return SampleAllLayers;
        } else if (referenceLayers == KisSelectionOptions::CurrentLayer) {
            return SampleCurrentLayer;
        } else if (referenceLayers == KisSelectionOptions::ColorLabeledLayers) {
            return SampleColorLabeledLayers;
        }
        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(true, SampleAllLayers);
        return SampleAllLayers;
    }

References KisSelectionOptions::AllLayers, KisSelectionOptions::ColorLabeledLayers, KisSelectionOptions::CurrentLayer, KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, KisToolSelectBase< BaseClass >::m_widgetHelper, KisSelectionToolConfigWidgetHelper::referenceLayers(), KisToolSelectBase< BaseClass >::SampleAllLayers, KisToolSelectBase< BaseClass >::SampleColorLabeledLayers, and KisToolSelectBase< BaseClass >::SampleCurrentLayer.

selectionAction()

template<class BaseClass >

SelectionAction KisToolSelectBase< BaseClass >::selectionAction ( ) const

inline

Definition at line 195 of file kis_tool_select_base.h.

    {
        if (alternateSelectionAction() == SELECTION_DEFAULT) {
            return m_widgetHelper.selectionAction();
        }
        return alternateSelectionAction();
    }

References KisToolSelectBase< BaseClass >::alternateSelectionAction(), KisToolSelectBase< BaseClass >::m_widgetHelper, SELECTION_DEFAULT, and KisSelectionToolConfigWidgetHelper::selectionAction().

selectionDidMove()

template<class BaseClass >

bool KisToolSelectBase< BaseClass >::selectionDidMove ( ) const

inline

Definition at line 561 of file kis_tool_select_base.h.

    {
        return m_didMove;
    }

References KisToolSelectBase< BaseClass >::m_didMove.

selectionMode()

template<class BaseClass >

SelectionMode KisToolSelectBase< BaseClass >::selectionMode ( ) const

inline

Definition at line 190 of file kis_tool_select_base.h.

    {
        return m_widgetHelper.selectionMode();
    }

References KisToolSelectBase< BaseClass >::m_widgetHelper, and KisSelectionToolConfigWidgetHelper::selectionMode().

selectionOptionWidget()

template<class BaseClass >

KisSelectionOptions * KisToolSelectBase< BaseClass >::selectionOptionWidget ( )

inline

Definition at line 253 of file kis_tool_select_base.h.

    {
        return m_widgetHelper.optionWidget();
    }

References KisToolSelectBase< BaseClass >::m_widgetHelper, and KisSelectionToolConfigWidgetHelper::optionWidget().

setAlternateSelectionAction()

template<class BaseClass >

virtual void KisToolSelectBase< BaseClass >::setAlternateSelectionAction ( SelectionAction action )

inlinevirtual

Definition at line 258 of file kis_tool_select_base.h.

    {
        m_selectionActionAlternate = action;
    }

References KisToolSelectBase< BaseClass >::m_selectionActionAlternate.

stopGrowingAtDarkestPixel()

template<class BaseClass >

bool KisToolSelectBase< BaseClass >::stopGrowingAtDarkestPixel ( ) const

inline

Definition at line 218 of file kis_tool_select_base.h.

    {
        return m_widgetHelper.stopGrowingAtDarkestPixel();
    }

References KisToolSelectBase< BaseClass >::m_widgetHelper, and KisSelectionToolConfigWidgetHelper::stopGrowingAtDarkestPixel().

updateActionShortcutToolTips()

template<class BaseClass >

void KisToolSelectBase< BaseClass >::updateActionShortcutToolTips ( )

inline

Definition at line 106 of file kis_tool_select_base.h.

                                        {
        KisSelectionOptions *widget = m_widgetHelper.optionWidget();
        if (widget) {
            widget->updateActionButtonToolTip(
                SELECTION_REPLACE,
                this->action("selection_tool_mode_replace")->shortcut());
            widget->updateActionButtonToolTip(
                SELECTION_ADD,
                this->action("selection_tool_mode_add")->shortcut());
            widget->updateActionButtonToolTip(
                SELECTION_SUBTRACT,
                this->action("selection_tool_mode_subtract")->shortcut());
            widget->updateActionButtonToolTip(
                SELECTION_INTERSECT,
                this->action("selection_tool_mode_intersect")->shortcut());
        }
    }

References KisToolSelectBase< BaseClass >::m_widgetHelper, KisSelectionToolConfigWidgetHelper::optionWidget(), SELECTION_ADD, SELECTION_INTERSECT, SELECTION_REPLACE, SELECTION_SUBTRACT, and KisSelectionOptions::updateActionButtonToolTip().

updateCursor()

template<class BaseClass >

void KisToolSelectBase< BaseClass >::updateCursor ( )

inline

Definition at line 657 of file kis_tool_select_base.h.

    {
 
        const Interaction interaction = currentInteraction();
        const CursorHit hit = checkCursorHit(m_currentPos, m_currentModifiers);
 
        switch (interaction)
        {
            case Interaction_MoveContent:
                switch (hit)
                {
                    case CursorHit_Border:
                        this->useCursor(KisCursor::moveCursor());
                        break;
                    case CursorHit_Inside:
                        this->useCursor(KisCursor::moveCursor());
                        break;
                    case CursorHit_Outside:
                        this->resetCursorStyle();
                        break;
                    case CursorHit_None:
                    default:
                        break;
                }
                break;
            case Interaction_MoveSelection:
                switch (hit)
                {
                    case CursorHit_Border:
                        this->useCursor(KisCursor::moveSelectionCursor());
                        break;
                    case CursorHit_Inside:
                        this->resetCursorStyle();
                        break;
                    case CursorHit_Outside:
                        this->resetCursorStyle();
                        break;
                    case CursorHit_None:
                    default:
                        break;
                }
                break;
            case Interaction_Select:
                this->useCursor(KisCursor::moveCursor());
                break;
            case Interaction_None:
                if (hit == CursorHit_Border){
                    this->useCursor(KisCursor::moveSelectionCursor());
                }
                else if (hit == CursorHit_Inside && this->moveSelectedContent()) {
                    this->useCursor(KisCursor::moveCursor());
                } else {
                    this->resetCursorStyle();
                }
                break;
            default:
                this->resetCursorStyle();
                break;
        }
    }

References KisToolSelectBase< BaseClass >::checkCursorHit(), KisToolSelectBase< BaseClass >::currentInteraction(), KisToolSelectBase< BaseClass >::CursorHit_Border, KisToolSelectBase< BaseClass >::CursorHit_Inside, KisToolSelectBase< BaseClass >::CursorHit_None, KisToolSelectBase< BaseClass >::CursorHit_Outside, KisToolSelectBase< BaseClass >::Interaction_MoveContent, KisToolSelectBase< BaseClass >::Interaction_MoveSelection, KisToolSelectBase< BaseClass >::Interaction_None, KisToolSelectBase< BaseClass >::Interaction_Select, KisToolSelectBase< BaseClass >::m_currentModifiers, KisToolSelectBase< BaseClass >::m_currentPos, KisCursor::moveCursor(), KisToolSelectBase< BaseClass >::moveSelectedContent(), and KisCursor::moveSelectionCursor().

updateCursorDelayed()

template<class BaseClass >

void KisToolSelectBase< BaseClass >::updateCursorDelayed ( )

inline

Definition at line 718 of file kis_tool_select_base.h.

                               {
        setAlternateSelectionAction(KisSelectionModifierMapper::map(m_currentModifiers));
        QTimer::singleShot(100, Qt::CoarseTimer,
            this,
            [this]()
            {
                updateCursor();
            }
        );
    }

References KisToolSelectBase< BaseClass >::m_currentModifiers, KisSelectionModifierMapper::map(), KisToolSelectBase< BaseClass >::setAlternateSelectionAction(), and KisToolSelectBase< BaseClass >::updateCursor().

usesColorLabels()

template<class BaseClass >

virtual bool KisToolSelectBase< BaseClass >::usesColorLabels ( ) const

inlineprotectedvirtual

Reimplemented in KisToolSelectContiguous, and KisToolSelectSimilar.

Definition at line 738 of file kis_tool_select_base.h.

                                         {
        return false;
    }

Member Data Documentation

m_accumulatedOffset

template<class BaseClass >

QPoint KisToolSelectBase< BaseClass >::m_accumulatedOffset

private

Definition at line 761 of file kis_tool_select_base.h.

m_currentInteraction

template<class BaseClass >

Interaction KisToolSelectBase< BaseClass >::m_currentInteraction {Interaction_None}

private

Definition at line 751 of file kis_tool_select_base.h.

{Interaction_None};

m_currentModifiers

template<class BaseClass >

Qt::KeyboardModifiers KisToolSelectBase< BaseClass >::m_currentModifiers

private

Definition at line 757 of file kis_tool_select_base.h.

m_currentPos

template<class BaseClass >

QPointF KisToolSelectBase< BaseClass >::m_currentPos

private

Definition at line 760 of file kis_tool_select_base.h.

m_didMove

template<class BaseClass >

bool KisToolSelectBase< BaseClass >::m_didMove = false

private

Definition at line 764 of file kis_tool_select_base.h.

m_dragStartOffset

template<class BaseClass >

QPoint KisToolSelectBase< BaseClass >::m_dragStartOffset

private

Definition at line 762 of file kis_tool_select_base.h.

m_dragStartPos

template<class BaseClass >

QPointF KisToolSelectBase< BaseClass >::m_dragStartPos

private

Definition at line 759 of file kis_tool_select_base.h.

m_modeConnections

template<class BaseClass >

KisSignalAutoConnectionsStore KisToolSelectBase< BaseClass >::m_modeConnections

private

Definition at line 766 of file kis_tool_select_base.h.

m_moveStrokeId

template<class BaseClass >

KisStrokeId KisToolSelectBase< BaseClass >::m_moveStrokeId

private

Definition at line 763 of file kis_tool_select_base.h.

m_selectionActionAlternate

template<class BaseClass >

SelectionAction KisToolSelectBase< BaseClass >::m_selectionActionAlternate

protected

Definition at line 732 of file kis_tool_select_base.h.

m_widgetHelper

template<class BaseClass >

KisSelectionToolConfigWidgetHelper KisToolSelectBase< BaseClass >::m_widgetHelper

protected

Definition at line 731 of file kis_tool_select_base.h.

---

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

• libs/ui/tool/kis_tool_select_base.h