/* =========== IN_MouseEvent =========== */ void IN_MouseEvent (int mstate) { int i; if (!mouseinitialized) return; // perform button actions for (i=0 ; i<mouse_buttons ; i++) { if ( (mstate & (1<<i)) && !(mouse_oldbuttonstate & (1<<i)) ) { Key_Event (K_MOUSE1 + i, true, sys_msg_time); } if ( !(mstate & (1<<i)) && (mouse_oldbuttonstate & (1<<i)) ) { Key_Event (K_MOUSE1 + i, false, sys_msg_time); } } mouse_oldbuttonstate = mstate; }
void JOY_Command (void) { struct js_event event; if (!joy_active || !joy_enable->int_val) return; while (read (joy_handle, &event, sizeof (struct js_event)) > -1) { if (event.type & JS_EVENT_BUTTON) { if(event.number >= JOY_MAX_BUTTONS) continue; joy_buttons[event.number].current = event.value; if (joy_buttons[event.number].current > joy_buttons[event.number].old) { Key_Event(K_AUX1 + event.number, true); } else { if (joy_buttons[event.number].current < joy_buttons[event.number].old) { Key_Event(K_AUX1 + event.number, false); } } joy_buttons[event.number].old = joy_buttons[event.number].current; } else { if (event.type & JS_EVENT_AXIS) { if (event.number >= JOY_MAX_AXES) continue; joy_axes[event.number].current = event.value; } } } }
/* ================ IN_JoyKeyEvent Sends a Key_Event if a unpressed -> pressed or pressed -> unpressed transition occurred, and generates key repeats if the button is held down. Adapted from DarkPlaces by lordhavoc ================ */ static void IN_JoyKeyEvent(qboolean wasdown, qboolean isdown, int key, double *timer) { // we can't use `realtime` for key repeats because it is not monotomic const double currenttime = Sys_DoubleTime(); if (wasdown) { if (isdown) { if (currenttime >= *timer) { *timer = currenttime + 0.1; Key_Event(key, true); } } else { *timer = 0; Key_Event(key, false); } } else { if (isdown) { *timer = currenttime + 0.5; Key_Event(key, true); } } }
/* * Key_MouseEvent * * A wrapper around Key_Event to generate double click events * A typical sequence of events will look like this: * +MOUSE1 - user pressed button * -MOUSE1 - user released button * +MOUSE1 - user pressed button (must be within 480 ms or so of the previous down event) * +MOUSE1DBLCLK - inserted by Key_MouseEvent * -MOUSE1DBLCLK - inserted by Key_MouseEvent * -MOUSE1 - user released button * (This order is not final! We might want to suppress the second pair of * mouse1 down/up events, or make +MOUSE1DBLCLK come before +MOUSE1) */ void Key_MouseEvent( int key, qboolean down, unsigned time ) { static unsigned int last_button1_click = 0; // use a lower delay than XP default (480 ms) because we don't support width/height yet const unsigned int doubleclick_time = 350; // milliseconds // static int last_button1_x, last_button1_y; // TODO // const int doubleclick_width = 4; // TODO // const int doubleclick_height = 4; // TODO if( key == K_MOUSE1 ) { if( down ) { if( last_button1_click && ( (time - last_button1_click) < doubleclick_time ) ) { last_button1_click = 0; Key_Event( key, down, time ); Key_Event( K_MOUSE1DBLCLK, qtrue, time ); Key_Event( K_MOUSE1DBLCLK, qfalse, time ); return; } else { last_button1_click = time; } } } else if( key == K_MOUSE2 || key == K_MOUSE3 ) { last_button1_click = 0; } Key_Event( key, down, time ); }
static void raw_mouse_event( PRAWMOUSE rm ) { int i; if( rm->usButtonFlags ) { for( i = 0; i < MOUSE_BUTTONS; i++ ) { if( rm->usButtonFlags & ( 1 << ( i * 2 ) ) ) { Key_Event( K_MOUSE1 + i, qtrue, win.lastMsgTime ); } if( rm->usButtonFlags & ( 1 << ( i * 2 + 1 ) ) ) { Key_Event( K_MOUSE1 + i, qfalse, win.lastMsgTime ); } } if( rm->usButtonFlags & RI_MOUSE_WHEEL ) { mouse_wheel_event( ( short )rm->usButtonData ); } // this flag is undocumented, but confirmed to work on Win7 if( rm->usButtonFlags & 0x0800 ) { mouse_hwheel_event( ( short )rm->usButtonData ); } } if( ( rm->usFlags & (MOUSE_MOVE_RELATIVE|MOUSE_MOVE_ABSOLUTE) ) == MOUSE_MOVE_RELATIVE ) { win.mouse.mx += rm->lLastX; win.mouse.my += rm->lLastY; } }
void IN_MouseEvent (int mstate) { int i; if (mouseactive && !dinput) { // perform button actions for (i=0 ; i<mouse_buttons ; i++) { if ( (mstate & (1<<i)) && !(mouse_oldbuttonstate & (1<<i)) ) { Key_Event (K_MOUSE1 + i, true); } if ( !(mstate & (1<<i)) && (mouse_oldbuttonstate & (1<<i)) ) { Key_Event (K_MOUSE1 + i, false); } } mouse_oldbuttonstate = mstate; } }
void IN_CommandsJoystick (void) { int i, key_index; DWORD buttonstate;//, povstate; struct js_event js; if (!joy_avail) return; if (read (joystick, &js, sizeof (struct js_event)) != sizeof (struct js_event)) return; switch (js.type & ~JS_EVENT_INIT) { case JS_EVENT_BUTTON: buttonstate = js.value; i = js.number; if (js.value) { key_index = (i < 4) ? K_JOY1 : K_AUX1; Key_Event (key_index + i, true); } if (!js.value) { key_index = (i < 4) ? K_JOY1 : K_AUX1; Key_Event (key_index + i, false); } joy_oldbuttonstate = buttonstate; } }
STATIC LRESULT CALLBACK LowLevelKeyboardProc( int nCode, WPARAM wParam, LPARAM lParam ) { PKBDLLHOOKSTRUCT kb = ( PKBDLLHOOKSTRUCT )lParam; unsigned key; if( nCode != HC_ACTION ) { goto ignore; } switch( kb->vkCode ) { case VK_LWIN: key = K_LWINKEY; break; case VK_RWIN: key = K_RWINKEY; break; default: goto ignore; } switch( wParam ) { case WM_KEYDOWN: Key_Event( key, qtrue, kb->time ); return TRUE; case WM_KEYUP: Key_Event( key, qfalse, kb->time ); return TRUE; default: break; } ignore: return CallNextHookEx( NULL, nCode, wParam, lParam ); }
// this is complicated because Win32 seems to pack multiple mouse events into // one update sometimes, so we always check all states and look for events static void legacy_mouse_event( WPARAM wParam ) { int i, mask, temp = 0; if( wParam & MK_LBUTTON ) temp |= 1; if( wParam & MK_RBUTTON ) temp |= 2; if( wParam & MK_MBUTTON ) temp |= 4; if( wParam & MK_XBUTTON1 ) temp |= 8; if( wParam & MK_XBUTTON2 ) temp |= 16; if( temp == win.mouse.state ) return; // perform button actions for( i = 0, mask = 1; i < MOUSE_BUTTONS; i++, mask <<= 1 ) { if( ( temp & mask ) && !( win.mouse.state & mask ) ) { Key_Event( K_MOUSE1 + i, qtrue, win.lastMsgTime ); } if( !( temp & mask ) && ( win.mouse.state & mask ) ) { Key_Event( K_MOUSE1 + i, qfalse, win.lastMsgTime ); } } win.mouse.state = temp; }
void Sys_SendKeyEvents(void) { int k, next; int outkey; // get key events while (keybuf_head != keybuf_tail) { k = keybuf[keybuf_tail++]; keybuf_tail &= (KEYBUF_SIZE-1); if (k==0xe0) { continue; // special / pause keys } next = keybuf[(keybuf_tail-2)&(KEYBUF_SIZE-1)]; if (next == 0xe1) { continue; // pause key bullshit } if (k==0xc5 && next == 0x9d) { Key_Event(K_PAUSE, true); continue; } // extended keyboard shift key bullshit if ((k&0x7f)==SC_LSHIFT || (k&0x7f)==SC_RSHIFT) { if (keybuf[(keybuf_tail-2)&(KEYBUF_SIZE-1)]==0xe0) { continue; } k &= 0x80; k |= SC_RSHIFT; } if (k==0xc5 && keybuf[(keybuf_tail-2)&(KEYBUF_SIZE-1)] == 0x9d) { continue; // more pause bullshit } outkey = scantokey[k & 0x7f]; if (k & 0x80) { Key_Event(outkey, false); } else { Key_Event(outkey, true); } } }
/* //========================= //process touch screen icon touch event */ void __inline__ Key_Event_Alt(int key, int action) { if(DpadAsturn == 1) Key_Event(key, action); else { key = key==K_LEFTARROW ? 0 : 1; Key_Event( turnKeysyms[1][key], action); } }
static void mouse_wheel_event(SDL_MouseWheelEvent *event) { if (event->y > 0) { Key_Event(K_MWHEELUP, true); Key_Event(K_MWHEELUP, false); } else if (event->y < 0) { Key_Event(K_MWHEELDOWN, true); Key_Event(K_MWHEELDOWN, false); } }
static void mouse_wheel_event( SDL_MouseWheelEvent *event ) { int key = event->y > 0 ? K_MWHEELUP : K_MWHEELDOWN; unsigned sys_msg_time = Sys_Milliseconds(); if( !mouse_active ) { return; } Key_Event( key, true, sys_msg_time ); Key_Event( key, false, sys_msg_time ); }
void Sys_SendKeyEvents (void) { int k, next; int outkey; // grab frame time sys_msg_time = Sys_Milliseconds(); // get key events while (keybuf_head != keybuf_tail) { k = keybuf[keybuf_tail++]; keybuf_tail &= (KEYBUF_SIZE - 1); if (k == 0xe0) continue; // special / pause keys next = keybuf[(keybuf_tail - 2) & (KEYBUF_SIZE - 1)]; // Pause generates e1 1d 45 e1 9d c5 when pressed, and // nothing when released. e1 is generated only for the // pause key. if (next == 0xe1) continue; // pause key bullshit if (k == 0xc5 && next == 0x9d) { Key_Event (K_PAUSE, true, sys_msg_time); continue; } // extended keyboard shift key bullshit if ( (k & 0x7f) == SC_LEFTSHIFT || (k & 0x7f) == SC_RIGHTSHIFT ) { if (keybuf[(keybuf_tail - 2) & (KEYBUF_SIZE - 1)] == 0xe0) continue; k &= 0x80; k |= SC_RIGHTSHIFT; } if (k == 0xc5 && keybuf[(keybuf_tail - 2) & (KEYBUF_SIZE - 1)] == 0x9d) continue; // more pause bullshit outkey = scantokey[k & 0x7f]; if (k & 0x80) Key_Event (outkey, false, sys_msg_time); else Key_Event (outkey, true, sys_msg_time); } sys_frame_time = Sys_Milliseconds(); /* FS: Need to update this for input to work properly */ }
static void mousehandler ( int buttonstate, int dx, int dy, int dz, int drx, int dry, int drz ) { mouse_buttonstate = buttonstate; mx += dx; my += dy; if (drx > 0) { Key_Event(K_MWHEELUP, 1); Key_Event(K_MWHEELUP, 0); } else if (drx < 0) { Key_Event(K_MWHEELDOWN, 1); Key_Event(K_MWHEELDOWN, 0); } }
void evdev_read( void ) { struct input_event evs[16], *ev; int i, j, numevs, time; size_t bytes; // FIXME: select for( i = 0; i < m_evdev_num; i++ ) { do { bytes = read( m_evdev_fds[i], evs, sizeof( evs ) ); if( !bytes ) break; numevs = bytes / sizeof( evs[0] ); for( j = 0, ev = evs; j < numevs; j++, ev++ ) { switch( ev->type ) { case EV_REL: if( ev->code == REL_Y ) my += ev->value; else if( ev->code == REL_X ) mx += ev->value; else if( ev->code == REL_WHEEL ) { time = Sys_EvdevTimeToSysTime( &ev->time ); Key_Event( ev->value < 0 ? K_MWHEELDOWN : K_MWHEELUP, 1, time ); Key_Event( ev->value < 0 ? K_MWHEELDOWN : K_MWHEELUP, 0, time ); } break; case EV_KEY: time = Sys_EvdevTimeToSysTime( &ev->time ); if( ev->code >= BTN_LEFT && ev->code <= BTN_TASK ) Key_MouseEvent( K_MOUSE1 + ( ev->code - BTN_LEFT ), ev->value, time ); break; default: break; } } } while( bytes == sizeof( evs ) ); } }
static void mouse_hwheel_event( int delta ) { UINT key; // FIXME: handle WHEEL_DELTA and partial scrolls... if( delta > 0 ) { key = K_MWHEELRIGHT; } else if( delta < 0 ) { key = K_MWHEELLEFT; } else { return; } Key_Event( key, qtrue, win.lastMsgTime ); Key_Event( key, qfalse, win.lastMsgTime ); }
static void mouse_button_event(SDL_MouseButtonEvent *event) { unsigned key; switch (event->button) { case SDL_BUTTON_LEFT: key = K_MOUSE1; break; case SDL_BUTTON_RIGHT: key = K_MOUSE2; break; case SDL_BUTTON_MIDDLE: key = K_MOUSE3; break; case 8: case SDL_BUTTON_X1: key = K_MOUSE4; break; case 9: case SDL_BUTTON_X2: key = K_MOUSE5; break; default: Com_DPrintf("%s: unknown button %d\n", __func__, event->button); return; } Key_Event(key, event->state); }
static void Handle_KeyMod(UInt32 keymod) { const struct keymod_to_event_s { UInt32 keybit; keynum_t event; } keymod_events [] = { { cmdKey, K_AUX1 }, { shiftKey, K_SHIFT }, { alphaLock, K_CAPSLOCK }, { optionKey, K_ALT }, { controlKey, K_CTRL }, { kEventKeyModifierNumLockMask, K_NUMLOCK }, { kEventKeyModifierFnMask, K_AUX2 } }; static UInt32 prev_keymod = 0; unsigned int i; UInt32 modChanges; modChanges = prev_keymod ^ keymod; if (modChanges == 0) return; for (i = 0; i < sizeof(keymod_events) / sizeof(keymod_events[0]); i++) { UInt32 keybit = keymod_events[i].keybit; if ((modChanges & keybit) != 0) Key_Event(keymod_events[i].event, '\0', (keymod & keybit) != 0); } prev_keymod = keymod; }
static void handle_button(XGenericEventCookie *cookie) { XIDeviceEvent *ev = (XIDeviceEvent *)cookie->data; qboolean down = cookie->evtype == XI_ButtonPress; int button = ev->detail; unsigned time = Sys_XTimeToSysTime(ev->time); int k_button; if(!mouse_active) return; switch(button) { case 1: k_button = K_MOUSE1; break; case 2: k_button = K_MOUSE3; break; case 3: k_button = K_MOUSE2; break; case 4: k_button = K_MWHEELUP; break; case 5: k_button = K_MWHEELDOWN; break; /* Switch place of MOUSE4-5 with MOUSE6-7 */ case 6: k_button = K_MOUSE6; break; case 7: k_button = K_MOUSE7; break; case 8: k_button = K_MOUSE4; break; case 9: k_button = K_MOUSE5; break; /* End switch */ case 10: k_button = K_MOUSE8; break; default: return; } Key_Event(k_button, down, time); }
/** * @sa CL_SendCommand */ void IN_SendKeyEvents (void) { while (keyq_head != keyq_tail) { Key_Event(keyq[keyq_tail].key, keyq[keyq_tail].unicode, keyq[keyq_tail].down, CL_Milliseconds()); keyq_tail = (keyq_tail + 1) & (MAX_KEYQ - 1); } }
/*set all arrow key up*/ void reset_arrow_key() { int i; for(i = 0; i<4; i++) { Key_Event(arrowkeys[i], SDL_RELEASED); } return; }
/** * Function which is called whenever a key is pressed or released. * @param event the SDL event object containing the keysym et all * @param state either true if it is a keydown event or false otherwise */ static void key_event( const SDL_KeyboardEvent *event, const bool state ) { wchar_t charkey = TranslateSDLScancode( event->keysym.scancode ); if( charkey >= 0 && charkey <= 255 ) { Key_Event( charkey, state, Sys_Milliseconds() ); } }
void idNewHud::OnPressRelease( int x, int y ) { //parentWidth - (rect.size.width + rect.origin.x) /*int _x = (vid.height - y) / 2; int _y = vid.width + ((vid.height - x) / 2.0); if(menuButton->IsPointInsideButton( _x, _y )) { Key_Event( K_ESCAPE, true ); } else { Key_Event( K_ESCAPE, false ); }*/ ////if(!upButton->IsPointInsideButton( _x, _y )) //{ // Key_Event( K_UPARROW, false ); //} ////if(!downButton->IsPointInsideButton( _x, _y )) //{ // Key_Event( K_DOWNARROW, false ); // //} ////if(!leftButton->IsPointInsideButton( _x, _y )) //{ // Key_Event( K_LEFTARROW, false ); //} ////if(!rightButton->IsPointInsideButton( _x, _y )) //{ // Key_Event( K_RIGHTARROW, false ); // //} { Key_Event( K_LEFTARROW, false ); Key_Event( K_RIGHTARROW, false ); Key_Event( K_UPARROW, false ); Key_Event( K_DOWNARROW, false ); Key_Event( K_ENTER, false ); Key_Event( K_SPACE, false ); Key_Event( K_CTRL, false ); Key_Event( K_ESCAPE, false ); } }
/* =================== Key_ClearStates =================== */ void Key_ClearStates (void) { int i; for (i = 0; i < 256; i++) { if (keydown[i]) Key_Event (i, false); } }
static void keyb_event(SDL_KeyboardEvent *event) { byte result = Key_ScancodeToQuakeCode(event->keysym.scancode); if (result == 0) { Com_Printf("%s: unknown scancode %d\n", __func__, event->keysym.scancode); return; } Key_Event(result, event->state); }
static void keyhandler ( int scancode, int state ) { int sc; sc = scancode & 0x7f; #if 0 Con_Printf("scancode=%x (%d%s)\n", scancode, sc, scancode&0x80?"+128":""); #endif Key_Event(scantokey[sc], state == KEY_EVENTPRESS); }
void ClearAllStates (void) { int i; // send an up event for each key, to make sure the server clears them all for (i = 0; i < sizeof(keydown) / sizeof(*keydown); i++) { if (keydown[i]) Key_Event (i, false); } Key_ClearStates (); IN_ClearStates (); }
/* =========== DI_GetMouseEvents =========== */ static void DI_GetMouseEvents(void) { DIDEVICEOBJECTDATA data[16]; LPDIDEVICEOBJECTDATA p, last; DWORD numElements, button; int value; HRESULT hr; if (di_grabbed != IN_GRAB) { return; } do { numElements = 16; hr = IDirectInputDevice_GetDeviceData(di_mouse, sizeof(data[0]), data, &numElements, 0); if (hr == DIERR_INPUTLOST || hr == DIERR_NOTACQUIRED) { IDirectInputDevice_Acquire(di_mouse); return; } if (FAILED(hr)) { Com_EPrintf("GetDeviceData failed with error 0x%lX\n", hr); return; } last = data + numElements; for (p = data; p < last; p++) { switch (p->dwOfs) { case DIMOFS_BUTTON0: case DIMOFS_BUTTON1: case DIMOFS_BUTTON2: case DIMOFS_BUTTON3: case DIMOFS_BUTTON4: case DIMOFS_BUTTON5: case DIMOFS_BUTTON6: case DIMOFS_BUTTON7: button = p->dwOfs - DIMOFS_BUTTON0; if (p->dwData & 0x80) { Key_Event(K_MOUSE1 + button, qtrue, p->dwTimeStamp); } else { Key_Event(K_MOUSE1 + button, qfalse, p->dwTimeStamp); } break; case DIMOFS_Z: value = p->dwData; if (!value) { break; } if (value > 0) { Key_Event(K_MWHEELUP, qtrue, p->dwTimeStamp); Key_Event(K_MWHEELUP, qfalse, p->dwTimeStamp); } else { Key_Event(K_MWHEELDOWN, qtrue, p->dwTimeStamp); Key_Event(K_MWHEELDOWN, qfalse, p->dwTimeStamp); } break; default: break; } } } while (hr == DI_BUFFEROVERFLOW); }
/* ================ ClearAllStates ================ */ static void ClearAllStates (void) { int i; // send an up event for each key, to make sure the server clears them all for (i = 0; i < 256; i++) { Key_Event (i, false); } Key_ClearStates (); IN_ClearStates (); }