void resman_check_watch(struct resman *rman)
{
struct watch_dir *wdir;
unsigned int idx;
unsigned int num_handles = dynarr_size(rman->watch_handles);
if(!num_handles) {
return;
}
idx = WaitForMultipleObjectsEx(num_handles, rman->watch_handles, FALSE, 0, TRUE);
if(idx == WAIT_FAILED) {
unsigned int err = GetLastError();
fprintf(stderr, "failed to check for file modification: %u\n", err);
return;
}
if(idx >= WAIT_OBJECT_0 && idx < WAIT_OBJECT_0 + num_handles) {
if(!(wdir = rb_find(rman->wdirbyev, rman->watch_handles[idx]))) {
fprintf(stderr, "got change handle, but failed to find corresponding watch_dir!\n");
return;
}
handle_event(rman, rman->watch_handles[idx], wdir);
/* restart the watch call */
ReadDirectoryChangesW(wdir->handle, wdir->buf, RES_BUF_SIZE, FALSE, FILE_NOTIFY_CHANGE_LAST_WRITE, 0, &wdir->over, 0);
}
}
static int ds_event(event_t event, int priority,
event_callback_args_t *args)
{
struct pcmcia_bus_socket *s;
ds_dbg(1, "ds_event(0x%06x, %d, 0x%p)\n",
event, priority, args->client_handle);
s = args->client_data;
switch (event) {
case CS_EVENT_CARD_REMOVAL:
s->state &= ~DS_SOCKET_PRESENT;
if (!(s->state & DS_SOCKET_REMOVAL_PENDING)) {
s->state |= DS_SOCKET_REMOVAL_PENDING;
schedule_delayed_work(&s->removal, HZ/10);
}
break;
case CS_EVENT_CARD_INSERTION:
s->state |= DS_SOCKET_PRESENT;
handle_event(s, event);
break;
case CS_EVENT_EJECTION_REQUEST:
return handle_request(s, event);
break;
default:
handle_event(s, event);
break;
}
return 0;
} /* ds_event */
void middleman_event_handler::update() {
BOOST_ACTOR_LOG_TRACE("");
auto mless = [](const fd_meta_info& lhs, native_socket_type rhs) {
return lhs.fd < rhs;
};
for (auto& elem_pair : m_alterations) {
auto& elem = elem_pair.first;
auto old = event::none;
auto last = m_meta.end();
auto iter = std::lower_bound(m_meta.begin(), last, elem.fd, mless);
if (iter != last) old = iter->mask;
auto mask = next_bitmask(old, elem.mask, elem_pair.second);
auto ptr = elem.ptr;
BOOST_ACTOR_LOG_DEBUG("new bitmask for "
<< elem.ptr << ": " << eb2str(mask));
if (iter == last || iter->fd != elem.fd) {
if (mask != event::none) {
// element has been removed from m_meta by an
// previous alteration but is not put back in
m_meta.insert(iter, elem);
handle_event(fd_meta_event::add, elem.fd,
event::none, mask, ptr);
}
}
else if (iter->fd == elem.fd) {
BOOST_ACTOR_REQUIRE(iter->ptr == elem.ptr);
if (mask == event::none) {
// note: we cannot decide whether it's safe to dispose `ptr`,
// because we didn't parse all alterations yet
m_dispose_list.emplace_back(ptr);
m_meta.erase(iter);
handle_event(fd_meta_event::erase, elem.fd, old, mask, ptr);
}
else {
iter->mask = mask;
handle_event(fd_meta_event::mod, elem.fd, old, mask, ptr);
}
}
}
m_alterations.clear();
// m_meta won't be touched inside loop
auto first = m_meta.begin();
auto last = m_meta.end();
// checks whether an element can be safely deleted,
// i.e., was not put back into m_meta by some alteration
auto is_alive = [&](native_socket_type fd) -> bool {
auto iter = std::lower_bound(first, last, fd, mless);
return iter != last && iter->fd == fd;
};
// dispose everything that wasn't put back into m_meta again
for (auto elem : m_dispose_list) {
auto rd = elem->read_handle();
auto wr = elem->write_handle();
if ( (rd == wr && !is_alive(rd))
|| (rd != wr && !is_alive(rd) && !is_alive(wr))) {
elem->dispose();
}
}
m_dispose_list.clear();
}
void CBot::handle_user_repetition()
{
if(same_input())
{
handle_event("REPETITION T1**");
}
else if(similar_input())
{
handle_event("REPETITION T2**");
}
}
void initServer(char *host, int port) {
char *msg;
int listendfd = anetTcpServer(msg, port, host);
if (listendfd <= 0) {
lookup_log(LOG_DEBUG, "create server error %s\n", msg);
exit(0);
}
lookup_log(LOG_DEBUG, "listened %s:%d\n", host, port);
if (anetNonBlock(msg, listendfd) < 0) {
lookup_log(LOG_DEBUG, "set noblocking server error %s\n", msg);
exit(0);
}
pool = create_event(1024);
add_event(pool, listendfd, EPOLLIN, serverAccept);
while (1) {
lookup_log(LOG_DEBUG, "polling\n");
int num = handle_event(pool, 30);
int i;
for (i=0; i<num; i++) {
int fd = pool->epollEv[i].data.fd;
noti_chain_callback cb = pool->events[fd].cb;
(*cb) (&pool->events[fd], fd);
}
}
close(listendfd);
}
int main(int argc, const char * const argv[])
{
sf::Event e;
sf::Window win;
sf::VideoMode vm;
std::stringstream win_title;
sf::ContextSettings cs;
win_title<<APP_TITLE<<" "<<APP_VERSION;
vm.width = WIDTH;
vm.height = HEIGHT;
vm.bitsPerPixel = 32;
cs.depthBits = 24;
cs.stencilBits = 8;
win.create(vm, win_title.str(), sf::Style::Default, cs);
win.setFramerateLimit(60);
win.setVerticalSyncEnabled(g_vsync);
win.setActive();
setup_render_state();
while(g_run) {
while (win.pollEvent(e))
handle_event(e);
render_scene();
win.display();
}
win.close();
return 0;
}
int main(int argc, char* argv[])
{
/* Unused arguments */
(void)argc;
(void)argv;
/* Initialize SDL */
if (SDL_Init(SDL_INIT_VIDEO) != 0){
SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR,
"SDL_Init Failure",
SDL_GetError(),
NULL);
return EXIT_FAILURE;
}
/* Initialize game state */
init_game();
/* Initialize graphics */
if (init_graphics() != 0){
return EXIT_FAILURE;
}
/* Start game logic thread */
SDL_CreateThread(game_thread, "GameLogic", NULL);
/* Main Loop */
while (!quit){
/* Handle events*/
handle_event();
/* Render graphics */
update_graphics();
}
return EXIT_SUCCESS;
}
WL_EXPORT void
wl_display_iterate(struct wl_display *display, uint32_t mask)
{
uint32_t p[2], opcode, size;
int len;
len = wl_connection_data(display->connection, mask);
while (len > 0) {
if (len < sizeof p)
break;
wl_connection_copy(display->connection, p, sizeof p);
opcode = p[1] & 0xffff;
size = p[1] >> 16;
if (len < size)
break;
handle_event(display, p[0], opcode, size);
len -= size;
}
if (len < 0) {
fprintf(stderr, "read error: %m\n");
exit(EXIT_FAILURE);
}
}
void* listener_run() {
struct timeval timeout;
int event = 0;
FD_ZERO(&reception_fd_set);
FD_SET(listening_fd, &reception_fd_set);
DEBUG("Start to listen\n");
DEBUG("=============================================\n");
while(!terminate) {
// Timeout needs to be reset each time
timeout.tv_sec = 0;
timeout.tv_usec = 150000;
fd_set active_set;
active_set = reception_fd_set;
event = select(FD_SETSIZE, &active_set, NULL, NULL, &timeout);
if(event == -1) {
perror("Select failed");
}
else if(event) {
handle_event(active_set);
}
else {
}
}
return NULL;
}
static int handle_events(void)
{
union {
struct inotify_event ev;
uint8_t raw[EVENT_BUFFER_LEN];
} buffer;
struct inotify_event *ievent;
ssize_t r;
int count = 0;
r = read(fd, buffer.raw, EVENT_BUFFER_LEN);
if (r <= 0) {
return r;
}
if (r < (ssize_t) sizeof(struct inotify_event)) {
return -EIO;
}
for (ievent = &buffer.ev; (uint8_t *) ievent < (uint8_t *) buffer.raw + r; ievent = (struct inotify_event *) (ievent + sizeof(struct inotify_event) + ievent->len)) {
handle_event(ievent);
count++;
}
return count;
}
/*
* Reads input from a particular node and ships it off to
* the "handle_event()"
*/
int net_input(int sd, int io_evt, void *node_)
{
merlin_event *pkt;
merlin_node *node = (merlin_node *)node_;
int len, events = 0;
errno = 0;
ldebug("NETINPUT from %p (%s)", node, node ? node->name : "oops");
len = node_recv(node);
if (len < 0) {
return 0;
}
node->stats.bytes.read += len;
node->last_recv = time(NULL);
while ((pkt = node_get_event(node))) {
events++;
handle_event(node, pkt);
free(pkt);
}
ldebug("Read %d events in %s from %s node %s",
events, human_bytes(len), node_type(node), node->name);
return events;
}
void event_poll::handle_poll()
{
int event_cnt;
while (looping()) {
event_cnt = _poll.poll(_event, 1000);
while (event_cnt > 0) {
io_epoll::event ev = _event.at(static_cast<size_t>(--event_cnt));
tunnel * tun = (tunnel *)ev.data.ptr;
if (io_epoll::ev_error(ev)) {
event_remove(tun);
} else {
if (io_epoll::ev_recv(ev)) {
event_recv(tun);
}
if (io_epoll::ev_send(ev)) {
event_send(tun);
}
}
}
handle_event();
}
}
/**
* The primary loop and logic. Listen for packets and process them accordingly.
*/
void run (void)
{
printf("Server running normally...\n");
ENetEvent *ev = NULL;
client *cli = NULL;
u64 nullpacks = 0;
connected = 1;
do {
ev = host_listen(500);
if (!ev) {
nullpacks++;
} else if (ev->type == ENET_EVENT_TYPE_CONNECT) {
ev->peer->data = client_new();
cli = ev->peer->data;
cli->peer = ev->peer;
fprintf(stderr, "Client connected.\n");
} else if (ev->type == ENET_EVENT_TYPE_RECEIVE) {
fprintf(stderr, "Packet received.\n");
handle_event(ev);
enet_packet_destroy(ev->packet);
} else if (ev->type == ENET_EVENT_TYPE_DISCONNECT) {
cli = ev->peer->data;
host_list(cli->channel);
client_destroy(cli);
fprintf(stderr, "Client left.\n");
} else {
fprintf(stderr, "Unrecognized event.\n");
}
} while (connected);
}
void perf_event::process(void *cookie)
{
struct perf_event_header *header;
if (perf_fd < 0)
return;
while (pc->data_tail != pc->data_head ) {
while (pc->data_tail >= (unsigned int)bufsize * getpagesize())
pc->data_tail -= bufsize * getpagesize();
header = (struct perf_event_header *)( (unsigned char *)data_mmap + pc->data_tail);
if (header->size == 0)
break;
pc->data_tail += header->size;
while (pc->data_tail >= (unsigned int)bufsize * getpagesize())
pc->data_tail -= bufsize * getpagesize();
if (header->type == PERF_RECORD_SAMPLE)
handle_event(header, cookie);
}
pc->data_tail = pc->data_head;
}
void Event() {
SDL_Event event;
while (SDL_PollEvent(&event)) {
handle_event(event);
}
}
int CApp::Execute() {
if (!init())
return -1;
double ticks = 0;
while (_running) {
SDL_Event e;
while (SDL_PollEvent(&e))
handle_event(&e);
update();
draw();
// wait for frame
double elapsed = SDL_GetTicks() - ticks;
while (elapsed < MS_PER_FRAME) {
elapsed = SDL_GetTicks() - ticks;
}
ticks += elapsed;
}
cleanup();
return 0;
}
int main(int argc, const char * const argv[])
{
sf::Event e;
sf::Window win;
sf::VideoMode vm;
sf::Clock c;
std::string win_title;
win_title = "Pointsz";
vm.width = win_w;
vm.height = win_h;
vm.bitsPerPixel = 32;
win.create(vm, win_title);
win.setFramerateLimit(60);
win.setVerticalSyncEnabled(g_vsync);
win.setActive();
setup_render_state();
c.restart();
while(g_run) {
while (win.pollEvent(e))
handle_event(e);
render_scene();
win.display();
}
win.close();
return 0;
}
void ShuttleThread::run()
{
kDebug() << "------- STARTING SHUTTLE: " << m_device;
const int fd = KDE_open((char *) m_device.toUtf8().data(), O_RDONLY);
if (fd < 0) {
fprintf(stderr, "Can't open Jog Shuttle FILE DESCRIPTOR\n");
return;;
}
EV ev;
if (ioctl(fd, EVIOCGRAB, 1) < 0) {
fprintf(stderr, "Can't get exclusive access on Jog Shuttle FILE DESCRIPTOR\n");
return;;
}
while (!stop_me) {
if (read(fd, &ev, sizeof(ev)) < 0) {
fprintf(stderr, "Failed to read event from Jog Shuttle FILE DESCRIPTOR\n");
}
handle_event(ev);
}
close(fd);
}
int main()
{
SDL_Init(SDL_INIT_EVERYTHING);
TTF_Init();
SDL_Window *window = SDL_CreateWindow("test", 100, 100, 640, 480, SDL_WINDOW_SHOWN);
SDL_Renderer *renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
TTF_Font *font = TTF_OpenFont("/usr/share/fonts/truetype/DroidSans.ttf", 13);
if (font == NULL)
printf("null font\n");
SDL_Color color = {255, 255, 255};
SDL_Surface *textSurface = TTF_RenderText_Solid(font, "some text", color);
if (textSurface == NULL)
printf("null text surface\n");
SDL_Texture *textTexture = SDL_CreateTextureFromSurface(renderer, textSurface);
if (textTexture == NULL)
printf("null text texture\n");
SDL_Rect rect = { 0, 0, 640, 480 };
while (handle_event() == 0) {
SDL_RenderClear(renderer);
SDL_RenderCopy(renderer, textTexture, &rect, &rect);
SDL_RenderPresent(renderer);
}
return 0;
}
int BC_Pot::keypress_event()
{
int result = 0;
switch(get_keypress())
{
case UP:
increase_value();
result = 1;
break;
case DOWN:
decrease_value();
result = 1;
break;
case LEFT:
decrease_value();
result = 1;
break;
case RIGHT:
increase_value();
result = 1;
break;
}
if(result)
{
show_value_tooltip();
draw(1);
handle_event();
}
return result;
}
int BC_Pot::cursor_motion_event()
{
if(top_level->button_down &&
top_level->event_win == win &&
status == POT_DN)
{
float angle = coords_to_angle(get_cursor_x(), get_cursor_y());
if(prev_angle >= 0 && prev_angle < 90 &&
angle >= 270 && angle < 360)
{
angle_correction -= 360;
}
else
if(prev_angle >= 270 && prev_angle < 360 &&
angle >= 0 && angle < 90)
{
angle_correction += 360;
}
prev_angle = angle;
if(percentage_to_value(
angle_to_percentage(angle + angle_correction - angle_offset)))
{
set_tooltip(get_caption());
draw(1);
handle_event();
}
return 1;
}
return 0;
}
bool widget::process_event(const SDL_Event& event, bool claimed)
{
if(disabled_) {
tooltip_ticks_ = INT_MAX;
return claimed;
}
if(!claimed) {
if(tooltip_ && event.type == SDL_MOUSEMOTION) {
if(event.motion.x >= x() && event.motion.x <= x()+width() &&
event.motion.y >= y() && event.motion.y <= y()+height()) {
if(!tooltip_displayed_) {
if(tooltip_display_delay_ == 0 || SDL_GetTicks() > tooltip_ticks_) {
gui::set_tooltip(tooltip_);
tooltip_displayed_ = true;
} else if(tooltip_ticks_ == INT_MAX) {
tooltip_ticks_ = SDL_GetTicks() + tooltip_display_delay_;
}
}
} else {
tooltip_ticks_ = INT_MAX;
if(tooltip_displayed_) {
gui::remove_tooltip(tooltip_);
tooltip_displayed_ = false;
}
}
}
} else {
tooltip_ticks_ = INT_MAX;
}
return handle_event(event, claimed);
}
int main(){
printf("\nInitialization starting...\n");
if(!elev_init()){
printf("\nFailed to initialize elevator...\n");
return 0;
}
printf("\nInitialization complete\n");
int state = BOOT;
int event = STOP;
int order_table[N_FLOORS][N_BUTTONS];
clear_order_table(order_table);
while(1){
//printf("\nCurrent state: %d, Current event: %d", state, event);
state = handle_event(state, event, order_table);
get_orders(order_table, state);
set_lights(order_table);
int temp_event = get_direction(order_table, state);
if(get_emergency(state)){
event = EMERGENCY_BUTTON;
}else if(get_obstruction(order_table, state)){
event = OBSTRUCTION;
}else if(temp_event != -1){
event = temp_event;
}
}
return 0;
} // End main
void do_event_loop(lstate *state)
{
do {
GrGetNextEvent(&state->event);
handle_event(state);
} while(state->event.type != GR_EVENT_TYPE_CLOSE_REQ);
}
int Game::main_loop()
{
// Poll for events, and handle the ones we care about.
SDL_Event event;
bool loop = true;
int P_lastmove;
while(loop)
{
while(tick_count < P_nextmove){
simulate_tick();
tick_count++;
redraw();
SDL_Delay(40);
while (SDL_PollEvent(&event));
}
while (SDL_PollEvent(&event))
{
handle_event(event);
if(getState() == GS_QUIT) loop = false;
}
calc_move();
if(SDL_GetTicks() - P_lastmove > 100 and move_req())
{
P_lastmove = SDL_GetTicks();
P_turn();
redraw();
P_nextmove = tick_count+1;
}
SDL_Delay(1000.0/30.0); // 30 fps
}
return 0;
}
void playable_custom_object::process(level& lvl)
{
if(player_info_.current_level() != lvl.id()) {
player_info_.set_current_level(lvl.id());
}
if(can_interact_ > 0) {
--can_interact_;
}
iphone_controls::set_underwater(underwater_controls_);
iphone_controls::set_can_interact(can_interact_ != 0);
iphone_controls::set_on_platform(on_platform());
iphone_controls::set_standing(is_standing(level::current()));
float underwater_x, underwater_y;
if(underwater_controls_ && iphone_controls::water_dir(&underwater_x, &underwater_y)) {
underwater_ctrl_x_ = underwater_x*1000;
underwater_ctrl_y_ = underwater_y*1000;
} else {
underwater_ctrl_x_ = 0;
underwater_ctrl_y_ = 0;
}
reverse_ab_ = preferences::reverse_ab();
bool controls[controls::NUM_CONTROLS];
for(int n = 0; n != controls::NUM_CONTROLS; ++n) {
controls[n] = control_status(static_cast<controls::CONTROL_ITEM>(n));
}
clear_control_status();
read_controls(lvl.cycle());
static const std::string keys[] = { "up", "down", "left", "right", "attack", "jump", "tongue" };
for(int n = 0; n != controls::NUM_CONTROLS; ++n) {
if(controls[n] != control_status(static_cast<controls::CONTROL_ITEM>(n))) {
if(controls[n]) {
handle_event("end_ctrl_" + keys[n]);
} else {
handle_event("ctrl_" + keys[n]);
}
}
}
custom_object::process(lvl);
}
static void
dga_vbl( void )
{
XEvent event;
while( XCheckIfEvent( x11.disp, &event, event_predicate, NULL ) )
handle_event( &event );
}
void Loop::ev_io_common_cb(struct ev_loop* loop, struct ev_io* w, int revents)
{
smart_ev_io* one_io = (smart_ev_io*)w;
auto sio = one_io->sio.lock();
if (sio) {
sio->handle_event(revents);
}
}
void handle_events (queue_t q) {
queue_entry_t event;
while (!queue_empty (q)) {
event = queue_dequeue (q);
handle_event (event);
free (event);
}
}
void Server::on_event_received(CL_NetGameConnection *connection, const CL_NetGameEvent &e)
{
cl_log_event("system", "Client sent event: %1", e.to_string());
ServerPlayer *player = ServerPlayer::get_player(connection);
handle_event(player, e);
}
