itkCommand.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkCommand.h,v $
  Language:  C++
  Date:      $Date: 2007-01-26 14:28:44 $
  Version:   $Revision: 1.36 $

  Copyright (c) Insight Software Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even 
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
#ifndef __itkCommand_h
#define __itkCommand_h

#include "itkObject.h"
#include "itkObjectFactory.h"


namespace itk
{

// The superclass that all commands should be subclasses of
class ITKCommon_EXPORT Command : public Object
{
public:
  typedef Command                   Self;
  typedef Object                    Superclass;
  typedef SmartPointer<Self>        Pointer;
  typedef SmartPointer<const Self>  ConstPointer;

  itkTypeMacro(Command,Object);

  virtual void Execute(Object *caller, const EventObject & event ) = 0;

  virtual void Execute(const Object *caller, const EventObject & event ) = 0;

protected:
  Command();
  ~Command();

private:
  Command(const Self&); //purposely not implemented
  void operator=(const Self&); //purposely not implemented
};

 
// some implementations for several callback types

template <class T>
class MemberCommand : public Command
{
public:
  typedef  void (T::*TMemberFunctionPointer)(Object*, const EventObject &);
  typedef  void (T::*TConstMemberFunctionPointer)(const Object*, 
                                                  const EventObject &);

  typedef MemberCommand       Self;
  typedef SmartPointer<Self>  Pointer;

  itkNewMacro(Self);

  itkTypeMacro(MemberCommand,Command);

  void SetCallbackFunction(T* object,  
                           TMemberFunctionPointer memberFunction)
    {
    m_This = object;
    m_MemberFunction = memberFunction;
    }
  void SetCallbackFunction(T* object,  
                           TConstMemberFunctionPointer memberFunction)
    {
    m_This = object;
    m_ConstMemberFunction = memberFunction;
    }

  virtual void Execute(Object *caller, const EventObject & event )
    { 
    if( m_MemberFunction ) 
      {
      ((*m_This).*(m_MemberFunction))(caller, event);
      }
    }

  virtual void Execute( const Object *caller, const EventObject & event )
    { 
    if( m_ConstMemberFunction ) 
      {
      ((*m_This).*(m_ConstMemberFunction))(caller, event);
      }
    }

protected:

  T* m_This;
  TMemberFunctionPointer m_MemberFunction;
  TConstMemberFunctionPointer m_ConstMemberFunction;
  MemberCommand():m_MemberFunction(0),m_ConstMemberFunction(0) {}
  virtual ~MemberCommand(){}

private:
  MemberCommand(const Self&); //purposely not implemented
  void operator=(const Self&); //purposely not implemented

};


template <class T>
class ReceptorMemberCommand : public Command
{
public:
  typedef  void (T::*TMemberFunctionPointer)(const EventObject &);

  typedef ReceptorMemberCommand  Self;
  typedef SmartPointer<Self>     Pointer;

  itkNewMacro(Self);

  itkTypeMacro(ReceptorMemberCommand,Command);

  void SetCallbackFunction(T* object,  
                           TMemberFunctionPointer memberFunction)
    {
    m_This = object;
    m_MemberFunction = memberFunction;
    }

  virtual void Execute(Object *, const EventObject & event )
    { 
    if( m_MemberFunction ) 
      {
      ((*m_This).*(m_MemberFunction))(event);
      }
    }

  virtual void Execute( const Object *, const EventObject & event )
    { 
    if( m_MemberFunction ) 
      {
      ((*m_This).*(m_MemberFunction))(event);
      }
    }

protected:
  T* m_This;
  TMemberFunctionPointer m_MemberFunction;
  ReceptorMemberCommand():m_MemberFunction(0) {}
  virtual ~ReceptorMemberCommand() {}

private:
  ReceptorMemberCommand(const Self&); //purposely not implemented
  void operator=(const Self&); //purposely not implemented
  
};


template <class T>
class SimpleMemberCommand : public Command
{ 
public:
  typedef  void (T::*TMemberFunctionPointer)(); 

