void notify(T func, A newA, B newB, C newC, D newD){
for (int32 i=(int32)mListeners.size()-1;
i>=0&&i<mListeners.size();
--i) {
((&*mListeners[i])->*func)(newA,newB,newC,newD);
}
}
void XMLHttpRequest::callReadyStateChangeListener()
{
if (m_doc && m_doc->frame() && m_onReadyStateChangeListener) {
RefPtr<Event> evt = new Event(readystatechangeEvent, true, true);
evt->setTarget(this);
evt->setCurrentTarget(this);
m_onReadyStateChangeListener->handleEvent(evt.get(), false);
}
if (m_doc && m_doc->frame() && m_state == Loaded) {
if (m_onLoadListener) {
RefPtr<Event> evt = new Event(loadEvent, true, true);
evt->setTarget(this);
evt->setCurrentTarget(this);
m_onLoadListener->handleEvent(evt.get(), false);
}
ListenerVector listenersCopy = m_eventListeners.get(loadEvent.impl());
for (ListenerVector::const_iterator listenerIter = listenersCopy.begin(); listenerIter != listenersCopy.end(); ++listenerIter) {
RefPtr<Event> evt = new Event(loadEvent, true, true);
evt->setTarget(this);
evt->setCurrentTarget(this);
listenerIter->get()->handleEvent(evt.get(), false);
}
}
}
void EventManager::TouchEvent( const int eventId, Producer* producer, void *data ) {
ListenerVector listenersListProc;
for( auto& listener: this->listenersList ) {
if( listener.eventId == eventId ) {
listenersListProc.push_back( listener );
}
}
for( auto& listener: listenersListProc ) {
listener.proc( listener.listener, producer, eventId, data );
}
}//TouchEvent
bool MessagePort::dispatchEvent(PassRefPtr<Event> event, ExceptionCode& ec)
{
if (!event || event->type().isEmpty()) {
ec = EventException::UNSPECIFIED_EVENT_TYPE_ERR;
return true;
}
ListenerVector listenersCopy = m_eventListeners.get(event->type());
for (ListenerVector::const_iterator listenerIter = listenersCopy.begin(); listenerIter != listenersCopy.end(); ++listenerIter) {
event->setTarget(this);
event->setCurrentTarget(this);
listenerIter->get()->handleEvent(event.get(), false);
}
return !event->defaultPrevented();
}
/**
* This function notifies all listeners. Listeners may add other listeners or remove themselves,
* though undefined behavior results from removing other listeners during the call.
* \param func which must be a member function of ListenerPtr gets called on all listeners
*/
template <typename T> void notify(T func){
for (int32 i=(int32)mListeners.size()-1;
i>=0&&i<(int32)mListeners.size();
--i) {
((&*mListeners[i])->*func)();
}
} /**
* This function notifies all listeners. Listeners may add other listeners or remove themselves,
* though undefined behavior results from removing other listeners during the call.
* \param func which must be a member function of ListenerPtr gets called on all listeners
* \param newA is the singular argument passed to func
*/
template <typename T, typename A> void notify(T func, A newA){
for (int32 i=(int32)mListeners.size()-1;
i>=0&&i<(int32)mListeners.size();
--i) {
((&*mListeners[i])->*func)(newA);
}
}
bool XMLHttpRequest::dispatchEvent(PassRefPtr<Event> evt, ExceptionCode& ec, bool /*tempEvent*/)
{
// FIXME: check for other error conditions enumerated in the spec.
if (evt->type().isEmpty()) {
ec = EventException::UNSPECIFIED_EVENT_TYPE_ERR;
return true;
}
ListenerVector listenersCopy = m_eventListeners.get(evt->type().impl());
for (ListenerVector::const_iterator listenerIter = listenersCopy.begin(); listenerIter != listenersCopy.end(); ++listenerIter) {
evt->setTarget(this);
evt->setCurrentTarget(this);
listenerIter->get()->handleEvent(evt.get(), false);
}
return !evt->defaultPrevented();
}
void XMLHttpRequest::addEventListener(const AtomicString& eventType, PassRefPtr<EventListener> eventListener, bool)
{
EventListenersMap::iterator iter = m_eventListeners.find(eventType.impl());
if (iter == m_eventListeners.end()) {
ListenerVector listeners;
listeners.append(eventListener);
m_eventListeners.add(eventType.impl(), listeners);
} else {
ListenerVector& listeners = iter->second;
for (ListenerVector::iterator listenerIter = listeners.begin(); listenerIter != listeners.end(); ++listenerIter)
if (*listenerIter == eventListener)
return;
listeners.append(eventListener);
m_eventListeners.add(eventType.impl(), listeners);
}
}
void WorkerContext::addEventListener(const AtomicString& eventType, PassRefPtr<EventListener> eventListener, bool)
{
EventListenersMap::iterator iter = m_eventListeners.find(eventType);
if (iter == m_eventListeners.end()) {
ListenerVector listeners;
listeners.append(eventListener);
m_eventListeners.add(eventType, listeners);
} else {
ListenerVector& listeners = iter->second;
for (ListenerVector::iterator listenerIter = listeners.begin(); listenerIter != listeners.end(); ++listenerIter) {
if (*listenerIter == eventListener)
return;
}
listeners.append(eventListener);
m_eventListeners.add(eventType, listeners);
}
}
/**
* This function adds a new listener to listen for notification
* This may be called during a notify call, but new functions will not be called until the next notification
*/
virtual void addListener(ListenerPtr p) {
if (mListeners.empty()) {
mListeners.push_back(p);
this->firstListenerAdded(p);
}else if (mListeners.size()==1) {
mListenerIndex[mListeners[0]]=0;
mListenerIndex[p]=1;
mListeners.push_back(p);
}else {
mListenerIndex[p]=mListeners.size();
mListeners.push_back(p);
}
this->listenerAdded(p);
}
/**
* This function removes a listener from listening for notification
* This may be called during a notify call on the currently notified listener only
*/
virtual void removeListener(ListenerPtr p) {
this->listenerRemoved(p);
if (mListeners.size()>1) {
typename ListenerMap::iterator where=mListenerIndex.find(p);
assert(where!=mListenerIndex.end());
if (where->second+1!=mListeners.size()) {
mListenerIndex[mListeners.back()]=where->second;
mListeners[where->second]=mListeners.back();
}
mListeners.resize(mListeners.size()-1);
mListenerIndex.erase(where);
}else {
this->lastListenerRemoved(p);
assert(mListeners[0]==p);
mListeners.resize(0);
mListenerIndex=ListenerMap();
}
}
//*************************************************************//
// SEND EVENT NOW
bool EventManager::SendEventNow( const Event* pEvent, const void* destination )
{
// Sanity-check the wrapper's status
assert( m_eStatus == E_INITIALIZED && "EventManager::SendMessageNow - wrapper has not been initialized" );
if( m_eStatus != E_INITIALIZED )
return false;
// Sanity-check the parameter
assert( pEvent != nullptr && "EventManager::SendEventNow - event parameter cannot be null" );
if( pEvent == nullptr )
return false;
// Hold a local ref (for readability)
const EventID& id = pEvent->GetEventID();
// Send the event to all registered listeners to process
// (does not deallocate the event)
LMapRange range = m_mListeners.equal_range( id );
if( range.first != range.second )
{
// Copy the intended listeners
ListenerVector vec;
// All listeners?
if( destination == nullptr )
{
for( LMapIter iter = range.first; iter != range.second; ++iter )
vec.push_back( iter->second );
}
else
{
// One intended listener (which may not exist)
for( LMapIter iter = range.first; iter != range.second; ++iter )
{
if( iter->second->GetChild() == destination )
{
vec.push_back( iter->second );
break;
}
}
}
// Send the event to the current listeners
for( unsigned int i = 0; i < vec.size(); i++ )
{
// Has this listener been removed from the event?
if( m_mUnlisteners.empty() == false )
{
LMapRange removed = m_mUnlisteners.equal_range( id );
if( removed.first != removed.second )
{
LMapIter iter = std::find( removed.first, removed.second, LMapValue( id, vec[i] ) );
if( iter != removed.second )
continue;
}
}
// Send event
vec[ i ]->HandleEvent( pEvent );
}
}
return true;
}
//*************************************************************//
// UPDATE
bool EventManager::Update( void )
{
// Sanity-check the wrapper's status
assert( m_eStatus == E_INITIALIZED && "EventManager::Update - wrapper has not been initialized" );
if( m_eStatus != E_INITIALIZED )
return false;
// Iterate through the entire queue
while( m_qEvents.empty() == false )
{
// Dequeue the first event
EventDestinationPair eventPair = m_qEvents.front();
m_qEvents.pop();
// Hold a local ref to the ID (for readability)
const EventID& id = eventPair.first->GetEventID();
// Send the event to all registered listeners for processing
LMapRange range = m_mListeners.equal_range( id );
if( range.first != range.second )
{
// Copy the intended listeners
ListenerVector vec;
// All listeners?
if( eventPair.second == nullptr )
{
for( LMapIter iter = range.first; iter != range.second; ++iter )
vec.push_back( iter->second );
}
else
{
// One intended listener (which may not exist)
for( LMapIter iter = range.first; iter != range.second; ++iter )
{
if( iter->second->GetChild() == eventPair.second )
{
vec.push_back( iter->second );
break;
}
}
}
// Send the event to the current listeners
for( unsigned int i = 0; i < vec.size(); i++ )
{
// Has a listener been removed from this event?
if( m_mUnlisteners.empty() == false )
{
LMapRange removed = m_mUnlisteners.equal_range( id );
if( removed.first != removed.second )
{
// Is this listener marked for removal from this event?
LMapIter iter = std::find( removed.first, removed.second, LMapValue( id, vec[i] ) );
if( iter != removed.second )
{
m_mUnlisteners.erase( iter );
// Skip over the HandleEvent
continue;
}
}
}
// Send event
vec[ i ]->HandleEvent( eventPair.first );
}
}
// Deallocate the event
delete eventPair.first;
}
// Unregistered listeners have all been processed
m_mUnlisteners.clear();
return true;
}
