mitkToolEvents.h

Go to the documentation of this file.

/*===================================================================

The Medical Imaging Interaction Toolkit (MITK)

Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.

This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.

See LICENSE.txt or http://www.mitk.org for details.

===================================================================*/

#ifndef MITK_TOOL_EVENTS_H
#define MITK_TOOL_EVENTS_H

#pragma GCC visibility push(default)
#include <itkEventObject.h>
#pragma GCC visibility pop

namespace mitk
{
#pragma GCC visibility push(default)
  itkEventMacro(ToolEvent, itk::ModifiedEvent);
#pragma GCC visibility pop

  template <typename T>
  class ParameterToolEvent : public ToolEvent
  {
  public:
    typedef ParameterToolEvent Self;
    typedef ToolEvent Superclass;

    ParameterToolEvent(const T parameter) : m_Parameter(parameter) {}
    ParameterToolEvent(const Self &s) : ToolEvent(s), m_Parameter(s.m_Parameter) {}
    virtual ~ParameterToolEvent() {}
    virtual const char *GetEventName() const override { return "ParameterToolEvent"; }
    virtual bool CheckEvent(const ::itk::EventObject *e) const override { return dynamic_cast<const Self *>(e); }
    virtual ::itk::EventObject *MakeObject() const override { return new Self(m_Parameter); }
    const T GetParameter() const { return m_Parameter; }
  protected:
    const T m_Parameter;

  private:
    ParameterToolEvent();

    void operator=(const Self &);
  };

  template <typename T, typename U>
  class TwoParameterToolEvent : public ToolEvent
  {
  public:
    typedef TwoParameterToolEvent Self;
    typedef ToolEvent Superclass;

    TwoParameterToolEvent(const T parameter1, const U parameter2) : m_Parameter1(parameter1), m_Parameter2(parameter2)
    {
    }

    TwoParameterToolEvent(const Self &s) : ToolEvent(s), m_Parameter1(s.m_Parameter1), m_Parameter2(s.m_Parameter2) {}
    virtual ~TwoParameterToolEvent() {}
    virtual const char *GetEventName() const override { return "TwoParameterToolEvent"; }
    virtual bool CheckEvent(const ::itk::EventObject *e) const override { return dynamic_cast<const Self *>(e); }
    virtual ::itk::EventObject *MakeObject() const override { return new Self(m_Parameter1, m_Parameter2); }
    const T GetParameter1() const { return m_Parameter1; }
    const T GetParameter2() const { return m_Parameter2; }
  protected:
    const T m_Parameter1;
    const U m_Parameter2;

  private:
    TwoParameterToolEvent();

    void operator=(const Self &);
  };

  typedef ParameterToolEvent<int> IntegerToolEvent;
  typedef ParameterToolEvent<float> FloatToolEvent;
  typedef ParameterToolEvent<bool> BoolToolEvent;

} // namespace

// some macros to let tools define their own event classes as inner classes (should then inherit from something like
// FloatToolEvent
// inheritance, because it allows observers to distinguish events

#define mitkToolEventMacro(eventname, baseevent)                                                                       \
  \
class eventname : public baseevent\
{virtual const char * GetEventName() const {return #eventname;                                                         \
  }                                                                                                                    \
  \
}                                                                                                                 \
  ;

#define mitkToolEventMacro1Param(eventname, paramtype1)                                                                \
  \
class eventname : public ParameterToolEvent<paramtype1>                                                                \
  \
{                                                                                                                 \
  public:                                                                                                              \
    virtual const char *GetEventName() const { return #eventname "(" #paramtype1 ")"; }                                \
    eventname(const paramtype1 parameter) : ParameterToolEvent<paramtype1>(parameter) {}                               \
  private:                                                                                                             \
    eventname();                                                                                                       \
  \
};

#define mitkToolEventMacro2Param(eventname, paramtype1, paramtype2)                                                    \
  \
class eventname : public TwoParameterToolEvent<paramtype1, paramtype2>                                                 \
  \
{                                                                                                                 \
  public:                                                                                                              \
    virtual const char *GetEventName() const { return #eventname "(" #paramtype1 "," #paramtype2 ")"; }                \
    eventname(const paramtype1 parameter1, const paramtype2 parameter2)                                                \
      : TwoParameterToolEvent<paramtype1, paramtype2>(parameter1, parameter2)                                          \
    {                                                                                                                  \
    }                                                                                                                  \
                                                                                                                       \
  private:                                                                                                             \
    eventname();                                                                                                       \
  \
};

#endif