/*=============================================================================
  
  NOTE: THIS FILE IS A HANDMADE WRAPPER FOR THE ManagedITK PROJECT.

  Project:   ManagedITK
  Program:   Insight Segmentation & Registration Toolkit
  Module:    itkManagedObject.cxx
  Language:  C++/CLI
  Author:    Dan Mueller
  $Date: 2007-04-11 16:26:16 +1000 (Wed, 11 Apr 2007) $
  $Revision: 128 $

  Copyright (c) Queensland University of Technology (QUT) 2007.
  All rights reserved.
  
  Portions of this code are covered under the ITK and VTK copyright.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.
  See VTKCopyright.txt or http://www.kitware.com/VTKCopyright.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.
  
=============================================================================*/

#pragma once
#pragma warning( disable : 4635 ) // Disable warnings about XML doc comments

#ifndef __itkManagedObject_cxx
#define __itkManagedObject_cxx

// Include some headers for string ops
#include <iostream>  
#include <map>
#include <string>
using std::string;

// Include some useful ManagedITK files
#include "itkManagedINativePointer.cxx"

// Use some managed namespaces
#using <mscorlib.dll>
#using <System.dll>
using namespace System;
using namespace System::IO;
using namespace System::Reflection;
using namespace System::Diagnostics;
using namespace System::Collections::Generic;


