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 /////////////////////
