KisToolInvocationAction Class Reference

Tool Invocation action of KisAbstractInputAction. More...

#include <kis_tool_invocation_action.h>

Inheritance diagram for KisToolInvocationAction:

Classes
class	Private

Public Types
enum	Shortcut {   ActivateShortcut , ConfirmShortcut , CancelShortcut , LineToolShortcut ,   EllipseToolShortcut , RectToolShortcut , MoveToolShortcut , FillToolShortcut ,   GradientToolShortcut , MeasureToolShortcut , EllipseSelToolShortcut , RectSelToolShortcut ,   ContigSelToolShortcut , FreehandSelToolShortcut , ActivateWithOtherColorShortcut }

Public Member Functions
void	activate (int shortcut) override
void	begin (int shortcut, QEvent *event) override
bool	canIgnoreModifiers () const override
void	deactivate (int shortcut) override
void	end (QEvent *event) override
KisInputActionGroup	inputActionGroup (int shortcut) const override
void	inputEvent (QEvent *event) override
bool	isShortcutRequired (int shortcut) const override
	KisToolInvocationAction ()
int	priority () const override
void	processUnhandledEvent (QEvent *event)
bool	supportsHiResInputEvents (int shortcut) const override
	~KisToolInvocationAction () override
Public Member Functions inherited from KisAbstractInputAction
virtual QString	description () const
virtual QString	id () const
virtual bool	isAvailable () const
	KisAbstractInputAction (const QString &id)
virtual QString	name () const
virtual QHash< QString, int >	shortcutIndexes () const
virtual	~KisAbstractInputAction ()

Private Attributes
Private *const	d

Additional Inherited Members
Public Attributes inherited from KisAbstractInputAction
QString	description
QString	id
QHash< QString, int >	indexes
QPointF	lastCursorPosition
QString	name
QPointF	startCursorPosition
Static Public Attributes inherited from KisAbstractInputAction
static KisInputManager *	inputManager
Protected Member Functions inherited from KisAbstractInputAction
virtual void	cursorMoved (const QPointF &lastPos, const QPointF &pos)
virtual void	cursorMovedAbsolute (const QPointF &startPos, const QPointF &pos)
QPoint	eventPos (const QEvent *event)
QPointF	eventPosF (const QEvent *event)
KisInputManager *	inputManager () const
void	setDescription (const QString &description)
void	setName (const QString &name)
void	setShortcutIndexes (const QHash< QString, int > &indexes)

Detailed Description

Tool Invocation action of KisAbstractInputAction.

The Tool Invocation action invokes the current tool, for example, using the brush tool, it will start painting.

Definition at line 18 of file kis_tool_invocation_action.h.

Member Enumeration Documentation

Shortcut

enum KisToolInvocationAction::Shortcut

Enumerator
ActivateShortcut
ConfirmShortcut
CancelShortcut
LineToolShortcut
EllipseToolShortcut
RectToolShortcut
MoveToolShortcut
FillToolShortcut
GradientToolShortcut
MeasureToolShortcut
EllipseSelToolShortcut
RectSelToolShortcut
ContigSelToolShortcut
FreehandSelToolShortcut
ActivateWithOtherColorShortcut

Definition at line 21 of file kis_tool_invocation_action.h.

                  {
        ActivateShortcut,
        ConfirmShortcut,
        CancelShortcut,
        LineToolShortcut,
        EllipseToolShortcut,
        RectToolShortcut,
        MoveToolShortcut,
        FillToolShortcut,
        GradientToolShortcut,
        MeasureToolShortcut,
        EllipseSelToolShortcut,
        RectSelToolShortcut,
        ContigSelToolShortcut,
        FreehandSelToolShortcut,
        ActivateWithOtherColorShortcut,
    };

Constructor & Destructor Documentation

KisToolInvocationAction()

KisToolInvocationAction::KisToolInvocationAction ( )

explicit