  typedef SimpleMemberCommand   Self;
  typedef SmartPointer<Self>    Pointer;

  itkTypeMacro(SimpleMemberCommand,Command);

  itkNewMacro(Self);

  void SetCallbackFunction(T* object,  
                           TMemberFunctionPointer memberFunction)
    {
    m_This = object;
    m_MemberFunction = memberFunction;
    }

  virtual void Execute(Object *,const EventObject & ) 
    { 
    if( m_MemberFunction ) 
      {
      ((*m_This).*(m_MemberFunction))();
      }
    }
  virtual void Execute(const Object *,const EventObject & ) 
    { 
    if( m_MemberFunction ) 
      {
      ((*m_This).*(m_MemberFunction))();
      }
    }

protected:
  T* m_This;
  TMemberFunctionPointer m_MemberFunction;
  SimpleMemberCommand():m_MemberFunction(0) {}
  virtual ~SimpleMemberCommand() {}

private:
  SimpleMemberCommand(const Self&); //purposely not implemented
  void operator=(const Self&); //purposely not implemented

};


template <class T>
class SimpleConstMemberCommand : public Command
{ 
public:
  typedef  void (T::*TMemberFunctionPointer)() const; 

  typedef SimpleConstMemberCommand  Self;
  typedef SmartPointer<Self>        Pointer;

  itkTypeMacro(SimpleConstMemberCommand,Command);

  itkNewMacro(Self);

  void SetCallbackFunction(const T* object,  
                           TMemberFunctionPointer memberFunction)
    {
    m_This = object;
    m_MemberFunction = memberFunction;
    }

  virtual void Execute(Object *,const EventObject & ) 
    { 
    if( m_MemberFunction ) 
      {
      ((*m_This).*(m_MemberFunction))();
      }
    }
  virtual void Execute(const Object *,const EventObject & ) 
    { 
    if( m_MemberFunction ) 
      {
      ((*m_This).*(m_MemberFunction))();
      }
    }

protected:
  const T* m_This;
  TMemberFunctionPointer m_MemberFunction;
  SimpleConstMemberCommand():m_MemberFunction(0) {}
  virtual ~SimpleConstMemberCommand() {} 

private:
  SimpleConstMemberCommand(const Self&); //purposely not implemented
  void operator=(const Self&); //purposely not implemented
  
};


class CStyleCommand : public Command
{
public:
  typedef  void (*FunctionPointer)(Object*, const EventObject &, void*);
  typedef  void (*ConstFunctionPointer)(const Object*, 
                                        const EventObject &, void*);
  typedef  void (*DeleteDataFunctionPointer)(void*);

  typedef CStyleCommand       Self;
  typedef SmartPointer<Self>  Pointer;

  itkTypeMacro(CStyleCommand,Command);

  itkNewMacro(Self);

  void SetClientData(void *cd) {m_ClientData = cd;}

  void SetCallback(FunctionPointer f)
    {m_Callback = f;}
  void SetConstCallback(ConstFunctionPointer f)
    {m_ConstCallback = f;}

  void SetClientDataDeleteCallback(DeleteDataFunctionPointer f)
    {m_ClientDataDeleteCallback = f;}

  void Execute(Object *caller, const EventObject & event )
    {
    if (m_Callback)
      {
      m_Callback(caller, event, m_ClientData );
      }
    }

  void Execute(const Object *caller, const EventObject & event )
    {
    if (m_ConstCallback)
      {
      m_ConstCallback(caller, event, m_ClientData );
      }
    }

protected:
  CStyleCommand(): m_ClientData(0), m_Callback(0), m_ConstCallback(0),
                   m_ClientDataDeleteCallback(0) 
    {
    // not implemented
    }
  ~CStyleCommand() 
    { 
    if (m_ClientDataDeleteCallback)
      {
      m_ClientDataDeleteCallback(m_ClientData);
      }
    }

  void *                    m_ClientData;
  FunctionPointer           m_Callback;
  ConstFunctionPointer      m_ConstCallback;
  DeleteDataFunctionPointer m_ClientDataDeleteCallback;
};


} // end namespace itk

#endif