Beispiel #1
11
/*
===========
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;
}
Beispiel #2
0
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;
			}
		}
	}
}
Beispiel #3
0
/*
================
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);
		}
	}
}
Beispiel #4
0
/*
* 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 );
}
Beispiel #5
0
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;
    }
}
Beispiel #6
0
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;
	}
}
Beispiel #7
0
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;
	} 
}
Beispiel #8
0
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 );
}
Beispiel #9
0
// 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;
}
Beispiel #10
0
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);
	 }
} 
Beispiel #12
0
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);
	}
}
Beispiel #13
0
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 );
}
Beispiel #14
0
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 */
}
Beispiel #15
0
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);
	}
}
Beispiel #16
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 ) );
	}
}
Beispiel #17
0
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 );
}
Beispiel #18
0
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);
}
Beispiel #19
0
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;
}
Beispiel #20
0
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);
}
Beispiel #21
0
/**
 * @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;
}
Beispiel #23
0
/**
 * 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() );
	}
}
Beispiel #24
0
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 );
		
	}

}
Beispiel #25
0
/*
===================
Key_ClearStates
===================
*/
void Key_ClearStates (void)
{
	int	i;

	for (i = 0; i < 256; i++)
	{
		if (keydown[i])
			Key_Event (i, false);
	}
}
Beispiel #26
0
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);
}
Beispiel #27
0
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);
}
Beispiel #28
0
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 ();
}
Beispiel #29
0
/*
===========
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 ();
}