bool EventManager::QueueEvent(const IEventPtr& pEvent)
{
	CB_ASSERT(m_ActiveQueue >= 0);
	CB_ASSERT(m_ActiveQueue < EVENTMANAGER_NUM_QUEUES);

	if (!pEvent)
	{
		CB_ERROR("Invalid Event");
		return false;
	}
	CB_LOG("Events", "Attempting to queue event: " + std::string(pEvent->GetName()));

	// make sure there are listeners for this event
	auto findIt = m_EventListeners.find(pEvent->GetEventType());
	if (findIt != m_EventListeners.end())
	{
		m_Queues[m_ActiveQueue].push_back(pEvent);
		CB_LOG("Events", "Successfully queued event: " + std::string(pEvent->GetName()));
		return true;
	}
	else
	{
		CB_LOG("Events", "No listeners for event: " + std::string(pEvent->GetName()));
		return false;
	}
}
bool EventManager::TriggerEvent(const IEventPtr& pEvent) const
{
	CB_LOG("Events", "Attempting to trigger event " + std::string(pEvent->GetName()));
	bool processed = false;

	// iterate the map looking for this event type
	auto findIt = m_EventListeners.find(pEvent->GetEventType());
	if (findIt != m_EventListeners.end())
	{
		// iterate the listener list and send the event to each listener
		const EventListenerList& listeners = findIt->second;
		for (EventListenerList::const_iterator it = listeners.begin(); it != listeners.end(); ++it)
		{
			EventListenerDelegate listener = (*it);
			CB_LOG("Events", "Sending event " + std::string(pEvent->GetName()) + " to delegate listener."); 
			listener(pEvent);
			processed = true;
		}
	}

	return processed;
}
Exemplo n.º 3
0
bool EventManager::VUpdate( unsigned long maxMs ) 
   {
   unsigned long currMs = (unsigned long) ( GetGlobalTimer()->GetTime() * 1000.0 );
   unsigned long targetMs = ( maxMs == kINFINITE )? kINFINITE: currMs + maxMs;

	// swap active queues and clear the new queue after the swap
    int queueToProcess = m_ActiveQueue;
	m_ActiveQueue = (m_ActiveQueue + 1) % EVENTMANAGER_NUM_QUEUES;
	m_EventQueues[m_ActiveQueue].clear();

   std::string s( ( "EventLoop", "Processing Event Queue " +
      ToStr( queueToProcess ) + "; " +
      ToStr( ( unsigned long ) m_EventQueues[ queueToProcess ].size() )
      + " events to process" ) ); \
      Logger::Log( "EventLoop", s, NULL, NULL, 0 ); \
   /*ENG_LOG("EventLoop", "Processing Event Queue " + 
            ToStr(queueToProcess) + "; " + 
            ToStr((unsigned long)m_EventQueues[queueToProcess].size()) 
            + " events to process");*/

	// Process the queue
	while ( !m_EventQueues[queueToProcess].empty() )
	   {
      // pop the front of the queue
		IEventPtr pEvent = m_EventQueues[queueToProcess].front();
      m_EventQueues[queueToProcess].pop_front();
      ENG_LOG( "EventLoop", "\t\tProcessing Event " + std::string( pEvent->GetName() ) );

		const EventType& eventType = pEvent->VGetEventType();

      // find all the delegate functions registered for this event
		auto findIt = m_EventListeners.find(eventType);
		if (findIt != m_EventListeners.end())
		   {
			const EventListenerList& eventListeners = findIt->second;
         ENG_LOG("EventLoop", "\t\tFound " + ToStr((unsigned long)eventListeners.size()) + " delegates");

         // call each listener
			for (auto it = eventListeners.begin(); it != eventListeners.end(); ++it)
			   {
            EventListenerDelegate listener = (*it);
            ENG_LOG("EventLoop", "\t\tSending event " + std::string(pEvent->GetName()) + " to delegate");
				listener(pEvent);
			   }
		   }

        // check to see if time ran out
		currMs = (unsigned long) ( GetGlobalTimer()->GetTime() * 1000.0 );
		if ( targetMs != IEventManager::kINFINITE && currMs >= targetMs )
         {
         ENG_LOG("EventLoop", "Aborting event processing; time ran out");
		   break;
         }
	   }
	
	// If we couldn't process all of the events, push the remaining events to the new active queue.
	// Note: To preserve sequencing, go back-to-front, inserting them at the head of the active queue
	bool queueFlushed = ( m_EventQueues[queueToProcess].empty() );
	if ( !queueFlushed )
	   {
		while (!m_EventQueues[queueToProcess].empty())
		   {
			IEventPtr pEvent = m_EventQueues[queueToProcess].back();
			m_EventQueues[queueToProcess].pop_back();
			m_EventQueues[m_ActiveQueue].push_front(pEvent);
		   }
	   }
	
	return queueFlushed;
   }
