void virtual_kb_esc(char *c) { char text[5]; text[0] = 27; text[1] = 0; SDL_SendKeyboardText(text); SDL_SendKeyboardKey(SDL_PRESSED,SDL_SCANCODE_ESCAPE); SDL_SendKeyboardKey(SDL_RELEASED,SDL_SCANCODE_ESCAPE); }
void virtual_kb_tab(char *c) { char text[5]; text[0] = '\t'; text[1] = 0; SDL_SendKeyboardText(text); SDL_SendKeyboardKey(SDL_PRESSED,SDL_SCANCODE_TAB); SDL_SendKeyboardKey(SDL_RELEASED,SDL_SCANCODE_TAB); }
int PortableKeyEvent(int state, int code, int unicode){ LOGI("PortableKeyEvent %d %d %d",state,code,unicode); if (state) SDL_SendKeyboardKey(SDL_PRESSED, (SDL_Scancode)code); else SDL_SendKeyboardKey(SDL_RELEASED, (SDL_Scancode) code); return 0; }
/* FIXME Mir still needs to implement its IM API, for now we assume a single key press produces a character. */ static void HandleKeyEvent(MirKeyboardEvent const* key_event, SDL_Window* window) { xkb_keysym_t key_code; Uint8 key_state; int event_scancode; uint32_t sdl_scancode = SDL_SCANCODE_UNKNOWN; MirKeyboardAction action = MIR_mir_keyboard_event_action(key_event); key_state = SDL_PRESSED; key_code = MIR_mir_keyboard_event_key_code(key_event); event_scancode = MIR_mir_keyboard_event_scan_code(key_event); if (action == mir_keyboard_action_up) key_state = SDL_RELEASED; if (event_scancode < SDL_arraysize(xfree86_scancode_table2)) sdl_scancode = xfree86_scancode_table2[event_scancode]; if (sdl_scancode != SDL_SCANCODE_UNKNOWN) SDL_SendKeyboardKey(key_state, sdl_scancode); if (key_state == SDL_PRESSED) HandleKeyText(key_code); }
void SDL_ANDROID_DeferredTextInput() { if( !deferredTextMutex ) deferredTextMutex = SDL_CreateMutex(); SDL_mutexP(deferredTextMutex); if( deferredTextIdx1 != deferredTextIdx2 ) { SDL_keysym keysym; deferredTextIdx1++; if( deferredTextIdx1 >= DEFERRED_TEXT_COUNT ) deferredTextIdx1 = 0; keysym = asciiToKeysym( deferredText[deferredTextIdx1].scancode, deferredText[deferredTextIdx1].unicode ); if( deferredText[deferredTextIdx1].down == SDL_RELEASED ) keysym.unicode = 0; SDL_SendKeyboardKey( deferredText[deferredTextIdx1].down, &keysym ); if( SDL_ANDROID_isMouseUsed ) SDL_ANDROID_MainThreadPushMouseMotion(SDL_ANDROID_currentMouseX + (SDL_ANDROID_currentMouseX % 2 ? -1 : 1), SDL_ANDROID_currentMouseY); // Force screen redraw } else { if( SDL_ANDROID_TextInputFinished ) { SDL_ANDROID_TextInputFinished = 0; SDL_ANDROID_IsScreenKeyboardShownFlag = 0; } } SDL_mutexV(deferredTextMutex); }
int BlackBerry_SendTextInput(SDL_Keysym keysym) { char text[5]; char *end; if (keysym.unused && (keysym.sym <= UNICODE_PRIVATE_USE_AREA_FIRST || keysym.sym >= UNICODE_PRIVATE_USE_AREA_LAST)) { end = SDL_UCS4ToUTF8((Uint32) keysym.sym, text); *end = '\0'; return SDL_SendKeyboardText(text); } else if (keysym.sym == KEYCODE_RETURN) { return SDL_SendKeyboardKey((keysym.unused)?SDL_PRESSED:SDL_RELEASED, SDL_SCANCODE_RETURN); } else if (keysym.sym == KEYCODE_BACKSPACE) { return SDL_SendKeyboardKey((keysym.unused)?SDL_PRESSED:SDL_RELEASED, SDL_SCANCODE_BACKSPACE); } return 0; }
void PSP_PumpEvents(_THIS) { int i; enum PspHprmKeys keys; enum PspHprmKeys changed; static enum PspHprmKeys old_keys = 0; SDL_Keysym sym; SDL_SemWait(event_sem); keys = hprm; SDL_SemPost(event_sem); /* HPRM Keyboard */ changed = old_keys ^ keys; old_keys = keys; if(changed) { for(i=0; i<sizeof(keymap_psp)/sizeof(keymap_psp[0]); i++) { if(changed & keymap_psp[i].id) { sym.scancode = keymap_psp[i].id; sym.sym = keymap_psp[i].sym; /* out of date SDL_PrivateKeyboard((keys & keymap_psp[i].id) ? SDL_PRESSED : SDL_RELEASED, &sym); */ SDL_SendKeyboardKey((keys & keymap_psp[i].id) ? SDL_PRESSED : SDL_RELEASED, SDL_GetScancodeFromKey(keymap_psp[i].sym)); } } } #ifdef PSPIRKEYB if (irkbd_ready) { unsigned char buffer[255]; int i, length, count; SIrKeybScanCodeData *scanData; if(pspIrKeybReadinput(buffer, &length) >= 0) { if((length % sizeof(SIrKeybScanCodeData)) == 0){ count = length / sizeof(SIrKeybScanCodeData); for( i=0; i < count; i++ ) { unsigned char raw, pressed; scanData=(SIrKeybScanCodeData*) buffer+i; raw = scanData->raw; pressed = scanData->pressed; sym.scancode = raw; sym.sym = keymap[raw]; /* not tested */ /* SDL_PrivateKeyboard(pressed?SDL_PRESSED:SDL_RELEASED, &sym); */ SDL_SendKeyboardKey((keys & keymap_psp[i].id) ? SDL_PRESSED : SDL_RELEASED, SDL_GetScancodeFromKey(keymap[raw]); } } } }
void SDL_ANDROID_processAndroidTrackballDampening() { SDL_keysym keysym; if( !TrackballDampening ) return; if( SDL_GetTicks() - lastTrackballAction > TrackballDampening ) { if( upPressed ) SDL_SendKeyboardKey( SDL_RELEASED, TranslateKey(KEYCODE_DPAD_UP ,&keysym) ); if( downPressed ) SDL_SendKeyboardKey( SDL_RELEASED, TranslateKey(KEYCODE_DPAD_DOWN ,&keysym) ); if( leftPressed ) SDL_SendKeyboardKey( SDL_RELEASED, TranslateKey(KEYCODE_DPAD_LEFT ,&keysym) ); if( rightPressed ) SDL_SendKeyboardKey( SDL_RELEASED, TranslateKey(KEYCODE_DPAD_RIGHT ,&keysym) ); upPressed = 0; downPressed = 0; leftPressed = 0; rightPressed = 0; } }
/* FIXME Mir still needs to implement its IM API, for now we assume a single key press produces a character. */ static void HandleKeyEvent(MirKeyEvent const ev, SDL_Window* window) { uint32_t scancode = SDL_SCANCODE_UNKNOWN; Uint8 key_state = ev.action == mir_key_action_up ? SDL_RELEASED : SDL_PRESSED; CheckKeyboardFocus(window); if (ev.scan_code < SDL_arraysize(xfree86_scancode_table2)) scancode = xfree86_scancode_table2[ev.scan_code]; if (scancode != SDL_SCANCODE_UNKNOWN) SDL_SendKeyboardKey(key_state, scancode); if (key_state == SDL_PRESSED) HandleKeyText(ev.key_code); }
int BlackBerry_OnKey(SDL_Keysym keysym, Uint8 state) { int scancode; SDL_SetModState(keysym.mod); if (keysym.scancode == SDL_SCANCODE_UNKNOWN) { for (scancode = SDL_SCANCODE_UNKNOWN; scancode < SDL_NUM_SCANCODES; ++scancode) { if (SDL_BlackBerry_keymap[scancode] == keysym.sym) { keysym.scancode = scancode; } } } return SDL_SendKeyboardKey(state, keysym.scancode); }
JNIEXPORT jboolean JNICALL JAVA_EXPORT_NAME(SDLSurfaceView_nativeKey) ( JNIEnv* env, jobject thiz, jint key, jint action, jint unicode ) { if( isTrackballUsed ) if( processAndroidTrackball(key, action) ) return; SDL_keysym keysym; SDL_keysym *ks = TranslateKey(key, &keysym); ks->unicode = unicode; if (ks->sym == KEYCODE_UNKNOWN) { return 0; } else { SDL_SendKeyboardKey( action ? SDL_PRESSED : SDL_RELEASED, ks); return 1; } }
static void keyboard_handle_key(void *data, struct wl_keyboard *keyboard, uint32_t serial, uint32_t time, uint32_t key, uint32_t state_w) { struct SDL_WaylandInput *input = data; SDL_WindowData *window = input->keyboard_focus; enum wl_keyboard_key_state state = state_w; const xkb_keysym_t *syms; uint32_t scancode; char text[8]; int size; if (key < SDL_arraysize(xfree86_scancode_table2)) { scancode = xfree86_scancode_table2[key]; // TODO when do we get WL_KEYBOARD_KEY_STATE_REPEAT? if (scancode != SDL_SCANCODE_UNKNOWN) SDL_SendKeyboardKey(state == WL_KEYBOARD_KEY_STATE_PRESSED ? SDL_PRESSED : SDL_RELEASED, scancode); } if (!window || window->keyboard_device != input || !input->xkb.state) return; // TODO can this happen? if (WAYLAND_xkb_state_key_get_syms(input->xkb.state, key + 8, &syms) != 1) return; if (state) { size = WAYLAND_xkb_keysym_to_utf8(syms[0], text, sizeof text); if (size > 0) { text[size] = 0; Wayland_data_device_set_serial(input->data_device, serial); SDL_SendKeyboardText(text); } } }
void virtual_kb_up(char *c) { SDL_SendKeyboardKey(SDL_PRESSED,SDL_SCANCODE_UP); SDL_SendKeyboardKey(SDL_RELEASED,SDL_SCANCODE_UP); }
void SDL_EVDEV_Poll(void) { struct input_event events[32]; int i, j, len; SDL_evdevlist_item *item; SDL_Scancode scan_code; int mouse_button; SDL_Mouse *mouse; float norm_x, norm_y; if (!_this) { return; } #if SDL_USE_LIBUDEV SDL_UDEV_Poll(); #endif mouse = SDL_GetMouse(); for (item = _this->first; item != NULL; item = item->next) { while ((len = read(item->fd, events, (sizeof events))) > 0) { len /= sizeof(events[0]); for (i = 0; i < len; ++i) { /* special handling for touchscreen, that should eventually be used for all devices */ if (item->out_of_sync && item->is_touchscreen && events[i].type == EV_SYN && events[i].code != SYN_REPORT) { break; } switch (events[i].type) { case EV_KEY: if (events[i].code >= BTN_MOUSE && events[i].code < BTN_MOUSE + SDL_arraysize(EVDEV_MouseButtons)) { mouse_button = events[i].code - BTN_MOUSE; if (events[i].value == 0) { SDL_SendMouseButton(mouse->focus, mouse->mouseID, SDL_RELEASED, EVDEV_MouseButtons[mouse_button]); } else if (events[i].value == 1) { SDL_SendMouseButton(mouse->focus, mouse->mouseID, SDL_PRESSED, EVDEV_MouseButtons[mouse_button]); } break; } /* Probably keyboard */ scan_code = SDL_EVDEV_translate_keycode(events[i].code); if (scan_code != SDL_SCANCODE_UNKNOWN) { if (events[i].value == 0) { SDL_SendKeyboardKey(SDL_RELEASED, scan_code); } else if (events[i].value == 1 || events[i].value == 2 /* key repeated */) { SDL_SendKeyboardKey(SDL_PRESSED, scan_code); #ifdef SDL_INPUT_LINUXKD SDL_EVDEV_do_text_input(events[i].code); #endif /* SDL_INPUT_LINUXKD */ } } break; case EV_ABS: switch(events[i].code) { case ABS_MT_SLOT: if (!item->is_touchscreen) /* FIXME: temp hack */ break; item->touchscreen_data->current_slot = events[i].value; break; case ABS_MT_TRACKING_ID: if (!item->is_touchscreen) /* FIXME: temp hack */ break; if (events[i].value >= 0) { item->touchscreen_data->slots[item->touchscreen_data->current_slot].tracking_id = events[i].value; item->touchscreen_data->slots[item->touchscreen_data->current_slot].delta = EVDEV_TOUCH_SLOTDELTA_DOWN; } else { item->touchscreen_data->slots[item->touchscreen_data->current_slot].delta = EVDEV_TOUCH_SLOTDELTA_UP; } break; case ABS_MT_POSITION_X: if (!item->is_touchscreen) /* FIXME: temp hack */ break; item->touchscreen_data->slots[item->touchscreen_data->current_slot].x = events[i].value; if (item->touchscreen_data->slots[item->touchscreen_data->current_slot].delta == EVDEV_TOUCH_SLOTDELTA_NONE) { item->touchscreen_data->slots[item->touchscreen_data->current_slot].delta = EVDEV_TOUCH_SLOTDELTA_MOVE; } break; case ABS_MT_POSITION_Y: if (!item->is_touchscreen) /* FIXME: temp hack */ break; item->touchscreen_data->slots[item->touchscreen_data->current_slot].y = events[i].value; if (item->touchscreen_data->slots[item->touchscreen_data->current_slot].delta == EVDEV_TOUCH_SLOTDELTA_NONE) { item->touchscreen_data->slots[item->touchscreen_data->current_slot].delta = EVDEV_TOUCH_SLOTDELTA_MOVE; } break; case ABS_X: if (item->is_touchscreen) /* FIXME: temp hack */ break; SDL_SendMouseMotion(mouse->focus, mouse->mouseID, SDL_FALSE, events[i].value, mouse->y); break; case ABS_Y: if (item->is_touchscreen) /* FIXME: temp hack */ break; SDL_SendMouseMotion(mouse->focus, mouse->mouseID, SDL_FALSE, mouse->x, events[i].value); break; default: break; } break; case EV_REL: switch(events[i].code) { case REL_X: SDL_SendMouseMotion(mouse->focus, mouse->mouseID, SDL_TRUE, events[i].value, 0); break; case REL_Y: SDL_SendMouseMotion(mouse->focus, mouse->mouseID, SDL_TRUE, 0, events[i].value); break; case REL_WHEEL: SDL_SendMouseWheel(mouse->focus, mouse->mouseID, 0, events[i].value, SDL_MOUSEWHEEL_NORMAL); break; case REL_HWHEEL: SDL_SendMouseWheel(mouse->focus, mouse->mouseID, events[i].value, 0, SDL_MOUSEWHEEL_NORMAL); break; default: break; } break; case EV_SYN: switch (events[i].code) { case SYN_REPORT: if (!item->is_touchscreen) /* FIXME: temp hack */ break; for(j = 0; j < item->touchscreen_data->max_slots; j++) { norm_x = (float)(item->touchscreen_data->slots[j].x - item->touchscreen_data->min_x) / (float)item->touchscreen_data->range_x; norm_y = (float)(item->touchscreen_data->slots[j].y - item->touchscreen_data->min_y) / (float)item->touchscreen_data->range_y; switch(item->touchscreen_data->slots[j].delta) { case EVDEV_TOUCH_SLOTDELTA_DOWN: SDL_SendTouch(item->fd, item->touchscreen_data->slots[j].tracking_id, SDL_TRUE, norm_x, norm_y, 1.0f); item->touchscreen_data->slots[j].delta = EVDEV_TOUCH_SLOTDELTA_NONE; break; case EVDEV_TOUCH_SLOTDELTA_UP: SDL_SendTouch(item->fd, item->touchscreen_data->slots[j].tracking_id, SDL_FALSE, norm_x, norm_y, 1.0f); item->touchscreen_data->slots[j].tracking_id = -1; item->touchscreen_data->slots[j].delta = EVDEV_TOUCH_SLOTDELTA_NONE; break; case EVDEV_TOUCH_SLOTDELTA_MOVE: SDL_SendTouchMotion(item->fd, item->touchscreen_data->slots[j].tracking_id, norm_x, norm_y, 1.0f); item->touchscreen_data->slots[j].delta = EVDEV_TOUCH_SLOTDELTA_NONE; break; default: break; } } if (item->out_of_sync) item->out_of_sync = 0; break; case SYN_DROPPED: if (item->is_touchscreen) item->out_of_sync = 1; SDL_EVDEV_sync_device(item); break; default: break; } break; } } } } }
void virtual_kb_right(char *c) { SDL_SendKeyboardKey(SDL_PRESSED,SDL_SCANCODE_RIGHT); SDL_SendKeyboardKey(SDL_RELEASED,SDL_SCANCODE_RIGHT); }
extern void SDL_ANDROID_MainThreadPushKeyboardKey(int pressed, SDL_scancode key, int unicode) { SDL_keysym keysym; if( SDL_ANDROID_moveMouseWithArrowKeys && ( key == SDL_KEY(UP) || key == SDL_KEY(DOWN) || key == SDL_KEY(LEFT) || key == SDL_KEY(RIGHT) ) ) { if( SDL_ANDROID_moveMouseWithKbX < 0 ) { SDL_ANDROID_moveMouseWithKbX = SDL_ANDROID_currentMouseX; SDL_ANDROID_moveMouseWithKbY = SDL_ANDROID_currentMouseY; } if( pressed ) { if( key == SDL_KEY(LEFT) ) { if( SDL_ANDROID_moveMouseWithKbSpeedX > 0 ) SDL_ANDROID_moveMouseWithKbSpeedX = 0; SDL_ANDROID_moveMouseWithKbSpeedX -= SDL_ANDROID_moveMouseWithKbSpeed; SDL_ANDROID_moveMouseWithKbAccelX = -SDL_ANDROID_moveMouseWithKbAccel; SDL_ANDROID_moveMouseWithKbAccelUpdateNeeded |= 1; } else if( key == SDL_KEY(RIGHT) ) { if( SDL_ANDROID_moveMouseWithKbSpeedX < 0 ) SDL_ANDROID_moveMouseWithKbSpeedX = 0; SDL_ANDROID_moveMouseWithKbSpeedX += SDL_ANDROID_moveMouseWithKbSpeed; SDL_ANDROID_moveMouseWithKbAccelX = SDL_ANDROID_moveMouseWithKbAccel; SDL_ANDROID_moveMouseWithKbAccelUpdateNeeded |= 1; } if( key == SDL_KEY(UP) ) { if( SDL_ANDROID_moveMouseWithKbSpeedY > 0 ) SDL_ANDROID_moveMouseWithKbSpeedY = 0; SDL_ANDROID_moveMouseWithKbSpeedY -= SDL_ANDROID_moveMouseWithKbSpeed; SDL_ANDROID_moveMouseWithKbAccelY = -SDL_ANDROID_moveMouseWithKbAccel; SDL_ANDROID_moveMouseWithKbAccelUpdateNeeded |= 2; } else if( key == SDL_KEY(DOWN) ) { if( SDL_ANDROID_moveMouseWithKbSpeedY < 0 ) SDL_ANDROID_moveMouseWithKbSpeedY = 0; SDL_ANDROID_moveMouseWithKbSpeedY += SDL_ANDROID_moveMouseWithKbSpeed; SDL_ANDROID_moveMouseWithKbAccelY = SDL_ANDROID_moveMouseWithKbAccel; SDL_ANDROID_moveMouseWithKbAccelUpdateNeeded |= 2; } } else { if( key == SDL_KEY(LEFT) || key == SDL_KEY(RIGHT) ) { SDL_ANDROID_moveMouseWithKbSpeedX = 0; SDL_ANDROID_moveMouseWithKbAccelX = 0; SDL_ANDROID_moveMouseWithKbAccelUpdateNeeded &= ~1; } if( key == SDL_KEY(UP) || key == SDL_KEY(DOWN) ) { SDL_ANDROID_moveMouseWithKbSpeedY = 0; SDL_ANDROID_moveMouseWithKbAccelY = 0; SDL_ANDROID_moveMouseWithKbAccelUpdateNeeded &= ~2; } } SDL_ANDROID_moveMouseWithKbX += SDL_ANDROID_moveMouseWithKbSpeedX; SDL_ANDROID_moveMouseWithKbY += SDL_ANDROID_moveMouseWithKbSpeedY; SDL_ANDROID_MainThreadPushMouseMotion(SDL_ANDROID_moveMouseWithKbX, SDL_ANDROID_moveMouseWithKbY); return; } if ( key >= SDLK_MOUSE_LEFT && key <= SDLK_MOUSE_X2 ) { SDL_ANDROID_MainThreadPushMouseButton(pressed, key - SDLK_MOUSE_LEFT + SDL_BUTTON_LEFT); return; } keysym.scancode = key; if ( key < SDLK_LAST ) keysym.scancode = SDL_android_keysym_to_scancode[key]; keysym.sym = key; keysym.mod = KMOD_NONE; keysym.unicode = 0; #if SDL_VERSION_ATLEAST(1,3,0) #else if ( SDL_TranslateUNICODE ) #endif keysym.unicode = unicode; if( (keysym.unicode & 0xFF80) != 0 ) keysym.sym = SDLK_WORLD_0; //else if( keysym.sym < 0x80 ) // keysym.unicode = keysym.sym; if( pressed == SDL_RELEASED ) keysym.unicode = 0; //__android_log_print(ANDROID_LOG_INFO, "libSDL","SDL_SendKeyboardKey sym %d scancode %d unicode %d", keysym.sym, keysym.scancode, keysym.unicode); SDL_SendKeyboardKey( pressed, &keysym ); }
int Android_OnSDLKeyDown(int keycode) { return SDL_SendKeyboardKey(SDL_PRESSED, keycode); }
int Android_OnKeyUp(int keycode) { return SDL_SendKeyboardKey(SDL_RELEASED, TranslateKeycode(keycode)); }
int Android_OnKeyDown(int keycode) { return SDL_SendKeyboardKey(SDL_PRESSED, TranslateKeycode(keycode)); }
extern void SDL_ANDROID_MainThreadPushKeyboardKey(int pressed, SDL_scancode key) { SDL_keysym keysym; if( SDL_ANDROID_moveMouseWithArrowKeys && ( key == SDL_KEY(UP) || key == SDL_KEY(DOWN) || key == SDL_KEY(LEFT) || key == SDL_KEY(RIGHT) ) ) { if( SDL_ANDROID_moveMouseWithKbX < 0 ) { SDL_ANDROID_moveMouseWithKbX = SDL_ANDROID_currentMouseX; SDL_ANDROID_moveMouseWithKbY = SDL_ANDROID_currentMouseY; } if( pressed ) { if( key == SDL_KEY(LEFT) ) { if( SDL_ANDROID_moveMouseWithKbSpeedX > 0 ) SDL_ANDROID_moveMouseWithKbSpeedX = 0; SDL_ANDROID_moveMouseWithKbSpeedX -= SDL_ANDROID_moveMouseWithKbSpeed; SDL_ANDROID_moveMouseWithKbAccelX = -SDL_ANDROID_moveMouseWithKbAccel; SDL_ANDROID_moveMouseWithKbAccelUpdateNeeded |= 1; } else if( key == SDL_KEY(RIGHT) ) { if( SDL_ANDROID_moveMouseWithKbSpeedX < 0 ) SDL_ANDROID_moveMouseWithKbSpeedX = 0; SDL_ANDROID_moveMouseWithKbSpeedX += SDL_ANDROID_moveMouseWithKbSpeed; SDL_ANDROID_moveMouseWithKbAccelX = SDL_ANDROID_moveMouseWithKbAccel; SDL_ANDROID_moveMouseWithKbAccelUpdateNeeded |= 1; } if( key == SDL_KEY(UP) ) { if( SDL_ANDROID_moveMouseWithKbSpeedY > 0 ) SDL_ANDROID_moveMouseWithKbSpeedY = 0; SDL_ANDROID_moveMouseWithKbSpeedY -= SDL_ANDROID_moveMouseWithKbSpeed; SDL_ANDROID_moveMouseWithKbAccelY = -SDL_ANDROID_moveMouseWithKbAccel; SDL_ANDROID_moveMouseWithKbAccelUpdateNeeded |= 2; } else if( key == SDL_KEY(DOWN) ) { if( SDL_ANDROID_moveMouseWithKbSpeedY < 0 ) SDL_ANDROID_moveMouseWithKbSpeedY = 0; SDL_ANDROID_moveMouseWithKbSpeedY += SDL_ANDROID_moveMouseWithKbSpeed; SDL_ANDROID_moveMouseWithKbAccelY = SDL_ANDROID_moveMouseWithKbAccel; SDL_ANDROID_moveMouseWithKbAccelUpdateNeeded |= 2; } } else { if( key == SDL_KEY(LEFT) || key == SDL_KEY(RIGHT) ) { SDL_ANDROID_moveMouseWithKbSpeedX = 0; SDL_ANDROID_moveMouseWithKbAccelX = 0; SDL_ANDROID_moveMouseWithKbAccelUpdateNeeded &= ~1; } if( key == SDL_KEY(UP) || key == SDL_KEY(DOWN) ) { SDL_ANDROID_moveMouseWithKbSpeedY = 0; SDL_ANDROID_moveMouseWithKbAccelY = 0; SDL_ANDROID_moveMouseWithKbAccelUpdateNeeded &= ~2; } } SDL_ANDROID_moveMouseWithKbX += SDL_ANDROID_moveMouseWithKbSpeedX; SDL_ANDROID_moveMouseWithKbY += SDL_ANDROID_moveMouseWithKbSpeedY; SDL_ANDROID_MainThreadPushMouseMotion(SDL_ANDROID_moveMouseWithKbX, SDL_ANDROID_moveMouseWithKbY); return; } keysym.scancode = key; keysym.sym = key; keysym.mod = KMOD_NONE; keysym.unicode = 0; #if SDL_VERSION_ATLEAST(1,3,0) #else if ( SDL_TranslateUNICODE ) #endif keysym.unicode = key; if( pressed == SDL_RELEASED ) keysym.unicode = 0; SDL_SendKeyboardKey( pressed, &keysym ); }
int SDL_ANDROID_processTouchscreenKeyboard(int x, int y, int action, int pointerId) { int i; SDL_keysym keysym; if( !touchscreenKeyboardShown ) return 0; if( action == MOUSE_DOWN ) { if( InsideRect( &arrows, x, y ) ) { OldCoords[pointerId] = &arrows; i = ArrowKeysPressed(x, y); if( i & ARROW_UP ) SDL_SendKeyboardKey( SDL_PRESSED, GetKeysym( SDL_KEY(UP), &keysym) ); if( i & ARROW_DOWN ) SDL_SendKeyboardKey( SDL_PRESSED, GetKeysym( SDL_KEY(DOWN), &keysym) ); if( i & ARROW_LEFT ) SDL_SendKeyboardKey( SDL_PRESSED, GetKeysym( SDL_KEY(LEFT), &keysym) ); if( i & ARROW_RIGHT ) SDL_SendKeyboardKey( SDL_PRESSED, GetKeysym( SDL_KEY(RIGHT), &keysym) ); oldArrows = i; return 1; } for( i = 0; i < nbuttons; i++ ) { if( InsideRect( &buttons[i], x, y) ) { OldCoords[pointerId] = &buttons[i]; SDL_SendKeyboardKey( SDL_PRESSED, GetKeysym(buttonKeysyms[i], &keysym) ); if( i < AutoFireButtonsNum ) { ButtonAutoFire[i] = 0; if(touchscreenKeyboardTheme == 0) { ButtonAutoFireX[i] = x; ButtonAutoFireRot[i] = 0; } else { ButtonAutoFireX[i*2] = 0; ButtonAutoFireX[i*2+1] = 0; ButtonAutoFireRot[i] = x; ButtonAutoFireDecay[i] = SDL_GetTicks(); } } return 1; } } } else if( action == MOUSE_UP ) { if( OldCoords[pointerId] == &arrows ) { OldCoords[pointerId] = NULL; SDL_SendKeyboardKey( SDL_RELEASED, GetKeysym( SDL_KEY(UP), &keysym) ); SDL_SendKeyboardKey( SDL_RELEASED, GetKeysym( SDL_KEY(DOWN), &keysym) ); SDL_SendKeyboardKey( SDL_RELEASED, GetKeysym( SDL_KEY(LEFT), &keysym) ); SDL_SendKeyboardKey( SDL_RELEASED, GetKeysym( SDL_KEY(RIGHT), &keysym) ); oldArrows = 0; return 1; } for( i = 0; i < nbuttons; i++ ) { if( OldCoords[pointerId] == &buttons[i] ) { if( ! ( i < AutoFireButtonsNum && ButtonAutoFire[i] ) ) { SDL_SendKeyboardKey( SDL_RELEASED, GetKeysym(buttonKeysyms[i] ,&keysym) ); } else { ButtonAutoFire[i] = 2; } OldCoords[pointerId] = NULL; if(touchscreenKeyboardTheme == 0) { ButtonAutoFireX[i] = 0; } else { ButtonAutoFireX[i*2] = 0; ButtonAutoFireX[i*2+1] = 0; } return 1; } } } else if( action == MOUSE_MOVE ) { if( OldCoords[pointerId] && !InsideRect(OldCoords[pointerId], x, y) ) { SDL_ANDROID_processTouchscreenKeyboard(x, y, MOUSE_UP, pointerId); return SDL_ANDROID_processTouchscreenKeyboard(x, y, MOUSE_DOWN, pointerId); } else if( OldCoords[pointerId] == &arrows ) { i = ArrowKeysPressed(x, y); if( i == oldArrows ) return 1; if( oldArrows & ARROW_UP && ! (i & ARROW_UP) ) SDL_SendKeyboardKey( SDL_RELEASED, GetKeysym( SDL_KEY(UP), &keysym) ); if( oldArrows & ARROW_DOWN && ! (i & ARROW_DOWN) ) SDL_SendKeyboardKey( SDL_RELEASED, GetKeysym( SDL_KEY(DOWN), &keysym) ); if( oldArrows & ARROW_LEFT && ! (i & ARROW_LEFT) ) SDL_SendKeyboardKey( SDL_RELEASED, GetKeysym( SDL_KEY(LEFT), &keysym) ); if( oldArrows & ARROW_RIGHT && ! (i & ARROW_RIGHT) ) SDL_SendKeyboardKey( SDL_RELEASED, GetKeysym( SDL_KEY(RIGHT), &keysym) ); if( i & ARROW_UP ) SDL_SendKeyboardKey( SDL_PRESSED, GetKeysym( SDL_KEY(UP), &keysym) ); if( i & ARROW_DOWN ) SDL_SendKeyboardKey( SDL_PRESSED, GetKeysym( SDL_KEY(DOWN), &keysym) ); if( i & ARROW_LEFT ) SDL_SendKeyboardKey( SDL_PRESSED, GetKeysym( SDL_KEY(LEFT), &keysym) ); if( i & ARROW_RIGHT ) SDL_SendKeyboardKey( SDL_PRESSED, GetKeysym( SDL_KEY(RIGHT), &keysym) ); oldArrows = i; } else { for(i = 0; i < AutoFireButtonsNum; i++) if( OldCoords[pointerId] == &buttons[i] ) { if(touchscreenKeyboardTheme == 0) { ButtonAutoFire[i] = abs(ButtonAutoFireX[i] - x) > buttons[i].w / 2; if( !ButtonAutoFire[i] ) ButtonAutoFireRot[i] = ButtonAutoFireX[i] - x; } else { int coeff = (buttonAutoFireImages[i*2+1].w > buttons[i].w) ? buttonAutoFireImages[i*2+1].w / buttons[i].w + 1 : 1; if( ButtonAutoFireRot[i] < x ) ButtonAutoFireX[i*2+1] += (x - ButtonAutoFireRot[i]) * coeff; if( ButtonAutoFireRot[i] > x ) ButtonAutoFireX[i*2] += (ButtonAutoFireRot[i] - x) * coeff; ButtonAutoFireRot[i] = x; if( ButtonAutoFireX[i*2] < 0 ) ButtonAutoFireX[i*2] = 0; if( ButtonAutoFireX[i*2+1] < 0 ) ButtonAutoFireX[i*2+1] = 0; if( ButtonAutoFireX[i*2] > buttonAutoFireImages[i*2+1].w / 2 ) ButtonAutoFireX[i*2] = buttonAutoFireImages[i*2+1].w / 2; if( ButtonAutoFireX[i*2+1] > buttonAutoFireImages[i*2+1].w / 2 ) ButtonAutoFireX[i*2+1] = buttonAutoFireImages[i*2+1].w / 2; if( ButtonAutoFireX[i*2] == buttonAutoFireImages[i*2+1].w / 2 && ButtonAutoFireX[i*2+1] == buttonAutoFireImages[i*2+1].w / 2 ) { if( ! ButtonAutoFire[i] ) ButtonAutoFireDecay[i] = SDL_GetTicks(); ButtonAutoFire[i] = 1; } } } } if( OldCoords[pointerId] ) return 1; return SDL_ANDROID_processTouchscreenKeyboard(x, y, MOUSE_DOWN, pointerId); } return 0; };
void virtual_kb_down(char *c) { SDL_SendKeyboardKey(SDL_PRESSED,SDL_SCANCODE_DOWN); SDL_SendKeyboardKey(SDL_RELEASED,SDL_SCANCODE_DOWN); }
void virtual_kb_left(char *c) { SDL_SendKeyboardKey(SDL_PRESSED,SDL_SCANCODE_LEFT); SDL_SendKeyboardKey(SDL_RELEASED,SDL_SCANCODE_LEFT); }
static void X11_DispatchEvent(_THIS) { SDL_VideoData *videodata = (SDL_VideoData *) _this->driverdata; Display *display = videodata->display; SDL_WindowData *data; XEvent xevent; int i; SDL_zero(xevent); /* valgrind fix. --ryan. */ XNextEvent(display, &xevent); /* filter events catchs XIM events and sends them to the correct handler */ if (XFilterEvent(&xevent, None) == True) { #if 0 printf("Filtered event type = %d display = %d window = %d\n", xevent.type, xevent.xany.display, xevent.xany.window); #endif return; } /* Send a SDL_SYSWMEVENT if the application wants them */ if (SDL_GetEventState(SDL_SYSWMEVENT) == SDL_ENABLE) { SDL_SysWMmsg wmmsg; SDL_VERSION(&wmmsg.version); wmmsg.subsystem = SDL_SYSWM_X11; wmmsg.msg.x11.event = xevent; SDL_SendSysWMEvent(&wmmsg); } #if SDL_VIDEO_DRIVER_X11_SUPPORTS_GENERIC_EVENTS if(xevent.type == GenericEvent) { X11_HandleGenericEvent(videodata,xevent); return; } #endif #if 0 printf("type = %d display = %d window = %d\n", xevent.type, xevent.xany.display, xevent.xany.window); #endif data = NULL; if (videodata && videodata->windowlist) { for (i = 0; i < videodata->numwindows; ++i) { if ((videodata->windowlist[i] != NULL) && (videodata->windowlist[i]->xwindow == xevent.xany.window)) { data = videodata->windowlist[i]; break; } } } if (!data) { return; } switch (xevent.type) { /* Gaining mouse coverage? */ case EnterNotify:{ #ifdef DEBUG_XEVENTS printf("window %p: EnterNotify! (%d,%d,%d)\n", data, xevent.xcrossing.x, xevent.xcrossing.y, xevent.xcrossing.mode); if (xevent.xcrossing.mode == NotifyGrab) printf("Mode: NotifyGrab\n"); if (xevent.xcrossing.mode == NotifyUngrab) printf("Mode: NotifyUngrab\n"); #endif SDL_SetMouseFocus(data->window); } break; /* Losing mouse coverage? */ case LeaveNotify:{ #ifdef DEBUG_XEVENTS printf("window %p: LeaveNotify! (%d,%d,%d)\n", data, xevent.xcrossing.x, xevent.xcrossing.y, xevent.xcrossing.mode); if (xevent.xcrossing.mode == NotifyGrab) printf("Mode: NotifyGrab\n"); if (xevent.xcrossing.mode == NotifyUngrab) printf("Mode: NotifyUngrab\n"); #endif if (xevent.xcrossing.mode != NotifyGrab && xevent.xcrossing.mode != NotifyUngrab && xevent.xcrossing.detail != NotifyInferior) { SDL_SetMouseFocus(NULL); } } break; /* Gaining input focus? */ case FocusIn:{ if (xevent.xfocus.detail == NotifyInferior) { #ifdef DEBUG_XEVENTS printf("window %p: FocusIn (NotifierInferior, ignoring)\n", data); #endif break; } #ifdef DEBUG_XEVENTS printf("window %p: FocusIn!\n", data); #endif if (data->pending_focus == PENDING_FOCUS_OUT && data->window == SDL_GetKeyboardFocus()) { /* We want to reset the keyboard here, because we may have missed keyboard messages after our previous FocusOut. */ SDL_ResetKeyboard(); } data->pending_focus = PENDING_FOCUS_IN; data->pending_focus_time = SDL_GetTicks() + PENDING_FOCUS_IN_TIME; } break; /* Losing input focus? */ case FocusOut:{ if (xevent.xfocus.detail == NotifyInferior) { /* We still have focus if a child gets focus */ #ifdef DEBUG_XEVENTS printf("window %p: FocusOut (NotifierInferior, ignoring)\n", data); #endif break; } #ifdef DEBUG_XEVENTS printf("window %p: FocusOut!\n", data); #endif data->pending_focus = PENDING_FOCUS_OUT; data->pending_focus_time = SDL_GetTicks() + PENDING_FOCUS_OUT_TIME; } break; /* Generated upon EnterWindow and FocusIn */ case KeymapNotify:{ #ifdef DEBUG_XEVENTS printf("window %p: KeymapNotify!\n", data); #endif /* FIXME: X11_SetKeyboardState(SDL_Display, xevent.xkeymap.key_vector); */ } break; /* Has the keyboard layout changed? */ case MappingNotify:{ #ifdef DEBUG_XEVENTS printf("window %p: MappingNotify!\n", data); #endif X11_UpdateKeymap(_this); } break; /* Key press? */ case KeyPress:{ KeyCode keycode = xevent.xkey.keycode; KeySym keysym = NoSymbol; char text[SDL_TEXTINPUTEVENT_TEXT_SIZE]; Status status = 0; #ifdef DEBUG_XEVENTS printf("window %p: KeyPress (X11 keycode = 0x%X)\n", data, xevent.xkey.keycode); #endif SDL_SendKeyboardKey(SDL_PRESSED, videodata->key_layout[keycode]); #if 1 if (videodata->key_layout[keycode] == SDL_SCANCODE_UNKNOWN) { int min_keycode, max_keycode; XDisplayKeycodes(display, &min_keycode, &max_keycode); #if SDL_VIDEO_DRIVER_X11_HAS_XKBKEYCODETOKEYSYM keysym = XkbKeycodeToKeysym(display, keycode, 0, 0); #else keysym = XKeycodeToKeysym(display, keycode, 0); #endif fprintf(stderr, "The key you just pressed is not recognized by SDL. To help get this fixed, please report this to the SDL mailing list <*****@*****.**> X11 KeyCode %d (%d), X11 KeySym 0x%lX (%s).\n", keycode, keycode - min_keycode, keysym, XKeysymToString(keysym)); } #endif /* */ SDL_zero(text); #ifdef X_HAVE_UTF8_STRING if (data->ic) { Xutf8LookupString(data->ic, &xevent.xkey, text, sizeof(text), &keysym, &status); } #else XLookupString(&xevent.xkey, text, sizeof(text), &keysym, NULL); #endif if (*text) { SDL_SendKeyboardText(text); } } break; /* Key release? */ case KeyRelease:{ KeyCode keycode = xevent.xkey.keycode; #ifdef DEBUG_XEVENTS printf("window %p: KeyRelease (X11 keycode = 0x%X)\n", data, xevent.xkey.keycode); #endif if (X11_KeyRepeat(display, &xevent)) { /* We're about to get a repeated key down, ignore the key up */ break; } SDL_SendKeyboardKey(SDL_RELEASED, videodata->key_layout[keycode]); } break; /* Have we been iconified? */ case UnmapNotify:{ #ifdef DEBUG_XEVENTS printf("window %p: UnmapNotify!\n", data); #endif X11_DispatchUnmapNotify(data); } break; /* Have we been restored? */ case MapNotify:{ #ifdef DEBUG_XEVENTS printf("window %p: MapNotify!\n", data); #endif X11_DispatchMapNotify(data); } break; /* Have we been resized or moved? */ case ConfigureNotify:{ #ifdef DEBUG_XEVENTS printf("window %p: ConfigureNotify! (position: %d,%d, size: %dx%d)\n", data, xevent.xconfigure.x, xevent.xconfigure.y, xevent.xconfigure.width, xevent.xconfigure.height); #endif if (xevent.xconfigure.x != data->last_xconfigure.x || xevent.xconfigure.y != data->last_xconfigure.y) { SDL_SendWindowEvent(data->window, SDL_WINDOWEVENT_MOVED, xevent.xconfigure.x, xevent.xconfigure.y); } if (xevent.xconfigure.width != data->last_xconfigure.width || xevent.xconfigure.height != data->last_xconfigure.height) { SDL_SendWindowEvent(data->window, SDL_WINDOWEVENT_RESIZED, xevent.xconfigure.width, xevent.xconfigure.height); } data->last_xconfigure = xevent.xconfigure; } break; /* Have we been requested to quit (or another client message?) */ case ClientMessage:{ if ((xevent.xclient.message_type == videodata->WM_PROTOCOLS) && (xevent.xclient.format == 32) && (xevent.xclient.data.l[0] == videodata->_NET_WM_PING)) { Window root = DefaultRootWindow(display); #ifdef DEBUG_XEVENTS printf("window %p: _NET_WM_PING\n", data); #endif xevent.xclient.window = root; XSendEvent(display, root, False, SubstructureRedirectMask | SubstructureNotifyMask, &xevent); break; } else if ((xevent.xclient.message_type == videodata->WM_PROTOCOLS) && (xevent.xclient.format == 32) && (xevent.xclient.data.l[0] == videodata->WM_DELETE_WINDOW)) { #ifdef DEBUG_XEVENTS printf("window %p: WM_DELETE_WINDOW\n", data); #endif SDL_SendWindowEvent(data->window, SDL_WINDOWEVENT_CLOSE, 0, 0); break; } } break; /* Do we need to refresh ourselves? */ case Expose:{ #ifdef DEBUG_XEVENTS printf("window %p: Expose (count = %d)\n", data, xevent.xexpose.count); #endif SDL_SendWindowEvent(data->window, SDL_WINDOWEVENT_EXPOSED, 0, 0); } break; case MotionNotify:{ SDL_Mouse *mouse = SDL_GetMouse(); if(!mouse->relative_mode) { #ifdef DEBUG_MOTION printf("window %p: X11 motion: %d,%d\n", xevent.xmotion.x, xevent.xmotion.y); #endif SDL_SendMouseMotion(data->window, 0, xevent.xmotion.x, xevent.xmotion.y); } } break; case ButtonPress:{ int ticks = 0; if (X11_IsWheelEvent(display,&xevent,&ticks) == SDL_TRUE) { SDL_SendMouseWheel(data->window, 0, ticks); } else { SDL_SendMouseButton(data->window, SDL_PRESSED, xevent.xbutton.button); } } break; case ButtonRelease:{ SDL_SendMouseButton(data->window, SDL_RELEASED, xevent.xbutton.button); } break; case PropertyNotify:{ #ifdef DEBUG_XEVENTS unsigned char *propdata; int status, real_format; Atom real_type; unsigned long items_read, items_left, i; char *name = XGetAtomName(display, xevent.xproperty.atom); if (name) { printf("window %p: PropertyNotify: %s %s\n", data, name, (xevent.xproperty.state == PropertyDelete) ? "deleted" : "changed"); XFree(name); } status = XGetWindowProperty(display, data->xwindow, xevent.xproperty.atom, 0L, 8192L, False, AnyPropertyType, &real_type, &real_format, &items_read, &items_left, &propdata); if (status == Success && items_read > 0) { if (real_type == XA_INTEGER) { int *values = (int *)propdata; printf("{"); for (i = 0; i < items_read; i++) { printf(" %d", values[i]); } printf(" }\n"); } else if (real_type == XA_CARDINAL) { if (real_format == 32) { Uint32 *values = (Uint32 *)propdata; printf("{"); for (i = 0; i < items_read; i++) { printf(" %d", values[i]); } printf(" }\n"); } else if (real_format == 16) { Uint16 *values = (Uint16 *)propdata; printf("{"); for (i = 0; i < items_read; i++) { printf(" %d", values[i]); } printf(" }\n"); } else if (real_format == 8) { Uint8 *values = (Uint8 *)propdata; printf("{"); for (i = 0; i < items_read; i++) { printf(" %d", values[i]); } printf(" }\n"); } } else if (real_type == XA_STRING || real_type == videodata->UTF8_STRING) { printf("{ \"%s\" }\n", propdata); } else if (real_type == XA_ATOM) { Atom *atoms = (Atom *)propdata; printf("{"); for (i = 0; i < items_read; i++) { char *name = XGetAtomName(display, atoms[i]); if (name) { printf(" %s", name); XFree(name); } } printf(" }\n"); } else { char *name = XGetAtomName(display, real_type); printf("Unknown type: %ld (%s)\n", real_type, name ? name : "UNKNOWN"); if (name) { XFree(name); } } } if (status == Success) { XFree(propdata); } #endif /* DEBUG_XEVENTS */ if (xevent.xproperty.atom == data->videodata->_NET_WM_STATE) { /* Get the new state from the window manager. Compositing window managers can alter visibility of windows without ever mapping / unmapping them, so we handle that here, because they use the NETWM protocol to notify us of changes. */ Uint32 flags = X11_GetNetWMState(_this, xevent.xproperty.window); if ((flags^data->window->flags) & SDL_WINDOW_HIDDEN) { if (flags & SDL_WINDOW_HIDDEN) { X11_DispatchUnmapNotify(data); } else { X11_DispatchMapNotify(data); } } } } break; /* Copy the selection from XA_CUT_BUFFER0 to the requested property */ case SelectionRequest: { XSelectionRequestEvent *req; XEvent sevent; int seln_format; unsigned long nbytes; unsigned long overflow; unsigned char *seln_data; req = &xevent.xselectionrequest; #ifdef DEBUG_XEVENTS printf("window %p: SelectionRequest (requestor = %ld, target = %ld)\n", data, req->requestor, req->target); #endif SDL_zero(sevent); sevent.xany.type = SelectionNotify; sevent.xselection.selection = req->selection; sevent.xselection.target = None; sevent.xselection.property = None; sevent.xselection.requestor = req->requestor; sevent.xselection.time = req->time; if (XGetWindowProperty(display, DefaultRootWindow(display), XA_CUT_BUFFER0, 0, INT_MAX/4, False, req->target, &sevent.xselection.target, &seln_format, &nbytes, &overflow, &seln_data) == Success) { if (sevent.xselection.target == req->target) { XChangeProperty(display, req->requestor, req->property, sevent.xselection.target, seln_format, PropModeReplace, seln_data, nbytes); sevent.xselection.property = req->property; } XFree(seln_data); } XSendEvent(display, req->requestor, False, 0, &sevent); XSync(display, False); } break; case SelectionNotify: { #ifdef DEBUG_XEVENTS printf("window %p: SelectionNotify (requestor = %ld, target = %ld)\n", data, xevent.xselection.requestor, xevent.xselection.target); #endif videodata->selection_waiting = SDL_FALSE; } break; default:{ #ifdef DEBUG_XEVENTS printf("window %p: Unhandled event %d\n", data, xevent.type); #endif } break; } }
JNIEXPORT void JNICALL JAVA_EXPORT_NAME(SDLSurfaceView_nativeMouse) ( JNIEnv* env, jobject thiz, jint x, jint y, jint action, jint pointerId, jint force, jint radius ) { if(pointerId < 0) pointerId = 0; if(pointerId > MAX_MULTITOUCH_POINTERS) pointerId = MAX_MULTITOUCH_POINTERS; // if( SDL_android_processTouchscreenKeyboard(x, y, action, pointerId) ) // return; if (GLES_pwidth != 0.0) { float ix = 1.0 * x / GLES_pwidth; float iy = 1.0 * y / GLES_pheight; x = (int) (GLES_vbox_left + ix * (GLES_vbox_right - GLES_vbox_left)); y = (int) (GLES_vbox_top + iy * (GLES_vbox_bottom - GLES_vbox_top)); } #if SDL_VIDEO_RENDER_RESIZE // Translate mouse coordinates #if SDL_VERSION_ATLEAST(1,3,0) SDL_Window * window = SDL_GetFocusWindow(); if( window && window->renderer->window ) { x = x * window->w / window->display->desktop_mode.w; y = y * window->h / window->display->desktop_mode.h; } #else x = x * SDL_ANDROID_sFakeWindowWidth / SDL_ANDROID_sWindowWidth; y = y * SDL_ANDROID_sFakeWindowHeight / SDL_ANDROID_sWindowHeight; #endif #endif if( isMultitouchUsed ) { if( CurrentJoysticks[pointerId] ) { SDL_PrivateJoystickAxis(CurrentJoysticks[pointerId+1], 0, x); SDL_PrivateJoystickAxis(CurrentJoysticks[pointerId+1], 1, y); SDL_PrivateJoystickAxis(CurrentJoysticks[pointerId+1], 2, force); SDL_PrivateJoystickAxis(CurrentJoysticks[pointerId+1], 3, radius); if( action == MOUSE_DOWN ) SDL_PrivateJoystickButton(CurrentJoysticks[pointerId+1], 0, SDL_PRESSED); if( action == MOUSE_UP ) SDL_PrivateJoystickButton(CurrentJoysticks[pointerId+1], 0, SDL_RELEASED); } } if( !isMouseUsed ) { SDL_keysym keysym; if( action != MOUSE_MOVE ) SDL_SendKeyboardKey( action == MOUSE_DOWN ? SDL_PRESSED : SDL_RELEASED, GetKeysym(SDL_KEY(SDL_KEY_VAL(SDL_ANDROID_KEYCODE_0)) ,&keysym) ); return; } if( action == MOUSE_DOWN || action == MOUSE_UP ) { #if SDL_VERSION_ATLEAST(1,3,0) SDL_SendMouseMotion(NULL, 0, x, y); SDL_SendMouseButton(NULL, (action == MOUSE_DOWN) ? SDL_PRESSED : SDL_RELEASED, 1 ); #else SDL_PrivateMouseMotion(0, 0, x, y); SDL_PrivateMouseButton( (action == MOUSE_DOWN) ? SDL_PRESSED : SDL_RELEASED, 1, x, y ); #endif } if( action == MOUSE_MOVE ) { #if SDL_VERSION_ATLEAST(1,3,0) SDL_SendMouseMotion(NULL, 0, x, y); #else SDL_PrivateMouseMotion(0, 0, x, y); #endif } if (action == MOUSE_UP) { SDL_PrivateMouseMotion(0, 0, -4096, -4096); } }
static void X11_DispatchEvent(_THIS) { SDL_VideoData *videodata = (SDL_VideoData *) _this->driverdata; Display *display = videodata->display; SDL_WindowData *data; XEvent xevent; int i; SDL_zero(xevent); /* valgrind fix. --ryan. */ XNextEvent(display, &xevent); /* filter events catchs XIM events and sends them to the correct handler */ if (XFilterEvent(&xevent, None) == True) { #if 0 printf("Filtered event type = %d display = %d window = %d\n", xevent.type, xevent.xany.display, xevent.xany.window); #endif return; } /* Send a SDL_SYSWMEVENT if the application wants them */ if (SDL_GetEventState(SDL_SYSWMEVENT) == SDL_ENABLE) { SDL_SysWMmsg wmmsg; SDL_VERSION(&wmmsg.version); wmmsg.subsystem = SDL_SYSWM_X11; wmmsg.x11.event = xevent; SDL_SendSysWMEvent(&wmmsg); } data = NULL; if (videodata && videodata->windowlist) { for (i = 0; i < videodata->numwindows; ++i) { if ((videodata->windowlist[i] != NULL) && (videodata->windowlist[i]->xwindow == xevent.xany.window)) { data = videodata->windowlist[i]; break; } } } if (!data) { return; } #if 0 printf("type = %d display = %d window = %d\n", xevent.type, xevent.xany.display, xevent.xany.window); #endif switch (xevent.type) { /* Gaining mouse coverage? */ case EnterNotify:{ #ifdef DEBUG_XEVENTS printf("EnterNotify! (%d,%d,%d)\n", xevent.xcrossing.x, xevent.xcrossing.y, xevent.xcrossing.mode); if (xevent.xcrossing.mode == NotifyGrab) printf("Mode: NotifyGrab\n"); if (xevent.xcrossing.mode == NotifyUngrab) printf("Mode: NotifyUngrab\n"); #endif SDL_SetMouseFocus(data->window); } break; /* Losing mouse coverage? */ case LeaveNotify:{ #ifdef DEBUG_XEVENTS printf("LeaveNotify! (%d,%d,%d)\n", xevent.xcrossing.x, xevent.xcrossing.y, xevent.xcrossing.mode); if (xevent.xcrossing.mode == NotifyGrab) printf("Mode: NotifyGrab\n"); if (xevent.xcrossing.mode == NotifyUngrab) printf("Mode: NotifyUngrab\n"); #endif if (xevent.xcrossing.mode != NotifyGrab && xevent.xcrossing.mode != NotifyUngrab && xevent.xcrossing.detail != NotifyInferior) { SDL_SetMouseFocus(NULL); } } break; /* Gaining input focus? */ case FocusIn:{ #ifdef DEBUG_XEVENTS printf("FocusIn!\n"); #endif SDL_SetKeyboardFocus(data->window); #ifdef X_HAVE_UTF8_STRING if (data->ic) { XSetICFocus(data->ic); } #endif } break; /* Losing input focus? */ case FocusOut:{ #ifdef DEBUG_XEVENTS printf("FocusOut!\n"); #endif SDL_SetKeyboardFocus(NULL); #ifdef X_HAVE_UTF8_STRING if (data->ic) { XUnsetICFocus(data->ic); } #endif } break; /* Generated upon EnterWindow and FocusIn */ case KeymapNotify:{ #ifdef DEBUG_XEVENTS printf("KeymapNotify!\n"); #endif /* FIXME: X11_SetKeyboardState(SDL_Display, xevent.xkeymap.key_vector); */ } break; /* Has the keyboard layout changed? */ case MappingNotify:{ #ifdef DEBUG_XEVENTS printf("MappingNotify!\n"); #endif X11_UpdateKeymap(_this); } break; /* Key press? */ case KeyPress:{ KeyCode keycode = xevent.xkey.keycode; KeySym keysym = NoSymbol; SDL_scancode scancode; char text[SDL_TEXTINPUTEVENT_TEXT_SIZE]; Status status = 0; #ifdef DEBUG_XEVENTS printf("KeyPress (X11 keycode = 0x%X)\n", xevent.xkey.keycode); #endif SDL_SendKeyboardKey(SDL_PRESSED, videodata->key_layout[keycode]); #if 1 if (videodata->key_layout[keycode] == SDLK_UNKNOWN) { int min_keycode, max_keycode; XDisplayKeycodes(display, &min_keycode, &max_keycode); keysym = XKeycodeToKeysym(display, keycode, 0); fprintf(stderr, "The key you just pressed is not recognized by SDL. To help get this fixed, please report this to the SDL mailing list <*****@*****.**> X11 KeyCode %d (%d), X11 KeySym 0x%lX (%s).\n", keycode, keycode - min_keycode, keysym, XKeysymToString(keysym)); } #endif /* */ SDL_zero(text); #ifdef X_HAVE_UTF8_STRING if (data->ic) { Xutf8LookupString(data->ic, &xevent.xkey, text, sizeof(text), &keysym, &status); } #else XLookupString(&xevent.xkey, text, sizeof(text), &keysym, NULL); #endif if (*text) { SDL_SendKeyboardText(text); } } break; /* Key release? */ case KeyRelease:{ KeyCode keycode = xevent.xkey.keycode; #ifdef DEBUG_XEVENTS printf("KeyRelease (X11 keycode = 0x%X)\n", xevent.xkey.keycode); #endif if (X11_KeyRepeat(display, &xevent)) { /* We're about to get a repeated key down, ignore the key up */ break; } SDL_SendKeyboardKey(SDL_RELEASED, videodata->key_layout[keycode]); } break; /* Have we been iconified? */ case UnmapNotify:{ #ifdef DEBUG_XEVENTS printf("UnmapNotify!\n"); #endif SDL_SendWindowEvent(data->window, SDL_WINDOWEVENT_HIDDEN, 0, 0); SDL_SendWindowEvent(data->window, SDL_WINDOWEVENT_MINIMIZED, 0, 0); } break; /* Have we been restored? */ case MapNotify:{ #ifdef DEBUG_XEVENTS printf("MapNotify!\n"); #endif SDL_SendWindowEvent(data->window, SDL_WINDOWEVENT_SHOWN, 0, 0); SDL_SendWindowEvent(data->window, SDL_WINDOWEVENT_RESTORED, 0, 0); } break; /* Have we been resized or moved? */ case ConfigureNotify:{ #ifdef DEBUG_XEVENTS printf("ConfigureNotify! (resize: %dx%d)\n", xevent.xconfigure.width, xevent.xconfigure.height); #endif SDL_SendWindowEvent(data->window, SDL_WINDOWEVENT_MOVED, xevent.xconfigure.x, xevent.xconfigure.y); SDL_SendWindowEvent(data->window, SDL_WINDOWEVENT_RESIZED, xevent.xconfigure.width, xevent.xconfigure.height); } break; /* Have we been requested to quit (or another client message?) */ case ClientMessage:{ if ((xevent.xclient.format == 32) && (xevent.xclient.data.l[0] == videodata->WM_DELETE_WINDOW)) { SDL_SendWindowEvent(data->window, SDL_WINDOWEVENT_CLOSE, 0, 0); } } break; /* Do we need to refresh ourselves? */ case Expose:{ #ifdef DEBUG_XEVENTS printf("Expose (count = %d)\n", xevent.xexpose.count); #endif SDL_SendWindowEvent(data->window, SDL_WINDOWEVENT_EXPOSED, 0, 0); } break; case MotionNotify:{ #ifdef DEBUG_MOTION printf("X11 motion: %d,%d\n", xevent.xmotion.x, xevent.xmotion.y); #endif SDL_SendMouseMotion(data->window, 0, xevent.xmotion.x, xevent.xmotion.y); } break; case ButtonPress:{ SDL_SendMouseButton(data->window, SDL_PRESSED, xevent.xbutton.button); } break; case ButtonRelease:{ SDL_SendMouseButton(data->window, SDL_RELEASED, xevent.xbutton.button); } break; case PropertyNotify:{ #ifdef DEBUG_XEVENTS unsigned char *propdata; int status, real_format; Atom real_type; unsigned long items_read, items_left, i; char *name = XGetAtomName(display, xevent.xproperty.atom); if (name) { printf("PropertyNotify: %s %s\n", name, (xevent.xproperty.state == PropertyDelete) ? "deleted" : "changed"); XFree(name); } status = XGetWindowProperty(display, data->xwindow, xevent.xproperty.atom, 0L, 8192L, False, AnyPropertyType, &real_type, &real_format, &items_read, &items_left, &propdata); if (status == Success && items_read > 0) { if (real_type == XA_INTEGER) { int *values = (int *)propdata; printf("{"); for (i = 0; i < items_read; i++) { printf(" %d", values[i]); } printf(" }\n"); } else if (real_type == XA_CARDINAL) { if (real_format == 32) { Uint32 *values = (Uint32 *)propdata; printf("{"); for (i = 0; i < items_read; i++) { printf(" %d", values[i]); } printf(" }\n"); } else if (real_format == 16) { Uint16 *values = (Uint16 *)propdata; printf("{"); for (i = 0; i < items_read; i++) { printf(" %d", values[i]); } printf(" }\n"); } else if (real_format == 8) { Uint8 *values = (Uint8 *)propdata; printf("{"); for (i = 0; i < items_read; i++) { printf(" %d", values[i]); } printf(" }\n"); } } else if (real_type == XA_STRING || real_type == videodata->UTF8_STRING) { printf("{ \"%s\" }\n", propdata); } else if (real_type == XA_ATOM) { Atom *atoms = (Atom *)propdata; printf("{"); for (i = 0; i < items_read; i++) { char *name = XGetAtomName(display, atoms[i]); if (name) { printf(" %s", name); XFree(name); } } printf(" }\n"); } else { char *name = XGetAtomName(display, real_type); printf("Unknown type: %ld (%s)\n", real_type, name ? name : "UNKNOWN"); if (name) { XFree(name); } } } #endif } break; /* Copy the selection from XA_CUT_BUFFER0 to the requested property */ case SelectionRequest: { XSelectionRequestEvent *req; XEvent sevent; int seln_format; unsigned long nbytes; unsigned long overflow; unsigned char *seln_data; req = &xevent.xselectionrequest; #ifdef DEBUG_XEVENTS printf("SelectionRequest (requestor = %ld, target = %ld)\n", req->requestor, req->target); #endif SDL_zero(sevent); sevent.xany.type = SelectionNotify; sevent.xselection.selection = req->selection; sevent.xselection.target = None; sevent.xselection.property = None; sevent.xselection.requestor = req->requestor; sevent.xselection.time = req->time; if (XGetWindowProperty(display, DefaultRootWindow(display), XA_CUT_BUFFER0, 0, INT_MAX/4, False, req->target, &sevent.xselection.target, &seln_format, &nbytes, &overflow, &seln_data) == Success) { if (sevent.xselection.target == req->target) { XChangeProperty(display, req->requestor, req->property, sevent.xselection.target, seln_format, PropModeReplace, seln_data, nbytes); sevent.xselection.property = req->property; } XFree(seln_data); } XSendEvent(display, req->requestor, False, 0, &sevent); XSync(display, False); } break; case SelectionNotify: { #ifdef DEBUG_XEVENTS printf("SelectionNotify (requestor = %ld, target = %ld)\n", xevent.xselection.requestor, xevent.xselection.target); #endif videodata->selection_waiting = SDL_FALSE; } break; default:{ #ifdef DEBUG_XEVENTS printf("Unhandled event %d\n", xevent.type); #endif } break; } }
void SDL_EVDEV_Poll(void) { struct input_event events[32]; int i, len; SDL_evdevlist_item *item; SDL_Scancode scan_code; int mouse_button; SDL_Mouse *mouse; #ifdef SDL_INPUT_LINUXKD Uint16 modstate; struct kbentry kbe; static char keysym[8]; char *end; Uint32 kval; #endif #if SDL_USE_LIBUDEV SDL_UDEV_Poll(); #endif mouse = SDL_GetMouse(); for (item = _this->first; item != NULL; item = item->next) { while ((len = read(item->fd, events, (sizeof events))) > 0) { len /= sizeof(events[0]); for (i = 0; i < len; ++i) { switch (events[i].type) { case EV_KEY: if (events[i].code >= BTN_MOUSE && events[i].code < BTN_MOUSE + SDL_arraysize(EVDEV_MouseButtons)) { mouse_button = events[i].code - BTN_MOUSE; if (events[i].value == 0) { SDL_SendMouseButton(mouse->focus, mouse->mouseID, SDL_RELEASED, EVDEV_MouseButtons[mouse_button]); } else if (events[i].value == 1) { SDL_SendMouseButton(mouse->focus, mouse->mouseID, SDL_PRESSED, EVDEV_MouseButtons[mouse_button]); } break; } /* Probably keyboard */ scan_code = SDL_EVDEV_translate_keycode(events[i].code); if (scan_code != SDL_SCANCODE_UNKNOWN) { if (events[i].value == 0) { SDL_SendKeyboardKey(SDL_RELEASED, scan_code); } else if (events[i].value == 1 || events[i].value == 2 /* Key repeated */ ) { SDL_SendKeyboardKey(SDL_PRESSED, scan_code); #ifdef SDL_INPUT_LINUXKD if (_this->console_fd >= 0) { kbe.kb_index = events[i].code; /* Convert the key to an UTF-8 char */ /* Ref: http://www.linuxjournal.com/article/2783 */ modstate = SDL_GetModState(); kbe.kb_table = 0; /* Ref: http://graphics.stanford.edu/~seander/bithacks.html#ConditionalSetOrClearBitsWithoutBranching */ kbe.kb_table |= -( (modstate & KMOD_LCTRL) != 0) & (1 << KG_CTRLL | 1 << KG_CTRL); kbe.kb_table |= -( (modstate & KMOD_RCTRL) != 0) & (1 << KG_CTRLR | 1 << KG_CTRL); kbe.kb_table |= -( (modstate & KMOD_LSHIFT) != 0) & (1 << KG_SHIFTL | 1 << KG_SHIFT); kbe.kb_table |= -( (modstate & KMOD_RSHIFT) != 0) & (1 << KG_SHIFTR | 1 << KG_SHIFT); kbe.kb_table |= -( (modstate & KMOD_LALT) != 0) & (1 << KG_ALT); kbe.kb_table |= -( (modstate & KMOD_RALT) != 0) & (1 << KG_ALTGR); if (ioctl(_this->console_fd, KDGKBENT, (unsigned long)&kbe) == 0 && ((KTYP(kbe.kb_value) == KT_LATIN) || (KTYP(kbe.kb_value) == KT_ASCII) || (KTYP(kbe.kb_value) == KT_LETTER))) { kval = KVAL(kbe.kb_value); /* While there's a KG_CAPSSHIFT symbol, it's not useful to build the table index with it * because 1 << KG_CAPSSHIFT overflows the 8 bits of kb_table * So, we do the CAPS LOCK logic here. Note that isalpha depends on the locale! */ if ( modstate & KMOD_CAPS && isalpha(kval) ) { if ( isupper(kval) ) { kval = tolower(kval); } else { kval = toupper(kval); } } /* Convert to UTF-8 and send */ end = SDL_UCS4ToUTF8( kval, keysym); *end = '\0'; SDL_SendKeyboardText(keysym); } } #endif /* SDL_INPUT_LINUXKD */ } } break; case EV_ABS: switch(events[i].code) { case ABS_X: SDL_SendMouseMotion(mouse->focus, mouse->mouseID, SDL_FALSE, events[i].value, mouse->y); break; case ABS_Y: SDL_SendMouseMotion(mouse->focus, mouse->mouseID, SDL_FALSE, mouse->x, events[i].value); break; default: break; } break; case EV_REL: switch(events[i].code) { case REL_X: SDL_SendMouseMotion(mouse->focus, mouse->mouseID, SDL_TRUE, events[i].value, 0); break; case REL_Y: SDL_SendMouseMotion(mouse->focus, mouse->mouseID, SDL_TRUE, 0, events[i].value); break; case REL_WHEEL: SDL_SendMouseWheel(mouse->focus, mouse->mouseID, 0, events[i].value); break; case REL_HWHEEL: SDL_SendMouseWheel(mouse->focus, mouse->mouseID, events[i].value, 0); break; default: break; } break; case EV_SYN: switch (events[i].code) { case SYN_DROPPED: SDL_EVDEV_sync_device(item); break; default: break; } break; } } } } }
int Android_OnSDLKeyUp(int keycode) { return SDL_SendKeyboardKey(SDL_RELEASED, keycode); }
static void X11_DispatchEvent(_THIS) { SDL_VideoData *videodata = (SDL_VideoData *) _this->driverdata; SDL_WindowData *data; XEvent xevent; int i; SDL_zero(xevent); /* valgrind fix. --ryan. */ XNextEvent(videodata->display, &xevent); /* filter events catchs XIM events and sends them to the correct handler */ if (XFilterEvent(&xevent, None) == True) { #if 0 printf("Filtered event type = %d display = %d window = %d\n", xevent.type, xevent.xany.display, xevent.xany.window); #endif return; } /* Send a SDL_SYSWMEVENT if the application wants them */ if (SDL_ProcessEvents[SDL_SYSWMEVENT] == SDL_ENABLE) { SDL_SysWMmsg wmmsg; SDL_VERSION(&wmmsg.version); wmmsg.subsystem = SDL_SYSWM_X11; wmmsg.event.xevent = xevent; SDL_SendSysWMEvent(&wmmsg); } data = NULL; if (videodata && videodata->windowlist) { for (i = 0; i < videodata->numwindows; ++i) { if ((videodata->windowlist[i] != NULL) && (videodata->windowlist[i]->window == xevent.xany.window)) { data = videodata->windowlist[i]; break; } } } if (!data) { return; } #if 0 printf("type = %d display = %d window = %d\n", xevent.type, xevent.xany.display, xevent.xany.window); #endif switch (xevent.type) { /* Gaining mouse coverage? */ case EnterNotify:{ #ifdef DEBUG_XEVENTS printf("EnterNotify! (%d,%d,%d)\n", xevent.xcrossing.x, xevent.xcrossing.y, xevent.xcrossing.mode); if (xevent.xcrossing.mode == NotifyGrab) printf("Mode: NotifyGrab\n"); if (xevent.xcrossing.mode == NotifyUngrab) printf("Mode: NotifyUngrab\n"); #endif #if 1 /* FIXME: Should we reset data for all mice? */ for (i = 0; i < SDL_GetNumMice(); ++i) { SDL_Mouse *mouse = SDL_GetMouse(i); SDL_SetMouseFocus(mouse->id, data->windowID); } #endif } break; /* Losing mouse coverage? */ case LeaveNotify:{ #ifdef DEBUG_XEVENTS printf("LeaveNotify! (%d,%d,%d)\n", xevent.xcrossing.x, xevent.xcrossing.y, xevent.xcrossing.mode); if (xevent.xcrossing.mode == NotifyGrab) printf("Mode: NotifyGrab\n"); if (xevent.xcrossing.mode == NotifyUngrab) printf("Mode: NotifyUngrab\n"); #endif if (xevent.xcrossing.detail != NotifyInferior) { #if 1 /* FIXME: Should we reset data for all mice? */ for (i = 0; i < SDL_GetNumMice(); ++i) { SDL_Mouse *mouse = SDL_GetMouse(i); SDL_SetMouseFocus(mouse->id, 0); } #endif } } break; /* Gaining input focus? */ case FocusIn:{ #ifdef DEBUG_XEVENTS printf("FocusIn!\n"); #endif SDL_SetKeyboardFocus(videodata->keyboard, data->windowID); #ifdef X_HAVE_UTF8_STRING if (data->ic) { XSetICFocus(data->ic); } #endif } break; /* Losing input focus? */ case FocusOut:{ #ifdef DEBUG_XEVENTS printf("FocusOut!\n"); #endif SDL_SetKeyboardFocus(videodata->keyboard, 0); #ifdef X_HAVE_UTF8_STRING if (data->ic) { XUnsetICFocus(data->ic); } #endif } break; /* Generated upon EnterWindow and FocusIn */ case KeymapNotify:{ #ifdef DEBUG_XEVENTS printf("KeymapNotify!\n"); #endif /* FIXME: X11_SetKeyboardState(SDL_Display, xevent.xkeymap.key_vector); */ } break; /* Has the keyboard layout changed? */ case MappingNotify:{ #ifdef DEBUG_XEVENTS printf("MappingNotify!\n"); #endif X11_UpdateKeymap(_this); } break; /* Key press? */ case KeyPress:{ KeyCode keycode = xevent.xkey.keycode; KeySym keysym = NoSymbol; char text[SDL_TEXTINPUTEVENT_TEXT_SIZE]; Status status = 0; #ifdef DEBUG_XEVENTS printf("KeyPress (X11 keycode = 0x%X)\n", xevent.xkey.keycode); #endif SDL_SendKeyboardKey(videodata->keyboard, SDL_PRESSED, videodata->key_layout[keycode]); #if 0 if (videodata->key_layout[keycode] == SDLK_UNKNOWN) { int min_keycode, max_keycode; XDisplayKeycodes(videodata->display, &min_keycode, &max_keycode); keysym = XKeycodeToKeysym(videodata->display, keycode, 0); fprintf(stderr, "The key you just pressed is not recognized by SDL. To help get this fixed, please report this to the SDL mailing list <*****@*****.**> X11 KeyCode %d (%d), X11 KeySym 0x%X (%s).\n", keycode, keycode - min_keycode, keysym, XKeysymToString(keysym)); } #endif /* */ SDL_zero(text); #ifdef X_HAVE_UTF8_STRING if (data->ic) { Xutf8LookupString(data->ic, &xevent.xkey, text, sizeof(text), &keysym, &status); } #else XLookupString(&xevent.xkey, text, sizeof(text), &keysym, NULL); #endif if (*text) { SDL_SendKeyboardText(videodata->keyboard, text); } } break; /* Key release? */ case KeyRelease:{ KeyCode keycode = xevent.xkey.keycode; #ifdef DEBUG_XEVENTS printf("KeyRelease (X11 keycode = 0x%X)\n", xevent.xkey.keycode); #endif SDL_SendKeyboardKey(videodata->keyboard, SDL_RELEASED, videodata->key_layout[keycode]); } break; /* Have we been iconified? */ case UnmapNotify:{ #ifdef DEBUG_XEVENTS printf("UnmapNotify!\n"); #endif SDL_SendWindowEvent(data->windowID, SDL_WINDOWEVENT_HIDDEN, 0, 0); SDL_SendWindowEvent(data->windowID, SDL_WINDOWEVENT_MINIMIZED, 0, 0); } break; /* Have we been restored? */ case MapNotify:{ #ifdef DEBUG_XEVENTS printf("MapNotify!\n"); #endif SDL_SendWindowEvent(data->windowID, SDL_WINDOWEVENT_SHOWN, 0, 0); SDL_SendWindowEvent(data->windowID, SDL_WINDOWEVENT_RESTORED, 0, 0); } break; /* Have we been resized or moved? */ case ConfigureNotify:{ #ifdef DEBUG_XEVENTS printf("ConfigureNotify! (resize: %dx%d)\n", xevent.xconfigure.width, xevent.xconfigure.height); #endif SDL_SendWindowEvent(data->windowID, SDL_WINDOWEVENT_MOVED, xevent.xconfigure.x, xevent.xconfigure.y); SDL_SendWindowEvent(data->windowID, SDL_WINDOWEVENT_RESIZED, xevent.xconfigure.width, xevent.xconfigure.height); } break; /* Have we been requested to quit (or another client message?) */ case ClientMessage:{ if ((xevent.xclient.format == 32) && (xevent.xclient.data.l[0] == videodata->WM_DELETE_WINDOW)) { SDL_SendWindowEvent(data->windowID, SDL_WINDOWEVENT_CLOSE, 0, 0); } } break; /* Do we need to refresh ourselves? */ case Expose:{ #ifdef DEBUG_XEVENTS printf("Expose (count = %d)\n", xevent.xexpose.count); #endif SDL_SendWindowEvent(data->windowID, SDL_WINDOWEVENT_EXPOSED, 0, 0); } break; default:{ for (i = 0; i < SDL_GetNumMice(); ++i) { SDL_Mouse *mouse; #if SDL_VIDEO_DRIVER_X11_XINPUT X11_MouseData *data; #endif mouse = SDL_GetMouse(i); if (!mouse->driverdata) { switch (xevent.type) { case MotionNotify: #ifdef DEBUG_MOTION printf("X11 motion: %d,%d\n", xevent.xmotion.x, xevent.xmotion.y); #endif SDL_SendMouseMotion(mouse->id, 0, xevent.xmotion.x, xevent.xmotion.y, 0); break; case ButtonPress: SDL_SendMouseButton(mouse->id, SDL_PRESSED, xevent.xbutton.button); break; case ButtonRelease: SDL_SendMouseButton(mouse->id, SDL_RELEASED, xevent.xbutton.button); break; } continue; } #if SDL_VIDEO_DRIVER_X11_XINPUT data = (X11_MouseData *) mouse->driverdata; if (xevent.type == data->motion) { XDeviceMotionEvent *move = (XDeviceMotionEvent *) & xevent; #ifdef DEBUG_MOTION printf("X11 motion: %d,%d\n", move->x, move->y); #endif SDL_SendMouseMotion(move->deviceid, 0, move->x, move->y, move->axis_data[2]); return; } if (xevent.type == data->button_pressed) { XDeviceButtonPressedEvent *pressed = (XDeviceButtonPressedEvent *) & xevent; SDL_SendMouseButton(pressed->deviceid, SDL_PRESSED, pressed->button); return; } if (xevent.type == data->button_released) { XDeviceButtonReleasedEvent *released = (XDeviceButtonReleasedEvent *) & xevent; SDL_SendMouseButton(released->deviceid, SDL_RELEASED, released->button); return; } if (xevent.type == data->proximity_in) { XProximityNotifyEvent *proximity = (XProximityNotifyEvent *) & xevent; SDL_SendProximity(proximity->deviceid, proximity->x, proximity->y, SDL_PROXIMITYIN); return; } if (xevent.type == data->proximity_out) { XProximityNotifyEvent *proximity = (XProximityNotifyEvent *) & xevent; SDL_SendProximity(proximity->deviceid, proximity->x, proximity->y, SDL_PROXIMITYOUT); return; } #endif } #ifdef DEBUG_XEVENTS printf("Unhandled event %d\n", xevent.type); #endif } break; } }
void NACL_PumpEvents(_THIS) { PSEvent* ps_event; PP_Resource event; PP_InputEvent_Type type; PP_InputEvent_Modifier modifiers; struct PP_Rect rect; struct PP_FloatPoint fp; struct PP_Point location; struct PP_Var var; const char *str; char text[64]; Uint32 str_len; SDL_VideoData *driverdata = (SDL_VideoData *) _this->driverdata; SDL_Mouse *mouse = SDL_GetMouse(); if (driverdata->window) { while ((ps_event = PSEventTryAcquire()) != NULL) { event = ps_event->as_resource; switch(ps_event->type) { /* From DidChangeView, contains a view resource */ case PSE_INSTANCE_DIDCHANGEVIEW: driverdata->ppb_view->GetRect(event, &rect); NACL_SetScreenResolution(rect.size.width, rect.size.height, SDL_PIXELFORMAT_UNKNOWN); // FIXME: Rebuild context? See life.c UpdateContext break; /* From HandleInputEvent, contains an input resource. */ case PSE_INSTANCE_HANDLEINPUT: type = driverdata->ppb_input_event->GetType(event); modifiers = driverdata->ppb_input_event->GetModifiers(event); switch(type) { case PP_INPUTEVENT_TYPE_MOUSEDOWN: SDL_SendMouseButton(mouse->focus, mouse->mouseID, SDL_PRESSED, SDL_NACL_translate_mouse_button(driverdata->ppb_mouse_input_event->GetButton(event))); break; case PP_INPUTEVENT_TYPE_MOUSEUP: SDL_SendMouseButton(mouse->focus, mouse->mouseID, SDL_RELEASED, SDL_NACL_translate_mouse_button(driverdata->ppb_mouse_input_event->GetButton(event))); break; case PP_INPUTEVENT_TYPE_WHEEL: /* FIXME: GetTicks provides high resolution scroll events */ fp = driverdata->ppb_wheel_input_event->GetDelta(event); SDL_SendMouseWheel(mouse->focus, mouse->mouseID, (int) fp.x, (int) fp.y, SDL_MOUSEWHEEL_NORMAL); break; case PP_INPUTEVENT_TYPE_MOUSEENTER: case PP_INPUTEVENT_TYPE_MOUSELEAVE: /* FIXME: Mouse Focus */ break; case PP_INPUTEVENT_TYPE_MOUSEMOVE: location = driverdata->ppb_mouse_input_event->GetPosition(event); SDL_SendMouseMotion(mouse->focus, mouse->mouseID, SDL_FALSE, location.x, location.y); break; case PP_INPUTEVENT_TYPE_TOUCHSTART: case PP_INPUTEVENT_TYPE_TOUCHMOVE: case PP_INPUTEVENT_TYPE_TOUCHEND: case PP_INPUTEVENT_TYPE_TOUCHCANCEL: /* FIXME: Touch events */ break; case PP_INPUTEVENT_TYPE_KEYDOWN: SDL_SendKeyboardKey(SDL_PRESSED, SDL_NACL_translate_keycode(driverdata->ppb_keyboard_input_event->GetKeyCode(event))); break; case PP_INPUTEVENT_TYPE_KEYUP: SDL_SendKeyboardKey(SDL_RELEASED, SDL_NACL_translate_keycode(driverdata->ppb_keyboard_input_event->GetKeyCode(event))); break; case PP_INPUTEVENT_TYPE_CHAR: var = driverdata->ppb_keyboard_input_event->GetCharacterText(event); str = driverdata->ppb_var->VarToUtf8(var, &str_len); /* str is not null terminated! */ if ( str_len >= SDL_arraysize(text) ) { str_len = SDL_arraysize(text) - 1; } SDL_strlcpy(text, str, str_len ); text[str_len] = '\0'; SDL_SendKeyboardText(text); /* FIXME: Do we have to handle ref counting? driverdata->ppb_var->Release(var);*/ break; default: break; } break; /* From HandleMessage, contains a PP_Var. */ case PSE_INSTANCE_HANDLEMESSAGE: break; /* From DidChangeFocus, contains a PP_Bool with the current focus state. */ case PSE_INSTANCE_DIDCHANGEFOCUS: break; /* When the 3D context is lost, no resource. */ case PSE_GRAPHICS3D_GRAPHICS3DCONTEXTLOST: break; /* When the mouse lock is lost. */ case PSE_MOUSELOCK_MOUSELOCKLOST: break; default: break; } PSEventRelease(ps_event); } } }