mirror of
git://source.winehq.org/git/wine.git
synced 2024-10-18 01:18:07 +00:00
e2b882aced
Added object properties for more than one object. Added error checks for acquired. Default to using c_dfDIJoystick2 data format. Try to use user supplied data formats (only works if same as one of the defaults). Code cleanup, error checking and tracing added. Added support for up to 8 axis.
874 lines
24 KiB
C
874 lines
24 KiB
C
/* DirectInput Device
|
|
*
|
|
* Copyright 1998 Marcus Meissner
|
|
* Copyright 1998,1999 Lionel Ulmer
|
|
*
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
|
|
/* This file contains all the Device specific functions that can be used as stubs
|
|
by real device implementations.
|
|
|
|
It also contains all the helper functions.
|
|
*/
|
|
#include "config.h"
|
|
|
|
#include <stdarg.h>
|
|
#include <string.h>
|
|
#include "wine/debug.h"
|
|
#include "wine/unicode.h"
|
|
#include "windef.h"
|
|
#include "winbase.h"
|
|
#include "winerror.h"
|
|
#include "dinput.h"
|
|
#include "device_private.h"
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(dinput);
|
|
|
|
/******************************************************************************
|
|
* Various debugging tools
|
|
*/
|
|
void _dump_cooperativelevel_DI(DWORD dwFlags) {
|
|
if (TRACE_ON(dinput)) {
|
|
int i;
|
|
static const struct {
|
|
DWORD mask;
|
|
const char *name;
|
|
} flags[] = {
|
|
#define FE(x) { x, #x}
|
|
FE(DISCL_BACKGROUND),
|
|
FE(DISCL_EXCLUSIVE),
|
|
FE(DISCL_FOREGROUND),
|
|
FE(DISCL_NONEXCLUSIVE)
|
|
#undef FE
|
|
};
|
|
for (i = 0; i < (sizeof(flags) / sizeof(flags[0])); i++)
|
|
if (flags[i].mask & dwFlags)
|
|
DPRINTF("%s ",flags[i].name);
|
|
DPRINTF("\n");
|
|
}
|
|
}
|
|
|
|
void _dump_EnumObjects_flags(DWORD dwFlags) {
|
|
if (TRACE_ON(dinput)) {
|
|
int i;
|
|
DWORD type, instance;
|
|
static const struct {
|
|
DWORD mask;
|
|
const char *name;
|
|
} flags[] = {
|
|
#define FE(x) { x, #x}
|
|
FE(DIDFT_RELAXIS),
|
|
FE(DIDFT_ABSAXIS),
|
|
FE(DIDFT_PSHBUTTON),
|
|
FE(DIDFT_TGLBUTTON),
|
|
FE(DIDFT_POV),
|
|
FE(DIDFT_COLLECTION),
|
|
FE(DIDFT_NODATA),
|
|
FE(DIDFT_FFACTUATOR),
|
|
FE(DIDFT_FFEFFECTTRIGGER),
|
|
FE(DIDFT_OUTPUT)
|
|
#undef FE
|
|
};
|
|
type = (dwFlags & 0xFF0000FF);
|
|
instance = ((dwFlags >> 8) & 0xFFFF);
|
|
DPRINTF("Type:");
|
|
if (type == DIDFT_ALL) {
|
|
DPRINTF(" DIDFT_ALL");
|
|
} else {
|
|
for (i = 0; i < (sizeof(flags) / sizeof(flags[0])); i++) {
|
|
if (flags[i].mask & type) {
|
|
type &= ~flags[i].mask;
|
|
DPRINTF(" %s",flags[i].name);
|
|
}
|
|
}
|
|
if (type) {
|
|
DPRINTF(" (unhandled: %08lx)", type);
|
|
}
|
|
}
|
|
DPRINTF(" / Instance: ");
|
|
if (instance == ((DIDFT_ANYINSTANCE >> 8) & 0xFFFF)) {
|
|
DPRINTF("DIDFT_ANYINSTANCE");
|
|
} else {
|
|
DPRINTF("%3ld", instance);
|
|
}
|
|
}
|
|
}
|
|
|
|
void _dump_DIPROPHEADER(LPCDIPROPHEADER diph) {
|
|
if (TRACE_ON(dinput)) {
|
|
DPRINTF(" - dwObj = 0x%08lx\n", diph->dwObj);
|
|
DPRINTF(" - dwHow = %s\n",
|
|
((diph->dwHow == DIPH_DEVICE) ? "DIPH_DEVICE" :
|
|
((diph->dwHow == DIPH_BYOFFSET) ? "DIPH_BYOFFSET" :
|
|
((diph->dwHow == DIPH_BYID)) ? "DIPH_BYID" : "unknown")));
|
|
}
|
|
}
|
|
|
|
void _dump_OBJECTINSTANCEA(DIDEVICEOBJECTINSTANCEA *ddoi) {
|
|
if (TRACE_ON(dinput)) {
|
|
DPRINTF(" - enumerating : %s ('%s') - %2ld - 0x%08lx - %s\n",
|
|
debugstr_guid(&ddoi->guidType), _dump_dinput_GUID(&ddoi->guidType), ddoi->dwOfs, ddoi->dwType, ddoi->tszName);
|
|
}
|
|
}
|
|
|
|
void _dump_OBJECTINSTANCEW(DIDEVICEOBJECTINSTANCEW *ddoi) {
|
|
if (TRACE_ON(dinput)) {
|
|
DPRINTF(" - enumerating : %s ('%s'), - %2ld - 0x%08lx - %s\n",
|
|
debugstr_guid(&ddoi->guidType), _dump_dinput_GUID(&ddoi->guidType), ddoi->dwOfs, ddoi->dwType, debugstr_w(ddoi->tszName));
|
|
}
|
|
}
|
|
|
|
/* This function is a helper to convert a GUID into any possible DInput GUID out there */
|
|
const char *_dump_dinput_GUID(const GUID *guid) {
|
|
int i;
|
|
static const struct {
|
|
const GUID *guid;
|
|
const char *name;
|
|
} guids[] = {
|
|
#define FE(x) { &x, #x}
|
|
FE(GUID_XAxis),
|
|
FE(GUID_YAxis),
|
|
FE(GUID_ZAxis),
|
|
FE(GUID_RxAxis),
|
|
FE(GUID_RyAxis),
|
|
FE(GUID_RzAxis),
|
|
FE(GUID_Slider),
|
|
FE(GUID_Button),
|
|
FE(GUID_Key),
|
|
FE(GUID_POV),
|
|
FE(GUID_Unknown),
|
|
FE(GUID_SysMouse),
|
|
FE(GUID_SysKeyboard),
|
|
FE(GUID_Joystick),
|
|
FE(GUID_ConstantForce),
|
|
FE(GUID_RampForce),
|
|
FE(GUID_Square),
|
|
FE(GUID_Sine),
|
|
FE(GUID_Triangle),
|
|
FE(GUID_SawtoothUp),
|
|
FE(GUID_SawtoothDown),
|
|
FE(GUID_Spring),
|
|
FE(GUID_Damper),
|
|
FE(GUID_Inertia),
|
|
FE(GUID_Friction),
|
|
FE(GUID_CustomForce)
|
|
#undef FE
|
|
};
|
|
if (guid == NULL)
|
|
return "null GUID";
|
|
for (i = 0; i < (sizeof(guids) / sizeof(guids[0])); i++) {
|
|
if (IsEqualGUID(guids[i].guid, guid)) {
|
|
return guids[i].name;
|
|
}
|
|
}
|
|
return "Unknown GUID";
|
|
}
|
|
|
|
void _dump_DIDATAFORMAT(const DIDATAFORMAT *df) {
|
|
int i;
|
|
|
|
TRACE("Dumping DIDATAFORMAT structure:\n");
|
|
TRACE(" - dwSize: %ld\n", df->dwSize);
|
|
if (df->dwSize != sizeof(DIDATAFORMAT)) {
|
|
WARN("Non-standard DIDATAFORMAT structure size (%ld instead of %d).\n", df->dwSize, sizeof(DIDATAFORMAT));
|
|
}
|
|
TRACE(" - dwObjsize: %ld\n", df->dwObjSize);
|
|
if (df->dwObjSize != sizeof(DIOBJECTDATAFORMAT)) {
|
|
WARN("Non-standard DIOBJECTDATAFORMAT structure size (%ld instead of %d).\n", df->dwObjSize, sizeof(DIOBJECTDATAFORMAT));
|
|
}
|
|
TRACE(" - dwFlags: 0x%08lx (", df->dwFlags);
|
|
switch (df->dwFlags) {
|
|
case DIDF_ABSAXIS: TRACE("DIDF_ABSAXIS"); break;
|
|
case DIDF_RELAXIS: TRACE("DIDF_RELAXIS"); break;
|
|
default: TRACE("unknown"); break;
|
|
}
|
|
TRACE(")\n");
|
|
TRACE(" - dwDataSize: %ld\n", df->dwDataSize);
|
|
TRACE(" - dwNumObjs: %ld\n", df->dwNumObjs);
|
|
|
|
for (i = 0; i < df->dwNumObjs; i++) {
|
|
TRACE(" - Object %d:\n", i);
|
|
TRACE(" * GUID: %s ('%s')\n", debugstr_guid(df->rgodf[i].pguid), _dump_dinput_GUID(df->rgodf[i].pguid));
|
|
TRACE(" * dwOfs: %ld\n", df->rgodf[i].dwOfs);
|
|
TRACE(" * dwType: 0x%08lx\n", df->rgodf[i].dwType);
|
|
TRACE(" "); _dump_EnumObjects_flags(df->rgodf[i].dwType); TRACE("\n");
|
|
TRACE(" * dwFlags: 0x%08lx\n", df->rgodf[i].dwFlags);
|
|
}
|
|
}
|
|
|
|
/* Conversion between internal data buffer and external data buffer */
|
|
void fill_DataFormat(void *out, void *in, DataFormat *df) {
|
|
int i;
|
|
char *in_c = (char *) in;
|
|
char *out_c = (char *) out;
|
|
|
|
if (df->dt == NULL) {
|
|
/* This means that the app uses Wine's internal data format */
|
|
memcpy(out, in, df->internal_format_size);
|
|
} else {
|
|
for (i = 0; i < df->size; i++) {
|
|
if (df->dt[i].offset_in >= 0) {
|
|
switch (df->dt[i].size) {
|
|
case 1:
|
|
TRACE("Copying (c) to %d from %d (value %d)\n",
|
|
df->dt[i].offset_out, df->dt[i].offset_in, *((char *) (in_c + df->dt[i].offset_in)));
|
|
*((char *) (out_c + df->dt[i].offset_out)) = *((char *) (in_c + df->dt[i].offset_in));
|
|
break;
|
|
|
|
case 2:
|
|
TRACE("Copying (s) to %d from %d (value %d)\n",
|
|
df->dt[i].offset_out, df->dt[i].offset_in, *((short *) (in_c + df->dt[i].offset_in)));
|
|
*((short *) (out_c + df->dt[i].offset_out)) = *((short *) (in_c + df->dt[i].offset_in));
|
|
break;
|
|
|
|
case 4:
|
|
TRACE("Copying (i) to %d from %d (value %d)\n",
|
|
df->dt[i].offset_out, df->dt[i].offset_in, *((int *) (in_c + df->dt[i].offset_in)));
|
|
*((int *) (out_c + df->dt[i].offset_out)) = *((int *) (in_c + df->dt[i].offset_in));
|
|
break;
|
|
|
|
default:
|
|
memcpy((out_c + df->dt[i].offset_out), (in_c + df->dt[i].offset_in), df->dt[i].size);
|
|
break;
|
|
}
|
|
} else {
|
|
switch (df->dt[i].size) {
|
|
case 1:
|
|
TRACE("Copying (c) to %d default value %d\n",
|
|
df->dt[i].offset_out, df->dt[i].value);
|
|
*((char *) (out_c + df->dt[i].offset_out)) = (char) df->dt[i].value;
|
|
break;
|
|
|
|
case 2:
|
|
TRACE("Copying (s) to %d default value %d\n",
|
|
df->dt[i].offset_out, df->dt[i].value);
|
|
*((short *) (out_c + df->dt[i].offset_out)) = (short) df->dt[i].value;
|
|
break;
|
|
|
|
case 4:
|
|
TRACE("Copying (i) to %d default value %d\n",
|
|
df->dt[i].offset_out, df->dt[i].value);
|
|
*((int *) (out_c + df->dt[i].offset_out)) = (int) df->dt[i].value;
|
|
break;
|
|
|
|
default:
|
|
memset((out_c + df->dt[i].offset_out), df->dt[i].size, 0);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
DataFormat *create_DataFormat(const DIDATAFORMAT *wine_format, LPCDIDATAFORMAT asked_format, int *offset) {
|
|
DataFormat *ret;
|
|
DataTransform *dt;
|
|
int i, j;
|
|
int same = 1;
|
|
int *done;
|
|
int index = 0;
|
|
|
|
ret = (DataFormat *) HeapAlloc(GetProcessHeap(), 0, sizeof(DataFormat));
|
|
|
|
done = (int *) HeapAlloc(GetProcessHeap(), 0, sizeof(int) * asked_format->dwNumObjs);
|
|
memset(done, 0, sizeof(int) * asked_format->dwNumObjs);
|
|
|
|
dt = (DataTransform *) HeapAlloc(GetProcessHeap(), 0, asked_format->dwNumObjs * sizeof(DataTransform));
|
|
|
|
TRACE("Creating DataTransform : \n");
|
|
|
|
for (i = 0; i < wine_format->dwNumObjs; i++) {
|
|
offset[i] = -1;
|
|
|
|
for (j = 0; j < asked_format->dwNumObjs; j++) {
|
|
if (done[j] == 1)
|
|
continue;
|
|
|
|
if (/* Check if the application either requests any GUID and if not, it if matches
|
|
* the GUID of the Wine object.
|
|
*/
|
|
((asked_format->rgodf[j].pguid == NULL) ||
|
|
(IsEqualGUID(wine_format->rgodf[i].pguid, asked_format->rgodf[j].pguid)))
|
|
&&
|
|
(/* Then check if it accepts any instance id, and if not, if it matches Wine's
|
|
* instance id.
|
|
*/
|
|
((asked_format->rgodf[j].dwType & 0x00FFFF00) == DIDFT_ANYINSTANCE) ||
|
|
(DIDFT_GETINSTANCE(wine_format->rgodf[i].dwType) == DIDFT_GETINSTANCE(asked_format->rgodf[j].dwType)))) {
|
|
|
|
done[j] = 1;
|
|
|
|
TRACE("Matching : \n");
|
|
TRACE(" - Asked (%d) :\n", j);
|
|
TRACE(" * GUID: %s ('%s')\n",
|
|
debugstr_guid(asked_format->rgodf[j].pguid),
|
|
_dump_dinput_GUID(asked_format->rgodf[j].pguid));
|
|
TRACE(" * Offset: %3ld\n", asked_format->rgodf[j].dwOfs);
|
|
TRACE(" * dwType: %08lx\n", asked_format->rgodf[j].dwType);
|
|
TRACE(" "); _dump_EnumObjects_flags(asked_format->rgodf[j].dwType); TRACE("\n");
|
|
|
|
TRACE(" - Wine (%d) :\n", j);
|
|
TRACE(" * GUID: %s ('%s')\n",
|
|
debugstr_guid(wine_format->rgodf[j].pguid),
|
|
_dump_dinput_GUID(wine_format->rgodf[j].pguid));
|
|
TRACE(" * Offset: %3ld\n", wine_format->rgodf[j].dwOfs);
|
|
TRACE(" * dwType: %08lx\n", wine_format->rgodf[j].dwType);
|
|
TRACE(" "); _dump_EnumObjects_flags(wine_format->rgodf[j].dwType); TRACE("\n");
|
|
|
|
if (wine_format->rgodf[i].dwType & DIDFT_BUTTON)
|
|
dt[index].size = sizeof(BYTE);
|
|
else
|
|
dt[index].size = sizeof(DWORD);
|
|
dt[index].offset_in = wine_format ->rgodf[i].dwOfs;
|
|
dt[index].offset_out = asked_format->rgodf[j].dwOfs;
|
|
dt[index].value = 0;
|
|
index++;
|
|
|
|
if (wine_format->rgodf[i].dwOfs != asked_format->rgodf[j].dwOfs)
|
|
same = 0;
|
|
|
|
offset[i] = asked_format->rgodf[j].dwOfs;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (j == asked_format->dwNumObjs)
|
|
same = 0;
|
|
}
|
|
|
|
TRACE("Setting to default value :\n");
|
|
for (j = 0; j < asked_format->dwNumObjs; j++) {
|
|
if (done[j] == 0) {
|
|
TRACE(" - Asked (%d) :\n", j);
|
|
TRACE(" * GUID: %s ('%s')\n",
|
|
debugstr_guid(asked_format->rgodf[j].pguid),
|
|
_dump_dinput_GUID(asked_format->rgodf[j].pguid));
|
|
TRACE(" * Offset: %3ld\n", asked_format->rgodf[j].dwOfs);
|
|
TRACE(" * dwType: %08lx\n", asked_format->rgodf[j].dwType);
|
|
TRACE(" "); _dump_EnumObjects_flags(asked_format->rgodf[j].dwType); TRACE("\n");
|
|
|
|
if (asked_format->rgodf[j].dwType & DIDFT_BUTTON)
|
|
dt[index].size = sizeof(BYTE);
|
|
else
|
|
dt[index].size = sizeof(DWORD);
|
|
dt[index].offset_in = -1;
|
|
dt[index].offset_out = asked_format->rgodf[j].dwOfs;
|
|
dt[index].value = 0;
|
|
index++;
|
|
|
|
same = 0;
|
|
}
|
|
}
|
|
|
|
ret->internal_format_size = wine_format->dwDataSize;
|
|
ret->size = index;
|
|
if (same) {
|
|
ret->dt = NULL;
|
|
HeapFree(GetProcessHeap(), 0, dt);
|
|
} else {
|
|
ret->dt = dt;
|
|
}
|
|
|
|
HeapFree(GetProcessHeap(), 0, done);
|
|
|
|
return ret;
|
|
}
|
|
|
|
BOOL DIEnumDevicesCallbackAtoW(LPCDIDEVICEOBJECTINSTANCEA lpddi, LPVOID lpvRef) {
|
|
DIDEVICEOBJECTINSTANCEW ddtmp;
|
|
device_enumobjects_AtoWcb_data* data;
|
|
|
|
data = (device_enumobjects_AtoWcb_data*) lpvRef;
|
|
|
|
memset(&ddtmp, 0, sizeof(DIDEVICEINSTANCEW));
|
|
|
|
ddtmp.dwSize = sizeof(DIDEVICEINSTANCEW);
|
|
ddtmp.guidType = lpddi->guidType;
|
|
ddtmp.dwOfs = lpddi->dwOfs;
|
|
ddtmp.dwType = lpddi->dwType;
|
|
ddtmp.dwFlags = lpddi->dwFlags;
|
|
MultiByteToWideChar(CP_ACP, 0, lpddi->tszName, -1, ddtmp.tszName, MAX_PATH);
|
|
|
|
if (lpddi->dwSize == sizeof(DIDEVICEINSTANCEA)) {
|
|
/**
|
|
* if dwSize < sizeof(DIDEVICEINSTANCEA of DInput version >= 5)
|
|
* force feedback and other newer datas aren't available
|
|
*/
|
|
ddtmp.dwFFMaxForce = lpddi->dwFFMaxForce;
|
|
ddtmp.dwFFForceResolution = lpddi->dwFFForceResolution;
|
|
ddtmp.wCollectionNumber = lpddi->wCollectionNumber;
|
|
ddtmp.wDesignatorIndex = lpddi->wDesignatorIndex;
|
|
ddtmp.wUsagePage = lpddi->wUsagePage;
|
|
ddtmp.wUsage = lpddi->wUsage;
|
|
ddtmp.dwDimension = lpddi->dwDimension;
|
|
ddtmp.wExponent = lpddi->wExponent;
|
|
ddtmp.wReserved = lpddi->wReserved;
|
|
}
|
|
return data->lpCallBack(&ddtmp, data->lpvRef);
|
|
}
|
|
|
|
/******************************************************************************
|
|
* IDirectInputDeviceA
|
|
*/
|
|
|
|
HRESULT WINAPI IDirectInputDevice2AImpl_SetDataFormat(
|
|
LPDIRECTINPUTDEVICE8A iface,LPCDIDATAFORMAT df
|
|
) {
|
|
ICOM_THIS(IDirectInputDevice2AImpl,iface);
|
|
|
|
TRACE("(this=%p,%p)\n",This,df);
|
|
|
|
_dump_DIDATAFORMAT(df);
|
|
|
|
return DI_OK;
|
|
}
|
|
|
|
HRESULT WINAPI IDirectInputDevice2AImpl_SetCooperativeLevel(
|
|
LPDIRECTINPUTDEVICE8A iface,HWND hwnd,DWORD dwflags
|
|
) {
|
|
ICOM_THIS(IDirectInputDevice2AImpl,iface);
|
|
TRACE("(this=%p,0x%08lx,0x%08lx)\n",This,(DWORD)hwnd,dwflags);
|
|
if (TRACE_ON(dinput)) {
|
|
TRACE(" cooperative level : ");
|
|
_dump_cooperativelevel_DI(dwflags);
|
|
}
|
|
return DI_OK;
|
|
}
|
|
|
|
HRESULT WINAPI IDirectInputDevice2AImpl_SetEventNotification(
|
|
LPDIRECTINPUTDEVICE8A iface,HANDLE hnd
|
|
) {
|
|
ICOM_THIS(IDirectInputDevice2AImpl,iface);
|
|
FIXME("(this=%p,0x%08lx): stub\n",This,(DWORD)hnd);
|
|
return DI_OK;
|
|
}
|
|
|
|
ULONG WINAPI IDirectInputDevice2AImpl_Release(LPDIRECTINPUTDEVICE8A iface)
|
|
{
|
|
ICOM_THIS(IDirectInputDevice2AImpl,iface);
|
|
This->ref--;
|
|
if (This->ref)
|
|
return This->ref;
|
|
HeapFree(GetProcessHeap(),0,This);
|
|
return DI_OK;
|
|
}
|
|
|
|
HRESULT WINAPI IDirectInputDevice2AImpl_QueryInterface(
|
|
LPDIRECTINPUTDEVICE8A iface,REFIID riid,LPVOID *ppobj
|
|
)
|
|
{
|
|
ICOM_THIS(IDirectInputDevice2AImpl,iface);
|
|
|
|
TRACE("(this=%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
|
|
if (IsEqualGUID(&IID_IUnknown,riid)) {
|
|
IDirectInputDevice2_AddRef(iface);
|
|
*ppobj = This;
|
|
return DI_OK;
|
|
}
|
|
if (IsEqualGUID(&IID_IDirectInputDeviceA,riid)) {
|
|
IDirectInputDevice2_AddRef(iface);
|
|
*ppobj = This;
|
|
return DI_OK;
|
|
}
|
|
if (IsEqualGUID(&IID_IDirectInputDevice2A,riid)) {
|
|
IDirectInputDevice2_AddRef(iface);
|
|
*ppobj = This;
|
|
return DI_OK;
|
|
}
|
|
if (IsEqualGUID(&IID_IDirectInputDevice7A,riid)) {
|
|
IDirectInputDevice7_AddRef(iface);
|
|
*ppobj = This;
|
|
return DI_OK;
|
|
}
|
|
TRACE("Unsupported interface !\n");
|
|
return E_FAIL;
|
|
}
|
|
|
|
HRESULT WINAPI IDirectInputDevice2WImpl_QueryInterface(
|
|
LPDIRECTINPUTDEVICE8W iface,REFIID riid,LPVOID *ppobj
|
|
)
|
|
{
|
|
ICOM_THIS(IDirectInputDevice2AImpl,iface);
|
|
|
|
TRACE("(this=%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
|
|
if (IsEqualGUID(&IID_IUnknown,riid)) {
|
|
IDirectInputDevice2_AddRef(iface);
|
|
*ppobj = This;
|
|
return DI_OK;
|
|
}
|
|
if (IsEqualGUID(&IID_IDirectInputDeviceW,riid)) {
|
|
IDirectInputDevice2_AddRef(iface);
|
|
*ppobj = This;
|
|
return DI_OK;
|
|
}
|
|
if (IsEqualGUID(&IID_IDirectInputDevice2W,riid)) {
|
|
IDirectInputDevice2_AddRef(iface);
|
|
*ppobj = This;
|
|
return DI_OK;
|
|
}
|
|
if (IsEqualGUID(&IID_IDirectInputDevice7W,riid)) {
|
|
IDirectInputDevice7_AddRef(iface);
|
|
*ppobj = This;
|
|
return DI_OK;
|
|
}
|
|
TRACE("Unsupported interface !\n");
|
|
return E_FAIL;
|
|
}
|
|
|
|
ULONG WINAPI IDirectInputDevice2AImpl_AddRef(
|
|
LPDIRECTINPUTDEVICE8A iface)
|
|
{
|
|
ICOM_THIS(IDirectInputDevice2AImpl,iface);
|
|
return ++This->ref;
|
|
}
|
|
|
|
HRESULT WINAPI IDirectInputDevice2AImpl_EnumObjects(
|
|
LPDIRECTINPUTDEVICE8A iface,
|
|
LPDIENUMDEVICEOBJECTSCALLBACKA lpCallback,
|
|
LPVOID lpvRef,
|
|
DWORD dwFlags)
|
|
{
|
|
FIXME("(this=%p,%p,%p,%08lx): stub!\n", iface, lpCallback, lpvRef, dwFlags);
|
|
if (TRACE_ON(dinput)) {
|
|
DPRINTF(" - flags = ");
|
|
_dump_EnumObjects_flags(dwFlags);
|
|
DPRINTF("\n");
|
|
}
|
|
|
|
return DI_OK;
|
|
}
|
|
|
|
HRESULT WINAPI IDirectInputDevice2WImpl_EnumObjects(
|
|
LPDIRECTINPUTDEVICE8W iface,
|
|
LPDIENUMDEVICEOBJECTSCALLBACKW lpCallback,
|
|
LPVOID lpvRef,
|
|
DWORD dwFlags)
|
|
{
|
|
FIXME("(this=%p,%p,%p,%08lx): stub!\n", iface, lpCallback, lpvRef, dwFlags);
|
|
if (TRACE_ON(dinput)) {
|
|
DPRINTF(" - flags = ");
|
|
_dump_EnumObjects_flags(dwFlags);
|
|
DPRINTF("\n");
|
|
}
|
|
|
|
return DI_OK;
|
|
}
|
|
|
|
HRESULT WINAPI IDirectInputDevice2AImpl_GetProperty(
|
|
LPDIRECTINPUTDEVICE8A iface,
|
|
REFGUID rguid,
|
|
LPDIPROPHEADER pdiph)
|
|
{
|
|
FIXME("(this=%p,%s,%p): stub!\n",
|
|
iface, debugstr_guid(rguid), pdiph);
|
|
|
|
if (TRACE_ON(dinput))
|
|
_dump_DIPROPHEADER(pdiph);
|
|
|
|
return DI_OK;
|
|
}
|
|
|
|
HRESULT WINAPI IDirectInputDevice2AImpl_GetObjectInfo(
|
|
LPDIRECTINPUTDEVICE8A iface,
|
|
LPDIDEVICEOBJECTINSTANCEA pdidoi,
|
|
DWORD dwObj,
|
|
DWORD dwHow)
|
|
{
|
|
FIXME("(this=%p,%p,%ld,0x%08lx): stub!\n",
|
|
iface, pdidoi, dwObj, dwHow);
|
|
|
|
return DI_OK;
|
|
}
|
|
|
|
HRESULT WINAPI IDirectInputDevice2WImpl_GetObjectInfo(
|
|
LPDIRECTINPUTDEVICE8W iface,
|
|
LPDIDEVICEOBJECTINSTANCEW pdidoi,
|
|
DWORD dwObj,
|
|
DWORD dwHow)
|
|
{
|
|
FIXME("(this=%p,%p,%ld,0x%08lx): stub!\n",
|
|
iface, pdidoi, dwObj, dwHow);
|
|
|
|
return DI_OK;
|
|
}
|
|
|
|
HRESULT WINAPI IDirectInputDevice2AImpl_GetDeviceInfo(
|
|
LPDIRECTINPUTDEVICE8A iface,
|
|
LPDIDEVICEINSTANCEA pdidi)
|
|
{
|
|
FIXME("(this=%p,%p): stub!\n",
|
|
iface, pdidi);
|
|
|
|
return DI_OK;
|
|
}
|
|
|
|
HRESULT WINAPI IDirectInputDevice2WImpl_GetDeviceInfo(
|
|
LPDIRECTINPUTDEVICE8W iface,
|
|
LPDIDEVICEINSTANCEW pdidi)
|
|
{
|
|
FIXME("(this=%p,%p): stub!\n",
|
|
iface, pdidi);
|
|
|
|
return DI_OK;
|
|
}
|
|
|
|
HRESULT WINAPI IDirectInputDevice2AImpl_RunControlPanel(
|
|
LPDIRECTINPUTDEVICE8A iface,
|
|
HWND hwndOwner,
|
|
DWORD dwFlags)
|
|
{
|
|
FIXME("(this=%p,%p,0x%08lx): stub!\n",
|
|
iface, hwndOwner, dwFlags);
|
|
|
|
return DI_OK;
|
|
}
|
|
|
|
HRESULT WINAPI IDirectInputDevice2AImpl_Initialize(
|
|
LPDIRECTINPUTDEVICE8A iface,
|
|
HINSTANCE hinst,
|
|
DWORD dwVersion,
|
|
REFGUID rguid)
|
|
{
|
|
FIXME("(this=%p,%p,%ld,%s): stub!\n",
|
|
iface, hinst, dwVersion, debugstr_guid(rguid));
|
|
return DI_OK;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* IDirectInputDevice2A
|
|
*/
|
|
|
|
HRESULT WINAPI IDirectInputDevice2AImpl_CreateEffect(
|
|
LPDIRECTINPUTDEVICE8A iface,
|
|
REFGUID rguid,
|
|
LPCDIEFFECT lpeff,
|
|
LPDIRECTINPUTEFFECT *ppdef,
|
|
LPUNKNOWN pUnkOuter)
|
|
{
|
|
FIXME("(this=%p,%s,%p,%p,%p): stub!\n",
|
|
iface, debugstr_guid(rguid), lpeff, ppdef, pUnkOuter);
|
|
return DI_OK;
|
|
}
|
|
|
|
HRESULT WINAPI IDirectInputDevice2AImpl_EnumEffects(
|
|
LPDIRECTINPUTDEVICE8A iface,
|
|
LPDIENUMEFFECTSCALLBACKA lpCallback,
|
|
LPVOID lpvRef,
|
|
DWORD dwFlags)
|
|
{
|
|
FIXME("(this=%p,%p,%p,0x%08lx): stub!\n",
|
|
iface, lpCallback, lpvRef, dwFlags);
|
|
|
|
if (lpCallback)
|
|
lpCallback(NULL, lpvRef);
|
|
return DI_OK;
|
|
}
|
|
|
|
HRESULT WINAPI IDirectInputDevice2WImpl_EnumEffects(
|
|
LPDIRECTINPUTDEVICE8W iface,
|
|
LPDIENUMEFFECTSCALLBACKW lpCallback,
|
|
LPVOID lpvRef,
|
|
DWORD dwFlags)
|
|
{
|
|
FIXME("(this=%p,%p,%p,0x%08lx): stub!\n",
|
|
iface, lpCallback, lpvRef, dwFlags);
|
|
|
|
if (lpCallback)
|
|
lpCallback(NULL, lpvRef);
|
|
return DI_OK;
|
|
}
|
|
|
|
HRESULT WINAPI IDirectInputDevice2AImpl_GetEffectInfo(
|
|
LPDIRECTINPUTDEVICE8A iface,
|
|
LPDIEFFECTINFOA lpdei,
|
|
REFGUID rguid)
|
|
{
|
|
FIXME("(this=%p,%p,%s): stub!\n",
|
|
iface, lpdei, debugstr_guid(rguid));
|
|
return DI_OK;
|
|
}
|
|
|
|
HRESULT WINAPI IDirectInputDevice2WImpl_GetEffectInfo(
|
|
LPDIRECTINPUTDEVICE8W iface,
|
|
LPDIEFFECTINFOW lpdei,
|
|
REFGUID rguid)
|
|
{
|
|
FIXME("(this=%p,%p,%s): stub!\n",
|
|
iface, lpdei, debugstr_guid(rguid));
|
|
return DI_OK;
|
|
}
|
|
|
|
HRESULT WINAPI IDirectInputDevice2AImpl_GetForceFeedbackState(
|
|
LPDIRECTINPUTDEVICE8A iface,
|
|
LPDWORD pdwOut)
|
|
{
|
|
FIXME("(this=%p,%p): stub!\n",
|
|
iface, pdwOut);
|
|
return DI_OK;
|
|
}
|
|
|
|
HRESULT WINAPI IDirectInputDevice2AImpl_SendForceFeedbackCommand(
|
|
LPDIRECTINPUTDEVICE8A iface,
|
|
DWORD dwFlags)
|
|
{
|
|
FIXME("(this=%p,0x%08lx): stub!\n",
|
|
iface, dwFlags);
|
|
return DI_OK;
|
|
}
|
|
|
|
HRESULT WINAPI IDirectInputDevice2AImpl_EnumCreatedEffectObjects(
|
|
LPDIRECTINPUTDEVICE8A iface,
|
|
LPDIENUMCREATEDEFFECTOBJECTSCALLBACK lpCallback,
|
|
LPVOID lpvRef,
|
|
DWORD dwFlags)
|
|
{
|
|
FIXME("(this=%p,%p,%p,0x%08lx): stub!\n",
|
|
iface, lpCallback, lpvRef, dwFlags);
|
|
if (lpCallback)
|
|
lpCallback(NULL, lpvRef);
|
|
return DI_OK;
|
|
}
|
|
|
|
HRESULT WINAPI IDirectInputDevice2AImpl_Escape(
|
|
LPDIRECTINPUTDEVICE8A iface,
|
|
LPDIEFFESCAPE lpDIEEsc)
|
|
{
|
|
FIXME("(this=%p,%p): stub!\n",
|
|
iface, lpDIEEsc);
|
|
return DI_OK;
|
|
}
|
|
|
|
HRESULT WINAPI IDirectInputDevice2AImpl_Poll(
|
|
LPDIRECTINPUTDEVICE8A iface)
|
|
{
|
|
/* Because wine devices do not need to be polled, just return DI_NOEFFECT */
|
|
return DI_NOEFFECT;
|
|
}
|
|
|
|
HRESULT WINAPI IDirectInputDevice2AImpl_SendDeviceData(
|
|
LPDIRECTINPUTDEVICE8A iface,
|
|
DWORD cbObjectData,
|
|
LPCDIDEVICEOBJECTDATA rgdod,
|
|
LPDWORD pdwInOut,
|
|
DWORD dwFlags)
|
|
{
|
|
FIXME("(this=%p,0x%08lx,%p,%p,0x%08lx): stub!\n",
|
|
iface, cbObjectData, rgdod, pdwInOut, dwFlags);
|
|
|
|
return DI_OK;
|
|
}
|
|
|
|
HRESULT WINAPI IDirectInputDevice7AImpl_EnumEffectsInFile(LPDIRECTINPUTDEVICE8A iface,
|
|
LPCSTR lpszFileName,
|
|
LPDIENUMEFFECTSINFILECALLBACK pec,
|
|
LPVOID pvRef,
|
|
DWORD dwFlags)
|
|
{
|
|
FIXME("(%p)->(%s,%p,%p,%08lx): stub !\n", iface, lpszFileName, pec, pvRef, dwFlags);
|
|
|
|
return DI_OK;
|
|
}
|
|
|
|
HRESULT WINAPI IDirectInputDevice7WImpl_EnumEffectsInFile(LPDIRECTINPUTDEVICE8W iface,
|
|
LPCWSTR lpszFileName,
|
|
LPDIENUMEFFECTSINFILECALLBACK pec,
|
|
LPVOID pvRef,
|
|
DWORD dwFlags)
|
|
{
|
|
FIXME("(%p)->(%s,%p,%p,%08lx): stub !\n", iface, debugstr_w(lpszFileName), pec, pvRef, dwFlags);
|
|
|
|
return DI_OK;
|
|
}
|
|
|
|
HRESULT WINAPI IDirectInputDevice7AImpl_WriteEffectToFile(LPDIRECTINPUTDEVICE8A iface,
|
|
LPCSTR lpszFileName,
|
|
DWORD dwEntries,
|
|
LPDIFILEEFFECT rgDiFileEft,
|
|
DWORD dwFlags)
|
|
{
|
|
FIXME("(%p)->(%s,%08lx,%p,%08lx): stub !\n", iface, lpszFileName, dwEntries, rgDiFileEft, dwFlags);
|
|
|
|
return DI_OK;
|
|
}
|
|
|
|
HRESULT WINAPI IDirectInputDevice7WImpl_WriteEffectToFile(LPDIRECTINPUTDEVICE8W iface,
|
|
LPCWSTR lpszFileName,
|
|
DWORD dwEntries,
|
|
LPDIFILEEFFECT rgDiFileEft,
|
|
DWORD dwFlags)
|
|
{
|
|
FIXME("(%p)->(%s,%08lx,%p,%08lx): stub !\n", iface, debugstr_w(lpszFileName), dwEntries, rgDiFileEft, dwFlags);
|
|
|
|
return DI_OK;
|
|
}
|
|
|
|
HRESULT WINAPI IDirectInputDevice8AImpl_BuildActionMap(LPDIRECTINPUTDEVICE8A iface,
|
|
LPDIACTIONFORMATA lpdiaf,
|
|
LPCSTR lpszUserName,
|
|
DWORD dwFlags)
|
|
{
|
|
FIXME("(%p)->(%p,%s,%08lx): stub !\n", iface, lpdiaf, lpszUserName, dwFlags);
|
|
|
|
return DI_OK;
|
|
}
|
|
|
|
HRESULT WINAPI IDirectInputDevice8WImpl_BuildActionMap(LPDIRECTINPUTDEVICE8W iface,
|
|
LPDIACTIONFORMATW lpdiaf,
|
|
LPCWSTR lpszUserName,
|
|
DWORD dwFlags)
|
|
{
|
|
FIXME("(%p)->(%p,%s,%08lx): stub !\n", iface, lpdiaf, debugstr_w(lpszUserName), dwFlags);
|
|
|
|
return DI_OK;
|
|
}
|
|
|
|
HRESULT WINAPI IDirectInputDevice8AImpl_SetActionMap(LPDIRECTINPUTDEVICE8A iface,
|
|
LPDIACTIONFORMATA lpdiaf,
|
|
LPCSTR lpszUserName,
|
|
DWORD dwFlags)
|
|
{
|
|
FIXME("(%p)->(%p,%s,%08lx): stub !\n", iface, lpdiaf, lpszUserName, dwFlags);
|
|
|
|
return DI_OK;
|
|
}
|
|
|
|
HRESULT WINAPI IDirectInputDevice8WImpl_SetActionMap(LPDIRECTINPUTDEVICE8W iface,
|
|
LPDIACTIONFORMATW lpdiaf,
|
|
LPCWSTR lpszUserName,
|
|
DWORD dwFlags)
|
|
{
|
|
FIXME("(%p)->(%p,%s,%08lx): stub !\n", iface, lpdiaf, debugstr_w(lpszUserName), dwFlags);
|
|
|
|
return DI_OK;
|
|
}
|
|
|
|
HRESULT WINAPI IDirectInputDevice8AImpl_GetImageInfo(LPDIRECTINPUTDEVICE8A iface,
|
|
LPDIDEVICEIMAGEINFOHEADERA lpdiDevImageInfoHeader)
|
|
{
|
|
FIXME("(%p)->(%p): stub !\n", iface, lpdiDevImageInfoHeader);
|
|
|
|
return DI_OK;
|
|
}
|
|
|
|
HRESULT WINAPI IDirectInputDevice8WImpl_GetImageInfo(LPDIRECTINPUTDEVICE8W iface,
|
|
LPDIDEVICEIMAGEINFOHEADERW lpdiDevImageInfoHeader)
|
|
{
|
|
FIXME("(%p)->(%p): stub !\n", iface, lpdiDevImageInfoHeader);
|
|
|
|
return DI_OK;
|
|
}
|