Definition at line 34 of file kis_tool_invocation_action.cpp.

    : KisAbstractInputAction("Tool Invocation")
    , d(new Private)
{
    setName(i18n("Tool Invocation"));
    setDescription(i18n("The <i>Tool Invocation</i> action invokes the current tool, for example, using the brush tool, it will start painting."));
 
    QHash<QString, int> indexes;
    indexes.insert(i18n("Activate"), ActivateShortcut);
    indexes.insert(i18n("Confirm"), ConfirmShortcut);
    indexes.insert(i18n("Cancel"), CancelShortcut);
    indexes.insert(i18n("Activate Line Tool"), LineToolShortcut);
    indexes.insert(i18n("Activate Ellipse Tool"), EllipseToolShortcut);
    indexes.insert(i18n("Activate Rectangle Tool"), RectToolShortcut);
    indexes.insert(i18n("Activate Move Tool"), MoveToolShortcut);
    indexes.insert(i18n("Activate Fill Tool"), FillToolShortcut);
    indexes.insert(i18n("Activate Gradient Tool"), GradientToolShortcut);
    indexes.insert(i18n("Activate Measure Tool"), MeasureToolShortcut);
    indexes.insert(i18n("Activate Elliptical Selection Tool"), EllipseSelToolShortcut);
    indexes.insert(i18n("Activate Rectangular Selection Tool"), RectSelToolShortcut);
    indexes.insert(i18n("Activate Contiguous Selection Tool"), ContigSelToolShortcut);
    indexes.insert(i18n("Activate Freehand Selection Tool"), FreehandSelToolShortcut);
    indexes.insert(i18n("Activate with Other Color"), ActivateWithOtherColorShortcut);
 
    setShortcutIndexes(indexes);
}

References ActivateShortcut, ActivateWithOtherColorShortcut, CancelShortcut, ConfirmShortcut, ContigSelToolShortcut, EllipseSelToolShortcut, EllipseToolShortcut, FillToolShortcut, FreehandSelToolShortcut, GradientToolShortcut, KisAbstractInputAction::indexes, LineToolShortcut, MeasureToolShortcut, MoveToolShortcut, RectSelToolShortcut, RectToolShortcut, KisAbstractInputAction::setDescription(), KisAbstractInputAction::setName(), and KisAbstractInputAction::setShortcutIndexes().

~KisToolInvocationAction()

KisToolInvocationAction::~KisToolInvocationAction ( )

override

Definition at line 61 of file kis_tool_invocation_action.cpp.

{
    delete d;
}

References d.

Member Function Documentation

activate()

void KisToolInvocationAction::activate ( int shortcut )

overridevirtual

The method is called when the action is yet to be started, that is, e.g. the user has pressed all the modifiers for the action but hasn't started painting yet. This method is a right place to show the user what is going to happen, e.g. change the cursor.

Reimplemented from KisAbstractInputAction.

Definition at line 66 of file kis_tool_invocation_action.cpp.

{
    Q_UNUSED(shortcut);
    if (!inputManager()) return;
 
    QString temporaryToolId;
    switch(shortcut) {
        case LineToolShortcut:
            temporaryToolId = "KritaShape/KisToolLine";
            break;
        case EllipseToolShortcut:
            temporaryToolId = "KritaShape/KisToolEllipse";
            break;
        case RectToolShortcut:
            temporaryToolId = "KritaShape/KisToolRectangle";
            break;
        case MoveToolShortcut:
            temporaryToolId = "KritaTransform/KisToolMove";
            break;
        case FillToolShortcut:
            temporaryToolId = "KritaFill/KisToolFill";
            break;
        case GradientToolShortcut:
            temporaryToolId = "KritaFill/KisToolGradient";
            break;
        case MeasureToolShortcut:
            temporaryToolId = "KritaShape/KisToolMeasure";
            break;
        case EllipseSelToolShortcut:
            temporaryToolId = "KisToolSelectElliptical";
            break;
        case RectSelToolShortcut:
            temporaryToolId = "KisToolSelectRectangular";
            break;
        case ContigSelToolShortcut:
            temporaryToolId = "KisToolSelectContiguous";
            break;
        case FreehandSelToolShortcut:
            temporaryToolId = "KisToolSelectOutline";
            break;
    }
 
    if (!temporaryToolId.isEmpty()) {
        KoToolManager::instance()->switchToolRequested(temporaryToolId);
    }
 
    d->activatedToolProxy = inputManager()->toolProxy();
 
    d->isUsingOtherColor = shortcut == ActivateWithOtherColorShortcut;
 
    if (d->isUsingOtherColor) {
        inputManager()->canvas()->resourceManager()->setUsingOtherColor(true);
    }
 
    d->activatedToolProxy->activateToolAction(KisTool::Primary);
}

References KisToolInvocationAction::Private::activatedToolProxy, ActivateWithOtherColorShortcut, KisInputManager::canvas(), ContigSelToolShortcut, d, EllipseSelToolShortcut, EllipseToolShortcut, FillToolShortcut, FreehandSelToolShortcut, GradientToolShortcut, KisAbstractInputAction::inputManager, KoToolManager::instance(), KisToolInvocationAction::Private::isUsingOtherColor, LineToolShortcut, MeasureToolShortcut, MoveToolShortcut, KisTool::Primary, RectSelToolShortcut, RectToolShortcut, KoCanvasBase::resourceManager, KoToolManager::switchToolRequested(), and KisInputManager::toolProxy().

begin()

