void TestRollover(CuTest *tc) { START_KEY_CAPTURE; CuAssertIntEquals(tc, 0, active_layer); SHOULDNOT_SEND; key_press(5);//F or layer 1 VERIFY_DIDNOT_SEND; CuAssertIntEquals(tc, 1, active_layer); key_press(6);//0 or 1 depending on layer EXPECT_SENT(3); CuAssertIntEquals(tc, 0, active_layer);//layer already reset key_release(5); CuAssertIntEquals(tc, 0, active_layer); key_release(6); EXPECT_SENT(4); VERIFY KEY(F); THEN NOKEYS; THEN KEY(0); THEN NOKEYS; }
void TestLayerLockActsAsLayerShift(CuTest *tc) { START_KEY_CAPTURE; SHOULDNOT_SEND; key_press(7);//;layer 1 CuAssertIntEquals(tc, 1, active_layer); VERIFY_DIDNOT_SEND; make_dualrole_modifier_possible();//pretend enough time has passed key_press(6);//0 or 1 depending on layer key_release(6); SHOULDNOT_SEND; key_release(7); CuAssertIntEquals(tc, 0, active_layer); VERIFY_DIDNOT_SEND; key_press(6);//0 or 1 depending on layer key_release(6); VERIFY KEY(1); THEN NOKEYS; THEN KEY(0); THEN NOKEYS; }
Input InputManager::get_input(){ static bool exit = false; frame_text.resize(0); SDL_Event evnt; SDL_StartTextInput(); //Will keep looping until there are no more events to process while (SDL_PollEvent(&evnt)) { switch (evnt.type) { case SDL_QUIT: return Input::EXIT_REQUEST; break; case SDL_MOUSEMOTION: set_mouse_coords((F32)evnt.motion.x, (F32)evnt.motion.y); break; case SDL_TEXTINPUT: frame_text += evnt.text.text; break; case SDL_KEYDOWN: key_press(evnt.key.keysym.sym , KEYBOARD); break; case SDL_KEYUP: key_release(evnt.key.keysym.sym , KEYBOARD); break; case SDL_MOUSEBUTTONDOWN: key_press(evnt.button.button , MOUSE); break; case SDL_MOUSEBUTTONUP: key_release(evnt.button.button , MOUSE); break; case SDL_JOYBUTTONDOWN: /* Handle Joystick Button Presses */ key_press(evnt.jbutton.button , CONTROLLER); break; case SDL_JOYBUTTONUP: /* Handle Joystick Button Presses */ key_release(evnt.jbutton.button , CONTROLLER); break; case SDL_JOYAXISMOTION: switch (evnt.jaxis.axis){ case 0: set_controller_axis_coord(&m_controller_LX_coords.x, evnt.jaxis.value); break; case 1: set_controller_axis_coord(&m_controller_LX_coords.y, evnt.jaxis.value); break; case 2: set_controller_axis_coord(&m_controller_RX_coords.x, evnt.jaxis.value); break; case 3: set_controller_axis_coord(&m_controller_RX_coords.y, evnt.jaxis.value); break; } } } SDL_StopTextInput(); if (is_key_pressed(SDLK_ESCAPE,KEYBOARD))exit = !exit; if(!exit)SDL_WarpMouseInWindow(m_window, WINDOW_WIDTH / 2.0f, WINDOW_HEIGHT / 2.0f); return Input::OK; }
void TestLayerLock(CuTest* tc) { START_KEY_CAPTURE; SHOULDNOT_SEND; key_press(7);//toggle layer to 1 CuAssertIntEquals(tc, 1, active_layer); key_release(7); CuAssertIntEquals(tc, 1, active_layer); VERIFY_DIDNOT_SEND; key_press(6);//0 or 1 depending on layer key_release(6); SHOULDNOT_SEND; key_press(7);//toggle layer to 0 CuAssertIntEquals(tc, 0, active_layer); key_release(7); CuAssertIntEquals(tc, 0, active_layer); VERIFY_DIDNOT_SEND; key_press(6);//0 or 1 depending on layer key_release(6); VERIFY KEY(1); THEN NOKEYS; THEN KEY(0); THEN NOKEYS; }
void TestComplicated(CuTest *tc) { START_KEY_CAPTURE; SHOULDNOT_SEND; key_press(5);//F or layer 1 VERIFY_DIDNOT_SEND; CuAssertIntEquals(tc, 1, active_layer); make_dualrole_modifier_possible();//pretend enough time has passed key_press(0);//LSFT of LBRACKET key_release(0); CuAssertIntEquals(tc, 1, active_layer); SHOULDNOT_SEND; key_release(5); VERIFY_DIDNOT_SEND; CuAssertIntEquals(tc, 0, active_layer); EXPECT_SENT(4); VERIFY NOKEYS WITH(LSFT); THEN NOKEYS NOMODS; THEN KEY(LBRACKET); THEN NOKEYS; }
void TestModifierTapRelease(CuTest *tc) { START_KEY_CAPTURE; key_press(4);//lshift or z make_dualrole_modifier_possible();//pretend enough time has passed key_press(0); key_release(4); key_release(0); VERIFY NOKEYS WITH(LSFT); THEN KEY(A) WITH(LSFT); THEN KEY(A) NOMODS; THEN NOKEYS NOMODS; }
int main(void) { uint8_t row, col, key_id; init(); for(;;) { _delay_ms(5); // Debouncing for(col=0; col<NCOL; col++) { *col_port[col] &= ~col_bit[col]; _delay_us(1); for(row=0; row<NROW; row++) { key_id = col*NROW+row; if(!(*row_port[row] & row_bit[row])) { if(!pressed[key_id]) key_press(key_id); } else if(pressed[key_id]) key_release(key_id); } *col_port[col] |= col_bit[col]; } // OCR1B++; OCR1C++; // TODO fixed keyboard leds. I disabled as I cannot test them //PORTB = (PORTB & 0b00111111) | ((keyboard_leds << 5) & 0b11000000); //DDRB = (DDRB & 0b00111111) | ((keyboard_leds << 5) & 0b11000000); } }
void TestKey(CuTest* tc) { START_KEY_CAPTURE; key_press(0);//A key_release(0); key_press(0);//A key_release(0); EXPECT_SENT(4); VERIFY KEY(A); THEN NOKEYS; THEN KEY(A); THEN NOKEYS; }
void main() { TRISB=0x00; TRISA=0x3C; TRISC=0x00; ADCON1=0x06; init_lcd(); init(); GIE=1; PEIE=1; //test_display(); cmd_wr(0x80); for(i=0;i<=12;i++) { data_wr(cnt[i]); } while(1) { while(key_ready!=1); a=key_code; ds1=ascii_tab[a]; key_release(); lcd_disp(); } }
void HistoryComboBox::focusOutEvent(QFocusEvent *e) { QKeyEvent key_press(QKeyEvent::KeyPress, Qt::Key_Return, Qt::NoModifier, QString(), false, 0 ); QApplication::sendEvent(this, &key_press); QKeyEvent key_release(QKeyEvent::KeyRelease, Qt::Key_Return, Qt::NoModifier, QString(), false, 0 ); QApplication::sendEvent(this, &key_release); QComboBox::focusOutEvent(e); }
void TestKeyModded(CuTest* tc) { START_KEY_CAPTURE; key_press(3);//sD key_release(3); EXPECT_SENT(3); VERIFY NOKEYS WITH(LSFT); THEN KEY(D) WITH(LSFT); THEN NOKEYS; }
void TestCancel(CuTest *tc) { START_KEY_CAPTURE; SHOULDNOT_SEND; key_press(5);//F or layer 1 VERIFY_DIDNOT_SEND; make_dualrole_tap_impossible();//pretend too much time has passed SHOULDNOT_SEND; key_release(5); VERIFY_DIDNOT_SEND; }
void TestLayerShiftOrKeyCanTap(CuTest *tc) { START_KEY_CAPTURE; SHOULDNOT_SEND; key_press(5);//F or layer 1 CuAssertIntEquals(tc, 1, active_layer); VERIFY_DIDNOT_SEND; key_release(5); CuAssertIntEquals(tc, 0, active_layer); key_press(0); key_release(0); CuAssertIntEquals(tc, 0, active_layer); VERIFY KEY(F); THEN NOKEYS; THEN KEY(A); THEN NOKEYS; }
void TestModifierOrKeyCanMod(CuTest *tc) { START_KEY_CAPTURE; key_press(4);//shift or Z make_dualrole_modifier_possible();//pretend enough time has passed key_press(0);//A key_release(0); key_release(4); key_press(0);//A key_release(0); EXPECT_SENT(6); VERIFY NOKEYS WITH(LSFT); THEN KEY(A) WITH(LSFT); THEN NOKEYS WITH(LSFT); THEN NOKEYS NOMODS; THEN KEY(A) NOMODS; THEN NOKEYS NOMODS; }
void TestModifierTapModded(CuTest *tc) { START_KEY_CAPTURE; key_press(2);//rshift or ) key_release(2); EXPECT_SENT(5); VERIFY NOKEYS WITH(RSFT); THEN NOKEYS NOMODS; THEN NOKEYS WITH(LSFT); THEN KEY(9) WITH(LSFT); THEN NOKEYS NOMODS; }
void TestModifierOrKeyCanTap(CuTest *tc) { START_KEY_CAPTURE; key_press(4);//shift or Z key_release(4); EXPECT_SENT(4); VERIFY NOKEYS WITH(LSFT); THEN NOKEYS NOMODS; THEN KEY(Z) NOMODS; THEN NOKEYS NOMODS; }
void TestSpaceFn(CuTest *tc) { START_KEY_CAPTURE; key_press(3); key_release(3); SHOULDNOT_SEND; key_press(16*8+6);//SPACE CuAssertIntEquals(tc, 1, active_layer); VERIFY_DIDNOT_SEND; key_release(16*8+6);//SPACE CuAssertIntEquals(tc, 0, active_layer); SHOULDNOT_SEND; key_press(16*8+6);//SPACE CuAssertIntEquals(tc, 1, active_layer); VERIFY_DIDNOT_SEND; make_dualrole_modifier_possible();//pretend enough time has passed key_press(11*8+3);//K or down key_release(11*8+3); SHOULDNOT_SEND; key_release(16*8+6);//SPACE CuAssertIntEquals(tc, 0, active_layer); VERIFY_DIDNOT_SEND; VERIFY NOKEYS WITH(RGUI); THEN NOKEYS NOMODS; THEN KEY(SPACE) NOMODS; THEN NOKEYS NOMODS; THEN KEY(DOWN); THEN NOKEYS; }
void TestModModded(CuTest* tc) { START_KEY_CAPTURE; SHOULDNOT_SEND; key_press(7);//toggle layer to 1 CuAssertIntEquals(tc, 1, active_layer); key_release(7); CuAssertIntEquals(tc, 1, active_layer); VERIFY_DIDNOT_SEND; key_press(2);//sLALT key_release(2);//sLALT SHOULDNOT_SEND; key_press(7);//toggle layer to 0 CuAssertIntEquals(tc, 0, active_layer); key_release(7); CuAssertIntEquals(tc, 0, active_layer); VERIFY_DIDNOT_SEND; VERIFY NOKEYS WITH(LSFT|LALT); THEN NOKEYS; }
void scan() { for (ic = 0; ic < COLS_COUNT; ic += 1) { digitalWrite(cols_pins[ic], HIGH); for (ir = 0; ir < ROWS_COUNT; ir += 1) { if (!keymap[ir][ic]) continue; if (digitalRead(rows_pins[ir])) key_press(keymap[ir][ic]); else key_release(keymap[ir][ic]); } digitalWrite(cols_pins[ic], LOW); } }
void keyprocess() { switch(key_code) { case 'A': process_a(); break; case 'B' : process_b(); break; case 'C' : process_c(); break; } key_release(); }
void replay_keypresses(void) { uint8_t i, k; clear_pressed(); // Go through all keys in the replay buf. We can determine whether // a command is a key press or release based on whether the key // is already pressed. for (i = 0; i < replay_buf_len; ++i) { k = replay_buf[i]; if (!key[k].pressed) { key_press(k); } else { key_release(k); } } }
void poll() { uint8_t row, col, key_id; for (row=0; row<ROWS; row++) { // scan rows *row_port[row] &= ~row_bit[row]; _delay_us(1); for (col=0; col<COLS; col++) { // read columns key_id = col*ROWS+row; if (! (*col_pin[col] & col_bit[col])) { // press key if (! pressed[key_id]) { key_press(key_id); } } else if (pressed[key_id]) { // release key key_release(key_id); } } *row_port[row] |= row_bit[row]; } if (caps_lock_led != (keyboard_leds & LED_CAPS_LOCK)) { // change layout caps_lock_change_layer(); } //if (keyboard_leds) LED_ON; else LED_OFF; repeat_tick(); _delay_ms(5); }
static bool process_event(union event *ev) { struct buffered_status *status = store_status(); bool rval = true; switch(ev->type) { case EVENT_BUTTON_DOWN: { Uint32 button = map_button(ev->button.pad, ev->button.button); rval = false; if((ev->button.pad == 0) && pointing) { Uint32 mousebutton; switch(ev->button.button) { case WPAD_BUTTON_A: mousebutton = MOUSE_BUTTON_LEFT; break; case WPAD_BUTTON_B: mousebutton = MOUSE_BUTTON_RIGHT; break; default: mousebutton = 0; break; } if(mousebutton) { status->mouse_button = mousebutton; status->mouse_repeat = mousebutton; status->mouse_button_state |= MOUSE_BUTTON(mousebutton); status->mouse_repeat_state = 1; status->mouse_drag_state = -1; status->mouse_time = get_ticks(); button = 256; rval = true; } } if((button < 256)) { enum keycode skey = input.joystick_button_map[ev->button.pad][button]; if(skey && (status->keymap[skey] == 0)) { key_press(status, skey, skey); rval = true; } } else { if((ev->button.pad < 4) && ((ev->button.button == WPAD_BUTTON_HOME) || ((ext_type[ev->button.pad] == WPAD_EXP_CLASSIC) && (ev->button.button == WPAD_CLASSIC_BUTTON_HOME)))) { status->keymap[IKEY_ESCAPE] = 1; status->key = IKEY_ESCAPE; status->keypress_time = get_ticks(); rval = true; break; } } break; } case EVENT_BUTTON_UP: { Uint32 button = map_button(ev->button.pad, ev->button.button); rval = false; if((ev->button.pad == 0) && status->mouse_button_state) { Uint32 mousebutton; switch(ev->button.button) { case WPAD_BUTTON_A: mousebutton = MOUSE_BUTTON_LEFT; break; case WPAD_BUTTON_B: mousebutton = MOUSE_BUTTON_RIGHT; break; default: mousebutton = 0; break; } if(mousebutton && (status->mouse_button_state & MOUSE_BUTTON(mousebutton))) { status->mouse_button_state &= ~MOUSE_BUTTON(mousebutton); status->mouse_repeat = 0; status->mouse_drag_state = 0; status->mouse_repeat_state = 0; button = 256; rval = true; } } if((button < 256)) { enum keycode skey = input.joystick_button_map[ev->button.pad][button]; if(skey) { key_release(status, skey); rval = true; } } break; } case EVENT_AXIS_MOVE: { int digital_value = -1; int axis = ev->axis.axis; int last_axis; enum keycode skey; if(ev->axis.pad < 4) { switch(ext_type[ev->axis.pad]) { case WPAD_EXP_NUNCHUK: break; case WPAD_EXP_CLASSIC: axis += 2; break; case WPAD_EXP_GUITARHERO3: axis += 6; break; default: axis = 256; break; // Not supposed to happen } } if(axis == 256) break; last_axis = status->axis[ev->axis.pad][axis]; if(ev->axis.pos > 10000) digital_value = 1; else if(ev->axis.pos < -10000) digital_value = 0; if(digital_value != -1) { skey = input.joystick_axis_map[ev->axis.pad][axis][digital_value]; if(skey) { if(status->keymap[skey] == 0) key_press(status, skey, skey); if(last_axis == (digital_value ^ 1)) { skey = input.joystick_axis_map[ev->axis.pad][axis][last_axis]; key_release(status, skey); } } } else { if(last_axis != -1) { skey = input.joystick_axis_map[ev->axis.pad][axis][last_axis]; if(skey) key_release(status, skey); } } status->axis[ev->axis.pad][axis] = digital_value; break; } case EVENT_CHANGE_EXT: { ext_type[ev->ext.pad] = ev->ext.ext; break; } case EVENT_POINTER_MOVE: { pointing = 1; status->mouse_moved = true; status->real_mouse_x = ev->pointer.x; status->real_mouse_y = ev->pointer.y; status->mouse_x = ev->pointer.x / 8; status->mouse_y = ev->pointer.y / 14; break; } case EVENT_POINTER_OUT: { pointing = 0; break; } case EVENT_KEY_DOWN: { enum keycode ckey = convert_USB_internal(ev->key.key); if(!ckey) { if(ev->key.unicode) ckey = IKEY_UNICODE; else { rval = false; break; } } if((ckey == IKEY_RETURN) && get_alt_status(keycode_internal) && get_ctrl_status(keycode_internal)) { toggle_fullscreen(); break; } if(ckey == IKEY_F12) { dump_screen(); break; } if(status->key_repeat && (status->key_repeat != IKEY_LSHIFT) && (status->key_repeat != IKEY_RSHIFT) && (status->key_repeat != IKEY_LALT) && (status->key_repeat != IKEY_RALT) && (status->key_repeat != IKEY_LCTRL) && (status->key_repeat != IKEY_RCTRL)) { // Stack current repeat key if it isn't shift, alt, or ctrl if(input.repeat_stack_pointer != KEY_REPEAT_STACK_SIZE) { input.key_repeat_stack[input.repeat_stack_pointer] = status->key_repeat; input.unicode_repeat_stack[input.repeat_stack_pointer] = status->unicode_repeat; input.repeat_stack_pointer++; } } key_press(status, ckey, ev->key.unicode); break; } case EVENT_KEY_UP: { enum keycode ckey = convert_USB_internal(ev->key.key); if(!ckey) { if(status->keymap[IKEY_UNICODE]) ckey = IKEY_UNICODE; else { rval = false; break; } } status->keymap[ckey] = 0; if(status->key_repeat == ckey) { status->key_repeat = IKEY_UNKNOWN; status->unicode_repeat = 0; } status->key_release = ckey; break; } case EVENT_KEY_LOCKS: { status->numlock_status = !!(ev->locks.locks & MOD_NUMLOCK); status->caps_status = !!(ev->locks.locks & MOD_CAPSLOCK); break; } case EVENT_MOUSE_MOVE: { int mx = status->real_mouse_x + ev->mmove.dx; int my = status->real_mouse_y + ev->mmove.dy; if(mx < 0) mx = 0; if(my < 0) my = 0; if(mx >= 640) mx = 639; if(my >= 350) my = 349; status->real_mouse_x = mx; status->real_mouse_y = my; status->mouse_x = mx / 8; status->mouse_y = my / 14; status->mouse_moved = true; break; } case EVENT_MOUSE_BUTTON_DOWN: { Uint32 button = 0; switch (ev->mbutton.button) { case USB_MOUSE_BTN_LEFT: button = MOUSE_BUTTON_LEFT; break; case USB_MOUSE_BTN_RIGHT: button = MOUSE_BUTTON_RIGHT; break; case USB_MOUSE_BTN_MIDDLE: button = MOUSE_BUTTON_MIDDLE; break; default: break; } if(!button) break; status->mouse_button = button; status->mouse_repeat = button; status->mouse_button_state |= MOUSE_BUTTON(button); status->mouse_repeat_state = 1; status->mouse_drag_state = -1; status->mouse_time = get_ticks(); break; } case EVENT_MOUSE_BUTTON_UP: { Uint32 button = 0; switch (ev->mbutton.button) { case USB_MOUSE_BTN_LEFT: button = MOUSE_BUTTON_LEFT; break; case USB_MOUSE_BTN_RIGHT: button = MOUSE_BUTTON_RIGHT; break; case USB_MOUSE_BTN_MIDDLE: button = MOUSE_BUTTON_MIDDLE; break; default: break; } if(!button) break; status->mouse_button_state &= ~MOUSE_BUTTON(button); status->mouse_repeat = 0; status->mouse_drag_state = 0; status->mouse_repeat_state = 0; break; } default: { rval = false; break; } } return rval; }
int key_release_hook(int keycode, t_env *e) { key_release(&e->key, keycode); return (0); }
static bool process_event(SDL_Event *event) { struct buffered_status *status = store_status(); enum keycode ckey; /* SDL's numlock keyboard modifier handling seems to be broken on X11, * and it will only get numlock's status right on application init. We * can trust this value once, and then toggle based on user presses of * the numlock key. * * On Windows, KEYDOWN/KEYUP seem to be sent separately, to indicate * enabling or disabling of numlock. But on X11, both KEYDOWN/KEYUP are * sent for each toggle, so this must be handled differently. * * What a mess! */ if(!numlock_status_initialized) { status->numlock_status = !!(SDL_GetModState() & KMOD_NUM); numlock_status_initialized = true; } switch(event->type) { case SDL_QUIT: { // Stuff an escape status->key = IKEY_ESCAPE; status->keymap[IKEY_ESCAPE] = 1; status->keypress_time = get_ticks(); break; } #if SDL_VERSION_ATLEAST(2,0,0) case SDL_WINDOWEVENT: { switch(event->window.event) { case SDL_WINDOWEVENT_RESIZED: { resize_screen(event->window.data1, event->window.data2); break; } case SDL_WINDOWEVENT_FOCUS_LOST: { // Pause while minimized if(input.unfocus_pause) { while(1) { SDL_WaitEvent(event); if(event->type == SDL_WINDOWEVENT && event->window.event == SDL_WINDOWEVENT_FOCUS_GAINED) break; } } break; } } break; } #else // !SDL_VERSION_ATLEAST(2,0,0) case SDL_VIDEORESIZE: { resize_screen(event->resize.w, event->resize.h); break; } case SDL_ACTIVEEVENT: { if(input.unfocus_pause) { // Pause while minimized if(event->active.state & (SDL_APPACTIVE | SDL_APPINPUTFOCUS)) { // Wait for SDL_APPACTIVE with gain of 1 do { SDL_WaitEvent(event); } while((event->type != SDL_ACTIVEEVENT) || (event->active.state & ~(SDL_APPACTIVE | SDL_APPINPUTFOCUS))); } } break; } #endif // !SDL_VERSION_ATLEAST(2,0,0) case SDL_MOUSEMOTION: { SDL_Window *window = SDL_GetWindowFromID(sdl_window_id); int mx_real = event->motion.x; int my_real = event->motion.y; int mx, my, min_x, min_y, max_x, max_y; get_screen_coords(mx_real, my_real, &mx, &my, &min_x, &min_y, &max_x, &max_y); if(mx > 639) SDL_WarpMouseInWindow(window, max_x, my_real); if(mx < 0) SDL_WarpMouseInWindow(window, min_x, my_real); if(my > 349) SDL_WarpMouseInWindow(window, mx_real, max_y); if(my < 0) SDL_WarpMouseInWindow(window, mx_real, min_y); status->real_mouse_x = mx; status->real_mouse_y = my; status->mouse_x = mx / 8; status->mouse_y = my / 14; status->mouse_moved = true; break; } case SDL_MOUSEBUTTONDOWN: { status->mouse_button = event->button.button; status->mouse_repeat = event->button.button; status->mouse_button_state |= SDL_BUTTON(event->button.button); status->mouse_repeat_state = 1; status->mouse_drag_state = -1; status->mouse_time = SDL_GetTicks(); break; } case SDL_MOUSEBUTTONUP: { status->mouse_button_state &= ~SDL_BUTTON(event->button.button); status->mouse_repeat = 0; status->mouse_drag_state = 0; status->mouse_repeat_state = 0; break; } case SDL_KEYDOWN: { Uint16 unicode = 0; #if SDL_VERSION_ATLEAST(2,0,0) // FIXME: SDL 2.0 finally implements proper key repeat. // We should probably use it instead of our hand-rolled stuff. if(event->key.repeat) break; #endif ckey = convert_SDL_internal(event->key.keysym.sym); if(!ckey) { #if !SDL_VERSION_ATLEAST(2,0,0) if(!event->key.keysym.unicode) break; #endif ckey = IKEY_UNICODE; } #if SDL_VERSION_ATLEAST(2,0,0) // SDL 2.0 sends the raw key and translated 'text' as separate events. // There is no longer a UNICODE mode that sends both at once. // Because of the way the SDL 1.2 assumption is embedded deeply in // the MZX event queue processor, emulate the 1.2 behaviour by waiting // for a TEXTINPUT event after a KEYDOWN. if(SDL_WaitEventTimeout(event, 1)) { if(event->type == SDL_TEXTINPUT) unicode = event->text.text[0] | event->text.text[1] << 8; else SDL_PushEvent(event); } #else unicode = event->key.keysym.unicode; #endif if((ckey == IKEY_RETURN) && get_alt_status(keycode_internal) && get_ctrl_status(keycode_internal)) { toggle_fullscreen(); break; } if(ckey == IKEY_CAPSLOCK) { status->caps_status = true; } if(ckey == IKEY_NUMLOCK) { #if !SDL_VERSION_ATLEAST(2,0,0) && defined(__WIN32__) status->numlock_status = true; #endif break; } if(ckey == IKEY_F12) { dump_screen(); break; } // Ignore alt + tab if((ckey == IKEY_TAB) && get_alt_status(keycode_internal)) { break; } if(status->key_repeat && (status->key_repeat != IKEY_LSHIFT) && (status->key_repeat != IKEY_RSHIFT) && (status->key_repeat != IKEY_LALT) && (status->key_repeat != IKEY_RALT) && (status->key_repeat != IKEY_LCTRL) && (status->key_repeat != IKEY_RCTRL)) { // Stack current repeat key if it isn't shift, alt, or ctrl if(input.repeat_stack_pointer != KEY_REPEAT_STACK_SIZE) { input.key_repeat_stack[input.repeat_stack_pointer] = status->key_repeat; input.unicode_repeat_stack[input.repeat_stack_pointer] = status->unicode_repeat; input.repeat_stack_pointer++; } } key_press(status, ckey, unicode); break; } case SDL_KEYUP: { #if SDL_VERSION_ATLEAST(2,0,0) // FIXME: SDL 2.0 finally implements proper key repeat. // We should probably use it instead of our hand-rolled stuff. if(event->key.repeat) break; #endif ckey = convert_SDL_internal(event->key.keysym.sym); if(!ckey) { #if !SDL_VERSION_ATLEAST(2,0,0) if(!status->keymap[IKEY_UNICODE]) break; #endif ckey = IKEY_UNICODE; } if(ckey == IKEY_NUMLOCK) { #if !SDL_VERSION_ATLEAST(2,0,0) && defined(__WIN32__) status->numlock_status = false; #else status->numlock_status = !status->numlock_status; #endif break; } if(ckey == IKEY_CAPSLOCK) { status->caps_status = false; } status->keymap[ckey] = 0; if(status->key_repeat == ckey) { status->key_repeat = IKEY_UNKNOWN; status->unicode_repeat = 0; } status->key_release = ckey; break; } case SDL_JOYAXISMOTION: { int axis_value = event->jaxis.value; int digital_value = -1; int which = event->jaxis.which; int axis = event->jaxis.axis; Sint8 last_axis = status->axis[which][axis]; enum keycode stuffed_key; if(axis_value > 10000) digital_value = 1; else if(axis_value < -10000) digital_value = 0; if(digital_value != -1) { stuffed_key = input.joystick_axis_map[which][axis][digital_value]; if(stuffed_key) { if(status->keymap[stuffed_key] == 0) key_press(status, stuffed_key, stuffed_key); if(last_axis == (digital_value ^ 1)) { key_release(status, input.joystick_axis_map[which][axis][last_axis]); } } } else if(last_axis != -1) { key_release(status, input.joystick_axis_map[which][axis][last_axis]); } status->axis[which][axis] = digital_value; break; } case SDL_JOYBUTTONDOWN: { int which = event->jbutton.which; int button = event->jbutton.button; enum keycode stuffed_key = input.joystick_button_map[which][button]; if(stuffed_key && (status->keymap[stuffed_key] == 0)) key_press(status, stuffed_key, stuffed_key); break; } case SDL_JOYBUTTONUP: { int which = event->jbutton.which; int button = event->jbutton.button; enum keycode stuffed_key = input.joystick_button_map[which][button]; if(stuffed_key) key_release(status, stuffed_key); break; } default: return false; } return true; }