void mouseDrvDInputAcquire(void)
{
HRESULT res;
fellowAddLog("mouseDrvDInputAcquire()\n");
if (mouse_drv_in_use)
{
if (mouse_drv_lpDID != NULL)
{
if ((res = IDirectInputDevice_Acquire(mouse_drv_lpDID)) != DI_OK)
{
mouseDrvDInputFailure("mouseDrvDInputAcquire():", res);
}
}
}
else
{
if (mouse_drv_lpDID != NULL)
{
if ((res = IDirectInputDevice_Unacquire(mouse_drv_lpDID)) != DI_OK)
{
mouseDrvDInputFailure("mouseDrvDInputUnacquire():", res);
}
}
}
}
/* key_dinput_acquire: [window thread]
* Acquires the keyboard device. This must be called after a
* window switch for example if the device is in foreground
* cooperative level.
*/
int key_dinput_acquire(void)
{
HRESULT hr;
BYTE keystate[256];
if (key_dinput_device) {
/* Read the current Windows keyboard state */
GetKeyboardState(keystate);
update_shifts(keystate);
hr = IDirectInputDevice_Acquire(key_dinput_device);
if (FAILED(hr)) {
_TRACE(PREFIX_E "acquire keyboard failed: %s\n", dinput_err_str(hr));
return -1;
}
/* Initialize keyboard state */
SetEvent(key_input_event);
return 0;
}
else
return -1;
}
/*
===========
DI_GrabMouse
===========
*/
static void DI_GrabMouse(grab_t grab)
{
HRESULT hr;
if (!di_initialized) {
return;
}
if (di_grabbed == grab) {
return;
}
if (grab == IN_GRAB) {
Com_DPrintf("IDirectInputDevice_Acquire\n");
hr = IDirectInputDevice_Acquire(di_mouse);
if (FAILED(hr)) {
Com_EPrintf("Failed to acquire mouse, error 0x%lX\n", hr);
}
} else {
Com_DPrintf("IDirectInputDevice_Unacquire\n");
hr = IDirectInputDevice_Unacquire(di_mouse);
if (FAILED(hr)) {
Com_EPrintf("Failed to unacquire mouse, error 0x%lX\n", hr);
}
}
di_grabbed = grab;
}
/*
===========
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);
}
mouse_state_t* read_mouse( void )
{
static float framelagfix = 0.0f;
static mouse_state_t state;
HRESULT hr;
framelagfix -= real_framelag;
if(framelagfix <= 0.0f)
{
framelagfix = 0.028f;
}
else
{
return &state;
}
hr = IDirectInputDevice_GetDeviceState(
lpdiMouse, sizeof(DIMOUSESTATE), &mouse);
if( hr == DI_OK )
{
state.xrel = mouse.lX;
state.yrel = mouse.lY;
}
else if( hr == DIERR_INPUTLOST )
{
DebugPrintf("dx input lost - reacuiring...\n");
IDirectInputDevice_Acquire(lpdiMouse);
}
else
{
DebugPrintf("mouse error: %d\n",hr);
}
return &state;
}
static void DIKeyboard_PollKeyboard()
{
HRESULT hr;
extern int mame_debug;
if (This.m_didKeyboard == NULL)
return;
again:
hr = IDirectInputDevice_GetDeviceState(This.m_didKeyboard,sizeof(This.m_key),&This.m_key);
if (hr == DIERR_INPUTLOST || hr == DIERR_NOTACQUIRED)
{
/*
DirectInput is telling us that the input stream has
been interrupted. We aren't tracking any state
between polls, so we don't have any special reset
that needs to be done. We just re-acquire and
try again.
*/
hr = IDirectInputDevice_Acquire(This.m_didKeyboard);
if (SUCCEEDED(hr))
goto again;
}
}
void IN_ActivateMouse (void)
{
mouseactivatetoggle = true;
if (mouseinitialized)
{
if (dinput)
{
if (g_pMouse)
{
if (!dinput_acquired)
{
IDirectInputDevice_Acquire(g_pMouse);
dinput_acquired = true;
}
}
else
{
return;
}
}
else
{
if (mouseparmsvalid)
restore_spi = SystemParametersInfo (SPI_SETMOUSE, 0, newmouseparms, 0);
SetCursorPos (window_center_x, window_center_y);
SetCapture (mainwindow);
ClipCursor (&window_rect);
}
mouseactive = true;
}
}
bool dx_init_mouse( void )
{
HRESULT err;
GUID guid_mouse = GUID_SysMouse;
err = DirectInputCreate(GetModuleHandle(NULL), DIRECTINPUT_VERSION, &lpdi, NULL);
if (FAILED(err))
return false;
err = IDirectInput_CreateDevice(lpdi, &guid_mouse, &lpdiMouse, NULL);
if ( err != DI_OK )
return false;
err = IDirectInputDevice_SetDataFormat(lpdiMouse, &c_dfDIMouse);
if(err != DI_OK)
return false;
err = IDirectInputDevice_SetCooperativeLevel(
lpdiMouse, GetActiveWindow(), DISCL_NONEXCLUSIVE | DISCL_BACKGROUND
);
if(err != DI_OK)
return false;
err = IDirectInputDevice_Acquire(lpdiMouse);
return true;
}
/*
===========
IN_ActivateMouse
Called when the window gains focus or changes in some way
===========
*/
void IN_ActivateMouse( void ) {
if ( !s_wmv.mouseInitialized ) {
return;
}
if ( !in_mouse->integer ) {
s_wmv.mouseActive = qfalse;
return;
}
if ( s_wmv.mouseActive ) {
return;
}
if ( directInput ) {
if ( g_pMouse ) {
if ( !directInput_acquired ) {
IDirectInputDevice_Acquire( g_pMouse );
directInput_acquired = qtrue;
}
} else {
return;
}
} else {
IN_ActivateWin32Mouse();
}
s_wmv.mouseActive = qtrue;
}
static void test_object_info(LPDIRECTINPUTDEVICE device, HWND hwnd)
{
HRESULT hr;
DIPROPDWORD dp;
DIDEVICEOBJECTINSTANCE obj_info;
DWORD obj_types[] = {DIDFT_BUTTON, DIDFT_AXIS, DIDFT_POV};
int type_index;
int cnt = 0, cnt1 = 0;
hr = IDirectInputDevice_EnumObjects(device, enum_callback, &cnt, DIDFT_ALL);
ok(SUCCEEDED(hr), "EnumObjects() failed: %08x\n", hr);
hr = IDirectInputDevice_SetDataFormat(device, &data_format);
ok(SUCCEEDED(hr), "SetDataFormat() failed: %08x\n", hr);
hr = IDirectInputDevice_EnumObjects(device, enum_callback, &cnt1, DIDFT_ALL);
ok(SUCCEEDED(hr), "EnumObjects() failed: %08x\n", hr);
if (0) /* fails for joystick only */
ok(cnt == cnt1, "Enum count changed from %d to %d\n", cnt, cnt1);
/* Testing EnumObjects with different types of device objects */
for (type_index=0; type_index < sizeof(obj_types)/sizeof(obj_types[0]); type_index++)
{
hr = IDirectInputDevice_EnumObjects(device, enum_type_callback, &obj_types[type_index], obj_types[type_index]);
ok(SUCCEEDED(hr), "EnumObjects() failed: %08x\n", hr);
}
/* No need to test devices without axis */
obj_info.dwSize = sizeof(obj_info);
hr = IDirectInputDevice_GetObjectInfo(device, &obj_info, 16, DIPH_BYOFFSET);
if (SUCCEEDED(hr))
{
/* No device supports per axis relative/absolute mode */
memset(&dp, 0, sizeof(dp));
dp.diph.dwSize = sizeof(DIPROPDWORD);
dp.diph.dwHeaderSize = sizeof(DIPROPHEADER);
dp.diph.dwHow = DIPH_BYOFFSET;
dp.diph.dwObj = 16;
dp.dwData = DIPROPAXISMODE_ABS;
hr = IDirectInputDevice_SetProperty(device, DIPROP_AXISMODE, &dp.diph);
ok(hr == DIERR_UNSUPPORTED, "SetProperty() returned: %08x\n", hr);
dp.diph.dwHow = DIPH_DEVICE;
hr = IDirectInputDevice_SetProperty(device, DIPROP_AXISMODE, &dp.diph);
ok(hr == DIERR_INVALIDPARAM, "SetProperty() returned: %08x\n", hr);
dp.diph.dwObj = 0;
hr = IDirectInputDevice_SetProperty(device, DIPROP_AXISMODE, &dp.diph);
ok(hr == DI_OK, "SetProperty() failed: %08x\n", hr);
/* Cannot change mode while acquired */
hr = IDirectInputDevice_Acquire(device);
ok(hr == DI_OK, "Acquire() failed: %08x\n", hr);
hr = IDirectInputDevice_SetProperty(device, DIPROP_AXISMODE, &dp.diph);
ok(hr == DIERR_ACQUIRED, "SetProperty() returned: %08x\n", hr);
hr = IDirectInputDevice_Unacquire(device);
ok(hr == DI_OK, "Unacquire() failed: %08x\n", hr);
}
}
static void OnActivateApp(HWND hWnd, BOOL fActivate, DWORD dwThreadId)
{
if (!This.m_didKeyboard)
return;
if (MAME32App.m_bIsActive == TRUE)
IDirectInputDevice_Acquire(This.m_didKeyboard);
else
IDirectInputDevice_Unacquire(This.m_didKeyboard);
}
static void test_acquire(LPDIRECTINPUT pDI, HWND hwnd)
{
HRESULT hr;
LPDIRECTINPUTDEVICE pMouse = NULL;
DIMOUSESTATE m_state;
hr = IDirectInput_CreateDevice(pDI, &GUID_SysMouse, &pMouse, NULL);
ok(SUCCEEDED(hr), "IDirectInput_CreateDevice() failed: %08x\n", hr);
if (FAILED(hr)) return;
hr = IDirectInputDevice_SetCooperativeLevel(pMouse, hwnd, DISCL_NONEXCLUSIVE | DISCL_FOREGROUND);
ok(hr == S_OK, "SetCooperativeLevel: %08x\n", hr);
hr = IDirectInputDevice_SetDataFormat(pMouse, &c_dfDIMouse);
ok(SUCCEEDED(hr), "IDirectInputDevice_SetDataFormat() failed: %08x\n", hr);
hr = IDirectInputDevice_Unacquire(pMouse);
ok(hr == S_FALSE, "IDirectInputDevice_Unacquire() should have failed: %08x\n", hr);
hr = IDirectInputDevice_Acquire(pMouse);
ok(SUCCEEDED(hr), "IDirectInputDevice_Acquire() failed: %08x\n", hr);
hr = IDirectInputDevice_Acquire(pMouse);
ok(hr == S_FALSE, "IDirectInputDevice_Acquire() should have failed: %08x\n", hr);
/* Foreground coop level requires window to have focus */
/* This should make dinput loose mouse input */
SetActiveWindow( 0 );
hr = IDirectInputDevice_GetDeviceState(pMouse, sizeof(m_state), &m_state);
ok(hr == DIERR_NOTACQUIRED, "GetDeviceState() should have failed: %08x\n", hr);
/* Workaround so we can test other things. Remove when Wine is fixed */
IDirectInputDevice_Unacquire(pMouse);
hr = IDirectInputDevice_Acquire(pMouse);
ok(hr == DIERR_OTHERAPPHASPRIO, "Acquire() should have failed: %08x\n", hr);
SetActiveWindow( hwnd );
hr = IDirectInputDevice_Acquire(pMouse);
ok(hr == S_OK, "Acquire() failed: %08x\n", hr);
if (pMouse) IUnknown_Release(pMouse);
}
void kbdDrvDInputAcquire(void)
{
fellowAddLog("kbdDrvDInputAcquire()\n");
if (kbd_drv_lpDID == NULL)
{
return;
}
kbdDrvDInputUnacquire();
HRESULT res = IDirectInputDevice_Acquire(kbd_drv_lpDID);
if (res != DI_OK)
{
kbdDrvDInputFailure("kbdDrvDInputAcquire():", res);
}
}
boolean I_InitMouse(void)
{
HWND hWnd;
HRESULT hr;
if(ArgCheck("-nomouse") || novideo)
return false;
hWnd = Sys_GetWindowHandle(mainWindowIdx);
if(!hWnd)
{
Con_Error("I_InitMouse: Main window not available, cannot init mouse.");
return false;
}
hr = IDirectInput_CreateDevice(dInput, &GUID_SysMouse, &didMouse, 0);
if(FAILED(hr))
{
Con_Message("I_InitMouse: Failed to create device (0x%x).\n", hr);
return false;
}
// Set data format.
hr = IDirectInputDevice_SetDataFormat(didMouse, &c_dfDIMouse2);
if(FAILED(hr))
{
Con_Message("I_InitMouse: Failed to set data format (0x%x).\n", hr);
goto kill_mouse;
}
// Set behaviour.
hr = IDirectInputDevice_SetCooperativeLevel(didMouse, hWnd,
DISCL_FOREGROUND |
DISCL_EXCLUSIVE);
if(FAILED(hr))
{
Con_Message("I_InitMouse: Failed to set co-op level (0x%x).\n", hr);
goto kill_mouse;
}
// Acquire the device.
IDirectInputDevice_Acquire(didMouse);
// Init was successful.
return true;
kill_mouse:
I_SAFE_RELEASE(didMouse);
return false;
}
/*
put here anything you need to do when the program is started. Return 0 if
initialization was successful, nonzero otherwise.
*/
static int DIKeyboard_init(options_type *options)
{
HRESULT hr;
int i;
This.m_didKeyboard = NULL;
This.m_DefaultInput = options->default_input;
for (i=0;i<256;i++)
This.m_key[i] = 0;
if (di == NULL)
{
ErrorMsg("DirectInput not initialized");
return 1;
}
/* setup the keyboard */
hr = IDirectInput_CreateDevice(di, &GUID_SysKeyboard, &This.m_didKeyboard, NULL);
if (FAILED(hr))
{
ErrorMsg("DirectInputCreateDevice failed!\n");
return 1;
}
hr = IDirectInputDevice_SetDataFormat(This.m_didKeyboard, &c_dfDIKeyboard);
if (FAILED(hr))
{
ErrorMsg("DirectInputDevice SetDataFormat failed\n");
return 1;
}
hr = IDirectInputDevice_SetCooperativeLevel(This.m_didKeyboard, MAME32App.m_hWnd,
DISCL_NONEXCLUSIVE | DISCL_FOREGROUND);
if (FAILED(hr))
{
ErrorMsg("DirectInputDevice SetCooperativeLevel failed!\n");
return 1;
}
hr = IDirectInputDevice_Acquire(This.m_didKeyboard);
return 0;
}
/**
* Copy n key events from the device and encode them into given buffer.
*
* @param evbuf Ptr to the buffer to encode events to.
* @param bufsize Size of the buffer.
*
* @return Number of key events written to the buffer.
*/
size_t I_GetKeyEvents(keyevent_t *evbuf, size_t bufsize)
{
DIDEVICEOBJECTDATA keyData[KEYBUFSIZE];
DWORD i, num = 0;
BYTE tries;
BOOL acquired;
HRESULT hr;
if(!initIOk)
return 0;
// Try two times to get the data.
tries = 1;
acquired = FALSE;
while(!acquired && tries > 0)
{
num = KEYBUFSIZE;
hr = IDirectInputDevice_GetDeviceData(didKeyb,
sizeof(DIDEVICEOBJECTDATA),
keyData, &num, 0);
if(SUCCEEDED(hr))
{
acquired = TRUE;
}
else if(tries > 0)
{
// Try to reacquire.
IDirectInputDevice_Acquire(didKeyb);
tries--;
}
}
if(!acquired)
return 0; // The operation is a failure.
// Get the events.
for(i = 0; i < num && i < bufsize; ++i)
{
evbuf[i].event =
(keyData[i].dwData & 0x80? IKE_KEY_DOWN : IKE_KEY_UP);
// Use the table to translate the scancode to a ddkey.
evbuf[i].ddkey = dIKeyToDDKey(keyData[i].dwOfs);
}
return (size_t) i;
}
HRESULT ReadKey (DIDEVICEOBJECTDATA *pdidod)
{
ULONG cElements = 1;
HRESULT hr;
if (g_lpdidKeybd == NULL)
return E_FAIL;
hr = IDirectInputDevice_Acquire (g_lpdidKeybd);
if (SUCCEEDED (hr))
{
hr = IDirectInputDevice_GetDeviceData (
g_lpdidKeybd,
sizeof (*pdidod),
pdidod,
(int *) &cElements,
0);
if (SUCCEEDED (hr) && cElements != 1)
hr = E_FAIL;
}
return hr;
}
void key_init()
{
HRESULT hr;
// my kingdom, my kingdom for C++...
if (SUCCEEDED (hr = DirectInputCreate (GetModuleHandle (NULL), DIRECTINPUT_VERSION, &g_lpdi, NULL)))
{
if (SUCCEEDED (hr = IDirectInput_CreateDevice (g_lpdi, (void *)&GUID_SysKeyboard, &g_lpdidKeybd, NULL)))
{
DIPROPDWORD dipdw;
dipdw.diph.dwSize = sizeof (DIPROPDWORD);
dipdw.diph.dwHeaderSize = sizeof (DIPROPHEADER);
dipdw.diph.dwObj = 0;
dipdw.diph.dwHow = DIPH_DEVICE;
dipdw.dwData = 40;
if (SUCCEEDED (hr = IDirectInputDevice_SetDataFormat (g_lpdidKeybd, &c_dfDIKeyboard)) &&
SUCCEEDED (hr = IDirectInputDevice_SetCooperativeLevel (g_lpdidKeybd, g_hWnd, DISCL_NONEXCLUSIVE | DISCL_FOREGROUND)) &&
SUCCEEDED (hr = IDirectInputDevice_SetProperty (g_lpdidKeybd, DIPROP_BUFFERSIZE, &dipdw.diph)) &&
SUCCEEDED (hr = IDirectInputDevice_Acquire (g_lpdidKeybd)))
{
// fine
WMKey_Handler_Ready = 1;
// Clear the keyboard array
KeyFlush();
atexit(key_close);
}
else
{
IDirectInputDevice_Release (g_lpdidKeybd);
g_lpdidKeybd = NULL;
}
}
}
}
/* mouse_dinput_acquire: [window thread]
* Acquires the mouse device.
*/
int mouse_dinput_acquire(void)
{
HRESULT hr;
if (mouse_dinput_device) {
_mouse_b = 0;
hr = IDirectInputDevice_Acquire(mouse_dinput_device);
if (FAILED(hr)) {
_TRACE(PREFIX_E "acquire mouse failed: %s\n", dinput_err_str(hr));
return -1;
}
/* The cursor may not be in the client area
* so we don't set _mouse_on here.
*/
return 0;
}
else {
return -1;
}
}
static BOOL CALLBACK EnumJoysticks(const DIDEVICEINSTANCEA *lpddi, void *pvRef)
{
HRESULT hr;
UserData * data = pvRef;
IDirectInputDeviceA *pJoystick;
DIDATAFORMAT format;
DIDEVCAPS caps;
DIJOYSTATE2 js;
JoystickInfo info;
int i, count;
ULONG ref;
DIDEVICEINSTANCEA inst;
DIDEVICEINSTANCE_DX3A inst3;
DIPROPDWORD dipw;
DIPROPSTRING dps;
DIPROPGUIDANDPATH dpg;
WCHAR nameBuffer[MAX_PATH];
HWND hWnd = get_hwnd();
char oldstate[248], curstate[248];
ok(data->version > 0x0300, "Joysticks not supported in version 0x%04x\n", data->version);
hr = IDirectInput_CreateDevice(data->pDI, &lpddi->guidInstance, NULL, NULL);
ok(hr==E_POINTER,"IDirectInput_CreateDevice() should have returned "
"E_POINTER, returned: %08x\n", hr);
hr = IDirectInput_CreateDevice(data->pDI, NULL, &pJoystick, NULL);
ok(hr==E_POINTER,"IDirectInput_CreateDevice() should have returned "
"E_POINTER, returned: %08x\n", hr);
hr = IDirectInput_CreateDevice(data->pDI, NULL, NULL, NULL);
ok(hr==E_POINTER,"IDirectInput_CreateDevice() should have returned "
"E_POINTER, returned: %08x\n", hr);
hr = IDirectInput_CreateDevice(data->pDI, &lpddi->guidInstance,
&pJoystick, NULL);
ok(hr==DI_OK,"IDirectInput_CreateDevice() failed: %08x\n", hr);
if (hr!=DI_OK)
goto DONE;
trace("---- %s ----\n", lpddi->tszProductName);
/* Test for joystick ID property */
ZeroMemory(&dipw, sizeof(dipw));
dipw.diph.dwSize = sizeof(DIPROPDWORD);
dipw.diph.dwHeaderSize = sizeof(DIPROPHEADER);
dipw.diph.dwObj = 0;
dipw.diph.dwHow = DIPH_DEVICE;
hr = IDirectInputDevice_GetProperty(pJoystick, DIPROP_JOYSTICKID, &dipw.diph);
ok(SUCCEEDED(hr), "IDirectInputDevice_GetProperty() for DIPROP_JOYSTICKID failed\n");
/* Test for INSTANCENAME property */
memset(&dps, 0, sizeof(dps));
dps.diph.dwSize = sizeof(DIPROPSTRING);
dps.diph.dwHeaderSize = sizeof(DIPROPHEADER);
dps.diph.dwHow = DIPH_DEVICE;
hr = IDirectInputDevice_GetProperty(pJoystick, DIPROP_INSTANCENAME, &dps.diph);
ok(SUCCEEDED(hr), "IDirectInput_GetProperty() for DIPROP_INSTANCENAME failed: %08x\n", hr);
/* Test if instance name is the same as present in DIDEVICEINSTANCE */
MultiByteToWideChar(CP_ACP, 0, lpddi->tszInstanceName, -1, nameBuffer, MAX_PATH);
ok(!lstrcmpW(nameBuffer, dps.wsz), "DIPROP_INSTANCENAME returned is wrong. Expected: %s Got: %s\n",
wine_dbgstr_w(nameBuffer), wine_dbgstr_w(dps.wsz));
/* Test for GUIDPATH properties */
memset(&dpg, 0, sizeof(dpg));
dpg.diph.dwSize = sizeof(DIPROPGUIDANDPATH);
dpg.diph.dwHeaderSize = sizeof(DIPROPHEADER);
dpg.diph.dwHow = DIPH_DEVICE;
hr = IDirectInputDevice_GetProperty(pJoystick, DIPROP_GUIDANDPATH, &dpg.diph);
todo_wine ok(SUCCEEDED(hr), "IDirectInput_GetProperty() for DIPROP_GUIDANDPATH failed: %08x\n", hr);
hr = IDirectInputDevice_SetDataFormat(pJoystick, NULL);
ok(hr==E_POINTER,"IDirectInputDevice_SetDataFormat() should have returned "
"E_POINTER, returned: %08x\n", hr);
ZeroMemory(&format, sizeof(format));
hr = IDirectInputDevice_SetDataFormat(pJoystick, &format);
ok(hr==DIERR_INVALIDPARAM,"IDirectInputDevice_SetDataFormat() should have "
"returned DIERR_INVALIDPARAM, returned: %08x\n", hr);
/* try the default formats */
hr = IDirectInputDevice_SetDataFormat(pJoystick, &c_dfDIJoystick);
ok(hr==DI_OK,"IDirectInputDevice_SetDataFormat() failed: %08x\n", hr);
hr = IDirectInputDevice_SetDataFormat(pJoystick, &c_dfDIJoystick2);
ok(hr==DI_OK,"IDirectInputDevice_SetDataFormat() failed: %08x\n", hr);
/* try an alternate format */
hr = IDirectInputDevice_SetDataFormat(pJoystick, &c_dfDIJoystickTest);
ok(hr==DI_OK,"IDirectInputDevice_SetDataFormat() failed: %08x\n", hr);
hr = IDirectInputDevice_SetDataFormat(pJoystick, &c_dfDIJoystick2);
ok(hr==DI_OK,"IDirectInputDevice_SetDataFormat() failed: %08x\n", hr);
if (hr != DI_OK)
goto RELEASE;
for (i=0; i<16; i++)
{
hr = IDirectInputDevice_SetCooperativeLevel(pJoystick, NULL, i);
ok(hr == SetCoop_null_window[i], "SetCooperativeLevel(NULL, %d): %08x\n", i, hr);
}
for (i=0; i<16; i++)
{
hr = IDirectInputDevice_SetCooperativeLevel(pJoystick, hWnd, i);
ok(hr == SetCoop_real_window[i], "SetCooperativeLevel(hwnd, %d): %08x\n", i, hr);
}
hr = IDirectInputDevice_SetCooperativeLevel(pJoystick, hWnd,
DISCL_NONEXCLUSIVE | DISCL_BACKGROUND);
ok(hr==DI_OK,"IDirectInputDevice_SetCooperativeLevel() failed: %08x\n", hr);
/* get capabilities */
hr = IDirectInputDevice_GetCapabilities(pJoystick, NULL);
ok(hr==E_POINTER,"IDirectInputDevice_GetCapabilities() "
"should have returned E_POINTER, returned: %08x\n", hr);
ZeroMemory(&caps, sizeof(caps));
hr = IDirectInputDevice_GetCapabilities(pJoystick, &caps);
ok(hr==DIERR_INVALIDPARAM,"IDirectInputDevice_GetCapabilities() "
"should have returned DIERR_INVALIDPARAM, returned: %08x\n", hr);
caps.dwSize = sizeof(caps);
hr = IDirectInputDevice_GetCapabilities(pJoystick, &caps);
ok(hr==DI_OK,"IDirectInputDevice_GetCapabilities() failed: %08x\n", hr);
ZeroMemory(&info, sizeof(info));
info.pJoystick = pJoystick;
/* default min/max limits */
info.lMin = 0;
info.lMax = 0xffff;
/* enumerate objects */
hr = IDirectInputDevice_EnumObjects(pJoystick, EnumAxes, &info, DIDFT_ALL);
ok(hr==DI_OK,"IDirectInputDevice_EnumObjects() failed: %08x\n", hr);
ok(caps.dwAxes == info.axis, "Number of enumerated axes (%d) doesn't match capabilities (%d)\n", info.axis, caps.dwAxes);
ok(caps.dwButtons == info.button, "Number of enumerated buttons (%d) doesn't match capabilities (%d)\n", info.button, caps.dwButtons);
ok(caps.dwPOVs == info.pov, "Number of enumerated POVs (%d) doesn't match capabilities (%d)\n", info.pov, caps.dwPOVs);
/* Set format and check limits again */
hr = IDirectInputDevice_SetDataFormat(pJoystick, &c_dfDIJoystick2);
ok(hr==DI_OK,"IDirectInputDevice_SetDataFormat() failed: %08x\n", hr);
info.lMin = -2000;
info.lMax = +2000;
info.dZone= 123;
hr = IDirectInputDevice_EnumObjects(pJoystick, EnumAxes, &info, DIDFT_ALL);
ok(hr==DI_OK,"IDirectInputDevice_EnumObjects() failed: %08x\n", hr);
hr = IDirectInputDevice_GetDeviceInfo(pJoystick, 0);
ok(hr==E_POINTER, "IDirectInputDevice_GetDeviceInfo() "
"should have returned E_POINTER, returned: %08x\n", hr);
ZeroMemory(&inst, sizeof(inst));
ZeroMemory(&inst3, sizeof(inst3));
hr = IDirectInputDevice_GetDeviceInfo(pJoystick, &inst);
ok(hr==DIERR_INVALIDPARAM, "IDirectInputDevice_GetDeviceInfo() "
"should have returned DIERR_INVALIDPARAM, returned: %08x\n", hr);
inst.dwSize = sizeof(inst);
hr = IDirectInputDevice_GetDeviceInfo(pJoystick, &inst);
ok(hr==DI_OK,"IDirectInputDevice_GetDeviceInfo() failed: %08x\n", hr);
inst3.dwSize = sizeof(inst3);
hr = IDirectInputDevice_GetDeviceInfo(pJoystick, (DIDEVICEINSTANCEA*)&inst3);
ok(hr==DI_OK,"IDirectInputDevice_GetDeviceInfo() failed: %08x\n", hr);
hr = IDirectInputDevice_Unacquire(pJoystick);
ok(hr == S_FALSE, "IDirectInputDevice_Unacquire() should have returned S_FALSE, got: %08x\n", hr);
hr = IDirectInputDevice_Acquire(pJoystick);
ok(hr==DI_OK,"IDirectInputDevice_Acquire() failed: %08x\n", hr);
if (hr != DI_OK)
goto RELEASE;
hr = IDirectInputDevice_Acquire(pJoystick);
ok(hr == S_FALSE, "IDirectInputDevice_Acquire() should have returned S_FALSE, got: %08x\n", hr);
if (info.pov < 4)
{
hr = IDirectInputDevice_GetDeviceState(pJoystick, sizeof(DIJOYSTATE2), &js);
ok(hr == DI_OK, "IDirectInputDevice_GetDeviceState() failed: %08x\n", hr);
ok(js.rgdwPOV[3] == -1, "Default for unassigned POV should be -1 not: %d\n", js.rgdwPOV[3]);
}
if (caps.dwFlags & DIDC_FORCEFEEDBACK)
{
DWORD axes[2] = {DIJOFS_X, DIJOFS_Y};
LONG direction[2] = {0, 0};
DICONSTANTFORCE force = {0};
DIEFFECT eff;
LPDIRECTINPUTEFFECT effect = NULL;
LONG cnt1, cnt2;
HWND real_hWnd;
HINSTANCE hInstance = GetModuleHandleW(NULL);
DIPROPDWORD dip_gain_set, dip_gain_get;
trace("Testing force-feedback\n");
memset(&eff, 0, sizeof(eff));
eff.dwSize = sizeof(eff);
eff.dwFlags = DIEFF_CARTESIAN | DIEFF_OBJECTOFFSETS;
eff.dwDuration = INFINITE;
eff.dwGain = DI_FFNOMINALMAX;
eff.dwTriggerButton = DIEB_NOTRIGGER;
eff.cAxes = sizeof(axes) / sizeof(axes[0]);
eff.rgdwAxes = axes;
eff.rglDirection = direction;
eff.cbTypeSpecificParams = sizeof(force);
eff.lpvTypeSpecificParams = &force;
/* Sending effects to joystick requires
* calling IDirectInputEffect_Initialize, which requires
* having exclusive access to the device, which requires
* - not having acquired the joystick when calling
* IDirectInputDevice_SetCooperativeLevel
* - a visible window
*/
real_hWnd = CreateWindowExA(0, "EDIT", "Test text", 0, 10, 10, 300, 300, NULL, NULL,
hInstance, NULL);
ok(real_hWnd!=0,"CreateWindowExA failed: %p\n", real_hWnd);
ShowWindow(real_hWnd, SW_SHOW);
hr = IDirectInputDevice_Unacquire(pJoystick);
ok(hr==DI_OK,"IDirectInputDevice_Unacquire() failed: %08x\n", hr);
hr = IDirectInputDevice_SetCooperativeLevel(pJoystick, real_hWnd,
DISCL_EXCLUSIVE | DISCL_FOREGROUND);
ok(hr==DI_OK,"IDirectInputDevice_SetCooperativeLevel() failed: %08x\n", hr);
hr = IDirectInputDevice_Acquire(pJoystick);
ok(hr==DI_OK,"IDirectInputDevice_Acquire() failed: %08x\n", hr);
cnt1 = get_refcount((IUnknown*)pJoystick);
hr = IDirectInputDevice2_CreateEffect((IDirectInputDevice2A*)pJoystick, &GUID_ConstantForce,
&eff, &effect, NULL);
ok(hr == DI_OK, "IDirectInputDevice_CreateEffect() failed: %08x\n", hr);
cnt2 = get_refcount((IUnknown*)pJoystick);
ok(cnt1 == cnt2, "Ref count is wrong %d != %d\n", cnt1, cnt2);
if (effect)
{
DWORD effect_status;
struct DIPROPDWORD diprop_word;
GUID guid = {0};
hr = IDirectInputEffect_Initialize(effect, hInstance, data->version,
&GUID_ConstantForce);
ok(hr==DI_OK,"IDirectInputEffect_Initialize failed: %08x\n", hr);
hr = IDirectInputEffect_SetParameters(effect, &eff, DIEP_AXES | DIEP_DIRECTION |
DIEP_TYPESPECIFICPARAMS);
ok(hr==DI_OK,"IDirectInputEffect_SetParameters failed: %08x\n", hr);
if (hr==DI_OK) {
/* Test that upload, unacquire, acquire still permits updating
* uploaded effect. */
hr = IDirectInputDevice_Unacquire(pJoystick);
ok(hr==DI_OK,"IDirectInputDevice_Unacquire() failed: %08x\n", hr);
hr = IDirectInputDevice_Acquire(pJoystick);
ok(hr==DI_OK,"IDirectInputDevice_Acquire() failed: %08x\n", hr);
hr = IDirectInputEffect_SetParameters(effect, &eff, DIEP_GAIN);
ok(hr==DI_OK,"IDirectInputEffect_SetParameters failed: %08x\n", hr);
}
/* Check effect status.
* State: initially stopped
* start
* State: started
* unacquire, acquire, download
* State: stopped
* start
* State: started
*
* Shows that:
* - effects are stopped after Unacquire + Acquire
* - effects are preserved (Download + Start doesn't complain
* about incomplete effect)
*/
hr = IDirectInputEffect_GetEffectStatus(effect, &effect_status);
ok(hr==DI_OK,"IDirectInputEffect_GetEffectStatus() failed: %08x\n", hr);
ok(effect_status==0,"IDirectInputEffect_GetEffectStatus() reported effect as started\n");
hr = IDirectInputEffect_SetParameters(effect, &eff, DIEP_START);
ok(hr==DI_OK,"IDirectInputEffect_SetParameters failed: %08x\n", hr);
hr = IDirectInputEffect_GetEffectStatus(effect, &effect_status);
ok(hr==DI_OK,"IDirectInputEffect_GetEffectStatus() failed: %08x\n", hr);
todo_wine ok(effect_status!=0,"IDirectInputEffect_GetEffectStatus() reported effect as stopped\n");
hr = IDirectInputDevice_Unacquire(pJoystick);
ok(hr==DI_OK,"IDirectInputDevice_Unacquire() failed: %08x\n", hr);
hr = IDirectInputDevice_Acquire(pJoystick);
ok(hr==DI_OK,"IDirectInputDevice_Acquire() failed: %08x\n", hr);
hr = IDirectInputEffect_Download(effect);
ok(hr==DI_OK,"IDirectInputEffect_Download() failed: %08x\n", hr);
hr = IDirectInputEffect_GetEffectStatus(effect, &effect_status);
ok(hr==DI_OK,"IDirectInputEffect_GetEffectStatus() failed: %08x\n", hr);
ok(effect_status==0,"IDirectInputEffect_GetEffectStatus() reported effect as started\n");
hr = IDirectInputEffect_Start(effect, 1, 0);
ok(hr==DI_OK,"IDirectInputEffect_Start() failed: %08x\n", hr);
hr = IDirectInputEffect_GetEffectStatus(effect, &effect_status);
ok(hr==DI_OK,"IDirectInputEffect_GetEffectStatus() failed: %08x\n", hr);
todo_wine ok(effect_status!=0,"IDirectInputEffect_GetEffectStatus() reported effect as stopped\n");
hr = IDirectInputEffect_GetEffectGuid(effect, &guid);
ok(hr==DI_OK,"IDirectInputEffect_GetEffectGuid() failed: %08x\n", hr);
ok(IsEqualGUID(&GUID_ConstantForce, &guid), "Wrong guid returned\n");
/* Check autocenter status
* State: initially stopped
* enable
* State: enabled
* acquire
* State: enabled
* unacquire
* State: enabled
*
* IDirectInputDevice2_SetProperty(DIPROP_AUTOCENTER) can only be
* executed when the device is released.
*
* If Executed interactively, user can feel that autocenter is
* only disabled when the joystick is acquired.
*/
diprop_word.diph.dwSize = sizeof(diprop_word);
diprop_word.diph.dwHeaderSize = sizeof(diprop_word.diph);
diprop_word.diph.dwObj = 0;
diprop_word.diph.dwHow = DIPH_DEVICE;
hr = IDirectInputDevice_Unacquire(pJoystick);
ok(hr==DI_OK,"IDirectInputDevice_Unacquire() failed: %08x\n", hr);
hr = IDirectInputDevice2_GetProperty(pJoystick, DIPROP_AUTOCENTER, &diprop_word.diph);
ok(hr==DI_OK,"IDirectInputDevice2_GetProperty() failed: %08x\n", hr);
ok(diprop_word.dwData==DIPROPAUTOCENTER_ON,"IDirectInputDevice2_GetProperty() reported autocenter as disabled\n");
diprop_word.dwData = DIPROPAUTOCENTER_OFF;
hr = IDirectInputDevice2_SetProperty(pJoystick, DIPROP_AUTOCENTER, &diprop_word.diph);
ok(hr==DI_OK,"IDirectInputDevice2_SetProperty() failed: %08x\n", hr);
hr = IDirectInputDevice2_GetProperty(pJoystick, DIPROP_AUTOCENTER, &diprop_word.diph);
ok(hr==DI_OK,"IDirectInputDevice2_GetProperty() failed: %08x\n", hr);
ok(diprop_word.dwData==DIPROPAUTOCENTER_OFF,"IDirectInputDevice2_GetProperty() reported autocenter as enabled\n");
if (winetest_interactive) {
trace("Acquiring in 2s, autocenter will be disabled.\n");
Sleep(2000);
}
hr = IDirectInputDevice_Acquire(pJoystick);
ok(hr==DI_OK,"IDirectInputDevice_Acquire() failed: %08x\n", hr);
if (winetest_interactive)
trace("Acquired.\n");
hr = IDirectInputDevice2_GetProperty(pJoystick, DIPROP_AUTOCENTER, &diprop_word.diph);
ok(hr==DI_OK,"IDirectInputDevice2_GetProperty() failed: %08x\n", hr);
ok(diprop_word.dwData==DIPROPAUTOCENTER_OFF,"IDirectInputDevice2_GetProperty() reported autocenter as enabled\n");
if (winetest_interactive) {
trace("Releasing in 2s, autocenter will be re-enabled.\n");
Sleep(2000);
}
hr = IDirectInputDevice_Unacquire(pJoystick);
ok(hr==DI_OK,"IDirectInputDevice_Unacquire() failed: %08x\n", hr);
if (winetest_interactive)
trace("Released\n");
hr = IDirectInputDevice2_GetProperty(pJoystick, DIPROP_AUTOCENTER, &diprop_word.diph);
ok(hr==DI_OK,"IDirectInputDevice2_GetProperty() failed: %08x\n", hr);
ok(diprop_word.dwData==DIPROPAUTOCENTER_OFF,"IDirectInputDevice2_GetProperty() reported autocenter as enabled\n");
hr = IDirectInputDevice_Acquire(pJoystick);
ok(hr==DI_OK,"IDirectInputDevice_Acquire() failed: %08x\n", hr);
hr = IDirectInputDevice2_GetProperty(pJoystick, DIPROP_AUTOCENTER, &diprop_word.diph);
ok(hr==DI_OK,"IDirectInputDevice2_GetProperty() failed: %08x\n", hr);
/* Device gain (DIPROP_FFGAIN).
* From MSDN:
* 0..10000 range, otherwise DIERR_INVALIDPARAM.
* Can be changed even if device is acquired.
* Difference found by tests:
* <0 is refused, >10000 is accepted
*/
dip_gain_set.diph.dwSize = sizeof(DIPROPDWORD);
dip_gain_set.diph.dwHeaderSize = sizeof(DIPROPHEADER);
dip_gain_set.diph.dwObj = 0;
dip_gain_set.diph.dwHow = DIPH_DEVICE;
dip_gain_set.dwData = 10000;
dip_gain_get.diph.dwSize = sizeof(DIPROPDWORD);
dip_gain_get.diph.dwHeaderSize = sizeof(DIPROPHEADER);
dip_gain_get.diph.dwObj = 0;
dip_gain_get.diph.dwHow = DIPH_DEVICE;
dip_gain_get.dwData = 0;
/* Test device is acquisition (non)impact. */
hr = IDirectInputDevice_Unacquire(pJoystick);
ok(hr == DI_OK, "IDirectInputDevice_Unacquire() should have returned S_FALSE, got: %08x\n", hr);
dip_gain_set.dwData = 1;
hr = IDirectInputDevice_SetProperty(pJoystick, DIPROP_FFGAIN, &dip_gain_set.diph);
ok(hr==DI_OK, "IDirectInputDevice_SetProperty() failed: %08x\n", hr);
hr = IDirectInputDevice_GetProperty(pJoystick, DIPROP_FFGAIN, &dip_gain_get.diph);
ok(hr==DI_OK, "IDirectInputDevice_GetProperty() failed: %08x\n", hr);
ok(dip_gain_get.dwData==dip_gain_set.dwData, "Gain not updated: %i\n", dip_gain_get.dwData);
hr = IDirectInputDevice_Acquire(pJoystick);
ok(hr==DI_OK,"IDirectInputDevice_Acquire() failed: %08x\n", hr);
dip_gain_set.dwData = 2;
hr = IDirectInputDevice_SetProperty(pJoystick, DIPROP_FFGAIN, &dip_gain_set.diph);
ok(hr==DI_OK, "IDirectInputDevice_SetProperty() failed: %08x\n", hr);
hr = IDirectInputDevice_GetProperty(pJoystick, DIPROP_FFGAIN, &dip_gain_get.diph);
ok(hr==DI_OK, "IDirectInputDevice_GetProperty() failed: %08x\n", hr);
ok(dip_gain_get.dwData==dip_gain_set.dwData, "Gain not updated: %i\n", dip_gain_get.dwData);
/* Test range and internal clamping. */
dip_gain_set.dwData = -1;
hr = IDirectInputDevice_SetProperty(pJoystick, DIPROP_FFGAIN, &dip_gain_set.diph);
todo_wine ok(hr==DIERR_INVALIDPARAM, "IDirectInputDevice_SetProperty() should have returned %08x: %08x\n", DIERR_INVALIDPARAM, hr);
dip_gain_set.dwData = 0;
hr = IDirectInputDevice_SetProperty(pJoystick, DIPROP_FFGAIN, &dip_gain_set.diph);
ok(hr==DI_OK, "IDirectInputDevice_SetProperty() failed: %08x\n", hr);
hr = IDirectInputDevice_GetProperty(pJoystick, DIPROP_FFGAIN, &dip_gain_get.diph);
ok(hr==DI_OK, "IDirectInputDevice_GetProperty() failed: %08x\n", hr);
ok(dip_gain_get.dwData==dip_gain_set.dwData, "Gain not updated: %i\n", dip_gain_get.dwData);
dip_gain_set.dwData = 10000;
hr = IDirectInputDevice_SetProperty(pJoystick, DIPROP_FFGAIN, &dip_gain_set.diph);
ok(hr==DI_OK, "IDirectInputDevice_SetProperty() failed: %08x\n", hr);
hr = IDirectInputDevice_GetProperty(pJoystick, DIPROP_FFGAIN, &dip_gain_get.diph);
ok(hr==DI_OK, "IDirectInputDevice_GetProperty() failed: %08x\n", hr);
ok(dip_gain_get.dwData==dip_gain_set.dwData, "Gain not updated: %i\n", dip_gain_get.dwData);
/* WARNING: This call succeeds, on the contrary of what is stated on MSDN. */
dip_gain_set.dwData = 10001;
hr = IDirectInputDevice_SetProperty(pJoystick, DIPROP_FFGAIN, &dip_gain_set.diph);
ok(hr==DI_OK, "IDirectInputDevice_SetProperty() failed: %08x\n", hr);
hr = IDirectInputDevice_GetProperty(pJoystick, DIPROP_FFGAIN, &dip_gain_get.diph);
ok(hr==DI_OK, "IDirectInputDevice_GetProperty() failed: %08x\n", hr);
ok(dip_gain_get.dwData==dip_gain_set.dwData, "Gain not updated: %i\n", dip_gain_get.dwData);
ref = IUnknown_Release(effect);
ok(ref == 0, "IDirectInputDevice_Release() reference count = %d\n", ref);
}
cnt1 = get_refcount((IUnknown*)pJoystick);
ok(cnt1 == cnt2, "Ref count is wrong %d != %d\n", cnt1, cnt2);
/* Before destroying the window, release joystick to revert to
* non-exclusive, background cooperative level. */
hr = IDirectInputDevice_Unacquire(pJoystick);
ok(hr==DI_OK,"IDirectInputDevice_Unacquire() failed: %08x\n", hr);
hr = IDirectInputDevice_SetCooperativeLevel(pJoystick, hWnd,
DISCL_NONEXCLUSIVE | DISCL_BACKGROUND);
ok(hr==DI_OK,"IDirectInputDevice_SetCooperativeLevel() failed: %08x\n", hr);
DestroyWindow (real_hWnd);
hr = IDirectInputDevice_Acquire(pJoystick);
ok(hr==DI_OK,"IDirectInputDevice_Acquire() failed: %08x\n", hr);
}
if (winetest_interactive) {
trace("You have 30 seconds to test all axes, sliders, POVs and buttons\n");
count = 300;
} else
count = 1;
trace("\n");
oldstate[0]='\0';
for (i = 0; i < count; i++) {
hr = IDirectInputDevice_GetDeviceState(pJoystick, sizeof(DIJOYSTATE2), &js);
ok(hr==DI_OK,"IDirectInputDevice_GetDeviceState() failed: %08x\n", hr);
if (hr != DI_OK)
break;
sprintf(curstate, "X%5d Y%5d Z%5d Rx%5d Ry%5d Rz%5d "
"S0%5d S1%5d POV0%5d POV1%5d POV2%5d POV3%5d "
"B %d %d %d %d %d %d %d %d %d %d %d %d\n",
js.lX, js.lY, js.lZ, js.lRx, js.lRy, js.lRz,
js.rglSlider[0], js.rglSlider[1],
js.rgdwPOV[0], js.rgdwPOV[1], js.rgdwPOV[2], js.rgdwPOV[3],
js.rgbButtons[0]>>7, js.rgbButtons[1]>>7, js.rgbButtons[2]>>7,
js.rgbButtons[3]>>7, js.rgbButtons[4]>>7, js.rgbButtons[5]>>7,
js.rgbButtons[6]>>7, js.rgbButtons[7]>>7, js.rgbButtons[8]>>7,
js.rgbButtons[9]>>7, js.rgbButtons[10]>>7, js.rgbButtons[11]>>7);
if (strcmp(oldstate, curstate) != 0)
{
trace("%s\n", curstate);
strcpy(oldstate, curstate);
}
Sleep(100);
}
trace("\n");
hr = IDirectInputDevice_Unacquire(pJoystick);
ok(hr==DI_OK,"IDirectInputDevice_Unacquire() failed: %08x\n", hr);
RELEASE:
ref = IDirectInputDevice_Release(pJoystick);
ok(ref==0,"IDirectInputDevice_Release() reference count = %d\n", ref);
DONE:
return DIENUM_CONTINUE;
}
void IN_MouseMove (usercmd_t *cmd)
{
int mx, my;
HDC hdc;
int i;
DIDEVICEOBJECTDATA od;
DWORD dwElements;
HRESULT hr;
if (!mouseactive)
return;
if (dinput)
{
mx = 0;
my = 0;
for (;;)
{
dwElements = 1;
hr = IDirectInputDevice_GetDeviceData(g_pMouse,
sizeof(DIDEVICEOBJECTDATA), &od, &dwElements, 0);
if ((hr == DIERR_INPUTLOST) || (hr == DIERR_NOTACQUIRED))
{
dinput_acquired = true;
IDirectInputDevice_Acquire(g_pMouse);
break;
}
/* Unable to read data or no data available */
if (FAILED(hr) || dwElements == 0)
{
break;
}
/* Look at the element to see what happened */
switch (od.dwOfs)
{
case DIMOFS_X:
mx += od.dwData;
break;
case DIMOFS_Y:
my += od.dwData;
break;
case DIMOFS_BUTTON0:
if (od.dwData & 0x80)
mstate_di |= 1;
else
mstate_di &= ~1;
break;
case DIMOFS_BUTTON1:
if (od.dwData & 0x80)
mstate_di |= (1<<1);
else
mstate_di &= ~(1<<1);
break;
case DIMOFS_BUTTON2:
if (od.dwData & 0x80)
mstate_di |= (1<<2);
else
mstate_di &= ~(1<<2);
break;
}
}
// perform button actions
for (i=0 ; i<mouse_buttons ; i++)
{
if ( (mstate_di & (1<<i)) &&
!(mouse_oldbuttonstate & (1<<i)) )
{
Key_Event (K_MOUSE1 + i, true);
}
if ( !(mstate_di & (1<<i)) &&
(mouse_oldbuttonstate & (1<<i)) )
{
Key_Event (K_MOUSE1 + i, false);
}
}
mouse_oldbuttonstate = mstate_di;
}
else
{
GetCursorPos (¤t_pos);
mx = current_pos.x - window_center_x + mx_accum;
my = current_pos.y - window_center_y + my_accum;
mx_accum = 0;
my_accum = 0;
}
//if (mx || my)
// Con_DPrintf("mx=%d, my=%d\n", mx, my);
if (m_filter.value)
{
mouse_x = (mx + old_mouse_x) * 0.5;
mouse_y = (my + old_mouse_y) * 0.5;
}
else
{
mouse_x = mx;
mouse_y = my;
}
old_mouse_x = mx;
old_mouse_y = my;
mouse_x *= sensitivity.value;
mouse_y *= sensitivity.value;
// add mouse X/Y movement to cmd
if ( (in_strafe.state & 1) || (lookstrafe.value && (in_mlook.state & 1) ))
cmd->sidemove += m_side.value * mouse_x;
else
cl.viewangles[YAW] -= m_yaw.value * mouse_x;
if (in_mlook.state & 1)
V_StopPitchDrift ();
if ( (in_mlook.state & 1) && !(in_strafe.state & 1))
{
cl.viewangles[PITCH] += m_pitch.value * mouse_y;
if (cl.viewangles[PITCH] > 80)
cl.viewangles[PITCH] = 80;
if (cl.viewangles[PITCH] < -70)
cl.viewangles[PITCH] = -70;
}
else
{
if ((in_strafe.state & 1) && noclip_anglehack)
cmd->upmove -= m_forward.value * mouse_y;
else
cmd->forwardmove -= m_forward.value * mouse_y;
}
// if the mouse has moved, force it to the center, so there's room to move
if (mx || my)
{
SetCursorPos (window_center_x, window_center_y);
}
}
static void acquire_tests(IDirectInputA *pDI, HWND hwnd)
{
HRESULT hr;
IDirectInputDeviceA *pKeyboard;
BYTE kbd_state[256];
LONG custom_state[6];
int i;
DIOBJECTDATAFORMAT dodf[] =
{
{ &GUID_Key, sizeof(LONG) * 0, DIDFT_MAKEINSTANCE(DIK_Q)|DIDFT_BUTTON, 0 },
{ &GUID_Key, sizeof(LONG) * 1, DIDFT_MAKEINSTANCE(DIK_W)|DIDFT_BUTTON, 0 },
{ &GUID_Key, sizeof(LONG) * 2, DIDFT_MAKEINSTANCE(DIK_E)|DIDFT_BUTTON, 0 },
{ &GUID_Key, sizeof(LONG) * 4, DIDFT_MAKEINSTANCE(DIK_R)|DIDFT_BUTTON, 0 },
};
DIDATAFORMAT df;
df.dwSize = sizeof( df );
df.dwObjSize = sizeof( DIOBJECTDATAFORMAT );
df.dwFlags = DIDF_RELAXIS;
df.dwDataSize = sizeof( custom_state );
df.dwNumObjs = sizeof( dodf )/sizeof( dodf[0] );
df.rgodf = dodf;
hr = IDirectInput_CreateDevice(pDI, &GUID_SysKeyboard, &pKeyboard, NULL);
ok(SUCCEEDED(hr), "IDirectInput_CreateDevice() failed: %08x\n", hr);
if (FAILED(hr)) return;
hr = IDirectInputDevice_SetDataFormat(pKeyboard, &c_dfDIKeyboard);
ok(SUCCEEDED(hr), "IDirectInputDevice_SetDataFormat() failed: %08x\n", hr);
hr = IDirectInputDevice_SetCooperativeLevel(pKeyboard, NULL, DISCL_NONEXCLUSIVE | DISCL_BACKGROUND);
ok(SUCCEEDED(hr), "IDirectInputDevice_SetCooperativeLevel() failed: %08x\n", hr);
hr = IDirectInputDevice_GetDeviceState(pKeyboard, 10, kbd_state);
ok(hr == DIERR_NOTACQUIRED, "IDirectInputDevice_GetDeviceState(10,) should have failed: %08x\n", hr);
hr = IDirectInputDevice_GetDeviceState(pKeyboard, sizeof(kbd_state), kbd_state);
ok(hr == DIERR_NOTACQUIRED, "IDirectInputDevice_GetDeviceState() should have failed: %08x\n", hr);
hr = IDirectInputDevice_Unacquire(pKeyboard);
ok(hr == S_FALSE, "IDirectInputDevice_Unacquire() should have failed: %08x\n", hr);
hr = IDirectInputDevice_Acquire(pKeyboard);
ok(SUCCEEDED(hr), "IDirectInputDevice_Acquire() failed: %08x\n", hr);
hr = IDirectInputDevice_Acquire(pKeyboard);
ok(hr == S_FALSE, "IDirectInputDevice_Acquire() should have failed: %08x\n", hr);
hr = IDirectInputDevice_GetDeviceState(pKeyboard, 10, kbd_state);
ok(hr == DIERR_INVALIDPARAM, "IDirectInputDevice_GetDeviceState(10,) should have failed: %08x\n", hr);
hr = IDirectInputDevice_GetDeviceState(pKeyboard, sizeof(kbd_state), kbd_state);
ok(SUCCEEDED(hr), "IDirectInputDevice_GetDeviceState() failed: %08x\n", hr);
hr = IDirectInputDevice_Unacquire(pKeyboard);
ok(SUCCEEDED(hr), "IDirectInputDevice_Uncquire() failed: %08x\n", hr);
hr = IDirectInputDevice_SetDataFormat( pKeyboard , &df );
ok(SUCCEEDED(hr), "IDirectInputDevice_SetDataFormat() failed: %08x\n", hr);
hr = IDirectInputDevice_Acquire(pKeyboard);
ok(SUCCEEDED(hr), "IDirectInputDevice_Acquire() failed: %08x\n", hr);
hr = IDirectInputDevice_GetDeviceState(pKeyboard, sizeof(custom_state), custom_state);
ok(SUCCEEDED(hr), "IDirectInputDevice_GetDeviceState(4,) failed: %08x\n", hr);
hr = IDirectInputDevice_GetDeviceState(pKeyboard, sizeof(kbd_state), kbd_state);
ok(hr == DIERR_INVALIDPARAM, "IDirectInputDevice_GetDeviceState(256,) should have failed: %08x\n", hr);
memset(custom_state, 0x56, sizeof(custom_state));
IDirectInputDevice_GetDeviceState(pKeyboard, sizeof(custom_state), custom_state);
for (i = 0; i < sizeof(custom_state) / sizeof(custom_state[0]); i++)
ok(custom_state[i] == 0, "Should be zeroed, got 0x%08x\n", custom_state[i]);
/* simulate some keyboard input */
SetFocus(hwnd);
keybd_event('Q', 0, 0, 0);
hr = IDirectInputDevice_GetDeviceState(pKeyboard, sizeof(custom_state), custom_state);
ok(SUCCEEDED(hr), "IDirectInputDevice_GetDeviceState() failed: %08x\n", hr);
if (!custom_state[0])
win_skip("Keyboard event not processed, skipping test\n");
else
{
/* unacquiring should reset the device state */
hr = IDirectInputDevice_Unacquire(pKeyboard);
ok(SUCCEEDED(hr), "IDirectInputDevice_Unacquire() failed: %08x\n", hr);
hr = IDirectInputDevice_Acquire(pKeyboard);
ok(SUCCEEDED(hr), "IDirectInputDevice_Acquire() failed: %08x\n", hr);
hr = IDirectInputDevice_GetDeviceState(pKeyboard, sizeof(custom_state), custom_state);
ok(SUCCEEDED(hr), "IDirectInputDevice_GetDeviceState failed: %08x\n", hr);
for (i = 0; i < sizeof(custom_state) / sizeof(custom_state[0]); i++)
ok(custom_state[i] == 0, "Should be zeroed, got 0x%08x\n", custom_state[i]);
}
keybd_event('Q', 0, KEYEVENTF_KEYUP, 0);
if (pKeyboard) IUnknown_Release(pKeyboard);
}
void IN_ActivateMouse (void)
{
mouseactivatetoggle = true;
if (mouseinitialized)
{
#if DIRECTINPUT_VERSION >= 0x0700
if (dinput)
{
if (g_pMouse)
{
if (!dinput_acquired)
{
HRESULT hr;
// we may fail to reacquire if the window has been recreated
hr = IDirectInputDevice_Acquire(g_pMouse);
if (FAILED(hr))
{
if ( !IN_InitDInput() )
{
Com_Printf ("WARNING: can't reinitializing dinput mouse...\n");
Com_Printf ("Falling back to Win32 mouse support...\n");
Cvar_LatchedSetValue( &in_mouse, mt_normal );
Cbuf_AddText ("in_restart\n");
}
}
else
{
dinput_acquired = true;
}
}
}
else
{
return;
}
} else
#endif // DIRECTINPUT_VERSION >= 0x700
{
#ifdef USINGRAWINPUT
if (rawmicecount > 0)
{
if (IN_RawInput_Register()) {
Com_Printf("Raw input: unable to register raw input, deinitializing\n");
IN_RawInput_DeInit();
}
}
#endif // USINGRAWINPUT
if (mouseparmsvalid)
restore_spi = SystemParametersInfo (SPI_SETMOUSE, 0, newmouseparms, 0);
IN_CenterMouseToWindow();
SetCapture (mainwindow);
ClipCursor (&window_rect);
}
mouseactive = true;
}
}
void IN_SMouseRead (int *mx, int *my)
{
static int acc_x, acc_y;
int x = 0, y = 0;
double t1, t2, maxtime, mintime;
int mouserate;
// Acquire device
IDirectInputDevice_Acquire(g_pMouse);
dinput_acquired = true;
// Gather data from last read seq to now.
for ( ; m_history_x_rseq < m_history_x_wseq; m_history_x_rseq++)
{
x += m_history_x[m_history_x_rseq & M_HIST_MASK].data;
}
for ( ; m_history_y_rseq < m_history_y_wseq; m_history_y_rseq++)
{
y += m_history_y[m_history_y_rseq & M_HIST_MASK].data;
}
x -= acc_x;
y -= acc_y;
acc_x = acc_y = 0;
// Show rate if requested.
if (m_showrate.value && (mouserate = IN_GetMouseRate()))
Com_Printf("mouse rate: %4d\n", mouserate);
// Smoothing goes here.
mintime = maxtime = 1.0 / max(m_rate.value, 10);
maxtime *= 1.2;
mintime *= 0.7;
// X axis
t1 = m_history_x[(m_history_x_rseq - 2) & M_HIST_MASK].time;
t2 = m_history_x[(m_history_x_rseq - 1) & M_HIST_MASK].time;
if (t2 - t1 > mintime && t2 - t1 < maxtime)
{
double vel = m_history_x[(m_history_x_rseq - 1) & M_HIST_MASK].data / (t2 - t1);
t1 = t2;
t2 = Sys_DoubleTime();
if (t2 - t1 < maxtime)
acc_x = vel * (t2 - t1);
}
// Y axis
t1 = m_history_y[(m_history_y_rseq - 2) & M_HIST_MASK].time;
t2 = m_history_y[(m_history_y_rseq - 1) & M_HIST_MASK].time;
if (t2 - t1 > mintime && t2 - t1 < maxtime)
{
double vel = m_history_y[(m_history_y_rseq-1) & M_HIST_MASK].data / (t2 - t1);
t1 = t2;
t2 = Sys_DoubleTime();
if (t2 - t1 < maxtime)
acc_y = vel * (t2 - t1);
}
x += acc_x;
y += acc_y;
// return data
*mx = x;
*my = y;
// serve wheel
// bound(0, wheel_dn_count, 10);
// bound(0, wheel_up_count, 10);
while (wheel_dn_count > 0)
{
Key_Event(K_MWHEELDOWN, true);
Key_Event(K_MWHEELDOWN, false);
wheel_dn_count--;
}
while (wheel_up_count > 0)
{
Key_Event(K_MWHEELUP, true);
Key_Event(K_MWHEELUP, false);
wheel_up_count--;
}
}
void IN_MouseMove (usercmd_t *cmd)
{
static int old_mouse_x = 0, old_mouse_y = 0;
int mx, my;
#if DIRECTINPUT_VERSION >= 0x0700
int i, value;
DIDEVICEOBJECTDATA od;
DWORD dwElements;
HRESULT hr;
#endif // DIRECTINPUT_VERSION
if (!mouseactive)
return;
#if DIRECTINPUT_VERSION >= 0x0700
if (dinput)
{
mx = my = 0;
if (use_m_smooth)
{
IN_SMouseRead(&mx, &my);
}
else if (in_di_buffered.integer)
{
while (1)
{
dwElements = 1;
hr = IDirectInputDevice_GetDeviceData(g_pMouse, sizeof(DIDEVICEOBJECTDATA), &od, &dwElements, 0);
if ((hr == DIERR_INPUTLOST) || (hr == DIERR_NOTACQUIRED))
{
dinput_acquired = true;
IDirectInputDevice_Acquire(g_pMouse);
break;
}
if (hr == DI_BUFFEROVERFLOW)
SetBufferSize();
// Unable to read data or no data available.
if (FAILED(hr) || !dwElements)
break;
// Look at the element to see what happened.
switch (od.dwOfs)
{
case DIMOFS_X:
{
mx += od.dwData;
break;
}
case DIMOFS_Y:
{
my += od.dwData;
break;
}
INPUT_CASE_DINPUT_MOUSE_BUTTONS
case DIMOFS_Z:
{
if (in_mwheeltype != MWHEEL_WINDOWMSG)
{
in_mwheeltype = MWHEEL_DINPUT;
value = od.dwData;
if (value > 0)
{
Key_Event(K_MWHEELUP, true);
Key_Event(K_MWHEELUP, false);
}
else if (value < 0)
{
Key_Event(K_MWHEELDOWN, true);
Key_Event(K_MWHEELDOWN, false);
}
}
break;
}
}
}
}
else
{
// immediate (non-buffered)
MYDATA st;
hr = IDirectInputDevice_GetDeviceState(g_pMouse, sizeof(st), &st);
if ((hr == DIERR_INPUTLOST) || (hr == DIERR_NOTACQUIRED))
{
dinput_acquired = true;
IDirectInputDevice_Acquire(g_pMouse);
}
else if (hr == DI_OK)
{
mx += st.lX;
my += st.lY;
for (i = 0; i < mouse_buttons; i++)
{
LONG v = *((BYTE*) ((&st.bButtonA) + i));
if (v & 0x80)
{
mstate_di |= (1 << i);
}
else
{
mstate_di &= ~(1 << i);
}
}
if (in_mwheeltype != MWHEEL_WINDOWMSG)
{
in_mwheeltype = MWHEEL_DINPUT;
value = st.lZ;
if (value > 0)
{
Key_Event(K_MWHEELUP, true);
Key_Event(K_MWHEELUP, false);
}
else if (value < 0)
{
Key_Event(K_MWHEELDOWN, true);
Key_Event(K_MWHEELDOWN, false);
}
}
}
else
{
// hr != DI_OK
Com_Printf("DInput: GetDeviceState failed\n");
}
}
// perform button actions
for (i = 0; i < mouse_buttons; i++)
{
if ( (mstate_di & (1 << i)) && !(mouse_oldbuttonstate & (1 << i)) )
Key_Event (K_MOUSE1 + i, true);
if ( !(mstate_di & (1 << i)) && (mouse_oldbuttonstate & (1 << i)) )
Key_Event (K_MOUSE1 + i, false);
}
mouse_oldbuttonstate = mstate_di;
}
/*
* IN_ActivateMouse
*
* Called when the window gains focus or changes in some way
*/
static void IN_ActivateMouse( void ) {
int width, height;
if( !mouseinitialized ) {
return;
}
if( !in_mouse->integer ) {
mouseactive = false;
return;
}
if( mouseactive ) {
return;
}
mouseactive = true;
if( dinput_initialized ) {
mstate_di = 0;
if( g_pMouse ) {
if( cl_hwnd ) {
if( FAILED( IDirectInputDevice_SetCooperativeLevel( g_pMouse, cl_hwnd, DISCL_EXCLUSIVE | DISCL_FOREGROUND ) ) ) {
Com_DPrintf( "Couldn't set DI coop level\n" );
return;
}
}
if( !dinput_acquired ) {
IDirectInputDevice_Acquire( g_pMouse );
dinput_acquired = true;
}
}
return;
}
if( rawinput_initialized ) {
if( IN_RawInput_Register() ) {
Com_Printf( "Raw input: unable to register raw input, deinitializing\n" );
IN_RawInput_Shutdown();
}
}
mouse_oldbuttonstate = 0;
if( mouseparmsvalid ) {
restore_spi = SystemParametersInfo( SPI_SETMOUSE, 0, newmouseparms, 0 );
}
width = GetSystemMetrics( SM_CXSCREEN );
height = GetSystemMetrics( SM_CYSCREEN );
GetWindowRect( cl_hwnd, &window_rect );
if( window_rect.left < 0 ) {
window_rect.left = 0;
}
if( window_rect.top < 0 ) {
window_rect.top = 0;
}
if( window_rect.right >= width ) {
window_rect.right = width - 1;
}
if( window_rect.bottom >= height - 1 ) {
window_rect.bottom = height - 1;
}
window_center_x = ( window_rect.right + window_rect.left ) / 2;
window_center_y = ( window_rect.top + window_rect.bottom ) / 2;
SetCursorPos( window_center_x, window_center_y );
SetCapture( cl_hwnd );
ClipCursor( &window_rect );
while( ShowCursor( FALSE ) >= 0 ) ;
}
/*
* IN_GetMouseMovement
*/
void IN_GetMouseMovement( int *dx, int *dy ) {
DIDEVICEOBJECTDATA od;
DWORD dwElements;
HRESULT hr;
*dx = *dy = 0;
if( !mouseactive ) {
return;
}
if( rawinput_initialized ) {
// probably not the right way...
int i;
mx = my = 0;
for( i = 0; i < rawmicecount; i++ ) {
mx += rawmice[i].delta[0];
my += rawmice[i].delta[1];
rawmice[i].delta[0] = rawmice[i].delta[1] = 0;
}
} else if( dinput_initialized ) {
mx = 0;
my = 0;
for(;; ) {
dwElements = 1;
hr = IDirectInputDevice_GetDeviceData( g_pMouse,
sizeof( DIDEVICEOBJECTDATA ), &od, &dwElements, 0 );
if( ( hr == DIERR_INPUTLOST ) || ( hr == DIERR_NOTACQUIRED ) ) {
dinput_acquired = true;
IDirectInputDevice_Acquire( g_pMouse );
break;
}
// unable to read data or no data available
if( FAILED( hr ) || dwElements == 0 ) {
break;
}
sys_msg_time = od.dwTimeStamp;
// look at the element to see what happened
switch( od.dwOfs ) {
case DIMOFS_X:
mx += (int)od.dwData;
break;
case DIMOFS_Y:
my += (int)od.dwData;
break;
case DIMOFS_Z:
if( mouse_wheel_type != MWHEEL_WM ) {
mouse_wheel_type = MWHEEL_DINPUT;
if( (int)od.dwData > 0 ) {
Key_Event( K_MWHEELUP, true, sys_msg_time );
Key_Event( K_MWHEELUP, false, sys_msg_time );
} else {
Key_Event( K_MWHEELDOWN, true, sys_msg_time );
Key_Event( K_MWHEELDOWN, false, sys_msg_time );
}
}
break;
case DIMOFS_BUTTON0:
case DIMOFS_BUTTON1:
case DIMOFS_BUTTON2:
case DIMOFS_BUTTON3:
case DIMOFS_BUTTON0 + 4:
case DIMOFS_BUTTON0 + 5:
case DIMOFS_BUTTON0 + 6:
case DIMOFS_BUTTON0 + 7:
if( od.dwData & 0x80 ) {
mstate_di |= ( 1 << ( od.dwOfs - DIMOFS_BUTTON0 ) );
} else {
mstate_di &= ~( 1 << ( od.dwOfs - DIMOFS_BUTTON0 ) );
}
break;
}
}
dinput_initialized = false; // FIXME...
IN_MouseEvent( mstate_di );
dinput_initialized = true;
} else {
// find mouse movement
if( !GetCursorPos( ¤t_pos ) ) {
return;
}
mx = current_pos.x - window_center_x;
my = current_pos.y - window_center_y;
// force the mouse to the center, so there's room to move
if( mx || my ) {
SetCursorPos( window_center_x, window_center_y );
}
}
*dx = mx;
*dy = my;
}
static void test_acquire(IDirectInputA *pDI, HWND hwnd)
{
HRESULT hr;
IDirectInputDeviceA *pMouse = NULL;
DIMOUSESTATE m_state;
HWND hwnd2;
DIPROPDWORD di_op;
DIDEVICEOBJECTDATA mouse_state;
DWORD cnt;
int i;
if (! SetForegroundWindow(hwnd))
{
skip("Not running as foreground app, skipping acquire tests\n");
return;
}
hr = IDirectInput_CreateDevice(pDI, &GUID_SysMouse, &pMouse, NULL);
ok(SUCCEEDED(hr), "IDirectInput_CreateDevice() failed: %08x\n", hr);
if (FAILED(hr)) return;
hr = IDirectInputDevice_SetCooperativeLevel(pMouse, hwnd, DISCL_NONEXCLUSIVE | DISCL_FOREGROUND);
ok(hr == S_OK, "SetCooperativeLevel: %08x\n", hr);
memset(&di_op, 0, sizeof(di_op));
di_op.dwData = 5;
di_op.diph.dwHow = DIPH_DEVICE;
di_op.diph.dwSize = sizeof(DIPROPDWORD);
di_op.diph.dwHeaderSize = sizeof(DIPROPHEADER);
hr = IDirectInputDevice_SetProperty(pMouse, DIPROP_BUFFERSIZE, (LPCDIPROPHEADER)&di_op);
ok(hr == S_OK, "SetProperty() failed: %08x\n", hr);
hr = IDirectInputDevice_SetDataFormat(pMouse, &c_dfDIMouse);
ok(SUCCEEDED(hr), "IDirectInputDevice_SetDataFormat() failed: %08x\n", hr);
hr = IDirectInputDevice_Unacquire(pMouse);
ok(hr == S_FALSE, "IDirectInputDevice_Unacquire() should have failed: %08x\n", hr);
hr = IDirectInputDevice_Acquire(pMouse);
ok(SUCCEEDED(hr), "IDirectInputDevice_Acquire() failed: %08x\n", hr);
hr = IDirectInputDevice_Acquire(pMouse);
ok(hr == S_FALSE, "IDirectInputDevice_Acquire() should have failed: %08x\n", hr);
/* Foreground coop level requires window to have focus */
/* Create a temporary window, this should make dinput
* lose mouse input */
hwnd2 = CreateWindowA("static", "Temporary", WS_VISIBLE, 10, 210, 200, 200, NULL, NULL, NULL,
NULL);
ok(hwnd2 != NULL, "CreateWindowA failed with %u\n", GetLastError());
hr = IDirectInputDevice_GetDeviceState(pMouse, sizeof(m_state), &m_state);
ok(hr == DIERR_NOTACQUIRED, "GetDeviceState() should have failed: %08x\n", hr);
hr = IDirectInputDevice_Acquire(pMouse);
ok(hr == DIERR_OTHERAPPHASPRIO, "Acquire() should have failed: %08x\n", hr);
SetActiveWindow( hwnd );
hr = IDirectInputDevice_Acquire(pMouse);
ok(hr == S_OK, "Acquire() failed: %08x\n", hr);
mouse_event(MOUSEEVENTF_MOVE, 10, 10, 0, 0);
cnt = 1;
hr = IDirectInputDevice_GetDeviceData(pMouse, sizeof(mouse_state), &mouse_state, &cnt, 0);
ok(hr == S_OK && cnt > 0, "GetDeviceData() failed: %08x cnt:%d\n", hr, cnt);
mouse_event(MOUSEEVENTF_MOVE, 10, 10, 0, 0);
IDirectInputDevice_Unacquire(pMouse);
cnt = 1;
hr = IDirectInputDevice_GetDeviceData(pMouse, sizeof(mouse_state), &mouse_state, &cnt, 0);
ok(hr == S_OK && cnt > 0, "GetDeviceData() failed: %08x cnt:%d\n", hr, cnt);
IDirectInputDevice_Acquire(pMouse);
mouse_event(MOUSEEVENTF_MOVE, 10, 10, 0, 0);
IDirectInputDevice_Unacquire(pMouse);
IDirectInputDevice_Acquire(pMouse);
cnt = 1;
hr = IDirectInputDevice_GetDeviceData(pMouse, sizeof(mouse_state), &mouse_state, &cnt, 0);
ok(hr == S_OK && cnt > 0, "GetDeviceData() failed: %08x cnt:%d\n", hr, cnt);
/* Check for buffer owerflow */
for (i = 0; i < 6; i++)
mouse_event(MOUSEEVENTF_MOVE, 10 + i, 10 + i, 0, 0);
cnt = 1;
hr = IDirectInputDevice_GetDeviceData(pMouse, sizeof(mouse_state), &mouse_state, &cnt, 0);
ok(hr == DI_OK, "GetDeviceData() failed: %08x cnt:%d\n", hr, cnt);
cnt = 1;
hr = IDirectInputDevice_GetDeviceData(pMouse, sizeof(mouse_state), &mouse_state, &cnt, 0);
ok(hr == DI_OK && cnt == 1, "GetDeviceData() failed: %08x cnt:%d\n", hr, cnt);
if (pMouse) IUnknown_Release(pMouse);
DestroyWindow( hwnd2 );
}
/*
===========
IN_MouseMove
===========
*/
void IN_MouseMove(void)
{
int mx, my;
int i;
DIDEVICEOBJECTDATA od;
DWORD dwElements;
HRESULT hResult;
int shiftbytes;
if(directInput)
{
mx = 0;
my = 0;
for(;;)
{
dwElements = 1;
hResult = IDirectInputDevice_GetDeviceData(g_pMouse, sizeof(DIDEVICEOBJECTDATA), &od, &dwElements, 0);
if((hResult == DIERR_INPUTLOST) || (hResult == DIERR_NOTACQUIRED))
{
directInput_acquired = qtrue;
IDirectInputDevice_Acquire(g_pMouse);
break;
}
// Unable to read data or no data available
if(FAILED(hResult) || dwElements == 0)
{
break;
}
// Look at the element to see what happened
switch (od.dwOfs)
{
case DIMOFS_X:
mx += od.dwData;
break;
case DIMOFS_Y:
my += od.dwData;
break;
case DIMOFS_Z:
if((int)od.dwData > 0)
{
Sys_QueEvent(g_wv.sysMsgTime, SE_KEY, K_MWHEELUP, qtrue, 0, NULL);
Sys_QueEvent(g_wv.sysMsgTime, SE_KEY, K_MWHEELUP, qfalse, 0, NULL);
}
else
{
Sys_QueEvent(g_wv.sysMsgTime, SE_KEY, K_MWHEELDOWN, qtrue, 0, NULL);
Sys_QueEvent(g_wv.sysMsgTime, SE_KEY, K_MWHEELDOWN, qfalse, 0, NULL);
}
break;
case DIMOFS_BUTTON0:
case DIMOFS_BUTTON1:
case DIMOFS_BUTTON2:
case DIMOFS_BUTTON3:
case DIMOFS_BUTTON0 + 4:
case DIMOFS_BUTTON0 + 5:
case DIMOFS_BUTTON0 + 6:
case DIMOFS_BUTTON0 + 7:
shiftbytes = (od.dwOfs - DIMOFS_BUTTON0);
if(od.dwData & 0x80)
{
mstate_di |= (1 << (shiftbytes));
}
else
{
mstate_di &= ~(1 << (shiftbytes));
}
break;
}
}
// perform button actions
for(i = 0; i < MAX_MOUSE_BUTTONS; i++)
{
if((mstate_di & (1 << i)) && !(s_wmv.oldButtonState & (1 << i)))
{
Sys_QueEvent(g_wv.sysMsgTime, SE_KEY, K_MOUSE1 + i, qtrue, 0, NULL);
}
if(!(mstate_di & (1 << i)) && (s_wmv.oldButtonState & (1 << i)))
{
Sys_QueEvent(g_wv.sysMsgTime, SE_KEY, K_MOUSE1 + i, qfalse, 0, NULL);
}
}
s_wmv.oldButtonState = mstate_di;
}
else
{
IN_Win32Mouse(&mx, &my);
}
if(!mx && !my)
{
return;
}
Sys_QueEvent(0, SE_MOUSE, mx, my, 0, NULL);
}
/* key_dinput_acquire: [window thread]
* Acquires the keyboard device. This must be called after a
* window switch for example if the device is in foreground
* cooperative level.
*/
int key_dinput_acquire(void)
{
HRESULT hr;
int mask, state;
char key_state[256];
if (key_dinput_device) {
mask = KB_SCROLOCK_FLAG | KB_NUMLOCK_FLAG | KB_CAPSLOCK_FLAG;
state = 0;
/* Read the current Windows keyboard state */
GetKeyboardState(key_state);
if (key_state[VK_SCROLL] & 1)
state |= KB_SCROLOCK_FLAG;
if (key_state[VK_NUMLOCK] & 1)
state |= KB_NUMLOCK_FLAG;
if (key_state[VK_CAPITAL] & 1)
state |= KB_CAPSLOCK_FLAG;
_key_shifts = (_key_shifts & ~mask) | (state & mask);
hr = IDirectInputDevice_Acquire(key_dinput_device);
if (FAILED(hr)) {
_TRACE(PREFIX_E "acquire keyboard failed: %s\n", dinput_err_str(hr));
return -1;
}
/* Initialize keyboard state */
SetEvent(key_input_event);
return 0;
}
else
return -1;
}
