mitkEventStateMachine.h

Go to the documentation of this file.

/*============================================================================
 
The Medical Imaging Interaction Toolkit (MITK)
 
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
 
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
 
============================================================================*/
 
#ifndef mitkEventStateMachine_h
#define mitkEventStateMachine_h
 
#include <itkObject.h>
#include <mitkCommon.h>
#include <mitkInteractionEventHandler.h>
#include <mitkMessage.h>
 
#include <MitkCoreExports.h>
#include <string>
 
#define CONNECT_FUNCTION(a, f)                                                                                         \
  ::mitk::EventStateMachine::AddActionFunction(                                                                        \
    a,                                                                                                                 \
    ::mitk::MessageDelegate2<Self, ::mitk::StateMachineAction *, ::mitk::InteractionEvent *, void>(this, &Self::f));
 
#define CONNECT_CONDITION(a, f)                                                                                        \
  ::mitk::EventStateMachine::AddConditionFunction(                                                                     \
    a, ::mitk::MessageDelegate1<Self, const ::mitk::InteractionEvent *, bool>(this, &Self::f));
 
namespace us
{
  class Module;
}
 
namespace mitk
{
  class StateMachineTransition;
  class StateMachineContainer;
  class StateMachineAction;
  class StateMachineCondition;
  class InteractionEvent;
  class StateMachineState;
  class DataNode;
  class UndoController;
 
  class MITKCORE_EXPORT EventStateMachine : public mitk::InteractionEventHandler
  {
  public:
    mitkClassMacro(EventStateMachine, InteractionEventHandler);
 
    typedef itk::SmartPointer<StateMachineState> StateMachineStateType;
 
    bool LoadStateMachine(const std::string &filename, const us::Module *module = nullptr);
 
    bool HandleEvent(InteractionEvent *event, DataNode *dataNode);
 
    void EnableUndo(bool enable) { m_UndoEnabled = enable; }
 
    void EnableInteraction(bool enable) { m_IsActive = enable; }
  protected:
    EventStateMachine();
    ~EventStateMachine() override;
 
    typedef MessageAbstractDelegate2<StateMachineAction *, InteractionEvent *, void> ActionFunctionDelegate;
    typedef MessageAbstractDelegate1<const InteractionEvent *, bool> ConditionFunctionDelegate;
 
    void AddActionFunction(const std::string &action, const ActionFunctionDelegate &delegate);
 
    void AddConditionFunction(const std::string &condition, const ConditionFunctionDelegate &delegate);
 
    StateMachineState *GetCurrentState() const;
 
    void ResetToStartState();
 
    virtual void ConnectActionsAndFunctions();
 
    virtual bool CheckCondition(const StateMachineCondition &condition, const InteractionEvent *interactionEvent);
 
    virtual void ExecuteAction(StateMachineAction *action, InteractionEvent *interactionEvent);
 
    virtual bool FilterEvents(InteractionEvent *interactionEvent, DataNode *dataNode);
 
    void SetMouseCursor(const char *xpm[], int hotspotX, int hotspotY);
 
    void ResetMouseCursor();
 
    StateMachineTransition *GetExecutableTransition(InteractionEvent *event);
 
    // Determines if state machine reacts to events
    bool m_IsActive;
    // Undo/Redo
    UndoController *m_UndoController;
    bool m_UndoEnabled;
 
  private:
    typedef std::map<std::string, ActionFunctionDelegate *> ActionDelegatesMapType;
    typedef std::map<std::string, ConditionFunctionDelegate *> ConditionDelegatesMapType;
 
    StateMachineContainer
      *m_StateMachineContainer; // storage of all states, action, transitions on which the statemachine operates.
    ActionDelegatesMapType m_ActionDelegatesMap;
    ConditionDelegatesMapType m_ConditionDelegatesMap;
    StateMachineStateType m_CurrentState;
 
    bool m_MouseCursorSet;
  };
 
} /* namespace mitk */
#endif