?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
user: Fix LB_GETTEXT unmapping for A<->W.
[wine/multimedia.git] / dlls / dinput / device.c
blob8cca6f5ca3a7d01a2f12a443143fe9bdbe7b4b8f
1 /* DirectInput Device
2 *
3 * Copyright 1998 Marcus Meissner
4 * Copyright 1998,1999 Lionel Ulmer
5 *
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21
22 /* This file contains all the Device specific functions that can be used as stubs
23 by real device implementations.
24
25 It also contains all the helper functions.
26 */
27 #include "config.h"
28
29 #include <stdarg.h>
30 #include <string.h>
31 #include "wine/debug.h"
32 #include "wine/unicode.h"
33 #include "windef.h"
34 #include "winbase.h"
35 #include "winerror.h"
36 #include "dinput.h"
37 #include "device_private.h"
38
39 WINE_DEFAULT_DEBUG_CHANNEL(dinput);
40
41 /******************************************************************************
42 * Various debugging tools
43 */
44 void _dump_cooperativelevel_DI(DWORD dwFlags) {
45 if (TRACE_ON(dinput)) {
46 unsigned int i;
47 static const struct {
48 DWORD mask;
49 const char *name;
50 } flags[] = {
51 #define FE(x) { x, #x}
52 FE(DISCL_BACKGROUND),
53 FE(DISCL_EXCLUSIVE),
54 FE(DISCL_FOREGROUND),
55 FE(DISCL_NONEXCLUSIVE)
56 #undef FE
57 };
58 for (i = 0; i < (sizeof(flags) / sizeof(flags[0])); i++)
59 if (flags[i].mask & dwFlags)
60 DPRINTF("%s ",flags[i].name);
61 DPRINTF("\n");
62 }
63 }
64
65 void _dump_EnumObjects_flags(DWORD dwFlags) {
66 if (TRACE_ON(dinput)) {
67 unsigned int i;
68 DWORD type, instance;
69 static const struct {
70 DWORD mask;
71 const char *name;
72 } flags[] = {
73 #define FE(x) { x, #x}
74 FE(DIDFT_RELAXIS),
75 FE(DIDFT_ABSAXIS),
76 FE(DIDFT_PSHBUTTON),
77 FE(DIDFT_TGLBUTTON),
78 FE(DIDFT_POV),
79 FE(DIDFT_COLLECTION),
80 FE(DIDFT_NODATA),
81 FE(DIDFT_FFACTUATOR),
82 FE(DIDFT_FFEFFECTTRIGGER),
83 FE(DIDFT_OUTPUT),
84 FE(DIDFT_VENDORDEFINED),
85 FE(DIDFT_ALIAS),
86 FE(DIDFT_OPTIONAL)
87 #undef FE
88 };
89 type = (dwFlags & 0xFF0000FF);
90 instance = ((dwFlags >> 8) & 0xFFFF);
91 DPRINTF("Type:");
92 if (type == DIDFT_ALL) {
93 DPRINTF(" DIDFT_ALL");
94 } else {
95 for (i = 0; i < (sizeof(flags) / sizeof(flags[0])); i++) {
96 if (flags[i].mask & type) {
97 type &= ~flags[i].mask;
98 DPRINTF(" %s",flags[i].name);
99 }
100 }
101 if (type) {
102 DPRINTF(" (unhandled: %08lx)", type);
103 }
104 }
105 DPRINTF(" / Instance: ");
106 if (instance == ((DIDFT_ANYINSTANCE >> 8) & 0xFFFF)) {
107 DPRINTF("DIDFT_ANYINSTANCE");
108 } else {
109 DPRINTF("%3ld", instance);
110 }
111 }
112 }
113
114 void _dump_DIPROPHEADER(LPCDIPROPHEADER diph) {
115 if (TRACE_ON(dinput)) {
116 DPRINTF(" - dwObj = 0x%08lx\n", diph->dwObj);
117 DPRINTF(" - dwHow = %s\n",
118 ((diph->dwHow == DIPH_DEVICE) ? "DIPH_DEVICE" :
119 ((diph->dwHow == DIPH_BYOFFSET) ? "DIPH_BYOFFSET" :
120 ((diph->dwHow == DIPH_BYID)) ? "DIPH_BYID" : "unknown")));
121 }
122 }
123
124 void _dump_OBJECTINSTANCEA(DIDEVICEOBJECTINSTANCEA *ddoi) {
125 if (TRACE_ON(dinput)) {
126 DPRINTF(" - enumerating : %s ('%s') - %2ld - 0x%08lx - %s\n",
127 debugstr_guid(&ddoi->guidType), _dump_dinput_GUID(&ddoi->guidType), ddoi->dwOfs, ddoi->dwType, ddoi->tszName);
128 }
129 }
130
131 void _dump_OBJECTINSTANCEW(DIDEVICEOBJECTINSTANCEW *ddoi) {
132 if (TRACE_ON(dinput)) {
133 DPRINTF(" - enumerating : %s ('%s'), - %2ld - 0x%08lx - %s\n",
134 debugstr_guid(&ddoi->guidType), _dump_dinput_GUID(&ddoi->guidType), ddoi->dwOfs, ddoi->dwType, debugstr_w(ddoi->tszName));
135 }
136 }
137
138 /* This function is a helper to convert a GUID into any possible DInput GUID out there */
139 const char *_dump_dinput_GUID(const GUID *guid) {
140 unsigned int i;
141 static const struct {
142 const GUID *guid;
143 const char *name;
144 } guids[] = {
145 #define FE(x) { &x, #x}
146 FE(GUID_XAxis),
147 FE(GUID_YAxis),
148 FE(GUID_ZAxis),
149 FE(GUID_RxAxis),
150 FE(GUID_RyAxis),
151 FE(GUID_RzAxis),
152 FE(GUID_Slider),
153 FE(GUID_Button),
154 FE(GUID_Key),
155 FE(GUID_POV),
156 FE(GUID_Unknown),
157 FE(GUID_SysMouse),
158 FE(GUID_SysKeyboard),
159 FE(GUID_Joystick),
160 FE(GUID_ConstantForce),
161 FE(GUID_RampForce),
162 FE(GUID_Square),
163 FE(GUID_Sine),
164 FE(GUID_Triangle),
165 FE(GUID_SawtoothUp),
166 FE(GUID_SawtoothDown),
167 FE(GUID_Spring),
168 FE(GUID_Damper),
169 FE(GUID_Inertia),
170 FE(GUID_Friction),
171 FE(GUID_CustomForce)
172 #undef FE
173 };
174 if (guid == NULL)
175 return "null GUID";
176 for (i = 0; i < (sizeof(guids) / sizeof(guids[0])); i++) {
177 if (IsEqualGUID(guids[i].guid, guid)) {
178 return guids[i].name;
179 }
180 }
181 return "Unknown GUID";
182 }
183
184 void _dump_DIDATAFORMAT(const DIDATAFORMAT *df) {
185 unsigned int i;
186
187 TRACE("Dumping DIDATAFORMAT structure:\n");
188 TRACE(" - dwSize: %ld\n", df->dwSize);
189 if (df->dwSize != sizeof(DIDATAFORMAT)) {
190 WARN("Non-standard DIDATAFORMAT structure size (%ld instead of %d).\n", df->dwSize, sizeof(DIDATAFORMAT));
191 }
192 TRACE(" - dwObjsize: %ld\n", df->dwObjSize);
193 if (df->dwObjSize != sizeof(DIOBJECTDATAFORMAT)) {
194 WARN("Non-standard DIOBJECTDATAFORMAT structure size (%ld instead of %d).\n", df->dwObjSize, sizeof(DIOBJECTDATAFORMAT));
195 }
196 TRACE(" - dwFlags: 0x%08lx (", df->dwFlags);
197 switch (df->dwFlags) {
198 case DIDF_ABSAXIS: TRACE("DIDF_ABSAXIS"); break;
199 case DIDF_RELAXIS: TRACE("DIDF_RELAXIS"); break;
200 default: TRACE("unknown"); break;
201 }
202 TRACE(")\n");
203 TRACE(" - dwDataSize: %ld\n", df->dwDataSize);
204 TRACE(" - dwNumObjs: %ld\n", df->dwNumObjs);
205
206 for (i = 0; i < df->dwNumObjs; i++) {
207 TRACE(" - Object %d:\n", i);
208 TRACE(" * GUID: %s ('%s')\n", debugstr_guid(df->rgodf[i].pguid), _dump_dinput_GUID(df->rgodf[i].pguid));
209 TRACE(" * dwOfs: %ld\n", df->rgodf[i].dwOfs);
210 TRACE(" * dwType: 0x%08lx\n", df->rgodf[i].dwType);
211 TRACE(" "); _dump_EnumObjects_flags(df->rgodf[i].dwType); TRACE("\n");
212 TRACE(" * dwFlags: 0x%08lx\n", df->rgodf[i].dwFlags);
213 }
214 }
215
216 /* Conversion between internal data buffer and external data buffer */
217 void fill_DataFormat(void *out, const void *in, DataFormat *df) {
218 int i;
219 char *in_c = (char *) in;
220 char *out_c = (char *) out;
221
222 if (df->dt == NULL) {
223 /* This means that the app uses Wine's internal data format */
224 memcpy(out, in, df->internal_format_size);
225 } else {
226 for (i = 0; i < df->size; i++) {
227 if (df->dt[i].offset_in >= 0) {
228 switch (df->dt[i].size) {
229 case 1:
230 TRACE("Copying (c) to %d from %d (value %d)\n",
231 df->dt[i].offset_out, df->dt[i].offset_in, *((char *) (in_c + df->dt[i].offset_in)));
232 *((char *) (out_c + df->dt[i].offset_out)) = *((char *) (in_c + df->dt[i].offset_in));
233 break;
234
235 case 2:
236 TRACE("Copying (s) to %d from %d (value %d)\n",
237 df->dt[i].offset_out, df->dt[i].offset_in, *((short *) (in_c + df->dt[i].offset_in)));
238 *((short *) (out_c + df->dt[i].offset_out)) = *((short *) (in_c + df->dt[i].offset_in));
239 break;
240
241 case 4:
242 TRACE("Copying (i) to %d from %d (value %d)\n",
243 df->dt[i].offset_out, df->dt[i].offset_in, *((int *) (in_c + df->dt[i].offset_in)));
244 *((int *) (out_c + df->dt[i].offset_out)) = *((int *) (in_c + df->dt[i].offset_in));
245 break;
246
247 default:
248 memcpy((out_c + df->dt[i].offset_out), (in_c + df->dt[i].offset_in), df->dt[i].size);
249 break;
250 }
251 } else {
252 switch (df->dt[i].size) {
253 case 1:
254 TRACE("Copying (c) to %d default value %d\n",
255 df->dt[i].offset_out, df->dt[i].value);
256 *((char *) (out_c + df->dt[i].offset_out)) = (char) df->dt[i].value;
257 break;
258
259 case 2:
260 TRACE("Copying (s) to %d default value %d\n",
261 df->dt[i].offset_out, df->dt[i].value);
262 *((short *) (out_c + df->dt[i].offset_out)) = (short) df->dt[i].value;
263 break;
264
265 case 4:
266 TRACE("Copying (i) to %d default value %d\n",
267 df->dt[i].offset_out, df->dt[i].value);
268 *((int *) (out_c + df->dt[i].offset_out)) = (int) df->dt[i].value;
269 break;
270
271 default:
272 memset((out_c + df->dt[i].offset_out), df->dt[i].size, 0);
273 break;
274 }
275 }
276 }
277 }
278 }
279
280 void release_DataFormat(DataFormat * format)
281 {
282 TRACE("Deleting DataTransform :\n");
283
284 HeapFree(GetProcessHeap(), 0, format->dt);
285 }
286
287 DataFormat *create_DataFormat(const DIDATAFORMAT *wine_format, LPCDIDATAFORMAT asked_format, int *offset) {
288 DataFormat *ret;
289 DataTransform *dt;
290 unsigned int i, j;
291 int same = 1;
292 int *done;
293 int index = 0;
294 DWORD next = 0;
295
296 ret = HeapAlloc(GetProcessHeap(), 0, sizeof(DataFormat));
297
298 done = HeapAlloc(GetProcessHeap(), 0, sizeof(int) * asked_format->dwNumObjs);
299 memset(done, 0, sizeof(int) * asked_format->dwNumObjs);
300
301 dt = HeapAlloc(GetProcessHeap(), 0, asked_format->dwNumObjs * sizeof(DataTransform));
302
303 TRACE("Creating DataTransform :\n");
304
305 for (i = 0; i < wine_format->dwNumObjs; i++) {
306 offset[i] = -1;
307
308 for (j = 0; j < asked_format->dwNumObjs; j++) {
309 if (done[j] == 1)
310 continue;
311
312 if (/* Check if the application either requests any GUID and if not, it if matches
313 * the GUID of the Wine object.
314 */
315 ((asked_format->rgodf[j].pguid == NULL) ||
316 (wine_format->rgodf[i].pguid == NULL) ||
317 (IsEqualGUID(wine_format->rgodf[i].pguid, asked_format->rgodf[j].pguid)))
318 &&
319 (/* Then check if it accepts any instance id, and if not, if it matches Wine's
320 * instance id.
321 */
322 (DIDFT_GETINSTANCE(asked_format->rgodf[j].dwType) == 0xFFFF) ||
323 (DIDFT_GETINSTANCE(asked_format->rgodf[j].dwType) == 0x00FF) || /* This is mentionned in no DX docs, but it works fine - tested on WinXP */
324 (DIDFT_GETINSTANCE(asked_format->rgodf[j].dwType) == DIDFT_GETINSTANCE(wine_format->rgodf[i].dwType)))
325 &&
326 ( /* Then if the asked type matches the one Wine provides */
327 wine_format->rgodf[i].dwType & asked_format->rgodf[j].dwType)) {
328
329 done[j] = 1;
330
331 TRACE("Matching :\n");
332 TRACE(" - Asked (%d) :\n", j);
333 TRACE(" * GUID: %s ('%s')\n",
334 debugstr_guid(asked_format->rgodf[j].pguid),
335 _dump_dinput_GUID(asked_format->rgodf[j].pguid));
336 TRACE(" * Offset: %3ld\n", asked_format->rgodf[j].dwOfs);
337 TRACE(" * dwType: %08lx\n", asked_format->rgodf[j].dwType);
338 TRACE(" "); _dump_EnumObjects_flags(asked_format->rgodf[j].dwType); TRACE("\n");
339
340 TRACE(" - Wine (%d) :\n", i);
341 TRACE(" * GUID: %s ('%s')\n",
342 debugstr_guid(wine_format->rgodf[i].pguid),
343 _dump_dinput_GUID(wine_format->rgodf[i].pguid));
344 TRACE(" * Offset: %3ld\n", wine_format->rgodf[i].dwOfs);
345 TRACE(" * dwType: %08lx\n", wine_format->rgodf[i].dwType);
346 TRACE(" "); _dump_EnumObjects_flags(wine_format->rgodf[i].dwType); TRACE("\n");
347
348 if (wine_format->rgodf[i].dwType & DIDFT_BUTTON)
349 dt[index].size = sizeof(BYTE);
350 else
351 dt[index].size = sizeof(DWORD);
352 dt[index].offset_in = wine_format->rgodf[i].dwOfs;
353 if (asked_format->rgodf[j].dwOfs < next) {
354 WARN("bad format: dwOfs=%ld, changing to %ld\n", asked_format->rgodf[j].dwOfs, next);
355 dt[index].offset_out = next;
356 offset[i] = next;
357 } else {
358 dt[index].offset_out = asked_format->rgodf[j].dwOfs;
359 offset[i] = asked_format->rgodf[j].dwOfs;
360 }
361 dt[index].value = 0;
362 next = next + dt[index].size;
363
364 if (wine_format->rgodf[i].dwOfs != dt[index].offset_out)
365 same = 0;
366
367 index++;
368 break;
369 }
370 }
371
372 if (j == asked_format->dwNumObjs)
373 same = 0;
374 }
375
376 TRACE("Setting to default value :\n");
377 for (j = 0; j < asked_format->dwNumObjs; j++) {
378 if (done[j] == 0) {
379 TRACE(" - Asked (%d) :\n", j);
380 TRACE(" * GUID: %s ('%s')\n",
381 debugstr_guid(asked_format->rgodf[j].pguid),
382 _dump_dinput_GUID(asked_format->rgodf[j].pguid));
383 TRACE(" * Offset: %3ld\n", asked_format->rgodf[j].dwOfs);
384 TRACE(" * dwType: %08lx\n", asked_format->rgodf[j].dwType);
385 TRACE(" "); _dump_EnumObjects_flags(asked_format->rgodf[j].dwType); TRACE("\n");
386
387 if (asked_format->rgodf[j].dwType & DIDFT_BUTTON)
388 dt[index].size = sizeof(BYTE);
389 else
390 dt[index].size = sizeof(DWORD);
391 dt[index].offset_in = -1;
392 dt[index].offset_out = asked_format->rgodf[j].dwOfs;
393 dt[index].value = 0;
394 index++;
395
396 same = 0;
397 }
398 }
399
400 ret->internal_format_size = wine_format->dwDataSize;
401 ret->size = index;
402 if (same) {
403 ret->dt = NULL;
404 HeapFree(GetProcessHeap(), 0, dt);
405 } else {
406 ret->dt = dt;
407 }
408
409 HeapFree(GetProcessHeap(), 0, done);
410
411 return ret;
412 }
413
414 BOOL DIEnumDevicesCallbackAtoW(LPCDIDEVICEOBJECTINSTANCEA lpddi, LPVOID lpvRef) {
415 DIDEVICEOBJECTINSTANCEW ddtmp;
416 device_enumobjects_AtoWcb_data* data;
417
418 data = (device_enumobjects_AtoWcb_data*) lpvRef;
419
420 memset(&ddtmp, 0, sizeof(ddtmp));
421
422 ddtmp.dwSize = sizeof(DIDEVICEINSTANCEW);
423 ddtmp.guidType = lpddi->guidType;
424 ddtmp.dwOfs = lpddi->dwOfs;
425 ddtmp.dwType = lpddi->dwType;
426 ddtmp.dwFlags = lpddi->dwFlags;
427 MultiByteToWideChar(CP_ACP, 0, lpddi->tszName, -1, ddtmp.tszName, MAX_PATH);
428
429 if (lpddi->dwSize == sizeof(DIDEVICEINSTANCEA)) {
430 /**
431 * if dwSize < sizeof(DIDEVICEINSTANCEA of DInput version >= 5)
432 * force feedback and other newer datas aren't available
433 */
434 ddtmp.dwFFMaxForce = lpddi->dwFFMaxForce;
435 ddtmp.dwFFForceResolution = lpddi->dwFFForceResolution;
436 ddtmp.wCollectionNumber = lpddi->wCollectionNumber;
437 ddtmp.wDesignatorIndex = lpddi->wDesignatorIndex;
438 ddtmp.wUsagePage = lpddi->wUsagePage;
439 ddtmp.wUsage = lpddi->wUsage;
440 ddtmp.dwDimension = lpddi->dwDimension;
441 ddtmp.wExponent = lpddi->wExponent;
442 ddtmp.wReserved = lpddi->wReserved;
443 }
444 return data->lpCallBack(&ddtmp, data->lpvRef);
445 }
446
447 /******************************************************************************
448 * IDirectInputDeviceA
449 */
450
451 HRESULT WINAPI IDirectInputDevice2AImpl_SetDataFormat(
452 LPDIRECTINPUTDEVICE8A iface,LPCDIDATAFORMAT df
453 ) {
454 IDirectInputDevice2AImpl *This = (IDirectInputDevice2AImpl *)iface;
455
456 TRACE("(this=%p,%p)\n",This,df);
457
458 _dump_DIDATAFORMAT(df);
459
460 return DI_OK;
461 }
462
463 HRESULT WINAPI IDirectInputDevice2AImpl_SetCooperativeLevel(
464 LPDIRECTINPUTDEVICE8A iface,HWND hwnd,DWORD dwflags
465 ) {
466 IDirectInputDevice2AImpl *This = (IDirectInputDevice2AImpl *)iface;
467 TRACE("(this=%p,%p,0x%08lx)\n",This,hwnd,dwflags);
468 if (TRACE_ON(dinput)) {
469 TRACE(" cooperative level : ");
470 _dump_cooperativelevel_DI(dwflags);
471 }
472 return DI_OK;
473 }
474
475 HRESULT WINAPI IDirectInputDevice2AImpl_SetEventNotification(
476 LPDIRECTINPUTDEVICE8A iface,HANDLE hnd
477 ) {
478 IDirectInputDevice2AImpl *This = (IDirectInputDevice2AImpl *)iface;
479 FIXME("(this=%p,%p): stub\n",This,hnd);
480 return DI_OK;
481 }
482
483 ULONG WINAPI IDirectInputDevice2AImpl_Release(LPDIRECTINPUTDEVICE8A iface)
484 {
485 IDirectInputDevice2AImpl *This = (IDirectInputDevice2AImpl *)iface;
486 ULONG ref;
487 ref = InterlockedDecrement(&(This->ref));
488 if (ref == 0)
489 HeapFree(GetProcessHeap(),0,This);
490 return ref;
491 }
492
493 HRESULT WINAPI IDirectInputDevice2AImpl_QueryInterface(
494 LPDIRECTINPUTDEVICE8A iface,REFIID riid,LPVOID *ppobj
495 )
496 {
497 IDirectInputDevice2AImpl *This = (IDirectInputDevice2AImpl *)iface;
498
499 TRACE("(this=%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
500 if (IsEqualGUID(&IID_IUnknown,riid)) {
501 IDirectInputDevice2_AddRef(iface);
502 *ppobj = This;
503 return DI_OK;
504 }
505 if (IsEqualGUID(&IID_IDirectInputDeviceA,riid)) {
506 IDirectInputDevice2_AddRef(iface);
507 *ppobj = This;
508 return DI_OK;
509 }
510 if (IsEqualGUID(&IID_IDirectInputDevice2A,riid)) {
511 IDirectInputDevice2_AddRef(iface);
512 *ppobj = This;
513 return DI_OK;
514 }
515 if (IsEqualGUID(&IID_IDirectInputDevice7A,riid)) {
516 IDirectInputDevice7_AddRef(iface);
517 *ppobj = This;
518 return DI_OK;
519 }
520 if (IsEqualGUID(&IID_IDirectInputDevice8A,riid)) {
521 IDirectInputDevice8_AddRef(iface);
522 *ppobj = This;
523 return DI_OK;
524 }
525 TRACE("Unsupported interface !\n");
526 return E_FAIL;
527 }
528
529 HRESULT WINAPI IDirectInputDevice2WImpl_QueryInterface(
530 LPDIRECTINPUTDEVICE8W iface,REFIID riid,LPVOID *ppobj
531 )
532 {
533 IDirectInputDevice2AImpl *This = (IDirectInputDevice2AImpl *)iface;
534
535 TRACE("(this=%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
536 if (IsEqualGUID(&IID_IUnknown,riid)) {
537 IDirectInputDevice2_AddRef(iface);
538 *ppobj = This;
539 return DI_OK;
540 }
541 if (IsEqualGUID(&IID_IDirectInputDeviceW,riid)) {
542 IDirectInputDevice2_AddRef(iface);
543 *ppobj = This;
544 return DI_OK;
545 }
546 if (IsEqualGUID(&IID_IDirectInputDevice2W,riid)) {
547 IDirectInputDevice2_AddRef(iface);
548 *ppobj = This;
549 return DI_OK;
550 }
551 if (IsEqualGUID(&IID_IDirectInputDevice7W,riid)) {
552 IDirectInputDevice7_AddRef(iface);
553 *ppobj = This;
554 return DI_OK;
555 }
556 if (IsEqualGUID(&IID_IDirectInputDevice8W,riid)) {
557 IDirectInputDevice8_AddRef(iface);
558 *ppobj = This;
559 return DI_OK;
560 }
561 TRACE("Unsupported interface !\n");
562 return E_FAIL;
563 }
564
565 ULONG WINAPI IDirectInputDevice2AImpl_AddRef(
566 LPDIRECTINPUTDEVICE8A iface)
567 {
568 IDirectInputDevice2AImpl *This = (IDirectInputDevice2AImpl *)iface;
569 return InterlockedIncrement(&(This->ref));
570 }
571
572 HRESULT WINAPI IDirectInputDevice2AImpl_EnumObjects(
573 LPDIRECTINPUTDEVICE8A iface,
574 LPDIENUMDEVICEOBJECTSCALLBACKA lpCallback,
575 LPVOID lpvRef,
576 DWORD dwFlags)
577 {
578 FIXME("(this=%p,%p,%p,%08lx): stub!\n", iface, lpCallback, lpvRef, dwFlags);
579 if (TRACE_ON(dinput)) {
580 DPRINTF(" - flags = ");
581 _dump_EnumObjects_flags(dwFlags);
582 DPRINTF("\n");
583 }
584
585 return DI_OK;
586 }
587
588 HRESULT WINAPI IDirectInputDevice2WImpl_EnumObjects(
589 LPDIRECTINPUTDEVICE8W iface,
590 LPDIENUMDEVICEOBJECTSCALLBACKW lpCallback,
591 LPVOID lpvRef,
592 DWORD dwFlags)
593 {
594 FIXME("(this=%p,%p,%p,%08lx): stub!\n", iface, lpCallback, lpvRef, dwFlags);
595 if (TRACE_ON(dinput)) {
596 DPRINTF(" - flags = ");
597 _dump_EnumObjects_flags(dwFlags);
598 DPRINTF("\n");
599 }
600
601 return DI_OK;
602 }
603
604 HRESULT WINAPI IDirectInputDevice2AImpl_GetProperty(
605 LPDIRECTINPUTDEVICE8A iface,
606 REFGUID rguid,
607 LPDIPROPHEADER pdiph)
608 {
609 FIXME("(this=%p,%s,%p): stub!\n",
610 iface, debugstr_guid(rguid), pdiph);
611
612 if (TRACE_ON(dinput))
613 _dump_DIPROPHEADER(pdiph);
614
615 return DI_OK;
616 }
617
618 HRESULT WINAPI IDirectInputDevice2AImpl_GetObjectInfo(
619 LPDIRECTINPUTDEVICE8A iface,
620 LPDIDEVICEOBJECTINSTANCEA pdidoi,
621 DWORD dwObj,
622 DWORD dwHow)
623 {
624 FIXME("(this=%p,%p,%ld,0x%08lx): stub!\n",
625 iface, pdidoi, dwObj, dwHow);
626
627 return DI_OK;
628 }
629
630 HRESULT WINAPI IDirectInputDevice2WImpl_GetObjectInfo(
631 LPDIRECTINPUTDEVICE8W iface,
632 LPDIDEVICEOBJECTINSTANCEW pdidoi,
633 DWORD dwObj,
634 DWORD dwHow)
635 {
636 FIXME("(this=%p,%p,%ld,0x%08lx): stub!\n",
637 iface, pdidoi, dwObj, dwHow);
638
639 return DI_OK;
640 }
641
642 HRESULT WINAPI IDirectInputDevice2AImpl_GetDeviceInfo(
643 LPDIRECTINPUTDEVICE8A iface,
644 LPDIDEVICEINSTANCEA pdidi)
645 {
646 FIXME("(this=%p,%p): stub!\n",
647 iface, pdidi);
648
649 return DI_OK;
650 }
651
652 HRESULT WINAPI IDirectInputDevice2WImpl_GetDeviceInfo(
653 LPDIRECTINPUTDEVICE8W iface,
654 LPDIDEVICEINSTANCEW pdidi)
655 {
656 FIXME("(this=%p,%p): stub!\n",
657 iface, pdidi);
658
659 return DI_OK;
660 }
661
662 HRESULT WINAPI IDirectInputDevice2AImpl_RunControlPanel(
663 LPDIRECTINPUTDEVICE8A iface,
664 HWND hwndOwner,
665 DWORD dwFlags)
666 {
667 FIXME("(this=%p,%p,0x%08lx): stub!\n",
668 iface, hwndOwner, dwFlags);
669
670 return DI_OK;
671 }
672
673 HRESULT WINAPI IDirectInputDevice2AImpl_Initialize(
674 LPDIRECTINPUTDEVICE8A iface,
675 HINSTANCE hinst,
676 DWORD dwVersion,
677 REFGUID rguid)
678 {
679 FIXME("(this=%p,%p,%ld,%s): stub!\n",
680 iface, hinst, dwVersion, debugstr_guid(rguid));
681 return DI_OK;
682 }
683
684 /******************************************************************************
685 * IDirectInputDevice2A
686 */
687
688 HRESULT WINAPI IDirectInputDevice2AImpl_CreateEffect(
689 LPDIRECTINPUTDEVICE8A iface,
690 REFGUID rguid,
691 LPCDIEFFECT lpeff,
692 LPDIRECTINPUTEFFECT *ppdef,
693 LPUNKNOWN pUnkOuter)
694 {
695 FIXME("(this=%p,%s,%p,%p,%p): stub!\n",
696 iface, debugstr_guid(rguid), lpeff, ppdef, pUnkOuter);
697 return DI_OK;
698 }
699
700 HRESULT WINAPI IDirectInputDevice2AImpl_EnumEffects(
701 LPDIRECTINPUTDEVICE8A iface,
702 LPDIENUMEFFECTSCALLBACKA lpCallback,
703 LPVOID lpvRef,
704 DWORD dwFlags)
705 {
706 FIXME("(this=%p,%p,%p,0x%08lx): stub!\n",
707 iface, lpCallback, lpvRef, dwFlags);
708
709 return DI_OK;
710 }
711
712 HRESULT WINAPI IDirectInputDevice2WImpl_EnumEffects(
713 LPDIRECTINPUTDEVICE8W iface,
714 LPDIENUMEFFECTSCALLBACKW lpCallback,
715 LPVOID lpvRef,
716 DWORD dwFlags)
717 {
718 FIXME("(this=%p,%p,%p,0x%08lx): stub!\n",
719 iface, lpCallback, lpvRef, dwFlags);
720
721 return DI_OK;
722 }
723
724 HRESULT WINAPI IDirectInputDevice2AImpl_GetEffectInfo(
725 LPDIRECTINPUTDEVICE8A iface,
726 LPDIEFFECTINFOA lpdei,
727 REFGUID rguid)
728 {
729 FIXME("(this=%p,%p,%s): stub!\n",
730 iface, lpdei, debugstr_guid(rguid));
731 return DI_OK;
732 }
733
734 HRESULT WINAPI IDirectInputDevice2WImpl_GetEffectInfo(
735 LPDIRECTINPUTDEVICE8W iface,
736 LPDIEFFECTINFOW lpdei,
737 REFGUID rguid)
738 {
739 FIXME("(this=%p,%p,%s): stub!\n",
740 iface, lpdei, debugstr_guid(rguid));
741 return DI_OK;
742 }
743
744 HRESULT WINAPI IDirectInputDevice2AImpl_GetForceFeedbackState(
745 LPDIRECTINPUTDEVICE8A iface,
746 LPDWORD pdwOut)
747 {
748 FIXME("(this=%p,%p): stub!\n",
749 iface, pdwOut);
750 return DI_OK;
751 }
752
753 HRESULT WINAPI IDirectInputDevice2AImpl_SendForceFeedbackCommand(
754 LPDIRECTINPUTDEVICE8A iface,
755 DWORD dwFlags)
756 {
757 FIXME("(this=%p,0x%08lx): stub!\n",
758 iface, dwFlags);
759 return DI_OK;
760 }
761
762 HRESULT WINAPI IDirectInputDevice2AImpl_EnumCreatedEffectObjects(
763 LPDIRECTINPUTDEVICE8A iface,
764 LPDIENUMCREATEDEFFECTOBJECTSCALLBACK lpCallback,
765 LPVOID lpvRef,
766 DWORD dwFlags)
767 {
768 FIXME("(this=%p,%p,%p,0x%08lx): stub!\n",
769 iface, lpCallback, lpvRef, dwFlags);
770 return DI_OK;
771 }
772
773 HRESULT WINAPI IDirectInputDevice2AImpl_Escape(
774 LPDIRECTINPUTDEVICE8A iface,
775 LPDIEFFESCAPE lpDIEEsc)
776 {
777 FIXME("(this=%p,%p): stub!\n",
778 iface, lpDIEEsc);
779 return DI_OK;
780 }
781
782 HRESULT WINAPI IDirectInputDevice2AImpl_Poll(
783 LPDIRECTINPUTDEVICE8A iface)
784 {
785 /* Because wine devices do not need to be polled, just return DI_NOEFFECT */
786 return DI_NOEFFECT;
787 }
788
789 HRESULT WINAPI IDirectInputDevice2AImpl_SendDeviceData(
790 LPDIRECTINPUTDEVICE8A iface,
791 DWORD cbObjectData,
792 LPCDIDEVICEOBJECTDATA rgdod,
793 LPDWORD pdwInOut,
794 DWORD dwFlags)
795 {
796 FIXME("(this=%p,0x%08lx,%p,%p,0x%08lx): stub!\n",
797 iface, cbObjectData, rgdod, pdwInOut, dwFlags);
798
799 return DI_OK;
800 }
801
802 HRESULT WINAPI IDirectInputDevice7AImpl_EnumEffectsInFile(LPDIRECTINPUTDEVICE8A iface,
803 LPCSTR lpszFileName,
804 LPDIENUMEFFECTSINFILECALLBACK pec,
805 LPVOID pvRef,
806 DWORD dwFlags)
807 {
808 FIXME("(%p)->(%s,%p,%p,%08lx): stub !\n", iface, lpszFileName, pec, pvRef, dwFlags);
809
810 return DI_OK;
811 }
812
813 HRESULT WINAPI IDirectInputDevice7WImpl_EnumEffectsInFile(LPDIRECTINPUTDEVICE8W iface,
814 LPCWSTR lpszFileName,
815 LPDIENUMEFFECTSINFILECALLBACK pec,
816 LPVOID pvRef,
817 DWORD dwFlags)
818 {
819 FIXME("(%p)->(%s,%p,%p,%08lx): stub !\n", iface, debugstr_w(lpszFileName), pec, pvRef, dwFlags);
820
821 return DI_OK;
822 }
823
824 HRESULT WINAPI IDirectInputDevice7AImpl_WriteEffectToFile(LPDIRECTINPUTDEVICE8A iface,
825 LPCSTR lpszFileName,
826 DWORD dwEntries,
827 LPDIFILEEFFECT rgDiFileEft,
828 DWORD dwFlags)
829 {
830 FIXME("(%p)->(%s,%08lx,%p,%08lx): stub !\n", iface, lpszFileName, dwEntries, rgDiFileEft, dwFlags);
831
832 return DI_OK;
833 }
834
835 HRESULT WINAPI IDirectInputDevice7WImpl_WriteEffectToFile(LPDIRECTINPUTDEVICE8W iface,
836 LPCWSTR lpszFileName,
837 DWORD dwEntries,
838 LPDIFILEEFFECT rgDiFileEft,
839 DWORD dwFlags)
840 {
841 FIXME("(%p)->(%s,%08lx,%p,%08lx): stub !\n", iface, debugstr_w(lpszFileName), dwEntries, rgDiFileEft, dwFlags);
842
843 return DI_OK;
844 }
845
846 HRESULT WINAPI IDirectInputDevice8AImpl_BuildActionMap(LPDIRECTINPUTDEVICE8A iface,
847 LPDIACTIONFORMATA lpdiaf,
848 LPCSTR lpszUserName,
849 DWORD dwFlags)
850 {
851 FIXME("(%p)->(%p,%s,%08lx): stub !\n", iface, lpdiaf, lpszUserName, dwFlags);
852
853 return DI_OK;
854 }
855
856 HRESULT WINAPI IDirectInputDevice8WImpl_BuildActionMap(LPDIRECTINPUTDEVICE8W iface,
857 LPDIACTIONFORMATW lpdiaf,
858 LPCWSTR lpszUserName,
859 DWORD dwFlags)
860 {
861 FIXME("(%p)->(%p,%s,%08lx): stub !\n", iface, lpdiaf, debugstr_w(lpszUserName), dwFlags);
862
863 return DI_OK;
864 }
865
866 HRESULT WINAPI IDirectInputDevice8AImpl_SetActionMap(LPDIRECTINPUTDEVICE8A iface,
867 LPDIACTIONFORMATA lpdiaf,
868 LPCSTR lpszUserName,
869 DWORD dwFlags)
870 {
871 FIXME("(%p)->(%p,%s,%08lx): stub !\n", iface, lpdiaf, lpszUserName, dwFlags);
872
873 return DI_OK;
874 }
875
876 HRESULT WINAPI IDirectInputDevice8WImpl_SetActionMap(LPDIRECTINPUTDEVICE8W iface,
877 LPDIACTIONFORMATW lpdiaf,
878 LPCWSTR lpszUserName,
879 DWORD dwFlags)
880 {
881 FIXME("(%p)->(%p,%s,%08lx): stub !\n", iface, lpdiaf, debugstr_w(lpszUserName), dwFlags);
882
883 return DI_OK;
884 }
885
886 HRESULT WINAPI IDirectInputDevice8AImpl_GetImageInfo(LPDIRECTINPUTDEVICE8A iface,
887 LPDIDEVICEIMAGEINFOHEADERA lpdiDevImageInfoHeader)
888 {
889 FIXME("(%p)->(%p): stub !\n", iface, lpdiDevImageInfoHeader);
890
891 return DI_OK;
892 }
893
894 HRESULT WINAPI IDirectInputDevice8WImpl_GetImageInfo(LPDIRECTINPUTDEVICE8W iface,
895 LPDIDEVICEIMAGEINFOHEADERW lpdiDevImageInfoHeader)
896 {
897 FIXME("(%p)->(%p): stub !\n", iface, lpdiDevImageInfoHeader);
898
899 return DI_OK;
900 }
Maarten's multimedia branch