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 TActionFunctor
  {
  public:
    virtual bool DoAction(StateMachineAction *, InteractionEvent *) = 0;
    virtual ~TActionFunctor() {}
  };
 
  // * \class TSpecificActionFunctor
  // * Specific implementation of ActionFunctor class, implements a reference to the function which is to be executed.
  // It
  // takes two arguments:
  // * StateMachineAction - the action by which the function call is invoked, InteractionEvent - the event that caused
  // the
  // transition.
  // */
  // template<class T>
  // class DEPRECATED() TSpecificActionFunctor : public TActionFunctor
  //{
  // public:
 
  //  TSpecificActionFunctor(T* object, bool (T::*memberFunctionPointer)(StateMachineAction*, InteractionEvent*)) :
  //      m_Object(object), m_MemberFunctionPointer(memberFunctionPointer)
  //  {
  //  }
 
  //  virtual ~TSpecificActionFunctor()
  //  {
  //  }
  //  virtual bool DoAction(StateMachineAction* action, InteractionEvent* event) override
  //  {
  //    return (*m_Object.*m_MemberFunctionPointer)(action, event);// executes member function
  //  }
 
  // private:
  //  T* m_Object;
  //  bool (T::*m_MemberFunctionPointer)(StateMachineAction*, InteractionEvent*);
  //};
 
  class MITKCORE_EXPORT EventStateMachine : public mitk::InteractionEventHandler
  {
  public:
    mitkClassMacro(EventStateMachine, InteractionEventHandler);
 
      typedef std::map<std::string, TActionFunctor *> DEPRECATED(ActionFunctionsMapType);
 
    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;
 
    DEPRECATED(void AddActionFunction(const std::string &action, TActionFunctor *functor));
 
    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.
    std::map<std::string, TActionFunctor *> m_ActionFunctionsMap; // stores association between action string
    ActionDelegatesMapType m_ActionDelegatesMap;
    ConditionDelegatesMapType m_ConditionDelegatesMap;
    StateMachineStateType m_CurrentState;
 
    bool m_MouseCursorSet;
  };
 
} /* namespace mitk */
#endif