namespace itk
{

/** Forward reference to itkObject */
ref class itkObject; 

///<summary>A delegate for events sent from an itkObject.</summary>
public delegate void itkObjectHandler(itkObject^ sender);
///<summary>A delegate for events sent from an itkObject, with a time.</summary>
public delegate void itkTimedEventHandler(itkObject^ sender, DateTime time);

///<summary>
///This class is a managed replacement for itk::Object.
///</summary>
///<remarks>
///Object is the second-highest level base class for most itk objects. 
///It extends the base object functionality of LightObject by          
///implementing callbacks (via object/observer), debug flags/methods,  
///and modification time tracking. Most ITK classes should be a subclass
///of Object due to the need to keep track of modified time.
///</remarks>
public ref class itkObject abstract : INativePointer
{

private:	
	String^ m_Name;
	Dictionary<String^, Object^>^ m_Metadata;
	itkTimedEventHandler^	m_EventStorage_Started;
	itkTimedEventHandler^	m_EventStorage_Ended;
	itkTimedEventHandler^	m_EventStorage_Aborted;
	itkObjectHandler^		m_EventStorage_Iteration;
	itkObjectHandler^		m_EventStorage_Modified;

protected:
	bool m_IsDisposed;
	String^ m_MangledTypeString;

    ///<summary>Protected constructor.</summary>
	itkObject( )
	{
        this->m_IsDisposed = false;
		this->m_MangledTypeString = String::Empty;
	}

public:
	///<summary>Gets if the object has been disposed.</summary>
	property bool IsDisposed
	{
		virtual bool get() { return this->m_IsDisposed; }
	}

	///<summary>Get a [name, value] list of 'metadata'.</summary>
	///<remarks>
	///This property was added to ManagedITK to easily create temporary
	///(ie. non-persisent, not save to file) 'metadata'.
	///</remarks>
	property Dictionary<String^, Object^>^ Metadata
    {
        virtual Dictionary<String^, Object^>^ get() 
		{ 
			// Create for first access
			if (this->m_Metadata == nullptr)
				this->m_Metadata = gcnew Dictionary<String^, Object^>();

			// Return
			return this->m_Metadata;	 
		}
    }

	///<summary>Get the last modified time.</summary>
	property unsigned long MTime { virtual unsigned long get()=0; }

	///<summary>Get a string representing the type instance of this INativePointer.</summary>
	///<example>"IUC2", "IF3", "IUC2IUC2".</example>
	property String^ MangledTypeString
	{ 
		virtual String^ get() { return this->m_MangledTypeString; }
	}
	
	///<summary>
	///Get/set the pointer to the native ITK object associated with
	///this wrapper instance.
	///</summary>
	///<returns>The pointer to the native ITK object.</returns>
	property void* NativePointer{ virtual void* get()=0; virtual void set ( void* value )=0; }

	///<summary>
    ///Remove all observers watching this object.
    ///</summary>
    ///<remarks>
	///By default, observers are created for all events. Calling this
	///method removes all native observers, and therefore prevents
	///the firing of managed events. Call AddAnyEventObserver() to
	///reset the default observers which enable the managed events.
	///</remarks>
	virtual void RemoveAllObservers ( ) = 0;

    ///<summary>
    ///Adds a native observer watching for any event.
    ///</summary>
    ///<remarks>
	///By default, observers are created for all events. Calling this
	///method adds a single native observer for any event. This
	///observer invokes the managed events. Therefore, calling this
	///method more than once, or calling it without first calling
	///RemoveAllObservers() may cause the managed events to be
	///invoked more than once.
	///</remarks>
	virtual void AddAnyEventObserver ( ) = 0;

	///<summary>An event which is raised when the object is modified.</summary>
	event itkObjectHandler^ Modified
	{
	public:
		void add (itkObjectHandler^ handler) { m_EventStorage_Modified += handler; }
		void remove (itkObjectHandler^ handler) { m_EventStorage_Modified -= handler; }
	internal:
		void raise( itkObject^ obj ) 
		{ 
			if (this->m_EventStorage_Modified != nullptr)
				this->m_EventStorage_Modified(obj);
		}
	}

    ///<summary>An event which is raised when the process is started.</summary>
	event itkTimedEventHandler^ Started
	{
	public:
		void add (itkTimedEventHandler^ handler) { m_EventStorage_Started += handler; }
		void remove (itkTimedEventHandler^ handler) { m_EventStorage_Started -= handler; }
	internal:
		void raise( itkObject^ obj, DateTime time ) 
		{ 
			if (this->m_EventStorage_Started != nullptr)
				this->m_EventStorage_Started(obj, time);
		}
	}

    ///<summary>An event which is raised when the process has finished.</summary>
	event itkTimedEventHandler^ Ended
	{
	public:
		void add (itkTimedEventHandler^ handler) { m_EventStorage_Ended += handler; }
		void remove (itkTimedEventHandler^ handler) { m_EventStorage_Ended -= handler; }
	internal:
		void raise( itkObject^ obj, DateTime time ) 
		{ 
			if (this->m_EventStorage_Ended != nullptr)
				this->m_EventStorage_Ended(obj, time);
		}
	}

    ///<summary>An event which is raised if the process is aborted.</summary>
	event itkTimedEventHandler^ Aborted
	{
	public:
		void add (itkTimedEventHandler^ handler) { m_EventStorage_Aborted += handler; }
		void remove (itkTimedEventHandler^ handler) { m_EventStorage_Aborted -= handler; }
	internal:
		void raise( itkObject^ obj, DateTime time ) 
		{ 
			if (this->m_EventStorage_Aborted != nullptr)
				this->m_EventStorage_Aborted(obj, time);
		}
	}    

    ///<summary>An event which is raised when the process iteration is updated.</summary>
	event itkObjectHandler^ Iteration
	{
	public:
		void add (itkObjectHandler^ handler) { m_EventStorage_Iteration += handler; }
		void remove (itkObjectHandler^ handler) { m_EventStorage_Iteration -= handler; }
	internal:
		void raise( itkObject^ obj ) 
		{ 
			if (this->m_EventStorage_Iteration != nullptr)
				this->m_EventStorage_Iteration(obj);
		}
	}

    ///<summary>Invoke the Started event.</summary>
	virtual void InvokeStartedEvent ( DateTime time )
	{ this->Started(this, time); }

    ///<summary>Invoke the Ended event.</summary>
	virtual void InvokeEndedEvent ( DateTime time )
	{ this->Ended(this, time); }

    ///<summary>Invoke the Aborted event.</summary>
	virtual void InvokeAbortedEvent ( DateTime time )
	{ this->Aborted(this, time); }

    ///<summary>Invoke the Iteration event.</summary>
	virtual void InvokeIterationEvent (  )
	{ this->Iteration( this ); }

    ///<summary>Invoke the Modified event.</summary>
	virtual void InvokeModifiedEvent ( )
	{ this->Modified(this); }

internal:
	///<summary>Marshal a managed string to the unmanaged heap.</summary>
	static void MarshalString ( System::String^ s, std::string& os )
    {
		const char* chars = 
			(const char*)(System::Runtime::InteropServices::Marshal::StringToHGlobalAnsi(s)).ToPointer();
		os = chars;
		System::Runtime::InteropServices::Marshal::FreeHGlobal(IntPtr((void*)chars));
	}

}; // end ref class

} // end namespace itk

#endif