The SBJ MVC Framework - The Design View, Responding to Model Change

//------------------------------------------------------------------------------
// $Workfile: EventMgr.cpp $
// $Header: /SbjDev/SbjCore/EventMgr.cpp 4     10/20/08 11:06a Steve $
//
//	Copyright � 2008 SbjCat
// All rights reserved.
//
//
// *** Authors ***
//	 Steve Johnson
//
// $Revision: 4 $
//
//-----------------------------------------------------------------------------

#include "stdafx.h"
#include "EventMgr.h"

namespace localNS
{
	typedef std::multimap<SbjCore::EventMgr::EventID, SbjCore::EventMgr::EventHandler*> t_EventIDToEventHandler; 
	typedef t_EventIDToEventHandler::value_type t_IDToHandlerValueType;
	typedef std::pair<t_EventIDToEventHandler::iterator, t_EventIDToEventHandler::iterator> t_EventHandlers; 

	static t_EventIDToEventHandler theEventIDs;

}

namespace SbjCore
{
	namespace EventMgr
	{
		///////////////////////////////////////////////////////////

		void Fire(EventID nEventID)
		{
			Event event(nEventID);
		}

		///////////////////////////////////////////////////////////

		struct EventImpl
		{
			EventID eventID;

			EventImpl() :
				eventID(0)
			{
			}

			EventImpl(EventID nID) :
	 			eventID(nID) 
			{
			}

			virtual ~EventImpl()
			{
			}

		};


		Event::Event() :
			m_pImpl(new EventImpl)
		{
		}

		Event::Event(EventID nEventID, bool bAutoFire /*= true*/) :
			m_pImpl(new EventImpl(nEventID))
		{
			if (bAutoFire)
			{
				NotifyHandlers();
			}
		}

		Event::~Event()
		{
			try
			{
				delete m_pImpl;
			}
			catch (...)
			{
				ASSERT(FALSE);
			}
		}

		void Event::Init(EventID nEventID, bool bAutoFire /*= true*/)
		{
			m_pImpl->eventID = EventID(nEventID);
			if (bAutoFire)
			{
				NotifyHandlers();
			}
		}

		void Event::NotifyHandlers()
		{
			localNS::t_EventHandlers theHandlers = localNS::theEventIDs.equal_range(m_pImpl->eventID);

			for ( ; theHandlers.first != theHandlers.second; ++theHandlers.first)
			{
				EventHandler *pHandler = (*theHandlers.first).second;

				pHandler->Handle(this);
			}
		}


		///////////////////////////////////////////////////////

		struct EventHandlerImpl
		{
			EventID eventID;
			bool bBlocked;

			EventHandlerImpl(EventID nEventID) :
				eventID(nEventID),
				bBlocked(false)
			{
			}
			
			virtual ~EventHandlerImpl()
			{
			}

			void Register(EventHandler* p)
			{
				localNS::theEventIDs.insert(localNS::t_IDToHandlerValueType(eventID, p));
			}
		};
		
		//////////////////////////////////////////////////////////////////////

		EventHandler::EventHandler(EventID nEventID) :
			m_pImpl(new EventHandlerImpl(nEventID))
		{
			m_pImpl->Register(this);
		}

		EventHandler::~EventHandler()
		{
			try 
			{
				localNS::t_EventHandlers theHandlers = localNS::theEventIDs.equal_range(m_pImpl->eventID);

				for ( ; theHandlers.first != theHandlers.second; ++theHandlers.first)
				{
					EventHandler *pHandler = (*theHandlers.first).second;
					if (pHandler == this)
					{
						(void)localNS::theEventIDs.erase(theHandlers.first);
						break;
					}	
				}
				delete m_pImpl;
			}
			catch (...)
			{
				ASSERT(FALSE);
			}
		}

		void EventHandler::Handle(Event* pEvent)
		{
			if (!m_pImpl->bBlocked)
			{
				OnHandle(pEvent);
			}
		}

		void EventHandler::SetBlock( bool bBlock )
		{
			m_pImpl->bBlocked = bBlock;
		}

		bool EventHandler::IsBlocked() const
		{
			return m_pImpl->bBlocked;
		}

	}
}

//*** Modification History ***
// $Log: /SbjDev/SbjCore/EventMgr.cpp $
// 
// 4     10/20/08 11:06a Steve
// Removed source parameter from Event and replaced with EventT data
// 
// 3     10/14/08 1:12p Steve
// Implemented Deletes