itkCommand.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkCommand.h,v $
  Language:  C++
  Date:      $Date: 2005/03/22 18:25:12 $
  Version:   $Revision: 1.33 $

  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) {}
  ~CStyleCommand() 
    { 
    if (m_ClientDataDeleteCallback)
      {
      m_ClientDataDeleteCallback(m_ClientData);
      }
    };
  void *m_ClientData;
  FunctionPointer m_Callback;
  ConstFunctionPointer m_ConstCallback;
  DeleteDataFunctionPointer m_ClientDataDeleteCallback;
};


} // end namespace itk

#endif

---