bool EventDispatcher::dispatchEvent( Event& event ) { event.setSender( this ); EventDispatcher::EventListeners::iterator iter = listeners_.begin(); EventDispatcher::EventListeners::iterator endIter = listeners_.end(); EventListener* el; // std::cout << "event dispatched: " << event.getType() << std::endl; while (iter != endIter) { el = (*iter); // std::cout << "listener of " << el->getType() << std::endl; // std::cout << "comparsion result: " << (el->getType().compare(event.getType()) == 1) << std::endl; if (el->getType().compare(event.getType()) == 0) { if (!el->exec(event)) { return false; } } ++iter; } return true; }
void EventManager::writeCallback(int fd, short ev, void* arg) { assert(ev == EV_WRITE && instance()->writes.count(fd)); EventListener* eh = static_cast<EventListener*>(arg); eh->onWrite(fd); }
void EventManager::readCallback(int fd, short ev, void* arg) { assert(ev == EV_READ && instance()->reads.count(fd)); EventListener* eh = static_cast<EventListener*>(arg); eh->onRead(fd); }
void EventListenerFixture::Should_Return_Correct_EventHandler_Function( ) { EventListener< Mock_EventSubject >* fullEventListener = static_cast< EventListener< Mock_EventSubject >* >( _eventListener ); CPPUNIT_ASSERT( &Mock_EventSubject::EventHandler == fullEventListener->GetHandlerFunctor( ) ); CPPUNIT_ASSERT( &Mock_EventSubject::FalseEventHandler != fullEventListener->GetHandlerFunctor( ) ); }
void KEventObject::FireEvent(const char* event, const ValueList& args) { // Make a copy of the listeners map here, because firing the event might // take a while and we don't want to block other threads that just need // too add event listeners. EventListenerList listenersCopy; { Poco::FastMutex::ScopedLock lock(this->listenersMutex); listenersCopy = listeners; } KObjectRef thisObject(this, true); EventListenerList::iterator li = listenersCopy.begin(); while (li != listenersCopy.end()) { EventListener* listener = *li++; if (listener->Handles(event)) { try { if (!listener->Dispatch(thisObject, args, true)) { // Stop event dispatch if callback tells us break; } } catch (ValueException& e) { this->ReportDispatchError(e.ToString()); break; } } } }
static void *serial_thread_handler(void *arg) { Connector *thiz = (Connector *)arg; EventListener listener = thiz->open_listener; PrivInfo *priv = (PrivInfo *)thiz->priv; if ((priv->fd = open(priv->serial_port, O_RDWR | O_NOCTTY)) == -1) { if (listener.cb_func != NULL) { listener.cb_func(strerror(errno), listener.ctx); } perror("open serial fail"); } serial_set_raw_mode(priv->fd); serial_set_speed(priv->fd, priv->baud_rate); serial_set_parity(priv->fd, DATA_BITS, PARITY_TYPE, STOP_BITS); priv->status = 1; if (listener.cb_func != NULL) { listener.cb_func(NULL, listener.ctx); } pthread_exit(NULL); }
void EventManager::signalCallback(int sig, short ev, void* arg) { assert(ev == EV_SIGNAL && instance()->signals.count(sig)); EventListener* eh = static_cast<EventListener*>(arg); eh->onSignal(sig); }
void EventListenerFixture::Should_Return_NULL_Handler_Given_Constructed_With_NULL_HandleTarget( ) { delete _eventListener; _eventListener = new EventListener< Mock_EventSubject >( TEST_EVENT, 0, &Mock_EventSubject::EventHandler ); EventListener< Mock_EventSubject >* fullEventListener = static_cast< EventListener< Mock_EventSubject >* >( _eventListener ); CPPUNIT_ASSERT( 0 == fullEventListener->GetHandlerTarget( ) ); }
void Event::notify(){ for (std::set<EventListener*>::iterator it=listeners.begin(); it!=listeners.end();){ EventListener* e = *it; it++; // Increment before calling handler in case the handler removes this listener, // which would invalidate the iterator. e->handler(); } }
EventReciever::~EventReciever() { // unplug any EventListeners that points to this object for(EventListener* l = _listeners.first(); _listeners.canMove(); l = _listeners.next()){ if (l != 0) l->_unplug(); } }
void EventListener::Function::operator()(EventListener const& eventListener) { if (eventListener.getType() == this->_type) { eventListener.execute(this->_widget, this->_event); ++this->_executed; } }
void InputManager::notifyObservers(QuadrantID q, EventType e) { // iterate through and call onEvent for each listener std::list<EventListener *>::iterator it; for (it = observers.begin(); it != observers.end(); ++it) { EventListener *observer = (*it); observer->onEvent(q, e); } }
EventListener* EventTarget::getAttributeEventListener(const AtomicString& eventType) { const EventListenerVector& entry = getEventListeners(eventType); for (size_t i = 0; i < entry.size(); ++i) { EventListener* listener = entry[i].listener.get(); if (listener->isAttribute() && listener->belongsToTheCurrentWorld()) return listener; } return 0; }
void AudioScheduledSourceNode::notifyEnded() { EventListener* listener = onended(); if (!listener) return; RefPtr<Event> event = Event::create(eventNames().endedEvent, FALSE, FALSE); event->setTarget(this); listener->handleEvent(context()->scriptExecutionContext(), event.get()); }
EventListener* EventTarget::getAttributeEventListener(const AtomicString& eventType) { const EventListenerVector& entry = getEventListeners(eventType); for (const auto& eventListener : entry) { EventListener* listener = eventListener.listener.get(); if (listener->isAttribute() && listener->belongsToTheCurrentWorld()) return listener; } return 0; }
void EventHandler::_broadcast(AmigoEvent &e) { std::lock_guard<std::mutex> lock(_mutex); std::vector<EventListener*>::iterator it; for(it=_listeners.begin(); it!=_listeners.end(); it++) { EventListener *l = *it; l->onEvent(e); } }
// removes any listeners that points to the same reciever and reciever callback method // the Listener object created here doesn't have to be the same object that was added to addListener // deleteObj is used if the EventListener whas created with new void EventSender::removeListener(EventListener &listener, bool deleteObj /*= false*/) { listener._sender = this; int32_t idx = _listeners.indexOf(&listener); if (idx > -1){ EventListener* l = _listeners[idx]; l->_unplug(); if (deleteObj) delete l; } }
int main() { //Test case 1 : Shouldn't throw { try { EventListener listener; EventConsumer consumer(listener); listener.on_connect().set_function([](Connection&){}); consumer.on_disconnect().set_function([](Connection&){}); consumer.on_server_disconnect().set_function([](TCPServer&){}); consumer.on_event().set_function([](Connection&, const Event&){}); consumer.bind("hellomsg").set_function([](Connection&, const Event&){}); listener.run(); listener.join(); } catch(Exception& e) { ASSERT(false, "Test case 1 failed: \n" << e.what()); } } #define TEST_THROW(n, slot, lambda) \ { \ try \ { \ EventListener listener; \ EventConsumer consumer1(listener); \ EventConsumer consumer2(listener); \ \ consumer1.slot.set_function(lambda); \ consumer2.slot.set_function(lambda); \ \ listener.run(); \ listener.join(); \ \ ASSERT(false, "Test case " n " failed: " \ "collision not detected."); \ } \ catch(Exception& e) \ {} \ } //Test cases 3-6 : Should throw TEST_THROW("3", on_disconnect(), [](Connection&){}); TEST_THROW("4", on_server_disconnect(), [](TCPServer&){}); TEST_THROW("5", on_event(), [](Connection&, const Event&){}); TEST_THROW("6", bind("hellomsg"), [](Connection&, const Event&){}); return EXIT_SUCCESS; }
void AbiCollabSessionManager::signal(const Event& event, BuddyPtr pSource) { UT_DEBUGMSG(("AbiCollabSessionManager::signal()\n")); // forward the event to all listeners for (UT_sint32 i = 0; i < m_vecEventListeners.getItemCount(); i++) { EventListener* pListener = m_vecEventListeners.getNthItem(i); if (pListener) pListener->signal(event, pSource); } }
void EventManager::timerCallback(int fd, short ev, void* arg) { assert(ev == EV_TIMEOUT && fd == -1); EventListener* eh = static_cast<EventListener*>(arg); assert(instance()->timers.count(eh)); int i = instance()->timers[eh].get<1>(); // timers are not persistent, so libevent will remove it. // we need to as well instance()->timers.erase(eh); eh->onTimer(i); }
void EventDispatcher::removeEventListenersForTarget(Node* target, bool recursive/* = false */) { // Ensure the node is removed from these immediately also. // Don't want any dangling pointers or the possibility of dealing with deleted objects.. _nodePriorityMap.erase(target); _dirtyNodes.erase(target); auto listenerIter = _nodeListenersMap.find(target); if (listenerIter != _nodeListenersMap.end()) { auto listeners = listenerIter->second; auto listenersCopy = *listeners; for (auto& l : listenersCopy) { removeEventListener(l); } } // Bug fix: ensure there are no references to the node in the list of listeners to be added. // If we find any listeners associated with the destroyed node in this list then remove them. // This is to catch the scenario where the node gets destroyed before it's listener // is added into the event dispatcher fully. This could happen if a node registers a listener // and gets destroyed while we are dispatching an event (touch etc.) for (auto iter = _toAddedListeners.begin(); iter != _toAddedListeners.end(); ) { EventListener * listener = *iter; if (listener->getAssociatedNode() == target) { listener->setAssociatedNode(nullptr); // Ensure no dangling ptr to the target node. listener->setRegistered(false); releaseListener(listener); iter = _toAddedListeners.erase(iter); } else { ++iter; } } if (recursive) { const auto& children = target->getChildren(); for (const auto& child : children) { removeEventListenersForTarget(child, true); } } }
TransferSharedPtr<WebValue> WebFrame::getWrappedAttributeEventListener(const char* name) { AtomicString type(name); Frame* coreFrame = core(this); if (!coreFrame && !coreFrame->document()) return 0; EventListener* listener = coreFrame->document()->getWindowAttributeEventListener(type); if (listener && listener->type() == EventListener::JSEventListenerType) { JSEventListener* jsListener = static_cast<JSEventListener*>(listener); JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(coreFrame->document(), mainThreadNormalWorld()); JSC::ExecState* execState = globalObject->globalExec(); return WebValue::createInstance(BALValue::create(coreFrame, execState, jsListener->jsFunction(coreFrame->document())).get()); } return 0; }
void EventEmitter::AddListener( EventListener& listener ) { if ( listener.IsConnected() ) throw Error( "Event listener is already connected to another emitter" ); m_listeners.Append( listener ); }
void EventDispatcher::removeEventListener( const std::string& type, const Object* invoker ) { EventDispatcher::EventListeners::iterator iter = listeners_.begin(); EventDispatcher::EventListeners::iterator endIter = listeners_.end(); EventListener* el; while (iter != endIter) { el = (*iter); if ( el->isEqual( type, invoker ) ) { SAFE_RELEASE( *iter ); listeners_.erase( iter ); break; } ++iter; } }
void KEventObject::RemoveEventListener(std::string& event, KMethodRef callback) { Poco::FastMutex::ScopedLock lock(this->listenersMutex); EventListenerList::iterator i = this->listeners.begin(); while (i != this->listeners.end()) { EventListener* listener = *i; if (listener->Handles(event.c_str()) && listener->Callback()->Equals(callback)) { this->listeners.erase(i); delete listener; break; } i++; } }
void EventTarget::markEventListeners(AJ::MarkStack& markStack, unsigned markID) { if (m_flags && m_listeners) { EventListener* cursor = m_listenerList->head(); while (cursor) { AJEventListener* l = cursor->toAJEventListener(); if (l) l->markCallback(markStack, markID); cursor = cursor->next(); } /* for (ListenerMap::iterator it = m_listeners->begin(); it != m_listeners->end(); ++it) { AJEventListener* l = it->second->toAJEventListener(); if (l) l->markCallback(markStack, markID); } */ } }
bool KEventObject::FireEvent(AutoPtr<Event> event, bool synchronous) { // Make a copy of the listeners map here, because firing the event might // take a while and we don't want to block other threads that just need // too add event listeners. EventListenerList listenersCopy; { Poco::FastMutex::ScopedLock lock(listenersMutex); listenersCopy = listeners; } KObjectRef thisObject(this, true); EventListenerList::iterator li = listenersCopy.begin(); while (li != listenersCopy.end()) { EventListener* listener = *li++; if (listener->Handles(event->eventName.c_str())) { ValueList args(Value::NewObject(event)); bool result = false; try { result = listener->Dispatch(thisObject, args, synchronous); } catch (ValueException& e) { this->ReportDispatchError(e.ToString()); } if (synchronous && (event->stopped || !result)) return !event->preventedDefault; } } if (this != GlobalObject::GetInstance().get()) GlobalObject::GetInstance()->FireEvent(event, synchronous); return !synchronous || !event->preventedDefault; }
bool EventManager::Trigger(const Event *event) const { // TODO: validate type // trigger events for wildcard listeners first EventListenerMap::const_iterator wildcardItor = m_registry.find(EVENT_TYPE_WILDCARD); if (wildcardItor != m_registry.end()) { const EventListenerTable &table = wildcardItor->second; for (EventListenerTable::const_iterator i = table.begin(); i != table.end(); ++i) { EventListener *listener = *i; listener->Handle(event); } } // find the listener list for the event type EventListenerMap::const_iterator itor = m_registry.find(event->GetTypeOf()); if (itor == m_registry.end()) return false; bool result = false; // trigger the event in each listener const EventListenerTable &table = itor->second; for (EventListenerTable::const_iterator i = table.begin(); i != table.end(); ++i) { EventListener *listener = *i; if (listener->Handle(event)) { // only return true if a listener signals they handled the event result = true; } } return result; }
bool ImageEventListener::operator==(const EventListener& other) { // All ImageEventListener objects compare as equal; OK since there is only one per document. return other.type() == ImageEventListenerType; }
int main(int argc, char *argv[]) { //QTextStream out (stdout); QApplication* app = new QApplication(argc,argv); //////////// Handling of drag and drop events //////////////// EventListener* eventListener = new EventListener(); app->installEventFilter(eventListener); app->processEvents(); //////////// End of handling of drag and drop events //////////////// // Splash screen QPixmap pixmap(":/icons/STAsplash.png"); QSplashScreen splash(pixmap, Qt::Tool); splash.resize(550, 326); splash.show(); QCoreApplication::setOrganizationName(QObject::tr("STA Steering Board")); QCoreApplication::setApplicationName("STA"); QCoreApplication::setOrganizationName("stasb"); // 'stasb' means STA Steering Board QCoreApplication::setOrganizationDomain("org"); // Patched by Guillermo QCoreApplication::setApplicationVersion("4.0"); QCoreApplication::setOrganizationDomain("STASB"); // Patched by Guillermo //QString ApplicationPath = QDir::currentPath (); //QString ResourcesPath = ApplicationPath + "/sta-data"; //QString ApplicationPath = QApplication::applicationFilePath(); // ApplicationPath.truncate(ApplicationPath.lastIndexOf("/")); //QString ResourcesPath = ApplicationPath + "/sta-data"; ParseCommandLine(); QString staResourcesPath = findDataFolder(); #if defined(Q_WS_MAC) if (!QDir::setCurrent(staResourcesPath)) { QMessageBox::warning(NULL, QObject::tr("STA Resources Not Found"), QObject::tr("STA resources folder wasn't found. This probably means that STA was not properly installed")); exit(0); } #else if (!QDir::setCurrent(staResourcesPath)) // Patched by Guillermo { QMessageBox::warning(NULL, QObject::tr("STA Resources Not Found"), QObject::tr("STA resources folder wasn't found. This probably means that STA was not properly installed")); exit(0); } #endif // Initialize the astro core SolarSystemBodyDictionary::Create(); // Initialize SPICE SpiceEphemeris* spiceEphem = SpiceEphemeris::InitializeSpice(QDesktopServices::storageLocation(QDesktopServices::DataLocation) + "/spice"); if (spiceEphem) { qDebug() << "Using SPICE ephemeris"; SolarSystemBodyDictionary::UseEphemeris(spiceEphem); qDebug() << "OK"; } else { qDebug() << "SPICE kernels for solar system ephemeris not located or incomplete. JPL DE405 ephemeris"; qDebug() << "will be instead. This is only a problem when analyzing missions to natural satellites"; qDebug() << "other than the Moon."; QString ephemerisFilename("ephemerides/de406_1800-2100.dat"); QFile ephemerisFile(ephemerisFilename); if (!ephemerisFile.open(QFile::ReadOnly)) { QMessageBox::critical(NULL, QObject::tr("Ephemeris Data Missing"), QObject::tr("Ephemeris data file %1 not found.").arg(ephemerisFilename)); exit(0); } sta::JPLEphemeris* ephemeris = sta::JPLEphemeris::load(&ephemerisFile); if (!ephemeris) { QMessageBox::critical(NULL, QObject::tr("Error Reading Ephemeris"), QObject::tr("Ephemeris file %1 is corrupted.").arg(ephemerisFilename)); exit(0); } SolarSystemBodyDictionary::UseEphemeris(ephemeris); } // end astro core initialization MainWindow* mainwindow = new MainWindow(); #if defined (Q_WS_MAC) eventListener->setMainWin(mainwindow); QString fileToOpen = eventListener->file(); mainwindow->openFileFromAEvent(fileToOpen); #else QString fileToOpen = ":/untitled.stas"; const QStringList args = QCoreApplication::arguments(); if (args.count() == 2) { fileToOpen = args.at(1); mainwindow->openFileFromAEvent(fileToOpen); } #endif mainwindow->show(); splash.hide(); int result = app->exec(); delete mainwindow; delete eventListener; delete app; return result; } ////////////////////////// End of Main.CPP /////////////////////