void KisToolInvocationAction::begin ( int shortcut, QEvent * event )

overridevirtual

Begin the action.

Parameters

shortcut	The index of the behaviour to trigger.
event	The mouse event that has triggered this action. Is null for keyboard-activated actions.

All the tools now have a KisTool::requestStrokeEnd() method, so they should use this instead of direct filtering Enter key press. Until all the tools support it, we just duplicate the key event and the method call

Some tools would like to distinguish automated requestStrokeEnd() calls from explicit user actions. Just let them do it!

Please note that this call should happen after requestStrokeEnd(). Some of the tools will switch to another tool on this request, and this (next) tool does not expect to get requestStrokeEnd() right after switching in.

The tools now have a KisTool::requestStrokeCancellation() method, so just request it.

Reimplemented from KisAbstractInputAction.

Definition at line 160 of file kis_tool_invocation_action.cpp.

{
    if (shortcut != ConfirmShortcut && shortcut != CancelShortcut ) {
        d->runningToolProxy = inputManager()->toolProxy();
        d->active =
            d->runningToolProxy->forwardEvent(
                KisToolProxy::BEGIN, KisTool::Primary, event, event);
    }
    else if (shortcut == ConfirmShortcut) {
        QKeyEvent pressEvent(QEvent::KeyPress, Qt::Key_Return, QFlags<Qt::KeyboardModifier>());
        inputManager()->toolProxy()->keyPressEvent(&pressEvent);
        QKeyEvent releaseEvent(QEvent::KeyRelease, Qt::Key_Return, QFlags<Qt::KeyboardModifier>());
        inputManager()->toolProxy()->keyReleaseEvent(&releaseEvent);
 
        inputManager()->canvas()->image()->requestStrokeEnd();
 
        inputManager()->toolProxy()->explicitUserStrokeEndRequest();
 
    } else if (shortcut == CancelShortcut) {
        inputManager()->canvas()->image()->requestStrokeCancellation();
    }
}

References KisToolInvocationAction::Private::active, KisToolProxy::BEGIN, CancelShortcut, KisInputManager::canvas(), ConfirmShortcut, d, KisCanvas2::image(), KisAbstractInputAction::inputManager, KisTool::Primary, KisImage::requestStrokeCancellation(), KisImage::requestStrokeEnd(), KisToolInvocationAction::Private::runningToolProxy, and KisInputManager::toolProxy().

canIgnoreModifiers()

bool KisToolInvocationAction::canIgnoreModifiers ( ) const

overridevirtual

