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));
}
}
