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