C++ EventHandler类代码示例

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