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 /* MITKEVENTSTATEMACHINE_H_ */