bool EventManager::Update(unsigned long maxMillis)
{
	unsigned long currMS = GetTickCount();
	// set the max milliseconds to process events
	unsigned long maxMS = (maxMillis == IEventManager::kINFINITE) ? IEventManager::kINFINITE : currMS + maxMillis;

	// handle events from other threads
	IEventPtr pRealtimeEvent;
	while (m_RealTimeEventQueue.try_pop(pRealtimeEvent))
	{
		QueueEvent(pRealtimeEvent);
		currMS = GetTickCount();

		if (maxMillis != IEventManager::kINFINITE)
		{
			if (currMS >= maxMS)
			{
				CB_ERROR("Too many real time processes hitting the event manager");
			}
		}
	}

	// swap active queues and clear the new active after the swap
	int queueToProcess = m_ActiveQueue;
	m_ActiveQueue = (m_ActiveQueue + 1) % EVENTMANAGER_NUM_QUEUES;
	m_Queues[m_ActiveQueue].clear();

	CB_LOG("EventLoop", "Processing Event Queue " + ToStr(queueToProcess) + "; " + ToStr((unsigned long)m_Queues[queueToProcess].size()) + " events to process");

	// process the queue of events
	while (!m_Queues[queueToProcess].empty())
	{
		// process the first event and pop it
		IEventPtr pEvent = m_Queues[queueToProcess].front();
		m_Queues[queueToProcess].pop_front();
		CB_LOG("EventLoop", "\t\tProcessing Event " + std::string(pEvent->GetName()));

		const EventType& eventType = pEvent->GetEventType();

		// find all the listeners registered for this event in the map
		auto findIt = m_EventListeners.find(eventType);
		if (findIt != m_EventListeners.end())
		{
			// get the list of listeners
			const EventListenerList& listeners = findIt->second;
			CB_LOG("Event Loop", "\t\tFound " + ToStr((unsigned long)listeners.size()) + " listeners");

			// call each listener for this event type
			for (auto it = listeners.begin(); it != listeners.end(); ++it)
			{
				EventListenerDelegate listener = *it;
				CB_LOG("EventLoop", "\t\tSending event " + std::string(pEvent->GetName()) + " to listener");
				listener(pEvent);
			}
		}

		// check to see if time ran out
		currMS = GetTickCount();
		if (maxMillis != IEventManager::kINFINITE && currMS >= maxMS)
		{
			CB_LOG("EventLoop", "Aborting event processing, time ran out");
			break;
		}
	}
	bool queueFlushed = m_Queues[queueToProcess].empty();
	// if we couldn't process all events, push remaining events on the new active queue
	if (!queueFlushed)
	{
		while (!m_Queues[queueToProcess].empty())
		{
			IEventPtr pEvent = m_Queues[queueToProcess].back();
			m_Queues[queueToProcess].pop_back();
			m_Queues[m_ActiveQueue].push_front(pEvent);
		}
	}

	return queueFlushed;
}