static void manageInvasionEvent(color_ostream& out) { if ( handlers[EventType::INVASION].empty() ) return; multimap<Plugin*,EventHandler> copy(handlers[EventType::INVASION].begin(), handlers[EventType::INVASION].end()); if ( df::global::ui->invasions.next_id <= nextInvasion ) return; nextInvasion = df::global::ui->invasions.next_id; for ( auto a = copy.begin(); a != copy.end(); a++ ) { EventHandler handle = (*a).second; handle.eventHandler(out, (void*)nextInvasion); } }
Mouse::~Mouse() { _pickerPath.remove_node(); EventHandler* events = EventHandler::get_global_event_handler(); events->remove_hook("mouse1", &Mouse::CallbackButton1, (void*)this); events->remove_hook("mouse2", &Mouse::CallbackButton2, (void*)this); events->remove_hook("mouse3", &Mouse::CallbackButton3, (void*)this); events->remove_hook("wheel_up", &Mouse::CallbackWheelUp, (void*)this); events->remove_hook("wheel_down", &Mouse::CallbackWheelDown, (void*)this); MouseCursor::Get()->SetCursorType("cursor-interaction"); }
/*-------------------------------------------------------------------------------- Function : InventoryScreen::eventLoop Description : Event loop for the inventory screen. Inputs : None Outputs : Results of the player's actions in the inventory. Return : bool (whether the action costs a turn) --------------------------------------------------------------------------------*/ bool InventoryScreen::eventLoop() { EventHandler eventHandler; EventType event; do { update(); event = eventHandler.getPlayerInput(); interpretEvent(event); } while(keepRunning); return false; }
int EventHandler::playToneHandler(ClientData cdata, Tcl_Interp *irp, int argc, const char *argv[]) { if(argc != 4) { char msg[] = "Usage: playTone <fq> <amp> <milliseconds>"; Tcl_SetResult(irp, msg, TCL_STATIC); return TCL_ERROR; } //cout << "EventHandler::playTone: " << argv[1] << endl; EventHandler *self = static_cast<EventHandler *>(cdata); self->playTone(atoi(argv[1]), atoi(argv[2]), atoi(argv[3])); return TCL_OK; }
static cell OnPlayerGiveDamage(AMX *amx) { int playerid = GetCellFromStack(amx, 0); int damagedid = GetCellFromStack(amx, 1); float amount = GetFloatFromStack(amx, 2); int weaponid = GetCellFromStack(amx, 3); EventHandler *cur = EventHandler::GetFirstEventHandler(); while (cur != 0) { if (!cur->OnPlayerGiveDamage(playerid, damagedid, amount, weaponid)) { return 0; } cur = cur->GetNext(); } return 1; }
// synchronized void InitiationDispatcher::removeHandler(const EventHandler & handler, const EventType & type) { BOOST_LOG_TRIVIAL(trace) << "InitiationDispatcher entering removeHandler."; lock_guard<mutex> grd_lock(m_mutex); string id = handler.getId(); BOOST_LOG_TRIVIAL(trace) << "Searching event handler w/ID [" << id << "]"; auto type_handler = m_handlers.find(id); if(type_handler != m_handlers.end()) { // found handler if (type_handler->second.type == type) { BOOST_LOG_TRIVIAL(info) << "Removing event handler w/ID [" << id + "] and type [" << EventTypeMap[type] << "]"; m_handlers.erase(id); } } }
// synchronized void InitiationDispatcher::registerHandler( const EventHandler & handler, const EventType & type) { BOOST_LOG_TRIVIAL(info) << "InitiationDispatcher entering registerHandler."; lock_guard<mutex> grd_lock(m_mutex); if(m_is_closed) { throw new runtime_error( "The initiation dispatcher is closed."); } string id = handler.getId(); BOOST_LOG_TRIVIAL(info) << "Registering event handler w/ID [" + id + "] and type [" + EventTypeMap[type] + "]"; if (m_handlers.find(id)) { throw invalid_argument ("Event handler with ID [" + id + "] has already been registered."); } EventTypeHandler type_handler; type_handler.type = type; type_handler.handler = handler; m_handlers.insert( pair<string,EventTypeHandler>(id, type_handler)); }
SelectManager::~SelectManager() { EventHandler *handler; EventMap::const_iterator iter; stop(); FD_ZERO(&m_readSet); FD_ZERO(&m_writeSet); for (iter = m_eventMap.begin(); iter != m_eventMap.end(); ) { handler = iter->second; if (handler->dec() == 0) delete handler; iter = m_eventMap.erase(iter); } }
static cell OnPlayerClickMap(AMX *amx) { int playerid = GetCellFromStack(amx, 0); float x = GetFloatFromStack(amx, 1); float y = GetFloatFromStack(amx, 2); float z = GetFloatFromStack(amx, 3); EventHandler *cur = EventHandler::GetFirstEventHandler(); while (cur != 0) { if (!cur->OnPlayerClickMap(playerid, x, y, z)) { return 0; } cur = cur->GetNext(); } return 1; }
void LibEventMain::errorfn(bufferevent *bev, short int error, void *arg) { INFO_OUT("Errorfn: %x\n", error); if (error & BEV_EVENT_CONNECTED) { bufferevent_setwatermark(bev, EV_READ, 0, max_buff); bufferevent_enable(bev, EV_READ | EV_WRITE); EventHandler *p = (EventHandler *) arg; if (p) { p->enable(); } } // if error & BEV_EVENT_EOF, BEV_EVENT_ERROR, BEV_EVENT_TIMEOUT if ((error & BEV_EVENT_ERROR) || (error & BEV_EVENT_EOF) || (error & BEV_EVENT_TIMEOUT)) { bufferevent_free(bev); } }
static cell OnVehicleRespray(AMX *amx) { int playerid = GetCellFromStack(amx, 0); int vehicleid = GetCellFromStack(amx, 1); int color1 = GetCellFromStack(amx, 2); int color2 = GetCellFromStack(amx, 3); EventHandler *cur = EventHandler::GetFirstEventHandler(); while (cur != 0) { if (!cur->OnVehicleRespray(playerid, vehicleid, color1, color2)) { return 0; } cur = cur->GetNext(); } return 1; }
static void manageBuildingEvent(color_ostream& out) { /* * TODO: could be faster * consider looking at jobs: building creation / destruction **/ if ( handlers[EventType::BUILDING].empty() ) return; multimap<Plugin*,EventHandler> copy(handlers[EventType::BUILDING].begin(), handlers[EventType::BUILDING].end()); //first alert people about new buildings for ( int32_t a = nextBuilding; a < *df::global::building_next_id; a++ ) { int32_t index = df::building::binsearch_index(df::global::world->buildings.all, a); if ( index == -1 ) { //out.print("%s, line %d: Couldn't find new building with id %d.\n", __FILE__, __LINE__, a); //the tricky thing is that when the game first starts, it's ok to skip buildings, but otherwise, if you skip buildings, something is probably wrong. TODO: make this smarter continue; } buildings.insert(a); for ( auto b = copy.begin(); b != copy.end(); b++ ) { EventHandler bob = (*b).second; bob.eventHandler(out, (void*)a); } } nextBuilding = *df::global::building_next_id; //now alert people about destroyed buildings unordered_set<int32_t> toDelete; for ( auto a = buildings.begin(); a != buildings.end(); a++ ) { int32_t id = *a; int32_t index = df::building::binsearch_index(df::global::world->buildings.all,id); if ( index != -1 ) continue; toDelete.insert(id); for ( auto b = copy.begin(); b != copy.end(); b++ ) { EventHandler bob = (*b).second; bob.eventHandler(out, (void*)id); } } for ( auto a = toDelete.begin(); a != toDelete.end(); a++ ) { int32_t id = *a; buildings.erase(id); } //out.print("Sent building event.\n %d", __LINE__); }
LiveTVPlayback::LiveTVPlayback(EventHandler& handler) : ProtoMonitor(handler.GetServer(), handler.GetPort()), EventSubscriber() , m_eventHandler(handler) , m_eventSubscriberId(0) , m_tuneDelay(MIN_TUNE_DELAY) , m_recorder() , m_signal() , m_chain() { m_eventSubscriberId = m_eventHandler.CreateSubscription(this); m_eventHandler.SubscribeForEvent(m_eventSubscriberId, EVENT_SIGNAL); m_eventHandler.SubscribeForEvent(m_eventSubscriberId, EVENT_LIVETV_CHAIN); m_eventHandler.SubscribeForEvent(m_eventSubscriberId, EVENT_LIVETV_WATCH); m_eventHandler.SubscribeForEvent(m_eventSubscriberId, EVENT_DONE_RECORDING); m_eventHandler.SubscribeForEvent(m_eventSubscriberId, EVENT_UPDATE_FILE_SIZE); Open(); }
void Game::addEventHandler(EventHandler & eventHandler) { if(window != NULL) { eventHandler.setGame(*this); window->addEventHandler(eventHandler); } }
void DynamicObject::AddEventHandler(const char *event, const char *code) { char *ename = strdup(event); while (ename) { char *end = strchr(ename, ','); if (end) { *end++ = 0; } Script *script = new Script(ename, code); EventHandler *handler = new EventHandler(ename, script); RegisterEventHandler(handler); handler->DecRef(); ename = end; } free(ename); }
int EventHandler::playFileHandler(ClientData cdata, Tcl_Interp *irp, int argc, const char *argv[]) { if(argc != 2) { char msg[] = "Usage: playFile: <filename>"; Tcl_SetResult(irp, msg, TCL_STATIC); return TCL_ERROR; } //cout << "EventHandler::playFile: " << argv[1] << endl; EventHandler *self = static_cast<EventHandler *>(cdata); string filename(argv[1]); self->playFile(filename); return TCL_OK; }
EventHandler *DynamicObject::FindEventHandler(const char *name) { EventHandler *handler = 0; Lock(); for (int i = 0; i < eventhandlers.size(); i++) { if (!systemObject->IsRunning() && !strcmp(eventhandlers[i]->GetName(),"*")) { continue; } if (eventhandlers[i]->IsEqual(name)) { handler = eventhandlers[i]; handler->IncRef(); break; } } Unlock(); return handler; }
int DynamicObject::FireEvent(const char *event) { int rc = 0; EventHandler *handler = FindEventHandler(event); if (handler) { Tls *tls = tlsGet(); tls->object = this; lmbox_free(tls->event); tls->event = strdup(event); systemObject->Log(3, "Executing event handler %s for event %s in %s (run=%d)", handler->GetName(), event, name, systemObject->IsRunning()); rc = handler->Fire(); systemObject->Log(5, "Result is %d in %s from event handler %s for event %s", rc, name, handler->GetName(), event); handler->DecRef(); lmbox_destroy((void**)&tls->event); } return rc; }
EventHandler* Object::FindSpecificEventHandler(Object* sender, StringHash eventType, EventHandler** previous) const { EventHandler* handler = eventHandlers_.First(); if (previous) *previous = 0; while (handler) { if (handler->GetSender() == sender && handler->GetEventType() == eventType) return handler; if (previous) *previous = handler; handler = eventHandlers_.Next(handler); } return 0; }
EventHandler* Object::FindEventHandler(StringHash eventType, EventHandler** previous) const { EventHandler* handler = eventHandlers_.First(); if (previous) *previous = 0; while (handler) { if (handler->GetEventType() == eventType) return handler; if (previous) *previous = handler; handler = eventHandlers_.Next(handler); } return 0; }
void Event::sendToHandler(EventHandler& eventHandler, void* pData) { pData_ = pData; for (EventHandlerListIterator iter = listeners_.begin(); iter != listeners_.end(); ++iter) { if (&eventHandler == *iter) { eventHandler.handleEvent(this); } } }
static cell OnDialogResponse(AMX *amx) { int playerid = GetCellFromStack(amx, 0); int dialogid = GetCellFromStack(amx, 1); bool response = GetCellFromStack(amx, 2) != 0; int listitem = GetCellFromStack(amx, 3); std::string inputtext = GetStringFromStack(amx, 4); EventHandler *cur = EventHandler::GetFirstEventHandler(); while (cur != 0) { if (!cur->OnDialogResponse(playerid, dialogid, response, listitem, inputtext.c_str())) { return 0; } cur = cur->GetNext(); } return 1; }
void Object::UnsubscribeFromAllEvents() { for (;;) { EventHandler* handler = eventHandlers_.First(); if (handler) { if (handler->GetSender()) context_->RemoveEventReceiver(this, handler->GetSender(), handler->GetEventType()); else context_->RemoveEventReceiver(this, handler->GetEventType()); eventHandlers_.Erase(handler); } else break; } }
void SelectReactorImpl::handle_events(TimeVal* timeout) { int ret = 0; int minfd = 0; int maxfd = 0; EventHandler* handler = NULL; EventType event; demux_table_->convert(minfd, maxfd, readfds_, writefds_, exceptfds_); //printf("min: %d, max: %d\n", minfd, maxfd); ret = select(maxfd + 1, readfds_, writefds_, exceptfds_, NULL); if (ret > 0) //event { for (int fd = minfd; fd <= maxfd; ++fd) //遍历查找 { if (demux_table_->get(fd, handler, event)) //被移除 { continue; } //printf("fd: %d, event: %d\n", fd, event); if ((event & READ_EVENT) && FD_ISSET(fd, readfds_)) { //printf("fd: %d, read event\n", fd); handler->handle_input(fd); } if ((event & WRITE_EVENT) && FD_ISSET(fd, writefds_)) { //printf("fd: %d, write event\n", fd); handler->handle_output(fd); } if ((event & CLOSE_EVENT) && FD_ISSET(fd, exceptfds_)) { printf("fd: %d, except event\n", fd); handler->handle_close(fd); } } } else if (ret == 0) //timeout { } else //error { } }
void testEventHandler() { EventHandler *handler = new EventHandler(); //handler->createEvent(&testObjectTOP, 0); EventHandle *handle1 = handler->createEvent(&testObjectMID, 2); handle1->setRecurrences(6); // "Times" to happen handle1->setPeriod(100); // period in milliseconds EventHandle *handle = handler->createEvent(&testObjectBOT, 1); handle->setRecurrences(3); handle->setPeriod(100); // add a single event EventHandle *handlex = handler->createEvent(&testObjectSingle, 0); handlex->setRecurrences(200); handlex->setPeriod(10); handlex->arg1 = (void*)"aaa"; // slower single event EventHandle *handlex2 = handler->createEvent(&testObjectSingle, 0); handlex2->setRecurrences(5); handlex2->setPeriod(1000); handlex2->arg1 = (void*)"bbb"; while(!handler->isEmpty()) { handler->handleEvents(); } }
void Object::UnsubscribeFromEvents(Object* sender) { if (!sender) return; for (;;) { EventHandler* previous; EventHandler* handler = FindSpecificEventHandler(sender, &previous); if (handler) { context_->RemoveEventReceiver(this, handler->GetSender(), handler->GetEventType()); eventHandlers_.Erase(handler, previous); } else break; } }
void Object::UnsubscribeFromEvent(StringHash eventType) { for (;;) { EventHandler* previous; EventHandler* handler = FindEventHandler(eventType, &previous); if (handler) { if (handler->GetSender()) context_->RemoveEventReceiver(this, handler->GetSender(), eventType); else context_->RemoveEventReceiver(this, eventType); eventHandlers_.Erase(handler, previous); } else break; } }
void notify(SpEventInfo pEvent) { if (m_pCppFunct) m_pCppFunct(m_pObject, pEvent); else if (m_pCFunct) m_pCFunct(pEvent); else if (m_pHandler) m_pHandler->handle_event(pEvent); }
void __EventCallBack(int/* fd*/, short events, void *arg) { EventHandler* handler = static_cast<EventHandler*>(arg); assert(handler); if (events & EV_TIMEOUT) { handler->HandleTimeout(NULL); } else if (events & EV_READ) { handler->HandleInput(); } else if (events & EV_WRITE) { handler->HandleOutput(); } }
void EventHandler::libeventCallback(int fd, short events, void* arg) { EventHandler* handler = reinterpret_cast<EventHandler*>(arg); assert(fd == handler->event_.ev_fd); auto observer = handler->eventBase_->getExecutionObserver(); if (observer) { observer->starting(reinterpret_cast<uintptr_t>(handler)); } // this can't possibly fire if handler->eventBase_ is nullptr (void) handler->eventBase_->bumpHandlingTime(); handler->handlerReady(events); if (observer) { observer->stopped(reinterpret_cast<uintptr_t>(handler)); } }