freControllerEvents.h

Go to the documentation of this file.

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

  Program:   F.R.E.E. - flexible registration evaluation engine
  Version:   v.1.0.0
  Date:      $Date: 2006/09/01 12:00:00 $
  Module:    $RCSfile: freControllerEvents.h,v $
  Language:  C++



  Copyright (c) 2007 Ralf o Floca (Department of Medical Informatics,
  Institute for Medical Biometry and Informatics, University of Heidelberg,
  Germany). All rights reserved.
  See FREECopyright.txt or http://www.mi.med.uni-hd.de/free/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 __freControllerEvents_h
#define __freControllerEvents_h

#include "freEvents.h"
#include "freIDPath.h"
#include "freSessionComponentCache.h"

#include "itkMutexLock.h"

namespace FREE
{

class CallbackCtrlEventBase : public itk::LightObject
{
public:
   typedef long CallbackType;
   typedef bool (*CallEvent)(const IDPath& senderID, CallbackType callbackID,
                             void* pData, SessionComponentCache* pSender, long threadID);

   typedef CallbackCtrlEventBase Self;
   typedef itk::SmartPointer<Self> Pointer;

         freNewEventBaseMacro(CallbackCtrlEventBase,CallEvent);
         itkTypeMacro(CallbackEventBase,itk::LightObject);

   void SetACR(SessionComponentCache* pCache);

   SessionComponentCache* GetACR();

   bool IsLegalSender(SessionComponentCache* pSender);

private:
  CallEvent m_CallEvent;
  SessionComponentCache* m_ACR;

  itk::SimpleMutexLock m_ACRMutex;

  CallbackCtrlEventBase(const Self&); //purposely not implemented
  void operator=(const Self&); //purposely not implemented

protected:
  CallbackCtrlEventBase(CallEvent pCE);
  CallbackCtrlEventBase();

  itk::SimpleMutexLock m_ExecutionMutex;

public:

   virtual bool Execute(const IDPath& senderID, CallbackType callbackID,
                        void* pData, SessionComponentCache* pSender, long threadID = 0);
};

class ProgressCtrlEventBase: public NotificationEventBase
{
public:
   typedef long StatusID;
   typedef void (*ProgEvent)(const IDPath& senderID,
                             const StatusID status,
                             const std::string& sComment,
                             SessionComponentCache* pSender,
                             long threadID);

   typedef ProgressCtrlEventBase Self;
   typedef itk::SmartPointer<Self> Pointer;
   
         freNewEventBaseMacro(ProgressCtrlEventBase,ProgEvent);
         itkTypeMacro(ProgressCtrlEventBase,NotificationEventBase);

   void SetACR(SessionComponentCache* pCache);

   SessionComponentCache* GetACR();

   bool IsLegalSender(SessionComponentCache* pSender);

private:
   ProgEvent m_ProgressEvent;
  SessionComponentCache* m_ACR;

  itk::SimpleMutexLock m_ACRMutex;

  ProgressCtrlEventBase(const Self&); //purposely not implemented
  void operator=(const Self&); //purposely not implemented

protected:
   ProgressCtrlEventBase(ProgEvent pPE);
   ProgressCtrlEventBase();

   itk::SimpleMutexLock m_ExecutionMutex;

public:
   virtual void Execute(const IDPath& senderID,
                        const StatusID status,
                        const std::string& sComment,
                        SessionComponentCache* pSender,
                        long threadID = 0);
};

template <typename T>
class CallbackCtrlEvent: public CallbackCtrlEventBase
{
public:  
   typedef bool (T::*CallEvent)(const IDPath& senderID, CallbackType callbackID,
                                void* pData, SessionComponentCache* pSender,
                                long threadID);

   typedef CallbackCtrlEvent<T>  Self;
   typedef itk::SmartPointer<Self> Pointer;

         freNewEventMacro(CallbackCtrlEvent, T, CallEvent);
         itkTypeMacro(CallbackCtrlEvent,CallbackCtrlEventBase);

private:
  T* m_Object;
  CallEvent m_CallEvent;

  CallbackCtrlEvent(const Self&); //purposely not implemented
  void operator=(const Self&); //purposely not implemented

protected:
   CallbackCtrlEvent(T* pObject, CallEvent pCE)
   {
          m_Object = pObject;
          m_CallEvent = pCE;
   };

public:
   virtual bool Execute(const IDPath& senderID, CallbackType callbackID,
                        void* pData, SessionComponentCache* pSender, long threadID = 0)
   {
      if (!this->m_Object)return false;
      if (!this->m_CallEvent) return false;

      bool result = false;

      if (this->IsLegalSender(pSender))
      {
        this->m_ExecutionMutex.Lock();
                result = (m_Object->*m_CallEvent)(senderID, callbackID, pData, pSender, threadID); 
        this->m_ExecutionMutex.Unlock();
      }

      return result;
   };
};

template <typename T>
class ProgressCtrlEvent: public ProgressCtrlEventBase
{
public:
   typedef void (T::*ProgEvent)(const IDPath& senderID,
                                const StatusID status,
                                const std::string& sComment,
                                SessionComponentCache* pSender,
                                long threadID);

   typedef ProgressCtrlEvent<T>  Self;
   typedef itk::SmartPointer<Self> Pointer;

         freNewEventMacro(ProgressCtrlEvent, T, ProgEvent);
         itkTypeMacro(ProgressCtrlEvent,ProgressCtrlEventBase);

private:
   T* m_Object;
   ProgEvent m_ProgressEvent;

  ProgressCtrlEvent(const Self&); //purposely not implemented
  void operator=(const Self&); //purposely not implemented

protected:
         ProgressCtrlEvent(T* pObject, ProgEvent pPE)
   {
          m_Object = pObject;
          m_ProgressEvent = pPE;
   };
   
public:
   virtual void Execute(const IDPath& senderID,
                        const StatusID status,
                        const std::string& sComment,
                        SessionComponentCache* pSender,
                        long threadID = 0)
   {
      if (!this->m_Object)return;
      if (!this->m_ProgressEvent) return;

      if (this->IsLegalSender(pSender))
      {
        this->m_ExecutionMutex.Lock();
          (m_Object->*m_ProgressEvent)(senderID, status, sComment, pSender, threadID);
        this->m_ExecutionMutex.Unlock();
      }
   };
};

} //end of namespace free
#endif

---