Returns true if an action can run with any modifiers pressed (the shortcut's modifiers list must be empty for that). That is used for making one type of actions default one.

Reimplemented from KisAbstractInputAction.

Definition at line 155 of file kis_tool_invocation_action.cpp.

{
    return true;
}

deactivate()

void KisToolInvocationAction::deactivate ( int shortcut )

overridevirtual

The method is called when the action is not a candidate for the starting anymore. The action should revert everything that was done in activate() method.

See also

activate()

Activate call might have come before actual input manager or tool proxy was attached. So we may end up with null activatedToolProxy.

Reimplemented from KisAbstractInputAction.

Definition at line 123 of file kis_tool_invocation_action.cpp.

{
    Q_UNUSED(shortcut);
    if (!inputManager()) return;
 
    // Revert UsingOtherColor
    if (d->isUsingOtherColor) {
        inputManager()->canvas()->resourceManager()->setUsingOtherColor(false);
    }
 
    if (d->activatedToolProxy) {
        d->activatedToolProxy->deactivateToolAction(KisTool::Primary);
        d->activatedToolProxy.clear();
    }
 
    if (shortcut != ActivateShortcut && shortcut != ConfirmShortcut && shortcut != CancelShortcut && shortcut != ActivateWithOtherColorShortcut && !d->deactivating) {
        // Switching tool will force deactivation and will re-enter
        d->deactivating = true;
        KoToolManager::instance()->switchBackRequested();
        d->deactivating = false;
    }
}

References KisToolInvocationAction::Private::activatedToolProxy, ActivateShortcut, ActivateWithOtherColorShortcut, CancelShortcut, KisInputManager::canvas(), ConfirmShortcut, d, KisToolInvocationAction::Private::deactivating, KisAbstractInputAction::inputManager, KoToolManager::instance(), KisToolInvocationAction::Private::isUsingOtherColor, KisTool::Primary, KoCanvasBase::resourceManager, and KoToolManager::switchBackRequested().

end()

void KisToolInvocationAction::end ( QEvent * event )

overridevirtual

End the action.

Parameters

event

The mouse event that has finished this action. Is null for keyboard-activated actions.

Reimplemented from KisAbstractInputAction.

Definition at line 203 of file kis_tool_invocation_action.cpp.

{
    if (d->active) {
        // It might happen that the action is still running, while the
        // canvas has been removed, which kills the toolProxy.
        KIS_SAFE_ASSERT_RECOVER_NOOP(d->runningToolProxy);
        if (d->runningToolProxy) {
            d->runningToolProxy->
                forwardEvent(KisToolProxy::END, KisTool::Primary, event, event);
            d->runningToolProxy.clear();
        }
        d->active = false;
    }
 
    KisAbstractInputAction::end(event);
}

References KisToolInvocationAction::Private::active, d, KisToolProxy::END, KisAbstractInputAction::end(), KIS_SAFE_ASSERT_RECOVER_NOOP, KisTool::Primary, and KisToolInvocationAction::Private::runningToolProxy.

inputActionGroup()

KisInputActionGroup KisToolInvocationAction::inputActionGroup ( int shortcut ) const

overridevirtual

Returns

the group of the action the specified shortcut belongs to

Reimplemented from KisAbstractInputAction.

Definition at line 255 of file kis_tool_invocation_action.cpp.

{
    Q_UNUSED(shortcut);
    return ToolInvoactionActionGroup;
}

References ToolInvoactionActionGroup.

inputEvent()

void KisToolInvocationAction::inputEvent ( QEvent * event )

overridevirtual

Process an input event.

By default handles MouseMove events and passes the data to a convenience cursorMoved() method

Parameters

event

An event to process.

Reimplemented from KisAbstractInputAction.

Definition at line 220 of file kis_tool_invocation_action.cpp.

{
    if (!d->active) return;
    if (!d->runningToolProxy) return;
 
    d->runningToolProxy->
        forwardEvent(KisToolProxy::CONTINUE, KisTool::Primary, event, event);
}

References KisToolInvocationAction::Private::active, KisToolProxy::CONTINUE, d, KisTool::Primary, and KisToolInvocationAction::Private::runningToolProxy.

isShortcutRequired()

bool KisToolInvocationAction::isShortcutRequired ( int shortcut ) const

overridevirtual

Return true when the specified shortcut is required for basic user interaction. This is used by the configuration system to prevent basic actions like painting from being removed.

Parameters

shortcut

The shortcut index to check.

Returns

True if the shortcut is required, false if not.

Reimplemented from KisAbstractInputAction.

Definition at line 248 of file kis_tool_invocation_action.cpp.

{
    // These three shortcuts are pretty important for basic user interaction,
    // so they should always exist.
    return (shortcut == ActivateShortcut || shortcut == ConfirmShortcut || shortcut == CancelShortcut);
}

References ActivateShortcut, CancelShortcut, and ConfirmShortcut.

priority()

int KisToolInvocationAction::priority ( ) const

overridevirtual

The priority for this action.

Priority determines how "important" the action is and is used to resolve conflicts when multiple actions can be activated.

Reimplemented from KisAbstractInputAction.

Definition at line 150 of file kis_tool_invocation_action.cpp.

{
    return 0;
}

processUnhandledEvent()

void KisToolInvocationAction::processUnhandledEvent

(

QEvent *

event

)

Definition at line 229 of file kis_tool_invocation_action.cpp.

{
    bool savedState = d->active;
    KisToolProxy *savedToolProxy = d->runningToolProxy;
    if (!d->runningToolProxy) {
        d->runningToolProxy = inputManager()->toolProxy();
    }
    d->active = true;
    inputEvent(event);
    d->active = savedState;
    d->runningToolProxy = savedToolProxy;
}

References KisToolInvocationAction::Private::active, d, inputEvent(), KisAbstractInputAction::inputManager, KisToolInvocationAction::Private::runningToolProxy, and KisInputManager::toolProxy().

supportsHiResInputEvents()

bool KisToolInvocationAction::supportsHiResInputEvents ( int shortcut ) const

overridevirtual

Returns true if the action can handle HiRes flow of move events which is generated by the tablet. If the function returns false, some of the events will be dropped or postponed. For most of the actions in Krita (except of real painting) it is perfectly acceptable, so 'false' is the default value.

Reimplemented from KisAbstractInputAction.

Definition at line 242 of file kis_tool_invocation_action.cpp.

{
    Q_UNUSED(shortcut);
    return inputManager()->toolProxy()->primaryActionSupportsHiResEvents();
}

References KisAbstractInputAction::inputManager, and KisInputManager::toolProxy().

Member Data Documentation

d

Private* const KisToolInvocationAction::d

private

Definition at line 63 of file kis_tool_invocation_action.h.

---

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

• libs/ui/input/kis_tool_invocation_action.h
• libs/ui/input/kis_tool_invocation_action.cpp