static void gdk_mir_event_source_queue_event (GdkDisplay *display, GdkWindow *window, const MirEvent *event) { const MirInputEvent *input_event; // FIXME: Only generate events if the window wanted them? switch (mir_event_get_type (event)) { case mir_event_type_input: input_event = mir_event_get_input_event (event); switch (mir_input_event_get_type (input_event)) { case mir_input_event_type_key: handle_key_event (window, input_event); break; case mir_input_event_type_touch: handle_motion_event (window, input_event); break; case mir_input_event_type_pointer: handle_motion_event (window, input_event); break; } break; case mir_event_type_key: handle_key_event (window, mir_event_get_input_event (event)); break; case mir_event_type_motion: handle_motion_event (window, mir_event_get_input_event (event)); break; case mir_event_type_surface: handle_surface_event (window, mir_event_get_surface_event (event)); break; case mir_event_type_resize: handle_resize_event (window, mir_event_get_resize_event (event)); break; case mir_event_type_prompt_session_state_change: // FIXME? break; case mir_event_type_orientation: // FIXME? break; case mir_event_type_close_surface: handle_close_event (window, mir_event_get_close_surface_event (event)); break; default: g_warning ("Ignoring unknown Mir event %d", mir_event_get_type (event)); // FIXME? break; } }
bool me::WindowManager::handle(MirEvent const& event) { assert(focus_controller); assert(display); assert(compositor); if (mir_event_get_type(&event) != mir_event_type_input) return false; auto iev = mir_event_get_input_event(&event); auto input_type = mir_input_event_get_type(iev); if (input_type == mir_input_event_type_key) { return handle_key_event(mir_input_event_get_keyboard_event(iev)); } else if (input_type == mir_input_event_type_pointer && focus_controller) { return handle_pointer_event(mir_input_event_get_pointer_event(iev)); } else if (input_type == mir_input_event_type_touch && focus_controller) { return handle_touch_event(mir_input_event_get_touch_event(iev)); } return false; }
static void *input_thread_work(void *cookie) { ev_init(); struct input_event ev; memset(mt_events, 0, sizeof(mt_events)); key_itr = 10; mt_slot = 0; int res; while(input_run) { while(ev_get(&ev, 1) == 0) { switch(ev.type) { case EV_KEY: handle_key_event(&ev); break; case EV_ABS: handle_abs_event(&ev); break; case EV_SYN: handle_syn_event(&ev); break; } } usleep(10000); } ev_exit(); pthread_exit(NULL); return NULL; }
void UI::update(const SDL_Event &event) { if (m_windows.empty()) { return; } switch (event.type) { case SDL_MOUSEBUTTONDOWN: handle_click(event); break; case SDL_MOUSEBUTTONUP: m_dragging = Drag_Status::NOT_DRAGGING; handle_click(event); break; case SDL_MOUSEMOTION: handle_motion(event); break; case SDL_KEYDOWN: handle_key_event(event); break; case SDL_TEXTINPUT: handle_text_input(event); break; default: break; } }
void Model01::act_on_matrix_scan() { for (byte row = 0; row < 4; row++) { for (byte col = 0; col < 8; col++) { uint8_t keynum = (row*8)+(col); uint8_t keyState = (bitRead(previousLeftHandState.all, keynum) << 0) | (bitRead(leftHandState.all, keynum) << 1); handle_key_event(Key_NoKey, row, 7-col, keyState); keyState = (bitRead(previousRightHandState.all, keynum) << 0) | (bitRead(rightHandState.all, keynum) << 1); handle_key_event(Key_NoKey, row, (15- col), keyState); } } }
static int32_t engine_handle_input(struct android_app* app, AInputEvent* event) { int32_t eventType = AInputEvent_getType(event); if (eventType == AINPUT_EVENT_TYPE_MOTION) return handle_motion_event(app, event); else if(eventType == AINPUT_EVENT_TYPE_KEY) return handle_key_event(app, event); return 0; }
void Macros_::play(const macro_t *macro_p) { macro_t macro = END; uint8_t interval = 0; Key key; if (!macro_p) return; while (true) { switch (macro = pgm_read_byte(macro_p++)) { case MACRO_ACTION_STEP_INTERVAL: interval = pgm_read_byte(macro_p++); break; case MACRO_ACTION_STEP_WAIT: { uint8_t wait = pgm_read_byte(macro_p++); delay(wait); break; } case MACRO_ACTION_STEP_KEYDOWN: key.flags = pgm_read_byte(macro_p++); key.keyCode = pgm_read_byte(macro_p++); handle_key_event(key, 255, 255, IS_PRESSED | INJECTED); Keyboard.sendReport(); break; case MACRO_ACTION_STEP_KEYUP: key.flags = pgm_read_byte(macro_p++); key.keyCode = pgm_read_byte(macro_p++); handle_key_event(key, 255, 255, WAS_PRESSED | INJECTED); Keyboard.sendReport(); break; case END: default: return; } delay(interval); } }
void Keyboard::handle_event(const SDL_Event& e) { if (!is_initialized_) return; switch (e.type) { case SDL_KEYDOWN: case SDL_KEYUP: handle_key_event(e.key); break; case SDL_TEXTEDITING: case SDL_TEXTINPUT: break; default: assert(!"Expected keyboard event."); return; } }
void OS_X11::process_xevents() { //printf("checking events %i\n", XPending(x11_display)); bool do_mouse_warp=false; while (XPending(x11_display) > 0) { XEvent event; XNextEvent(x11_display, &event); switch (event.type) { case Expose: Main::force_redraw(); break; case NoExpose: minimized = true; break; case VisibilityNotify: { XVisibilityEvent * visibility = (XVisibilityEvent *)&event; minimized = (visibility->state == VisibilityFullyObscured); } break; case FocusIn: main_loop->notification(MainLoop::NOTIFICATION_WM_FOCUS_IN); if (mouse_mode==MOUSE_MODE_CAPTURED) { XGrabPointer(x11_display, x11_window, True, ButtonPressMask | ButtonReleaseMask | PointerMotionMask, GrabModeAsync, GrabModeAsync, x11_window, None, CurrentTime); } break; case FocusOut: main_loop->notification(MainLoop::NOTIFICATION_WM_FOCUS_OUT); if (mouse_mode==MOUSE_MODE_CAPTURED) { //dear X11, I try, I really try, but you never work, you do whathever you want. XUngrabPointer(x11_display, CurrentTime); } break; case ConfigureNotify: /* call resizeGLScene only if our window-size changed */ if ((event.xconfigure.width == current_videomode.width) && (event.xconfigure.height == current_videomode.height)) break; current_videomode.width=event.xconfigure.width; current_videomode.height=event.xconfigure.height; break; case ButtonPress: case ButtonRelease: { /* exit in case of a mouse button press */ last_timestamp=event.xbutton.time; if (mouse_mode==MOUSE_MODE_CAPTURED) { event.xbutton.x=last_mouse_pos.x; event.xbutton.y=last_mouse_pos.y; } InputEvent mouse_event; mouse_event.ID=++event_id; mouse_event.type = InputEvent::MOUSE_BUTTON; mouse_event.device=0; mouse_event.mouse_button.mod = get_key_modifier_state(event.xbutton.state); mouse_event.mouse_button.button_mask = get_mouse_button_state(event.xbutton.state); mouse_event.mouse_button.x=event.xbutton.x; mouse_event.mouse_button.y=event.xbutton.y; mouse_event.mouse_button.global_x=event.xbutton.x; mouse_event.mouse_button.global_y=event.xbutton.y; mouse_event.mouse_button.button_index=event.xbutton.button; if (mouse_event.mouse_button.button_index==2) mouse_event.mouse_button.button_index=3; else if (mouse_event.mouse_button.button_index==3) mouse_event.mouse_button.button_index=2; mouse_event.mouse_button.pressed=(event.type==ButtonPress); if (event.type==ButtonPress && event.xbutton.button==1) { uint64_t diff = get_ticks_usec()/1000 - last_click_ms; if (diff<400 && Point2(last_click_pos).distance_to(Point2(event.xbutton.x,event.xbutton.y))<5) { last_click_ms=0; last_click_pos = Point2(-100,-100); mouse_event.mouse_button.doubleclick=true; mouse_event.ID=++event_id; } else { last_click_ms+=diff; last_click_pos = Point2(event.xbutton.x,event.xbutton.y); } } input->parse_input_event( mouse_event); } break; case MotionNotify: { last_timestamp=event.xmotion.time; // Motion is also simple. // A little hack is in order // to be able to send relative motion events. Point2i pos( event.xmotion.x, event.xmotion.y ); if (mouse_mode==MOUSE_MODE_CAPTURED) { #if 1 Vector2 c = Point2i(current_videomode.width/2,current_videomode.height/2); if (pos==Point2i(current_videomode.width/2,current_videomode.height/2)) { //this sucks, it's a hack, etc and is a little inaccurate, etc. //but nothing I can do, X11 sucks. center=pos; break; } Point2i ncenter = pos; pos = last_mouse_pos + ( pos-center ); center=ncenter; do_mouse_warp=true; #else //Dear X11, thanks for making my life miserable center.x = current_videomode.width/2; center.y = current_videomode.height/2; pos = last_mouse_pos + ( pos-center ); if (pos==last_mouse_pos) break; XWarpPointer(x11_display, None, x11_window, 0,0,0,0, (int)center.x, (int)center.y); #endif } if (!last_mouse_pos_valid) { last_mouse_pos=pos; last_mouse_pos_valid=true; } Point2i rel = pos - last_mouse_pos; InputEvent motion_event; motion_event.ID=++event_id; motion_event.type=InputEvent::MOUSE_MOTION; motion_event.device=0; motion_event.mouse_motion.mod = get_key_modifier_state(event.xmotion.state); motion_event.mouse_motion.button_mask = get_mouse_button_state(event.xmotion.state); motion_event.mouse_motion.x=pos.x; motion_event.mouse_motion.y=pos.y; input->set_mouse_pos(pos); motion_event.mouse_motion.global_x=pos.x; motion_event.mouse_motion.global_y=pos.y; motion_event.mouse_motion.speed_x=input->get_mouse_speed().x; motion_event.mouse_motion.speed_y=input->get_mouse_speed().y; motion_event.mouse_motion.relative_x=rel.x; motion_event.mouse_motion.relative_y=rel.y; last_mouse_pos=pos; input->parse_input_event( motion_event); } break; case KeyPress: case KeyRelease: { last_timestamp=event.xkey.time; // key event is a little complex, so // it will be handled in it's own function. handle_key_event( (XKeyEvent*)&event ); } break; case SelectionRequest: { XSelectionRequestEvent *req; XEvent e, respond; e = event; req=&(e.xselectionrequest); if (req->target == XA_STRING || req->target == XInternAtom(x11_display, "COMPOUND_TEXT", 0) || req->target == XInternAtom(x11_display, "UTF8_STRING", 0)) { CharString clip = OS::get_clipboard().utf8(); XChangeProperty (x11_display, req->requestor, req->property, req->target, 8, PropModeReplace, (unsigned char*)clip.get_data(), clip.length()); respond.xselection.property=req->property; } else if (req->target == XInternAtom(x11_display, "TARGETS", 0)) { Atom data[2]; data[0] = XInternAtom(x11_display, "UTF8_STRING", 0); data[1] = XA_STRING; XChangeProperty (x11_display, req->requestor, req->property, req->target, 8, PropModeReplace, (unsigned char *) &data, sizeof (data)); respond.xselection.property=req->property; } else { printf ("No String %x\n", (int)req->target); respond.xselection.property= None; } respond.xselection.type= SelectionNotify; respond.xselection.display= req->display; respond.xselection.requestor= req->requestor; respond.xselection.selection=req->selection; respond.xselection.target= req->target; respond.xselection.time = req->time; XSendEvent (x11_display, req->requestor,0,0,&respond); XFlush (x11_display); } break; case ClientMessage: if ((unsigned int)event.xclient.data.l[0]==(unsigned int)wm_delete) main_loop->notification(MainLoop::NOTIFICATION_WM_QUIT_REQUEST); break; default: break; } } XFlush(x11_display); if (do_mouse_warp) { XWarpPointer(x11_display, None, x11_window, 0,0,0,0, (int)current_videomode.width/2, (int)current_videomode.height/2); } }
void OS_X11::handle_key_event(XKeyEvent *p_event, bool p_echo) { // X11 functions don't know what const is XKeyEvent *xkeyevent = p_event; // This code was pretty difficult to write. // The docs stink and every toolkit seems to // do it in a different way. /* Phase 1, obtain a proper keysym */ // This was also very difficult to figure out. // You'd expect you could just use Keysym provided by // XKeycodeToKeysym to obtain internationalized // input.. WRONG!! // you must use XLookupString (???) which not only wastes // cycles generating an unnecesary string, but also // still works in half the cases. (won't handle deadkeys) // For more complex input methods (deadkeys and more advanced) // you have to use XmbLookupString (??). // So.. then you have to chosse which of both results // you want to keep. // This is a real bizarreness and cpu waster. KeySym keysym_keycode=0; // keysym used to find a keycode KeySym keysym_unicode=0; // keysym used to find unicode int nbytes=0; // bytes the string takes // XLookupString returns keysyms usable as nice scancodes/ char str[256+1]; nbytes=XLookupString(xkeyevent, str, 256, &keysym_keycode, NULL); // Meanwhile, XLookupString returns keysyms useful for unicode. if (!xmbstring) { // keep a temporary buffer for the string xmbstring=(char*)memalloc(sizeof(char)*8); xmblen=8; } if (xkeyevent->type == KeyPress && xic) { Status status; do { int mnbytes = XmbLookupString (xic, xkeyevent, xmbstring, xmblen - 1, &keysym_unicode, &status); xmbstring[mnbytes] = '\0'; if (status == XBufferOverflow) { xmblen = mnbytes + 1; xmbstring = (char*)memrealloc (xmbstring, xmblen); } } while (status == XBufferOverflow); } /* Phase 2, obtain a pigui keycode from the keysym */ // KeyMappingX11 just translated the X11 keysym to a PIGUI // keysym, so it works in all platforms the same. unsigned int keycode = KeyMappingX11::get_keycode(keysym_keycode); /* Phase 3, obtain an unicode character from the keysym */ // KeyMappingX11 also translates keysym to unicode. // It does a binary search on a table to translate // most properly. //print_line("keysym_unicode: "+rtos(keysym_unicode)); unsigned int unicode = keysym_unicode>0? KeyMappingX11::get_unicode_from_keysym(keysym_unicode):0; /* Phase 4, determine if event must be filtered */ // This seems to be a side-effect of using XIM. // XEventFilter looks like a core X11 funciton, // but it's actually just used to see if we must // ignore a deadkey, or events XIM determines // must not reach the actual gui. // Guess it was a design problem of the extension bool keypress = xkeyevent->type == KeyPress; if (xkeyevent->type == KeyPress && xic) { if (XFilterEvent((XEvent*)xkeyevent, x11_window)) return; } if (keycode==0 && unicode==0) return; /* Phase 5, determine modifier mask */ // No problems here, except I had no way to // know Mod1 was ALT and Mod4 was META (applekey/winkey) // just tried Mods until i found them. //print_line("mod1: "+itos(xkeyevent->state&Mod1Mask)+" mod 5: "+itos(xkeyevent->state&Mod5Mask)); InputModifierState state = get_key_modifier_state(xkeyevent->state); /* Phase 6, determine echo character */ // Echo characters in X11 are a keyrelease and a keypress // one after the other with the (almot) same timestamp. // To detect them, i use XPeekEvent and check that their // difference in time is below a treshold. if (xkeyevent->type != KeyPress) { // make sure there are events pending, // so this call won't block. if (XPending(x11_display)>0) { XEvent peek_event; XPeekEvent(x11_display, &peek_event); // I'm using a treshold of 5 msecs, // since sometimes there seems to be a little // jitter. I'm still not convinced that all this approach // is correct, but the xorg developers are // not very helpful today. ::Time tresh=ABS(peek_event.xkey.time-xkeyevent->time); if (peek_event.type == KeyPress && tresh<5 ) { KeySym rk; nbytes=XLookupString((XKeyEvent*)&peek_event, str, 256, &rk, NULL); if (rk==keysym_keycode) { XEvent event; XNextEvent(x11_display, &event); //erase next event handle_key_event( (XKeyEvent*)&event,true ); return; //ignore current, echo next } } // use the time from peek_event so it always works } // save the time to check for echo when keypress happens } /* Phase 7, send event to Window */ InputEvent event; event.ID=++event_id; event.type = InputEvent::KEY; event.device=0; event.key.mod=state; event.key.pressed=keypress; if (keycode>='a' && keycode<='z') keycode-='a'-'A'; event.key.scancode=keycode; event.key.unicode=unicode; event.key.echo=p_echo; if (event.key.scancode==KEY_BACKTAB) { //make it consistent accross platforms. event.key.scancode=KEY_TAB; event.key.mod.shift=true; } //printf("key: %x\n",event.key.scancode); input->parse_input_event( event); }
void OS_X11::process_xevents() { //printf("checking events %i\n", XPending(x11_display)); do_mouse_warp=false; while (XPending(x11_display) > 0) { XEvent event; XNextEvent(x11_display, &event); switch (event.type) { case Expose: Main::force_redraw(); break; case NoExpose: minimized = true; break; case VisibilityNotify: { XVisibilityEvent * visibility = (XVisibilityEvent *)&event; minimized = (visibility->state == VisibilityFullyObscured); } break; case LeaveNotify: { if (main_loop && mouse_mode!=MOUSE_MODE_CAPTURED) main_loop->notification(MainLoop::NOTIFICATION_WM_MOUSE_EXIT); if (input) input->set_mouse_in_window(false); } break; case EnterNotify: { if (main_loop && mouse_mode!=MOUSE_MODE_CAPTURED) main_loop->notification(MainLoop::NOTIFICATION_WM_MOUSE_ENTER); if (input) input->set_mouse_in_window(true); } break; case FocusIn: minimized = false; #ifdef NEW_WM_API if(current_videomode.fullscreen) { set_wm_fullscreen(true); } #endif main_loop->notification(MainLoop::NOTIFICATION_WM_FOCUS_IN); if (mouse_mode==MOUSE_MODE_CAPTURED) { XGrabPointer(x11_display, x11_window, True, ButtonPressMask | ButtonReleaseMask | PointerMotionMask, GrabModeAsync, GrabModeAsync, x11_window, None, CurrentTime); } break; case FocusOut: #ifdef NEW_WM_API if(current_videomode.fullscreen) { set_wm_fullscreen(false); set_window_minimized(true); } #endif main_loop->notification(MainLoop::NOTIFICATION_WM_FOCUS_OUT); if (mouse_mode==MOUSE_MODE_CAPTURED) { //dear X11, I try, I really try, but you never work, you do whathever you want. XUngrabPointer(x11_display, CurrentTime); } break; case ConfigureNotify: /* call resizeGLScene only if our window-size changed */ if ((event.xconfigure.width == current_videomode.width) && (event.xconfigure.height == current_videomode.height)) break; current_videomode.width=event.xconfigure.width; current_videomode.height=event.xconfigure.height; break; case ButtonPress: case ButtonRelease: { /* exit in case of a mouse button press */ last_timestamp=event.xbutton.time; if (mouse_mode==MOUSE_MODE_CAPTURED) { event.xbutton.x=last_mouse_pos.x; event.xbutton.y=last_mouse_pos.y; } InputEvent mouse_event; mouse_event.ID=++event_id; mouse_event.type = InputEvent::MOUSE_BUTTON; mouse_event.device=0; mouse_event.mouse_button.mod = get_key_modifier_state(event.xbutton.state); mouse_event.mouse_button.button_mask = get_mouse_button_state(event.xbutton.state); mouse_event.mouse_button.x=event.xbutton.x; mouse_event.mouse_button.y=event.xbutton.y; mouse_event.mouse_button.global_x=event.xbutton.x; mouse_event.mouse_button.global_y=event.xbutton.y; mouse_event.mouse_button.button_index=event.xbutton.button; if (mouse_event.mouse_button.button_index==2) mouse_event.mouse_button.button_index=3; else if (mouse_event.mouse_button.button_index==3) mouse_event.mouse_button.button_index=2; mouse_event.mouse_button.pressed=(event.type==ButtonPress); if (event.type==ButtonPress && event.xbutton.button==1) { uint64_t diff = get_ticks_usec()/1000 - last_click_ms; if (diff<400 && Point2(last_click_pos).distance_to(Point2(event.xbutton.x,event.xbutton.y))<5) { last_click_ms=0; last_click_pos = Point2(-100,-100); mouse_event.mouse_button.doubleclick=true; mouse_event.ID=++event_id; } else { last_click_ms+=diff; last_click_pos = Point2(event.xbutton.x,event.xbutton.y); } } input->parse_input_event( mouse_event); } break; case MotionNotify: { // F**K YOU X11 API YOU SERIOUSLY GROSS ME OUT // YOU ARE AS GROSS AS LOOKING AT A PUTRID PILE // OF POOP STICKING OUT OF A CLOGGED TOILET // HOW THE F**K I AM SUPPOSED TO KNOW WHICH ONE // OF THE MOTION NOTIFY EVENTS IS THE ONE GENERATED // BY WARPING THE MOUSE POINTER? // YOU ARE FORCING ME TO FILTER ONE BY ONE TO FIND IT // PLEASE DO ME A FAVOR AND DIE DROWNED IN A FECAL // MOUNTAIN BECAUSE THAT'S WHERE YOU BELONG. while(true) { if (mouse_mode==MOUSE_MODE_CAPTURED && event.xmotion.x==current_videomode.width/2 && event.xmotion.y==current_videomode.height/2) { //this is likely the warp event since it was warped here center=Vector2(event.xmotion.x,event.xmotion.y); break; } if (XPending(x11_display) > 0) { XEvent tevent; XPeekEvent(x11_display, &tevent); if (tevent.type==MotionNotify) { XNextEvent(x11_display,&event); } else { break; } } else { break; } } last_timestamp=event.xmotion.time; // Motion is also simple. // A little hack is in order // to be able to send relative motion events. Point2i pos( event.xmotion.x, event.xmotion.y ); if (mouse_mode==MOUSE_MODE_CAPTURED) { #if 1 //Vector2 c = Point2i(current_videomode.width/2,current_videomode.height/2); if (pos==Point2i(current_videomode.width/2,current_videomode.height/2)) { //this sucks, it's a hack, etc and is a little inaccurate, etc. //but nothing I can do, X11 sucks. center=pos; break; } Point2i new_center = pos; pos = last_mouse_pos + ( pos - center ); center=new_center; do_mouse_warp=true; #else //Dear X11, thanks for making my life miserable center.x = current_videomode.width/2; center.y = current_videomode.height/2; pos = last_mouse_pos + ( pos-center ); if (pos==last_mouse_pos) break; XWarpPointer(x11_display, None, x11_window, 0,0,0,0, (int)center.x, (int)center.y); #endif } if (!last_mouse_pos_valid) { last_mouse_pos=pos; last_mouse_pos_valid=true; } Point2i rel = pos - last_mouse_pos; #ifdef NEW_WM_API if (mouse_mode==MOUSE_MODE_CAPTURED) { pos.x = current_videomode.width / 2; pos.y = current_videomode.height / 2; } #endif InputEvent motion_event; motion_event.ID=++event_id; motion_event.type=InputEvent::MOUSE_MOTION; motion_event.device=0; motion_event.mouse_motion.mod = get_key_modifier_state(event.xmotion.state); motion_event.mouse_motion.button_mask = get_mouse_button_state(event.xmotion.state); motion_event.mouse_motion.x=pos.x; motion_event.mouse_motion.y=pos.y; input->set_mouse_pos(pos); motion_event.mouse_motion.global_x=pos.x; motion_event.mouse_motion.global_y=pos.y; motion_event.mouse_motion.speed_x=input->get_mouse_speed().x; motion_event.mouse_motion.speed_y=input->get_mouse_speed().y; motion_event.mouse_motion.relative_x=rel.x; motion_event.mouse_motion.relative_y=rel.y; last_mouse_pos=pos; // printf("rel: %d,%d\n", rel.x, rel.y ); input->parse_input_event( motion_event); } break; case KeyPress: case KeyRelease: { last_timestamp=event.xkey.time; // key event is a little complex, so // it will be handled in it's own function. handle_key_event( (XKeyEvent*)&event ); } break; case SelectionRequest: { XSelectionRequestEvent *req; XEvent e, respond; e = event; req=&(e.xselectionrequest); if (req->target == XA_STRING || req->target == XInternAtom(x11_display, "COMPOUND_TEXT", 0) || req->target == XInternAtom(x11_display, "UTF8_STRING", 0)) { CharString clip = OS::get_clipboard().utf8(); XChangeProperty (x11_display, req->requestor, req->property, req->target, 8, PropModeReplace, (unsigned char*)clip.get_data(), clip.length()); respond.xselection.property=req->property; } else if (req->target == XInternAtom(x11_display, "TARGETS", 0)) { Atom data[2]; data[0] = XInternAtom(x11_display, "UTF8_STRING", 0); data[1] = XA_STRING; XChangeProperty (x11_display, req->requestor, req->property, req->target, 8, PropModeReplace, (unsigned char *) &data, sizeof (data)); respond.xselection.property=req->property; } else { printf ("No String %x\n", (int)req->target); respond.xselection.property= None; } respond.xselection.type= SelectionNotify; respond.xselection.display= req->display; respond.xselection.requestor= req->requestor; respond.xselection.selection=req->selection; respond.xselection.target= req->target; respond.xselection.time = req->time; XSendEvent (x11_display, req->requestor,0,0,&respond); XFlush (x11_display); } break; case ClientMessage: if ((unsigned int)event.xclient.data.l[0]==(unsigned int)wm_delete) main_loop->notification(MainLoop::NOTIFICATION_WM_QUIT_REQUEST); break; default: break; } } XFlush(x11_display); if (do_mouse_warp) { XWarpPointer(x11_display, None, x11_window, 0,0,0,0, (int)current_videomode.width/2, (int)current_videomode.height/2); /* Window root, child; int root_x, root_y; int win_x, win_y; unsigned int mask; XQueryPointer( x11_display, x11_window, &root, &child, &root_x, &root_y, &win_x, &win_y, &mask ); printf("Root: %d,%d\n", root_x, root_y); printf("Win: %d,%d\n", win_x, win_y); */ } }
void mbdesktop_main(MBDesktop *mb) { XEvent ev; Atom workarea_atom = XInternAtom(mb->dpy, "_NET_WORKAREA",False); MBDesktopModuleslist *module_current = NULL; #ifdef USE_DNOTIFY sigset_t block_sigset; sigemptyset(&block_sigset); sigaddset(&block_sigset, SIGRTMIN); /* XXX should also add stuff like a HUP etc .. */ #endif mbdesktop_view_paint(mb, True); XFlush(mb->dpy); while (1) { if (WantReload) /* Triggered by dnotify signals etc */ { mbdesktop_item_folder_contents_free(mb, mb->top_head_item); mb->current_folder_item = mb->top_head_item; modules_unload(mb); /* XXX more eficient way ? */ modules_init(mb); mb->kbd_focus_item = mb->current_head_item = mb->scroll_offset_item = mb->top_head_item->item_child; mbdesktop_view_paint(mb, False); WantReload = False; XSync(mb->dpy, False); } XNextEvent(mb->dpy, &ev); #ifdef USE_DNOTIFY /* Block dnotify signal */ sigprocmask(SIG_BLOCK, &block_sigset, NULL); #endif #ifdef USE_XSETTINGS if (mb->xsettings_client != NULL) xsettings_client_process_event(mb->xsettings_client, &ev); #endif switch (ev.type) { case MappingNotify: XRefreshKeyboardMapping(&ev.xmapping); break; case FocusIn: mb->have_focus = True; mbdesktop_view_paint(mb, True); break; case FocusOut: mbdesktop_view_paint(mb, True); mb->have_focus = False; break; case Expose: if (ev.xexpose.count > 0) mbdesktop_view_paint(mb, True); break; case PropertyNotify: if (ev.xproperty.atom == workarea_atom) { int wx, wy, ww, wh; if (mbdesktop_get_workarea(mb, &wx, &wy, &ww, &wh)) { if (mb->workarea_x != wx || mb->workarea_y != wy || mb->workarea_width != ww || mb->workarea_height != wh) mbdesktop_view_configure(mb); } } else if (ev.xproperty.atom == mb->atom_mb_theme) { if (mbdesktop_get_theme_via_root_prop(mb)) mbdesktop_switch_theme (mb, NULL ); } break; /* case ConfigureRequest: mbdesktop_win_plugin_configure_request(mb, &ev.xconfigurerequest); break; */ case ConfigureNotify: if ( ev.xconfigure.width != mb->desktop_width || ev.xconfigure.height != mb->desktop_height) { mb->desktop_width = ev.xconfigure.width; mb->desktop_height = ev.xconfigure.height; mbdesktop_view_configure(mb); } break; case ButtonPress: handle_button_event(mb, &ev.xbutton); break; case KeyPress: handle_key_event(mb, &ev.xkey); break; } module_current = mb->modules; while (module_current != NULL) { if (module_current->module_handle->mod_xevent) module_current->module_handle->mod_xevent(mb, module_current->module_handle, &ev); module_current = module_current->next; } /* if (mb->current_folder_item && mb->current_folder_item->module_handle && mb->current_folder_item->module_handle->folder_xevent) { mb->current_folder_item->module_handle->folder_xevent(mb, mb->current_folder_item, &ev); } */ #ifdef USE_DNOTIFY /* Unblock dnotify signal */ sigprocmask(SIG_UNBLOCK, &block_sigset, NULL); #endif } }
int real_main() { srand48(time(NULL)); if (!al_init()) { puts("Could not initialise allegro"); return 1; } if (!al_install_keyboard()) { puts("Could not initialise allegro keyboard subsystem"); return 1; } keys = malloc(sizeof(ALLEGRO_KEYBOARD_STATE)); if (!init_font()) { puts("Could not initialise allegro font subsystem"); return 1; } al_set_new_display_flags(ALLEGRO_FULLSCREEN_WINDOW); ALLEGRO_DISPLAY* display = al_create_display(1, 1); if (!display) { puts("Could not initialise allegro display"); return 1; } Vector size = new_vector(); size.x = al_get_display_width(display); size.y = al_get_display_height(display); Game* game = new_game(size); int i; for (i = 0; i < ASTEROIDN; i++) spawn_asteroid(game); ALLEGRO_TIMER* timer = al_create_timer(1.0/FPS); ALLEGRO_EVENT_QUEUE *timereq = al_create_event_queue(); ALLEGRO_EVENT_QUEUE *genericeq = al_create_event_queue(); if (!timereq || !genericeq) { puts("Could not create allegro event queue"); return 1; } al_register_event_source(timereq, al_get_timer_event_source(timer)); al_register_event_source(genericeq, al_get_keyboard_event_source()); al_register_event_source(genericeq, al_get_display_event_source(display)); al_start_timer(timer); // Start generating timer events ALLEGRO_EVENT *timerevent = malloc(sizeof(ALLEGRO_EVENT)); ALLEGRO_EVENT *genericevent = malloc(sizeof(ALLEGRO_EVENT)); float last_drawn, now; last_drawn = now = al_get_time(); while (game->status != Quit) { al_get_keyboard_state(keys); al_wait_for_event(timereq, NULL); al_get_next_event(timereq, timerevent); // No need to fill up the queue if we are late drawing frames al_flush_event_queue(timereq); handle_key_status(game, keys); while(al_get_next_event(genericeq, genericevent)) switch(genericevent->type) { case ALLEGRO_EVENT_KEY_DOWN: handle_key_event(game, genericevent->keyboard.keycode); break; case ALLEGRO_EVENT_DISPLAY_RESIZE: game->size.x = genericevent->display.x; game->size.y = genericevent->display.y; al_acknowledge_resize(display); break; case ALLEGRO_EVENT_DISPLAY_CLOSE: game->status = Quit; break; } now = al_get_time(); update_game(game, now - last_drawn); last_drawn = now; draw_game(game, game->status == Playing ? 1 : 0.2); switch(game->status) { case Playing: break; case Paused: draw_paused(game); break; case Won: draw_won(game); break; case Lost: draw_lost(game); break; default: break; } al_flip_display(); } free(timerevent); free(genericevent); delete_game(game); return 0; }
void handle_events(const SDL_Event& event) { switch (event.type) { #ifdef USE_SDL2 case SDL_WINDOWEVENT: handle_window_event(event); break; case SDL_TEXTINPUT: handle_text_event(event); break; case SDL_MOUSEWHEEL: handle_mouse_event(event); break; case SDL_FINGERMOTION: handle_mouse_event(event); break; case SDL_FINGERUP: handle_mouse_event(event); break; case SDL_FINGERDOWN: handle_mouse_event(event); break; #endif case SDL_KEYDOWN: handle_key_event(event); break; case SDL_KEYUP: handle_key_event(event); break; case SDL_MOUSEMOTION: handle_mouse_event(event); break; case SDL_MOUSEBUTTONUP: handle_mouse_event(event); break; case SDL_MOUSEBUTTONDOWN: handle_mouse_event(event); break; case SDL_JOYAXISMOTION: handle_joy_event(event); break; case SDL_JOYBUTTONDOWN: handle_joy_event(event); break; case SDL_JOYBUTTONUP: handle_joy_event(event); break; case SDL_QUIT: quit(0); break; default: #ifdef OUYA if(event.type == OuyaControllerManager::BUTTON_DOWN_EVENT) { if(OuyaController::ButtonEnum(int(event.user.data1)) == OuyaController::BUTTON_O) input_continue = true; else if(OuyaController::ButtonEnum(int(event.user.data1)) == OuyaController::BUTTON_DPAD_UP) scroll_amount = 5; else if(OuyaController::ButtonEnum(int(event.user.data1)) == OuyaController::BUTTON_DPAD_DOWN) scroll_amount = -5; else if(OuyaController::ButtonEnum(int(event.user.data1)) == OuyaController::BUTTON_MENU) sendFakeKeyDownEvent(SDLK_ESCAPE); key_press_event = 1; } else if(event.type == OuyaControllerManager::AXIS_EVENT) { const OuyaController& c = OuyaControllerManager::getController(event.user.code); // This should not be in an event or else it's jerky. float v = c.getAxisValue(OuyaController::AXIS_LS_Y) + c.getAxisValue(OuyaController::AXIS_RS_Y); if(fabs(v) > OuyaController::DEADZONE) scroll_amount = -5*v; } #endif break; } }