mitkTimeNavigationController.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 TimeNavigationController_h
#define TimeNavigationController_h
 
#include <MitkCoreExports.h>
 
#include <mitkBaseController.h>
#include <mitkTimeGeometry.h>
 
#include <itkCommand.h>
 
namespace mitk
{
  class MITKCORE_EXPORT TimeNavigationController : public BaseController
  {
  public:
 
    mitkClassMacro(TimeNavigationController, BaseController);
    itkNewMacro(Self);
 
    void SetInputWorldTimeGeometry(const TimeGeometry* geometry);
    itkGetConstObjectMacro(InputWorldTimeGeometry, mitk::TimeGeometry);
 
    virtual void Update();
 
    virtual void SendTime();
 
    class MITKCORE_EXPORT TimeEvent : public itk::AnyEvent
    {
    public:
 
      typedef TimeEvent Self;
      typedef itk::AnyEvent Superclass;
 
      TimeEvent(TimeStepType timeStep) : m_TimeStep(timeStep) {}
      ~TimeEvent() override {}
      const char *GetEventName() const override { return "TimeEvent"; }
      bool CheckEvent(const ::itk::EventObject *e) const override { return dynamic_cast<const Self *>(e); }
      ::itk::EventObject *MakeObject() const override { return new Self(m_TimeStep); }
      TimeStepType GetTimeStep() const { return m_TimeStep; }
    private:
 
      TimeStepType m_TimeStep;
      void operator=(const Self &);
    };
 
    template <typename T>
    void ConnectTimeEvent(T* receiver)
    {
      typedef typename itk::ReceptorMemberCommand<T>::Pointer ReceptorMemberCommandPointer;
      ReceptorMemberCommandPointer eventReceptorCommand = itk::ReceptorMemberCommand<T>::New();
      eventReceptorCommand->SetCallbackFunction(receiver, &T::SetGeometryTime);
      unsigned long tag = AddObserver(TimeEvent(0), eventReceptorCommand);
      m_ReceiverToObserverTagsMap[static_cast<void *>(receiver)].push_back(tag);
    }
 
    // use a templated method to get the right offset when casting to void*
    template <typename T>
    void Disconnect(T* receiver)
    {
      auto i = m_ReceiverToObserverTagsMap.find(static_cast<void*>(receiver));
      if (i == m_ReceiverToObserverTagsMap.end())
        return;
      const std::list<unsigned long>& tags = i->second;
      for (auto tagIter = tags.begin(); tagIter != tags.end(); ++tagIter)
      {
        RemoveObserver(*tagIter);
      }
      m_ReceiverToObserverTagsMap.erase(i);
    }
 
    TimeStepType GetSelectedTimeStep() const;
 
    TimePointType GetSelectedTimePoint() const;
 
  protected:
 
    TimeNavigationController();
    ~TimeNavigationController() override;
 
    TimeGeometry::ConstPointer m_InputWorldTimeGeometry;
 
    bool m_BlockUpdate;
 
    typedef std::map<void*, std::list<unsigned long>> ObserverTagsMapType;
    ObserverTagsMapType m_ReceiverToObserverTagsMap;
  };
 
} // namespace mitk
 
#endif