?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Avoid referencing stackframe.h from outside kernel32.
[wine/testsucceed.git] / dlls / dinput / joystick_linux.c
blob14ad4b0e254eba80e8dca200142a6ab0df69f338
1 /* DirectInput Joystick device
2 *
3 * Copyright 1998 Marcus Meissner
4 * Copyright 1998,1999 Lionel Ulmer
5 * Copyright 2000-2001 TransGaming Technologies Inc.
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 /*
23 * To Do:
24 * dead zone
25 * force feedback
26 */
27
28 #include "config.h"
29 #include "wine/port.h"
30
31 #include <stdarg.h>
32 #include <stdio.h>
33 #include <string.h>
34 #include <time.h>
35 #include <errno.h>
36 #ifdef HAVE_UNISTD_H
37 # include <unistd.h>
38 #endif
39 #ifdef HAVE_SYS_TIME_H
40 # include <sys/time.h>
41 #endif
42 #include <sys/fcntl.h>
43 #ifdef HAVE_SYS_IOCTL_H
44 # include <sys/ioctl.h>
45 #endif
46 #include <errno.h>
47 #ifdef HAVE_SYS_ERRNO_H
48 # include <sys/errno.h>
49 #endif
50 #ifdef HAVE_LINUX_IOCTL_H
51 # include <linux/ioctl.h>
52 #endif
53 #ifdef HAVE_LINUX_JOYSTICK_H
54 # include <linux/joystick.h>
55 #endif
56
57 #include "wine/debug.h"
58 #include "wine/unicode.h"
59 #include "windef.h"
60 #include "winbase.h"
61 #include "winerror.h"
62 #include "winreg.h"
63 #include "dinput.h"
64
65 #include "dinput_private.h"
66 #include "device_private.h"
67
68 WINE_DEFAULT_DEBUG_CHANNEL(dinput);
69
70 #ifdef HAVE_LINUX_22_JOYSTICK_API
71
72 #define JOYDEV "/dev/js"
73
74 typedef struct {
75 LONG lMin;
76 LONG lMax;
77 LONG lDeadZone;
78 LONG lSaturation;
79 } ObjProps;
80
81 typedef struct {
82 LONG lX;
83 LONG lY;
84 } POV;
85
86 typedef struct JoystickImpl JoystickImpl;
87 static IDirectInputDevice8AVtbl JoystickAvt;
88 static IDirectInputDevice8WVtbl JoystickWvt;
89 struct JoystickImpl
90 {
91 LPVOID lpVtbl;
92 DWORD ref;
93 GUID guid;
94 char dev[32];
95
96 /* The 'parent' DInput */
97 IDirectInputImpl *dinput;
98
99 /* joystick private */
100 int joyfd;
101 DIJOYSTATE2 js; /* wine data */
102 LPDIDATAFORMAT user_df; /* user defined format */
103 DataFormat *transform; /* wine to user format converter */
104 int *offsets; /* object offsets */
105 ObjProps *props;
106 HANDLE hEvent;
107 LPDIDEVICEOBJECTDATA data_queue;
108 int queue_head, queue_tail, queue_len;
109 BOOL acquired;
110 char *name;
111 DIDEVCAPS devcaps;
112 LONG deadzone;
113 int *axis_map;
114 int axes;
115 int buttons;
116 POV povs[4];
117 CRITICAL_SECTION crit;
118 BOOL overflow;
119 };
120
121 static GUID DInput_Wine_Joystick_GUID = { /* 9e573ed9-7734-11d2-8d4a-23903fb6bdf7 */
122 0x9e573ed9,
123 0x7734,
124 0x11d2,
125 {0x8d, 0x4a, 0x23, 0x90, 0x3f, 0xb6, 0xbd, 0xf7}
126 };
127
128 static void _dump_DIDEVCAPS(LPDIDEVCAPS lpDIDevCaps)
129 {
130 TRACE("dwSize: %ld\n", lpDIDevCaps->dwSize);
131 TRACE("dwFlags: %08lx\n",lpDIDevCaps->dwFlags);
132 TRACE("dwDevType: %08lx %s\n", lpDIDevCaps->dwDevType,
133 lpDIDevCaps->dwDevType == DIDEVTYPE_DEVICE ? "DIDEVTYPE_DEVICE" :
134 lpDIDevCaps->dwDevType == DIDEVTYPE_DEVICE ? "DIDEVTYPE_DEVICE" :
135 lpDIDevCaps->dwDevType == DIDEVTYPE_MOUSE ? "DIDEVTYPE_MOUSE" :
136 lpDIDevCaps->dwDevType == DIDEVTYPE_KEYBOARD ? "DIDEVTYPE_KEYBOARD" :
137 lpDIDevCaps->dwDevType == DIDEVTYPE_JOYSTICK ? "DIDEVTYPE_JOYSTICK" :
138 lpDIDevCaps->dwDevType == DIDEVTYPE_HID ? "DIDEVTYPE_HID" : "UNKNOWN");
139 TRACE("dwAxes: %ld\n",lpDIDevCaps->dwAxes);
140 TRACE("dwButtons: %ld\n",lpDIDevCaps->dwButtons);
141 TRACE("dwPOVs: %ld\n",lpDIDevCaps->dwPOVs);
142 if (lpDIDevCaps->dwSize > sizeof(DIDEVCAPS_DX3)) {
143 TRACE("dwFFSamplePeriod: %ld\n",lpDIDevCaps->dwFFSamplePeriod);
144 TRACE("dwFFMinTimeResolution: %ld\n",lpDIDevCaps->dwFFMinTimeResolution);
145 TRACE("dwFirmwareRevision: %ld\n",lpDIDevCaps->dwFirmwareRevision);
146 TRACE("dwHardwareRevision: %ld\n",lpDIDevCaps->dwHardwareRevision);
147 TRACE("dwFFDriverVersion: %ld\n",lpDIDevCaps->dwFFDriverVersion);
148 }
149 }
150
151 static BOOL joydev_enum_deviceA(DWORD dwDevType, DWORD dwFlags, LPDIDEVICEINSTANCEA lpddi, DWORD version, int id)
152 {
153 int fd = -1;
154 char dev[32];
155
156 if (dwFlags & DIEDFL_FORCEFEEDBACK) {
157 WARN("force feedback not supported\n");
158 return FALSE;
159 }
160
161 if ((dwDevType == 0) ||
162 ((dwDevType == DIDEVTYPE_JOYSTICK) && (version > 0x0300 && version < 0x0800)) ||
163 (((dwDevType == DI8DEVCLASS_GAMECTRL) || (dwDevType == DI8DEVTYPE_JOYSTICK)) && (version >= 0x0800))) {
164 /* check whether we have a joystick */
165 sprintf(dev, "%s%d", JOYDEV, id);
166 if ((fd = open(dev,O_RDONLY)) < 0) {
167 WARN("open(%s,O_RDONLY) failed: %s\n", dev, strerror(errno));
168 return FALSE;
169 }
170
171 /* Return joystick */
172 lpddi->guidInstance = DInput_Wine_Joystick_GUID;
173 lpddi->guidInstance.Data3 = id;
174 lpddi->guidProduct = DInput_Wine_Joystick_GUID;
175 /* we only support traditional joysticks for now */
176 if (version >= 0x0800)
177 lpddi->dwDevType = DI8DEVTYPE_JOYSTICK | (DI8DEVTYPEJOYSTICK_STANDARD << 8);
178 else
179 lpddi->dwDevType = DIDEVTYPE_JOYSTICK | (DIDEVTYPEJOYSTICK_TRADITIONAL << 8);
180 sprintf(lpddi->tszInstanceName, "Joystick %d", id);
181 #if defined(JSIOCGNAME)
182 if (ioctl(fd,JSIOCGNAME(sizeof(lpddi->tszProductName)),lpddi->tszProductName) < 0) {
183 WARN("ioctl(%s,JSIOCGNAME) failed: %s\n", dev, strerror(errno));
184 strcpy(lpddi->tszProductName, "Wine Joystick");
185 }
186 #else
187 strcpy(lpddi->tszProductName, "Wine Joystick");
188 #endif
189
190 lpddi->guidFFDriver = GUID_NULL;
191 close(fd);
192 TRACE("Enumerating the linux Joystick device: %s (%s)\n", dev, lpddi->tszProductName);
193 return TRUE;
194 }
195
196 return FALSE;
197 }
198
199 static BOOL joydev_enum_deviceW(DWORD dwDevType, DWORD dwFlags, LPDIDEVICEINSTANCEW lpddi, DWORD version, int id)
200 {
201 int fd = -1;
202 char name[MAX_PATH];
203 char dev[32];
204 char friendly[32];
205
206 if (dwFlags & DIEDFL_FORCEFEEDBACK) {
207 WARN("force feedback not supported\n");
208 return FALSE;
209 }
210
211 if ((dwDevType == 0) ||
212 ((dwDevType == DIDEVTYPE_JOYSTICK) && (version > 0x0300 && version < 0x0800)) ||
213 (((dwDevType == DI8DEVCLASS_GAMECTRL) || (dwDevType == DI8DEVTYPE_JOYSTICK)) && (version >= 0x0800))) {
214 /* check whether we have a joystick */
215 sprintf(dev, "%s%d", JOYDEV, id);
216 if ((fd = open(dev,O_RDONLY)) < 0) {
217 WARN("open(%s,O_RDONLY) failed: %s\n", dev, strerror(errno));
218 return FALSE;
219 }
220
221 /* Return joystick */
222 lpddi->guidInstance = DInput_Wine_Joystick_GUID;
223 lpddi->guidInstance.Data3 = id;
224 lpddi->guidProduct = DInput_Wine_Joystick_GUID;
225 /* we only support traditional joysticks for now */
226 if (version >= 0x0800)
227 lpddi->dwDevType = DI8DEVTYPE_JOYSTICK | (DI8DEVTYPEJOYSTICK_STANDARD << 8);
228 else
229 lpddi->dwDevType = DIDEVTYPE_JOYSTICK | (DIDEVTYPEJOYSTICK_TRADITIONAL << 8);
230 sprintf(friendly, "Joystick %d", id);
231 MultiByteToWideChar(CP_ACP, 0, friendly, -1, lpddi->tszInstanceName, MAX_PATH);
232 #if defined(JSIOCGNAME)
233 if (ioctl(fd,JSIOCGNAME(sizeof(name)),name) < 0) {
234 WARN("ioctl(%s,JSIOCGNAME) failed: %s\n", dev, strerror(errno));
235 strcpy(name, "Wine Joystick");
236 }
237 #else
238 strcpy(name, "Wine Joystick");
239 #endif
240 MultiByteToWideChar(CP_ACP, 0, name, -1, lpddi->tszProductName, MAX_PATH);
241 lpddi->guidFFDriver = GUID_NULL;
242 close(fd);
243 TRACE("Enumerating the linux Joystick device: %s (%s)\n",dev,name);
244 return TRUE;
245 }
246
247 return FALSE;
248 }
249
250 /*
251 * Get a config key from either the app-specific or the default config
252 */
253
254 inline static DWORD get_config_key( HKEY defkey, HKEY appkey, const char *name,
255 char *buffer, DWORD size )
256 {
257 if (appkey && !RegQueryValueExA( appkey, name, 0, NULL, buffer, &size ))
258 return 0;
259
260 if (defkey && !RegQueryValueExA( defkey, name, 0, NULL, buffer, &size ))
261 return 0;
262
263 return ERROR_FILE_NOT_FOUND;
264 }
265
266 /*
267 * Setup the dinput options.
268 */
269
270 static HRESULT setup_dinput_options(JoystickImpl * device)
271 {
272 char buffer[MAX_PATH+1];
273 HKEY hkey, appkey = 0;
274 DWORD len;
275
276 buffer[MAX_PATH]='\0';
277
278 if (RegOpenKeyA( HKEY_LOCAL_MACHINE, "Software\\Wine\\dinput", &hkey)) hkey = 0;
279
280 len = GetModuleFileNameA( 0, buffer, MAX_PATH );
281 if (len && len < MAX_PATH) {
282 HKEY tmpkey;
283
284 if (!RegOpenKeyA( HKEY_LOCAL_MACHINE, "Software\\Wine\\AppDefaults", &tmpkey )) {
285 char appname[MAX_PATH+16];
286 char *p = strrchr( buffer, '\\' );
287 if (p!=NULL) {
288 strcpy(appname,p+1);
289 strcat(appname,"\\dinput");
290 TRACE("appname = [%s] \n",appname);
291 if (RegOpenKeyA( tmpkey, appname, &appkey )) appkey = 0;
292 }
293 RegCloseKey( tmpkey );
294 }
295 }
296
297 /* get options */
298
299 if (!get_config_key( hkey, appkey, "DefaultDeadZone", buffer, MAX_PATH )) {
300 device->deadzone = atoi(buffer);
301 TRACE("setting default deadzone to: \"%s\" %ld\n", buffer, device->deadzone);
302 }
303
304 if (!get_config_key( hkey, appkey, device->name, buffer, MAX_PATH )) {
305 int tokens = 0;
306 int axis = 0;
307 int pov = 0;
308 const char *delim = ",";
309 char * ptr;
310 TRACE("\"%s\" = \"%s\"\n", device->name, buffer);
311
312 device->axis_map = HeapAlloc(GetProcessHeap(), 0, device->axes * sizeof(int));
313 if (device->axis_map == 0)
314 return DIERR_OUTOFMEMORY;
315
316 if ((ptr = strtok(buffer, delim)) != NULL) {
317 do {
318 if (strcmp(ptr, "X") == 0) {
319 device->axis_map[tokens] = 0;
320 axis++;
321 } else if (strcmp(ptr, "Y") == 0) {
322 device->axis_map[tokens] = 1;
323 axis++;
324 } else if (strcmp(ptr, "Z") == 0) {
325 device->axis_map[tokens] = 2;
326 axis++;
327 } else if (strcmp(ptr, "Rx") == 0) {
328 device->axis_map[tokens] = 3;
329 axis++;
330 } else if (strcmp(ptr, "Ry") == 0) {
331 device->axis_map[tokens] = 4;
332 axis++;
333 } else if (strcmp(ptr, "Rz") == 0) {
334 device->axis_map[tokens] = 5;
335 axis++;
336 } else if (strcmp(ptr, "Slider1") == 0) {
337 device->axis_map[tokens] = 6;
338 axis++;
339 } else if (strcmp(ptr, "Slider2") == 0) {
340 device->axis_map[tokens] = 7;
341 axis++;
342 } else if (strcmp(ptr, "POV1") == 0) {
343 device->axis_map[tokens++] = 8;
344 device->axis_map[tokens] = 8;
345 pov++;
346 } else if (strcmp(ptr, "POV2") == 0) {
347 device->axis_map[tokens++] = 9;
348 device->axis_map[tokens] = 9;
349 pov++;
350 } else if (strcmp(ptr, "POV3") == 0) {
351 device->axis_map[tokens++] = 10;
352 device->axis_map[tokens] = 10;
353 pov++;
354 } else if (strcmp(ptr, "POV4") == 0) {
355 device->axis_map[tokens++] = 11;
356 device->axis_map[tokens] = 11;
357 pov++;
358 } else {
359 ERR("invalid joystick axis type: %s\n", ptr);
360 device->axis_map[tokens] = tokens;
361 axis++;
362 }
363
364 tokens++;
365 } while ((ptr = strtok(NULL, delim)) != NULL);
366
367 if (tokens != device->devcaps.dwAxes) {
368 ERR("not all joystick axes mapped: %d axes(%d,%d), %d arguments\n", device->axes, axis, pov,tokens);
369 while (tokens < device->axes) {
370 device->axis_map[tokens] = tokens;
371 tokens++;
372 }
373 }
374 }
375
376 device->devcaps.dwAxes = axis;
377 device->devcaps.dwPOVs = pov;
378 }
379
380 if (appkey)
381 RegCloseKey( appkey );
382
383 if (hkey)
384 RegCloseKey( hkey );
385
386 return DI_OK;
387 }
388
389 void calculate_ids(JoystickImpl* device)
390 {
391 int i;
392 int axis = 0;
393 int button = 0;
394 int pov = 0;
395 int axis_base;
396 int pov_base;
397 int button_base;
398
399 /* Make two passes over the format. The first counts the number
400 * for each type and the second sets the id */
401 for (i = 0; i < device->user_df->dwNumObjs; i++) {
402 if (DIDFT_GETTYPE(device->user_df->rgodf[i].dwType) & DIDFT_AXIS)
403 axis++;
404 else if (DIDFT_GETTYPE(device->user_df->rgodf[i].dwType) & DIDFT_POV)
405 pov++;
406 else if (DIDFT_GETTYPE(device->user_df->rgodf[i].dwType) & DIDFT_BUTTON)
407 button++;
408 }
409
410 axis_base = 0;
411 pov_base = axis;
412 button_base = axis + pov;
413
414 axis = 0;
415 button = 0;
416 pov = 0;
417
418 for (i = 0; i < device->user_df->dwNumObjs; i++) {
419 DWORD type = 0;
420 if (DIDFT_GETTYPE(device->user_df->rgodf[i].dwType) & DIDFT_AXIS) {
421 axis++;
422 type = DIDFT_GETTYPE(device->user_df->rgodf[i].dwType) |
423 DIDFT_MAKEINSTANCE(axis + axis_base);
424 TRACE("axis type = 0x%08lx\n", type);
425 } else if (DIDFT_GETTYPE(device->user_df->rgodf[i].dwType) & DIDFT_POV) {
426 pov++;
427 type = DIDFT_GETTYPE(device->user_df->rgodf[i].dwType) |
428 DIDFT_MAKEINSTANCE(pov + pov_base);
429 TRACE("POV type = 0x%08lx\n", type);
430 } else if (DIDFT_GETTYPE(device->user_df->rgodf[i].dwType) & DIDFT_BUTTON) {
431 button++;
432 type = DIDFT_GETTYPE(device->user_df->rgodf[i].dwType) |
433 DIDFT_MAKEINSTANCE(button + button_base);
434 TRACE("button type = 0x%08lx\n", type);
435 }
436 device->user_df->rgodf[i].dwType = type;
437 }
438 }
439
440 static HRESULT alloc_device(REFGUID rguid, LPVOID jvt, IDirectInputImpl *dinput, LPDIRECTINPUTDEVICEA* pdev)
441 {
442 DWORD i;
443 JoystickImpl* newDevice;
444 char name[MAX_PATH];
445 HRESULT hr;
446
447 newDevice = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(JoystickImpl));
448 if (newDevice == 0) {
449 WARN("out of memory\n");
450 *pdev = 0;
451 return DIERR_OUTOFMEMORY;
452 }
453
454 sprintf(newDevice->dev, "%s%d", JOYDEV, rguid->Data3);
455
456 if ((newDevice->joyfd = open(newDevice->dev,O_RDONLY)) < 0) {
457 WARN("open(%s,O_RDONLY) failed: %s\n", newDevice->dev, strerror(errno));
458 HeapFree(GetProcessHeap(), 0, newDevice);
459 return DIERR_DEVICENOTREG;
460 }
461
462 /* get the device name */
463 #if defined(JSIOCGNAME)
464 if (ioctl(newDevice->joyfd,JSIOCGNAME(MAX_PATH),name) < 0) {
465 WARN("ioctl(%s,JSIOCGNAME) failed: %s\n", newDevice->dev, strerror(errno));
466 strcpy(name, "Wine Joystick");
467 }
468 #else
469 strcpy(name, "Wine Joystick");
470 #endif
471
472 /* copy the device name */
473 newDevice->name = HeapAlloc(GetProcessHeap(),0,strlen(name) + 1);
474 strcpy(newDevice->name, name);
475
476 #ifdef JSIOCGAXES
477 if (ioctl(newDevice->joyfd,JSIOCGAXES,&newDevice->axes) < 0) {
478 WARN("ioctl(%s,JSIOCGAXES) failed: %s, defauting to 2\n", newDevice->dev, strerror(errno));
479 newDevice->axes = 2;
480 }
481 #endif
482 #ifdef JSIOCGBUTTONS
483 if (ioctl(newDevice->joyfd,JSIOCGBUTTONS,&newDevice->buttons) < 0) {
484 WARN("ioctl(%s,JSIOCGBUTTONS) failed: %s, defauting to 2\n", newDevice->dev, strerror(errno));
485 newDevice->buttons = 2;
486 }
487 #endif
488
489 newDevice->lpVtbl = jvt;
490 newDevice->ref = 1;
491 newDevice->dinput = dinput;
492 newDevice->acquired = FALSE;
493 newDevice->overflow = FALSE;
494 CopyMemory(&(newDevice->guid),rguid,sizeof(*rguid));
495
496 /* setup_dinput_options may change these */
497 newDevice->deadzone = 5000;
498 newDevice->devcaps.dwButtons = newDevice->buttons;
499 newDevice->devcaps.dwAxes = newDevice->axes;
500 newDevice->devcaps.dwPOVs = 0;
501
502 /* do any user specified configuration */
503 hr = setup_dinput_options(newDevice);
504 if (hr != DI_OK)
505 goto FAILED1;
506
507 if (newDevice->axis_map == 0) {
508 newDevice->axis_map = HeapAlloc(GetProcessHeap(), 0, newDevice->axes * sizeof(int));
509 if (newDevice->axis_map == 0)
510 goto FAILED;
511
512 for (i = 0; i < newDevice->axes; i++)
513 newDevice->axis_map[i] = i;
514 }
515
516 /* wine uses DIJOYSTATE2 as it's internal format so copy
517 * the already defined format c_dfDIJoystick2 */
518 newDevice->user_df = HeapAlloc(GetProcessHeap(),0,c_dfDIJoystick2.dwSize);
519 if (newDevice->user_df == 0)
520 goto FAILED;
521
522 CopyMemory(newDevice->user_df, &c_dfDIJoystick2, c_dfDIJoystick2.dwSize);
523
524 /* copy default objects */
525 newDevice->user_df->rgodf = HeapAlloc(GetProcessHeap(),0,c_dfDIJoystick2.dwNumObjs*c_dfDIJoystick2.dwObjSize);
526 if (newDevice->user_df->rgodf == 0)
527 goto FAILED;
528
529 CopyMemory(newDevice->user_df->rgodf,c_dfDIJoystick2.rgodf,c_dfDIJoystick2.dwNumObjs*c_dfDIJoystick2.dwObjSize);
530
531 /* create default properties */
532 newDevice->props = HeapAlloc(GetProcessHeap(),0,c_dfDIJoystick2.dwNumObjs*sizeof(ObjProps));
533 if (newDevice->props == 0)
534 goto FAILED;
535
536 /* initialize default properties */
537 for (i = 0; i < c_dfDIJoystick2.dwNumObjs; i++) {
538 newDevice->props[i].lMin = 0;
539 newDevice->props[i].lMax = 0xffff;
540 newDevice->props[i].lDeadZone = newDevice->deadzone; /* % * 1000 */
541 newDevice->props[i].lSaturation = 0;
542 }
543
544 /* create an offsets array */
545 newDevice->offsets = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,c_dfDIJoystick2.dwNumObjs*sizeof(int));
546 if (newDevice->offsets == 0)
547 goto FAILED;
548
549 /* create the default transform filter */
550 newDevice->transform = create_DataFormat(&c_dfDIJoystick2, newDevice->user_df, newDevice->offsets);
551
552 calculate_ids(newDevice);
553
554 IDirectInputDevice_AddRef((LPDIRECTINPUTDEVICE8A)newDevice->dinput);
555 InitializeCriticalSection(&(newDevice->crit));
556 newDevice->crit.DebugInfo->Spare[1] = (DWORD)"DINPUT_Mouse";
557
558 newDevice->devcaps.dwSize = sizeof(newDevice->devcaps);
559 newDevice->devcaps.dwFlags = DIDC_ATTACHED;
560 if (newDevice->dinput->dwVersion >= 0x0800)
561 newDevice->devcaps.dwDevType = DI8DEVTYPE_JOYSTICK | (DI8DEVTYPEJOYSTICK_STANDARD << 8);
562 else
563 newDevice->devcaps.dwDevType = DIDEVTYPE_JOYSTICK | (DIDEVTYPEJOYSTICK_TRADITIONAL << 8);
564 newDevice->devcaps.dwFFSamplePeriod = 0;
565 newDevice->devcaps.dwFFMinTimeResolution = 0;
566 newDevice->devcaps.dwFirmwareRevision = 0;
567 newDevice->devcaps.dwHardwareRevision = 0;
568 newDevice->devcaps.dwFFDriverVersion = 0;
569
570 if (TRACE_ON(dinput)) {
571 _dump_DIDATAFORMAT(newDevice->user_df);
572 for (i = 0; i < (newDevice->axes); i++)
573 TRACE("axis_map[%ld] = %d\n", i, newDevice->axis_map[i]);
574 _dump_DIDEVCAPS(&newDevice->devcaps);
575 }
576
577 *pdev = (LPDIRECTINPUTDEVICEA)newDevice;
578
579 return DI_OK;
580
581 FAILED:
582 hr = DIERR_OUTOFMEMORY;
583 FAILED1:
584 HeapFree(GetProcessHeap(),0,newDevice->axis_map);
585 HeapFree(GetProcessHeap(),0,newDevice->name);
586 HeapFree(GetProcessHeap(),0,newDevice->props);
587 HeapFree(GetProcessHeap(),0,newDevice->user_df->rgodf);
588 HeapFree(GetProcessHeap(),0,newDevice->user_df);
589 HeapFree(GetProcessHeap(),0,newDevice);
590 *pdev = 0;
591
592 return hr;
593 }
594
595 static BOOL IsJoystickGUID(REFGUID guid)
596 {
597 GUID wine_joystick = DInput_Wine_Joystick_GUID;
598 GUID dev_guid = *guid;
599
600 wine_joystick.Data3 = 0;
601 dev_guid.Data3 = 0;
602
603 return IsEqualGUID(&wine_joystick, &dev_guid);
604 }
605
606 static HRESULT joydev_create_deviceA(IDirectInputImpl *dinput, REFGUID rguid, REFIID riid, LPDIRECTINPUTDEVICEA* pdev)
607 {
608 if ((IsEqualGUID(&GUID_Joystick,rguid)) ||
609 (IsJoystickGUID(rguid))) {
610 if ((riid == NULL) ||
611 IsEqualGUID(&IID_IDirectInputDeviceA,riid) ||
612 IsEqualGUID(&IID_IDirectInputDevice2A,riid) ||
613 IsEqualGUID(&IID_IDirectInputDevice7A,riid) ||
614 IsEqualGUID(&IID_IDirectInputDevice8A,riid)) {
615 return alloc_device(rguid, &JoystickAvt, dinput, pdev);
616 } else {
617 WARN("no interface\n");
618 *pdev = 0;
619 return DIERR_NOINTERFACE;
620 }
621 }
622
623 WARN("invalid device GUID\n");
624 *pdev = 0;
625 return DIERR_DEVICENOTREG;
626 }
627
628 static HRESULT joydev_create_deviceW(IDirectInputImpl *dinput, REFGUID rguid, REFIID riid, LPDIRECTINPUTDEVICEW* pdev)
629 {
630 if ((IsEqualGUID(&GUID_Joystick,rguid)) ||
631 (IsJoystickGUID(rguid))) {
632 if ((riid == NULL) ||
633 IsEqualGUID(&IID_IDirectInputDeviceW,riid) ||
634 IsEqualGUID(&IID_IDirectInputDevice2W,riid) ||
635 IsEqualGUID(&IID_IDirectInputDevice7W,riid) ||
636 IsEqualGUID(&IID_IDirectInputDevice8W,riid)) {
637 return alloc_device(rguid, &JoystickWvt, dinput, (LPDIRECTINPUTDEVICEA *)pdev);
638 } else {
639 WARN("no interface\n");
640 *pdev = 0;
641 return DIERR_NOINTERFACE;
642 }
643 }
644
645 WARN("invalid device GUID\n");
646 *pdev = 0;
647 return DIERR_DEVICENOTREG;
648 }
649
650 const struct dinput_device joystick_linux_device = {
651 "Wine Linux joystick driver",
652 joydev_enum_deviceA,
653 joydev_enum_deviceW,
654 joydev_create_deviceA,
655 joydev_create_deviceW
656 };
657
658 /******************************************************************************
659 * Joystick
660 */
661 static ULONG WINAPI JoystickAImpl_Release(LPDIRECTINPUTDEVICE8A iface)
662 {
663 JoystickImpl *This = (JoystickImpl *)iface;
664 ULONG ref;
665
666 ref = InterlockedDecrement((&This->ref));
667 if (ref)
668 return ref;
669
670 /* Free the device name */
671 HeapFree(GetProcessHeap(),0,This->name);
672
673 /* Free the axis map */
674 HeapFree(GetProcessHeap(),0,This->axis_map);
675
676 /* Free the data queue */
677 HeapFree(GetProcessHeap(),0,This->data_queue);
678
679 /* Free the DataFormat */
680 HeapFree(GetProcessHeap(), 0, This->user_df->rgodf);
681 HeapFree(GetProcessHeap(), 0, This->user_df);
682
683 /* Free the properties */
684 HeapFree(GetProcessHeap(), 0, This->props);
685
686 /* Free the offsets array */
687 HeapFree(GetProcessHeap(),0,This->offsets);
688
689 /* release the data transform filter */
690 release_DataFormat(This->transform);
691
692 This->crit.DebugInfo->Spare[1] = 0;
693 DeleteCriticalSection(&(This->crit));
694 IDirectInputDevice_Release((LPDIRECTINPUTDEVICE8A)This->dinput);
695
696 HeapFree(GetProcessHeap(),0,This);
697 return 0;
698 }
699
700 /******************************************************************************
701 * SetDataFormat : the application can choose the format of the data
702 * the device driver sends back with GetDeviceState.
703 */
704 static HRESULT WINAPI JoystickAImpl_SetDataFormat(
705 LPDIRECTINPUTDEVICE8A iface,
706 LPCDIDATAFORMAT df)
707 {
708 JoystickImpl *This = (JoystickImpl *)iface;
709 unsigned int i;
710 LPDIDATAFORMAT new_df = 0;
711 LPDIOBJECTDATAFORMAT new_rgodf = 0;
712 ObjProps * new_props = 0;
713
714 TRACE("(%p,%p)\n",This,df);
715
716 if (df == NULL) {
717 WARN("invalid pointer\n");
718 return E_POINTER;
719 }
720
721 if (df->dwSize != sizeof(*df)) {
722 WARN("invalid argument\n");
723 return DIERR_INVALIDPARAM;
724 }
725
726 if (This->acquired) {
727 WARN("acquired\n");
728 return DIERR_ACQUIRED;
729 }
730
731 if (TRACE_ON(dinput))
732 _dump_DIDATAFORMAT(df);
733
734 /* Store the new data format */
735 new_df = HeapAlloc(GetProcessHeap(),0,df->dwSize);
736 if (new_df == 0)
737 goto FAILED;
738
739 new_rgodf = HeapAlloc(GetProcessHeap(),0,df->dwNumObjs*df->dwObjSize);
740 if (new_rgodf == 0)
741 goto FAILED;
742
743 new_props = HeapAlloc(GetProcessHeap(),0,df->dwNumObjs*sizeof(ObjProps));
744 if (new_props == 0)
745 goto FAILED;
746
747 HeapFree(GetProcessHeap(),0,This->user_df);
748 HeapFree(GetProcessHeap(),0,This->user_df->rgodf);
749 HeapFree(GetProcessHeap(),0,This->props);
750 release_DataFormat(This->transform);
751
752 This->user_df = new_df;
753 CopyMemory(This->user_df, df, df->dwSize);
754 This->user_df->rgodf = new_rgodf;
755 CopyMemory(This->user_df->rgodf,df->rgodf,df->dwNumObjs*df->dwObjSize);
756 This->props = new_props;
757 for (i = 0; i < df->dwNumObjs; i++) {
758 This->props[i].lMin = 0;
759 This->props[i].lMax = 0xffff;
760 This->props[i].lDeadZone = 1000;
761 This->props[i].lSaturation = 0;
762 }
763 This->transform = create_DataFormat(&c_dfDIJoystick2, This->user_df, This->offsets);
764
765 calculate_ids(This);
766
767 return DI_OK;
768
769 FAILED:
770 WARN("out of memory\n");
771 HeapFree(GetProcessHeap(),0,new_props);
772 HeapFree(GetProcessHeap(),0,new_rgodf);
773 HeapFree(GetProcessHeap(),0,new_df);
774 return DIERR_OUTOFMEMORY;
775 }
776
777 /******************************************************************************
778 * Acquire : gets exclusive control of the joystick
779 */
780 static HRESULT WINAPI JoystickAImpl_Acquire(LPDIRECTINPUTDEVICE8A iface)
781 {
782 JoystickImpl *This = (JoystickImpl *)iface;
783
784 TRACE("(%p)\n",This);
785
786 if (This->acquired) {
787 WARN("already acquired\n");
788 return S_FALSE;
789 }
790
791 /* open the joystick device */
792 if (This->joyfd==-1) {
793 TRACE("opening joystick device %s\n", This->dev);
794
795 This->joyfd=open(This->dev,O_RDONLY);
796 if (This->joyfd==-1) {
797 ERR("open(%s) failed: %s\n", This->dev, strerror(errno));
798 return DIERR_NOTFOUND;
799 }
800 }
801
802 This->acquired = TRUE;
803
804 return DI_OK;
805 }
806
807 /******************************************************************************
808 * Unacquire : frees the joystick
809 */
810 static HRESULT WINAPI JoystickAImpl_Unacquire(LPDIRECTINPUTDEVICE8A iface)
811 {
812 JoystickImpl *This = (JoystickImpl *)iface;
813
814 TRACE("(%p)\n",This);
815
816 if (!This->acquired) {
817 WARN("not acquired\n");
818 return DIERR_NOTACQUIRED;
819 }
820
821 if (This->joyfd!=-1) {
822 TRACE("closing joystick device\n");
823 close(This->joyfd);
824 This->joyfd = -1;
825 This->acquired = FALSE;
826 return DI_OK;
827 }
828
829 This->acquired = FALSE;
830
831 return DI_NOEFFECT;
832 }
833
834 LONG map_axis(JoystickImpl * This, short val, short index)
835 {
836 double fval = val;
837 double fmin = This->props[index].lMin;
838 double fmax = This->props[index].lMax;
839 double fret;
840
841 fret = (((fval + 32767.0) * (fmax - fmin)) / (32767.0*2.0)) + fmin;
842
843 if (fret >= 0.0)
844 fret += 0.5;
845 else
846 fret -= 0.5;
847
848 return fret;
849 }
850
851 /* convert wine format offset to user format object index */
852 int offset_to_object(JoystickImpl *This, int offset)
853 {
854 int i;
855
856 for (i = 0; i < This->user_df->dwNumObjs; i++) {
857 if (This->user_df->rgodf[i].dwOfs == offset)
858 return i;
859 }
860
861 return -1;
862 }
863
864 static LONG calculate_pov(JoystickImpl *This, int index)
865 {
866 if (This->povs[index].lX < 16384) {
867 if (This->povs[index].lY < 16384)
868 This->js.rgdwPOV[index] = 31500;
869 else if (This->povs[index].lY > 49150)
870 This->js.rgdwPOV[index] = 22500;
871 else
872 This->js.rgdwPOV[index] = 27000;
873 } else if (This->povs[index].lX > 49150) {
874 if (This->povs[index].lY < 16384)
875 This->js.rgdwPOV[index] = 4500;
876 else if (This->povs[index].lY > 49150)
877 This->js.rgdwPOV[index] = 13500;
878 else
879 This->js.rgdwPOV[index] = 9000;
880 } else {
881 if (This->povs[index].lY < 16384)
882 This->js.rgdwPOV[index] = 0;
883 else if (This->povs[index].lY > 49150)
884 This->js.rgdwPOV[index] = 18000;
885 else
886 This->js.rgdwPOV[index] = -1;
887 }
888
889 return This->js.rgdwPOV[index];
890 }
891
892 static void joy_polldev(JoystickImpl *This) {
893 struct timeval tv;
894 fd_set readfds;
895 struct js_event jse;
896 TRACE("(%p)\n", This);
897
898 if (This->joyfd==-1) {
899 WARN("no device\n");
900 return;
901 }
902 while (1) {
903 memset(&tv,0,sizeof(tv));
904 FD_ZERO(&readfds);FD_SET(This->joyfd,&readfds);
905 if (1>select(This->joyfd+1,&readfds,NULL,NULL,&tv))
906 return;
907 /* we have one event, so we can read */
908 if (sizeof(jse)!=read(This->joyfd,&jse,sizeof(jse))) {
909 return;
910 }
911 TRACE("js_event: type 0x%x, number %d, value %d\n",
912 jse.type,jse.number,jse.value);
913 if (jse.type & JS_EVENT_BUTTON) {
914 int offset = This->offsets[jse.number + 12];
915 int value = jse.value?0x80:0x00;
916
917 This->js.rgbButtons[jse.number] = value;
918 GEN_EVENT(offset,value,jse.time,(This->dinput->evsequence)++);
919 } else if (jse.type & JS_EVENT_AXIS) {
920 int number = This->axis_map[jse.number]; /* wine format object index */
921 if (number < 12) {
922 int offset = This->offsets[number];
923 int index = offset_to_object(This, offset);
924 LONG value = map_axis(This, jse.value, index);
925
926 /* FIXME do deadzone and saturation here */
927
928 TRACE("changing axis %d => %d\n", jse.number, number);
929 switch (number) {
930 case 0:
931 This->js.lX = value;
932 break;
933 case 1:
934 This->js.lY = value;
935 break;
936 case 2:
937 This->js.lZ = value;
938 break;
939 case 3:
940 This->js.lRx = value;
941 break;
942 case 4:
943 This->js.lRy = value;
944 break;
945 case 5:
946 This->js.lRz = value;
947 break;
948 case 6:
949 This->js.rglSlider[0] = value;
950 break;
951 case 7:
952 This->js.rglSlider[1] = value;
953 break;
954 case 8:
955 /* FIXME don't go off array */
956 if (This->axis_map[jse.number + 1] == number)
957 This->povs[0].lX = value;
958 else if (This->axis_map[jse.number - 1] == number)
959 This->povs[0].lY = value;
960 value = calculate_pov(This, 0);
961 break;
962 case 9:
963 if (This->axis_map[jse.number + 1] == number)
964 This->povs[1].lX = value;
965 else if (This->axis_map[jse.number - 1] == number)
966 This->povs[1].lY = value;
967 value = calculate_pov(This, 1);
968 break;
969 case 10:
970 if (This->axis_map[jse.number + 1] == number)
971 This->povs[2].lX = value;
972 else if (This->axis_map[jse.number - 1] == number)
973 This->povs[2].lY = value;
974 value = calculate_pov(This, 2);
975 break;
976 case 11:
977 if (This->axis_map[jse.number + 1] == number)
978 This->povs[3].lX = value;
979 else if (This->axis_map[jse.number - 1] == number)
980 This->povs[3].lY = value;
981 value = calculate_pov(This, 3);
982 break;
983 }
984
985 GEN_EVENT(offset,value,jse.time,(This->dinput->evsequence)++);
986 } else
987 WARN("axis %d not supported\n", number);
988 }
989 }
990 }
991
992 /******************************************************************************
993 * GetDeviceState : returns the "state" of the joystick.
994 *
995 */
996 static HRESULT WINAPI JoystickAImpl_GetDeviceState(
997 LPDIRECTINPUTDEVICE8A iface,
998 DWORD len,
999 LPVOID ptr)
1000 {
1001 JoystickImpl *This = (JoystickImpl *)iface;
1002
1003 TRACE("(%p,0x%08lx,%p)\n",This,len,ptr);
1004
1005 if (!This->acquired) {
1006 WARN("not acquired\n");
1007 return DIERR_NOTACQUIRED;
1008 }
1009
1010 /* update joystick state */
1011 joy_polldev(This);
1012
1013 /* convert and copy data to user supplied buffer */
1014 fill_DataFormat(ptr, &This->js, This->transform);
1015
1016 return DI_OK;
1017 }
1018
1019 /******************************************************************************
1020 * GetDeviceData : gets buffered input data.
1021 */
1022 static HRESULT WINAPI JoystickAImpl_GetDeviceData(
1023 LPDIRECTINPUTDEVICE8A iface,
1024 DWORD dodsize,
1025 LPDIDEVICEOBJECTDATA dod,
1026 LPDWORD entries,
1027 DWORD flags)
1028 {
1029 JoystickImpl *This = (JoystickImpl *)iface;
1030 DWORD len;
1031 int nqtail;
1032 HRESULT hr = DI_OK;
1033
1034 TRACE("(%p)->(dods=%ld,entries=%ld,fl=0x%08lx)\n",This,dodsize,*entries,flags);
1035
1036 if (!This->acquired) {
1037 WARN("not acquired\n");
1038 return DIERR_NOTACQUIRED;
1039 }
1040
1041 EnterCriticalSection(&(This->crit));
1042
1043 joy_polldev(This);
1044
1045 len = ((This->queue_head < This->queue_tail) ? This->queue_len : 0)
1046 + (This->queue_head - This->queue_tail);
1047 if (len > *entries)
1048 len = *entries;
1049
1050 if (dod == NULL) {
1051 if (len)
1052 TRACE("Application discarding %ld event(s).\n", len);
1053
1054 *entries = len;
1055 nqtail = This->queue_tail + len;
1056 while (nqtail >= This->queue_len)
1057 nqtail -= This->queue_len;
1058 } else {
1059 if (dodsize < sizeof(DIDEVICEOBJECTDATA_DX3)) {
1060 ERR("Wrong structure size !\n");
1061 LeaveCriticalSection(&(This->crit));
1062 return DIERR_INVALIDPARAM;
1063 }
1064
1065 if (len)
1066 TRACE("Application retrieving %ld event(s).\n", len);
1067
1068 *entries = 0;
1069 nqtail = This->queue_tail;
1070 while (len) {
1071 /* Copy the buffered data into the application queue */
1072 memcpy((char *)dod + *entries * dodsize, This->data_queue + nqtail, dodsize);
1073 /* Advance position */
1074 nqtail++;
1075 if (nqtail >= This->queue_len)
1076 nqtail -= This->queue_len;
1077 (*entries)++;
1078 len--;
1079 }
1080 }
1081
1082 if (This->overflow) {
1083 hr = DI_BUFFEROVERFLOW;
1084 if (!(flags & DIGDD_PEEK)) {
1085 This->overflow = FALSE;
1086 }
1087 }
1088
1089 if (!(flags & DIGDD_PEEK))
1090 This->queue_tail = nqtail;
1091
1092 LeaveCriticalSection(&(This->crit));
1093
1094 return hr;
1095 }
1096
1097 int find_property(JoystickImpl * This, LPCDIPROPHEADER ph)
1098 {
1099 int i;
1100 if (ph->dwHow == DIPH_BYOFFSET) {
1101 return offset_to_object(This, ph->dwObj);
1102 } else if (ph->dwHow == DIPH_BYID) {
1103 for (i = 0; i < This->user_df->dwNumObjs; i++) {
1104 if ((This->user_df->rgodf[i].dwType & 0x00ffffff) == (ph->dwObj & 0x00ffffff)) {
1105 return i;
1106 }
1107 }
1108 }
1109
1110 return -1;
1111 }
1112
1113 /******************************************************************************
1114 * SetProperty : change input device properties
1115 */
1116 static HRESULT WINAPI JoystickAImpl_SetProperty(
1117 LPDIRECTINPUTDEVICE8A iface,
1118 REFGUID rguid,
1119 LPCDIPROPHEADER ph)
1120 {
1121 JoystickImpl *This = (JoystickImpl *)iface;
1122 int i;
1123
1124 TRACE("(%p,%s,%p)\n",This,debugstr_guid(rguid),ph);
1125
1126 if (ph == NULL) {
1127 WARN("invalid parameter: ph == NULL\n");
1128 return DIERR_INVALIDPARAM;
1129 }
1130
1131 if (TRACE_ON(dinput))
1132 _dump_DIPROPHEADER(ph);
1133
1134 if (!HIWORD(rguid)) {
1135 switch ((DWORD)rguid) {
1136 case (DWORD) DIPROP_BUFFERSIZE: {
1137 LPCDIPROPDWORD pd = (LPCDIPROPDWORD)ph;
1138 TRACE("buffersize = %ld\n",pd->dwData);
1139 if (This->data_queue)
1140 This->data_queue = HeapReAlloc(GetProcessHeap(),0, This->data_queue, pd->dwData * sizeof(DIDEVICEOBJECTDATA));
1141 else
1142 This->data_queue = HeapAlloc(GetProcessHeap(),0, pd->dwData * sizeof(DIDEVICEOBJECTDATA));
1143 This->queue_head = 0;
1144 This->queue_tail = 0;
1145 This->queue_len = pd->dwData;
1146 break;
1147 }
1148 case (DWORD)DIPROP_RANGE: {
1149 LPCDIPROPRANGE pr = (LPCDIPROPRANGE)ph;
1150 if (ph->dwHow == DIPH_DEVICE) {
1151 TRACE("proprange(%ld,%ld) all\n",pr->lMin,pr->lMax);
1152 for (i = 0; i < This->user_df->dwNumObjs; i++) {
1153 This->props[i].lMin = pr->lMin;
1154 This->props[i].lMax = pr->lMax;
1155 }
1156 } else {
1157 int obj = find_property(This, ph);
1158 TRACE("proprange(%ld,%ld) obj=%d\n",pr->lMin,pr->lMax,obj);
1159 if (obj >= 0) {
1160 This->props[obj].lMin = pr->lMin;
1161 This->props[obj].lMax = pr->lMax;
1162 return DI_OK;
1163 }
1164 }
1165 break;
1166 }
1167 case (DWORD)DIPROP_DEADZONE: {
1168 LPCDIPROPDWORD pd = (LPCDIPROPDWORD)ph;
1169 if (ph->dwHow == DIPH_DEVICE) {
1170 TRACE("deadzone(%ld) all\n",pd->dwData);
1171 for (i = 0; i < This->user_df->dwNumObjs; i++)
1172 This->props[i].lDeadZone = pd->dwData;
1173 } else {
1174 int obj = find_property(This, ph);
1175 TRACE("deadzone(%ld) obj=%d\n",pd->dwData,obj);
1176 if (obj >= 0) {
1177 This->props[obj].lDeadZone = pd->dwData;
1178 return DI_OK;
1179 }
1180 }
1181 break;
1182 }
1183 case (DWORD)DIPROP_SATURATION: {
1184 LPCDIPROPDWORD pd = (LPCDIPROPDWORD)ph;
1185 if (ph->dwHow == DIPH_DEVICE) {
1186 TRACE("saturation(%ld) all\n",pd->dwData);
1187 for (i = 0; i < This->user_df->dwNumObjs; i++)
1188 This->props[i].lSaturation = pd->dwData;
1189 } else {
1190 int obj = find_property(This, ph);
1191 TRACE("saturation(%ld) obj=%d\n",pd->dwData,obj);
1192 if (obj >= 0) {
1193 This->props[obj].lSaturation = pd->dwData;
1194 return DI_OK;
1195 }
1196 }
1197 break;
1198 }
1199 default:
1200 FIXME("Unknown type %ld (%s)\n",(DWORD)rguid,debugstr_guid(rguid));
1201 break;
1202 }
1203 }
1204
1205 return DI_OK;
1206 }
1207
1208 /******************************************************************************
1209 * SetEventNotification : specifies event to be sent on state change
1210 */
1211 static HRESULT WINAPI JoystickAImpl_SetEventNotification(
1212 LPDIRECTINPUTDEVICE8A iface, HANDLE hnd
1213 ) {
1214 JoystickImpl *This = (JoystickImpl *)iface;
1215
1216 TRACE("(this=%p,0x%08lx)\n",This,(DWORD)hnd);
1217 This->hEvent = hnd;
1218 return DI_OK;
1219 }
1220
1221 static HRESULT WINAPI JoystickAImpl_GetCapabilities(
1222 LPDIRECTINPUTDEVICE8A iface,
1223 LPDIDEVCAPS lpDIDevCaps)
1224 {
1225 JoystickImpl *This = (JoystickImpl *)iface;
1226 int size;
1227
1228 TRACE("%p->(%p)\n",iface,lpDIDevCaps);
1229
1230 if (lpDIDevCaps == NULL) {
1231 WARN("invalid pointer\n");
1232 return E_POINTER;
1233 }
1234
1235 size = lpDIDevCaps->dwSize;
1236
1237 if (!(size == sizeof(DIDEVCAPS) || size == sizeof(DIDEVCAPS_DX3))) {
1238 WARN("invalid parameter\n");
1239 return DIERR_INVALIDPARAM;
1240 }
1241
1242 CopyMemory(lpDIDevCaps, &This->devcaps, size);
1243 lpDIDevCaps->dwSize = size;
1244
1245 if (TRACE_ON(dinput))
1246 _dump_DIDEVCAPS(lpDIDevCaps);
1247
1248 return DI_OK;
1249 }
1250
1251 static HRESULT WINAPI JoystickAImpl_Poll(LPDIRECTINPUTDEVICE8A iface)
1252 {
1253 JoystickImpl *This = (JoystickImpl *)iface;
1254
1255 TRACE("(%p)\n",This);
1256
1257 if (!This->acquired) {
1258 WARN("not acquired\n");
1259 return DIERR_NOTACQUIRED;
1260 }
1261
1262 joy_polldev(This);
1263 return DI_OK;
1264 }
1265
1266 /******************************************************************************
1267 * EnumObjects : enumerate the different buttons and axis...
1268 */
1269 static HRESULT WINAPI JoystickAImpl_EnumObjects(
1270 LPDIRECTINPUTDEVICE8A iface,
1271 LPDIENUMDEVICEOBJECTSCALLBACKA lpCallback,
1272 LPVOID lpvRef,
1273 DWORD dwFlags)
1274 {
1275 JoystickImpl *This = (JoystickImpl *)iface;
1276 DIDEVICEOBJECTINSTANCEA ddoi;
1277 BYTE i;
1278 int user_offset;
1279 int user_object;
1280
1281 TRACE("(this=%p,%p,%p,%08lx)\n", This, lpCallback, lpvRef, dwFlags);
1282 if (TRACE_ON(dinput)) {
1283 TRACE(" - flags = ");
1284 _dump_EnumObjects_flags(dwFlags);
1285 TRACE("\n");
1286 }
1287
1288 /* Only the fields till dwFFMaxForce are relevant */
1289 ddoi.dwSize = FIELD_OFFSET(DIDEVICEOBJECTINSTANCEA, dwFFMaxForce);
1290
1291 /* For the joystick, do as is done in the GetCapabilities function */
1292 if ((dwFlags == DIDFT_ALL) ||
1293 (dwFlags & DIDFT_AXIS) ||
1294 (dwFlags & DIDFT_POV)) {
1295 int pov[4] = { 0, 0, 0, 0 };
1296 int axes = 0;
1297 int povs = 0;
1298
1299 for (i = 0; i < This->axes; i++) {
1300 int wine_obj = This->axis_map[i];
1301 BOOL skip = FALSE;
1302
1303 switch (wine_obj) {
1304 case 0:
1305 ddoi.guidType = GUID_XAxis;
1306 break;
1307 case 1:
1308 ddoi.guidType = GUID_YAxis;
1309 break;
1310 case 2:
1311 ddoi.guidType = GUID_ZAxis;
1312 break;
1313 case 3:
1314 ddoi.guidType = GUID_RxAxis;
1315 break;
1316 case 4:
1317 ddoi.guidType = GUID_RyAxis;
1318 break;
1319 case 5:
1320 ddoi.guidType = GUID_RzAxis;
1321 break;
1322 case 6:
1323 ddoi.guidType = GUID_Slider;
1324 break;
1325 case 7:
1326 ddoi.guidType = GUID_Slider;
1327 break;
1328 case 8:
1329 pov[0]++;
1330 ddoi.guidType = GUID_POV;
1331 break;
1332 case 9:
1333 pov[1]++;
1334 ddoi.guidType = GUID_POV;
1335 break;
1336 case 10:
1337 pov[2]++;
1338 ddoi.guidType = GUID_POV;
1339 break;
1340 case 11:
1341 pov[3]++;
1342 ddoi.guidType = GUID_POV;
1343 break;
1344 default:
1345 ddoi.guidType = GUID_Unknown;
1346 }
1347 if (wine_obj < 8) {
1348 user_offset = This->offsets[wine_obj]; /* get user offset from wine index */
1349 user_object = offset_to_object(This, user_offset);
1350
1351 ddoi.dwType = This->user_df->rgodf[user_object].dwType & 0x00ffffff;
1352 ddoi.dwOfs = This->user_df->rgodf[user_object].dwOfs;
1353 sprintf(ddoi.tszName, "Axis %d", axes);
1354 axes++;
1355 } else {
1356 if (pov[wine_obj - 8] < 2) {
1357 user_offset = This->offsets[wine_obj]; /* get user offset from wine index */
1358 user_object = offset_to_object(This, user_offset);
1359
1360 ddoi.dwType = This->user_df->rgodf[user_object].dwType & 0x00ffffff;
1361 ddoi.dwOfs = This->user_df->rgodf[user_object].dwOfs;
1362 sprintf(ddoi.tszName, "POV %d", povs);
1363 povs++;
1364 } else
1365 skip = TRUE;
1366 }
1367 if (!skip) {
1368 _dump_OBJECTINSTANCEA(&ddoi);
1369 if (lpCallback(&ddoi, lpvRef) != DIENUM_CONTINUE)
1370 return DI_OK;
1371 }
1372 }
1373 }
1374
1375 if ((dwFlags == DIDFT_ALL) ||
1376 (dwFlags & DIDFT_BUTTON)) {
1377
1378 /* The DInput SDK says that GUID_Button is only for mouse buttons but well... */
1379 ddoi.guidType = GUID_Button;
1380
1381 for (i = 0; i < This->buttons; i++) {
1382 user_offset = This->offsets[i + 12]; /* get user offset from wine index */
1383 user_object = offset_to_object(This, user_offset);
1384 ddoi.guidType = GUID_Button;
1385 ddoi.dwType = This->user_df->rgodf[user_object].dwType & 0x00ffffff;
1386 ddoi.dwOfs = This->user_df->rgodf[user_object].dwOfs;
1387 sprintf(ddoi.tszName, "Button %d", i);
1388 _dump_OBJECTINSTANCEA(&ddoi);
1389 if (lpCallback(&ddoi, lpvRef) != DIENUM_CONTINUE) return DI_OK;
1390 }
1391 }
1392
1393 return DI_OK;
1394 }
1395
1396 /******************************************************************************
1397 * EnumObjects : enumerate the different buttons and axis...
1398 */
1399 static HRESULT WINAPI JoystickWImpl_EnumObjects(
1400 LPDIRECTINPUTDEVICE8W iface,
1401 LPDIENUMDEVICEOBJECTSCALLBACKW lpCallback,
1402 LPVOID lpvRef,
1403 DWORD dwFlags)
1404 {
1405 JoystickImpl *This = (JoystickImpl *)iface;
1406
1407 device_enumobjects_AtoWcb_data data;
1408
1409 data.lpCallBack = lpCallback;
1410 data.lpvRef = lpvRef;
1411
1412 return JoystickAImpl_EnumObjects((LPDIRECTINPUTDEVICE8A) This, (LPDIENUMDEVICEOBJECTSCALLBACKA) DIEnumDevicesCallbackAtoW, (LPVOID) &data, dwFlags);
1413 }
1414
1415 /******************************************************************************
1416 * GetProperty : get input device properties
1417 */
1418 static HRESULT WINAPI JoystickAImpl_GetProperty(
1419 LPDIRECTINPUTDEVICE8A iface,
1420 REFGUID rguid,
1421 LPDIPROPHEADER pdiph)
1422 {
1423 JoystickImpl *This = (JoystickImpl *)iface;
1424
1425 TRACE("(%p,%s,%p)\n", iface, debugstr_guid(rguid), pdiph);
1426
1427 if (TRACE_ON(dinput))
1428 _dump_DIPROPHEADER(pdiph);
1429
1430 if (!HIWORD(rguid)) {
1431 switch ((DWORD)rguid) {
1432 case (DWORD) DIPROP_BUFFERSIZE: {
1433 LPDIPROPDWORD pd = (LPDIPROPDWORD)pdiph;
1434 TRACE(" return buffersize = %d\n",This->queue_len);
1435 pd->dwData = This->queue_len;
1436 break;
1437 }
1438 case (DWORD) DIPROP_RANGE: {
1439 LPDIPROPRANGE pr = (LPDIPROPRANGE) pdiph;
1440 int obj = find_property(This, pdiph);
1441 /* The app is querying the current range of the axis
1442 * return the lMin and lMax values */
1443 if (obj >= 0) {
1444 pr->lMin = This->props[obj].lMin;
1445 pr->lMax = This->props[obj].lMax;
1446 TRACE("range(%ld, %ld) obj=%d\n", pr->lMin, pr->lMax, obj);
1447 return DI_OK;
1448 }
1449 break;
1450 }
1451 case (DWORD) DIPROP_DEADZONE: {
1452 LPDIPROPDWORD pd = (LPDIPROPDWORD)pdiph;
1453 int obj = find_property(This, pdiph);
1454 if (obj >= 0) {
1455 pd->dwData = This->props[obj].lDeadZone;
1456 TRACE("deadzone(%ld) obj=%d\n", pd->dwData, obj);
1457 return DI_OK;
1458 }
1459 break;
1460 }
1461 case (DWORD) DIPROP_SATURATION: {
1462 LPDIPROPDWORD pd = (LPDIPROPDWORD)pdiph;
1463 int obj = find_property(This, pdiph);
1464 if (obj >= 0) {
1465 pd->dwData = This->props[obj].lSaturation;
1466 TRACE("saturation(%ld) obj=%d\n", pd->dwData, obj);
1467 return DI_OK;
1468 }
1469 break;
1470 }
1471 default:
1472 FIXME("Unknown type %ld (%s)\n",(DWORD)rguid,debugstr_guid(rguid));
1473 break;
1474 }
1475 }
1476
1477 return DI_OK;
1478 }
1479
1480 /******************************************************************************
1481 * GetObjectInfo : get object info
1482 */
1483 HRESULT WINAPI JoystickAImpl_GetObjectInfo(
1484 LPDIRECTINPUTDEVICE8A iface,
1485 LPDIDEVICEOBJECTINSTANCEA pdidoi,
1486 DWORD dwObj,
1487 DWORD dwHow)
1488 {
1489 JoystickImpl *This = (JoystickImpl *)iface;
1490 DIDEVICEOBJECTINSTANCEA didoiA;
1491 unsigned int i;
1492
1493 TRACE("(%p,%p,%ld,0x%08lx(%s))\n",
1494 iface, pdidoi, dwObj, dwHow,
1495 dwHow == DIPH_BYOFFSET ? "DIPH_BYOFFSET" :
1496 dwHow == DIPH_BYID ? "DIPH_BYID" :
1497 dwHow == DIPH_BYUSAGE ? "DIPH_BYUSAGE" :
1498 "UNKNOWN");
1499
1500 if (pdidoi == NULL) {
1501 WARN("invalid parameter: pdidoi = NULL\n");
1502 return DIERR_INVALIDPARAM;
1503 }
1504
1505 if ((pdidoi->dwSize != sizeof(DIDEVICEOBJECTINSTANCEA)) &&
1506 (pdidoi->dwSize != sizeof(DIDEVICEOBJECTINSTANCE_DX3A))) {
1507 WARN("invalid parameter: pdidoi->dwSize = %ld != %d or %d\n",
1508 pdidoi->dwSize, sizeof(DIDEVICEOBJECTINSTANCEA),
1509 sizeof(DIDEVICEOBJECTINSTANCE_DX3A));
1510 return DIERR_INVALIDPARAM;
1511 }
1512
1513 ZeroMemory(&didoiA, sizeof(didoiA));
1514 didoiA.dwSize = pdidoi->dwSize;
1515
1516 switch (dwHow) {
1517 case DIPH_BYOFFSET: {
1518 int axis = 0;
1519 int pov = 0;
1520 int button = 0;
1521 for (i = 0; i < This->user_df->dwNumObjs; i++) {
1522 if (This->user_df->rgodf[i].dwOfs == dwObj) {
1523 if (This->user_df->rgodf[i].pguid)
1524 didoiA.guidType = *This->user_df->rgodf[i].pguid;
1525 else
1526 didoiA.guidType = GUID_NULL;
1527
1528 didoiA.dwOfs = dwObj;
1529 didoiA.dwType = This->user_df->rgodf[i].dwType;
1530 didoiA.dwFlags = This->user_df->rgodf[i].dwFlags;
1531
1532 if (DIDFT_GETTYPE(This->user_df->rgodf[i].dwType) & DIDFT_AXIS)
1533 sprintf(didoiA.tszName, "Axis %d", axis);
1534 else if (DIDFT_GETTYPE(This->user_df->rgodf[i].dwType) & DIDFT_POV)
1535 sprintf(didoiA.tszName, "POV %d", pov);
1536 else if (DIDFT_GETTYPE(This->user_df->rgodf[i].dwType) & DIDFT_BUTTON)
1537 sprintf(didoiA.tszName, "Button %d", button);
1538
1539 CopyMemory(pdidoi, &didoiA, pdidoi->dwSize);
1540 return DI_OK;
1541 }
1542
1543 if (DIDFT_GETTYPE(This->user_df->rgodf[i].dwType) & DIDFT_AXIS)
1544 axis++;
1545 else if (DIDFT_GETTYPE(This->user_df->rgodf[i].dwType) & DIDFT_POV)
1546 pov++;
1547 else if (DIDFT_GETTYPE(This->user_df->rgodf[i].dwType) & DIDFT_BUTTON)
1548 button++;
1549 }
1550 break;
1551 }
1552 case DIPH_BYID:
1553 FIXME("dwHow = DIPH_BYID not implemented\n");
1554 break;
1555 case DIPH_BYUSAGE:
1556 FIXME("dwHow = DIPH_BYUSAGE not implemented\n");
1557 break;
1558 default:
1559 WARN("invalid parameter: dwHow = %08lx\n", dwHow);
1560 return DIERR_INVALIDPARAM;
1561 }
1562
1563 CopyMemory(pdidoi, &didoiA, pdidoi->dwSize);
1564
1565 return DI_OK;
1566 }
1567
1568 /******************************************************************************
1569 * GetDeviceInfo : get information about a device's identity
1570 */
1571 HRESULT WINAPI JoystickAImpl_GetDeviceInfo(
1572 LPDIRECTINPUTDEVICE8A iface,
1573 LPDIDEVICEINSTANCEA pdidi)
1574 {
1575 JoystickImpl *This = (JoystickImpl *)iface;
1576
1577 TRACE("(%p,%p)\n", iface, pdidi);
1578
1579 if (pdidi == NULL) {
1580 WARN("invalid pointer\n");
1581 return E_POINTER;
1582 }
1583
1584 if ((pdidi->dwSize != sizeof(DIDEVICEINSTANCE_DX3A)) &&
1585 (pdidi->dwSize != sizeof(DIDEVICEINSTANCEA))) {
1586 WARN("invalid parameter: pdidi->dwSize = %ld != %d or %d\n",
1587 pdidi->dwSize, sizeof(DIDEVICEINSTANCE_DX3A),
1588 sizeof(DIDEVICEINSTANCEA));
1589 return DIERR_INVALIDPARAM;
1590 }
1591
1592 /* Return joystick */
1593 pdidi->guidInstance = GUID_Joystick;
1594 pdidi->guidProduct = DInput_Wine_Joystick_GUID;
1595 /* we only support traditional joysticks for now */
1596 pdidi->dwDevType = This->devcaps.dwDevType;
1597 strcpy(pdidi->tszInstanceName, "Joystick");
1598 strcpy(pdidi->tszProductName, This->name);
1599 if (pdidi->dwSize > sizeof(DIDEVICEINSTANCE_DX3A)) {
1600 pdidi->guidFFDriver = GUID_NULL;
1601 pdidi->wUsagePage = 0;
1602 pdidi->wUsage = 0;
1603 }
1604
1605 return DI_OK;
1606 }
1607
1608 /******************************************************************************
1609 * GetDeviceInfo : get information about a device's identity
1610 */
1611 HRESULT WINAPI JoystickWImpl_GetDeviceInfo(
1612 LPDIRECTINPUTDEVICE8W iface,
1613 LPDIDEVICEINSTANCEW pdidi)
1614 {
1615 JoystickImpl *This = (JoystickImpl *)iface;
1616
1617 TRACE("(%p,%p)\n", iface, pdidi);
1618
1619 if ((pdidi->dwSize != sizeof(DIDEVICEINSTANCE_DX3W)) &&
1620 (pdidi->dwSize != sizeof(DIDEVICEINSTANCEW))) {
1621 WARN("invalid parameter: pdidi->dwSize = %ld != %d or %d\n",
1622 pdidi->dwSize, sizeof(DIDEVICEINSTANCE_DX3W),
1623 sizeof(DIDEVICEINSTANCEW));
1624 return DIERR_INVALIDPARAM;
1625 }
1626
1627 /* Return joystick */
1628 pdidi->guidInstance = GUID_Joystick;
1629 pdidi->guidProduct = DInput_Wine_Joystick_GUID;
1630 /* we only support traditional joysticks for now */
1631 pdidi->dwDevType = This->devcaps.dwDevType;
1632 MultiByteToWideChar(CP_ACP, 0, "Joystick", -1, pdidi->tszInstanceName, MAX_PATH);
1633 MultiByteToWideChar(CP_ACP, 0, This->name, -1, pdidi->tszProductName, MAX_PATH);
1634 if (pdidi->dwSize > sizeof(DIDEVICEINSTANCE_DX3W)) {
1635 pdidi->guidFFDriver = GUID_NULL;
1636 pdidi->wUsagePage = 0;
1637 pdidi->wUsage = 0;
1638 }
1639
1640 return DI_OK;
1641 }
1642
1643 static IDirectInputDevice8AVtbl JoystickAvt =
1644 {
1645 IDirectInputDevice2AImpl_QueryInterface,
1646 IDirectInputDevice2AImpl_AddRef,
1647 JoystickAImpl_Release,
1648 JoystickAImpl_GetCapabilities,
1649 JoystickAImpl_EnumObjects,
1650 JoystickAImpl_GetProperty,
1651 JoystickAImpl_SetProperty,
1652 JoystickAImpl_Acquire,
1653 JoystickAImpl_Unacquire,
1654 JoystickAImpl_GetDeviceState,
1655 JoystickAImpl_GetDeviceData,
1656 JoystickAImpl_SetDataFormat,
1657 JoystickAImpl_SetEventNotification,
1658 IDirectInputDevice2AImpl_SetCooperativeLevel,
1659 JoystickAImpl_GetObjectInfo,
1660 JoystickAImpl_GetDeviceInfo,
1661 IDirectInputDevice2AImpl_RunControlPanel,
1662 IDirectInputDevice2AImpl_Initialize,
1663 IDirectInputDevice2AImpl_CreateEffect,
1664 IDirectInputDevice2AImpl_EnumEffects,
1665 IDirectInputDevice2AImpl_GetEffectInfo,
1666 IDirectInputDevice2AImpl_GetForceFeedbackState,
1667 IDirectInputDevice2AImpl_SendForceFeedbackCommand,
1668 IDirectInputDevice2AImpl_EnumCreatedEffectObjects,
1669 IDirectInputDevice2AImpl_Escape,
1670 JoystickAImpl_Poll,
1671 IDirectInputDevice2AImpl_SendDeviceData,
1672 IDirectInputDevice7AImpl_EnumEffectsInFile,
1673 IDirectInputDevice7AImpl_WriteEffectToFile,
1674 IDirectInputDevice8AImpl_BuildActionMap,
1675 IDirectInputDevice8AImpl_SetActionMap,
1676 IDirectInputDevice8AImpl_GetImageInfo
1677 };
1678
1679 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
1680 # define XCAST(fun) (typeof(SysJoystickWvt.fun))
1681 #else
1682 # define XCAST(fun) (void*)
1683 #endif
1684
1685 static IDirectInputDevice8WVtbl SysJoystickWvt =
1686 {
1687 IDirectInputDevice2WImpl_QueryInterface,
1688 XCAST(AddRef)IDirectInputDevice2AImpl_AddRef,
1689 XCAST(Release)JoystickAImpl_Release,
1690 XCAST(GetCapabilities)JoystickAImpl_GetCapabilities,
1691 JoystickWImpl_EnumObjects,
1692 XCAST(GetProperty)JoystickAImpl_GetProperty,
1693 XCAST(SetProperty)JoystickAImpl_SetProperty,
1694 XCAST(Acquire)JoystickAImpl_Acquire,
1695 XCAST(Unacquire)JoystickAImpl_Unacquire,
1696 XCAST(GetDeviceState)JoystickAImpl_GetDeviceState,
1697 XCAST(GetDeviceData)JoystickAImpl_GetDeviceData,
1698 XCAST(SetDataFormat)JoystickAImpl_SetDataFormat,
1699 XCAST(SetEventNotification)JoystickAImpl_SetEventNotification,
1700 XCAST(SetCooperativeLevel)IDirectInputDevice2AImpl_SetCooperativeLevel,
1701 IDirectInputDevice2WImpl_GetObjectInfo,
1702 JoystickWImpl_GetDeviceInfo,
1703 XCAST(RunControlPanel)IDirectInputDevice2AImpl_RunControlPanel,
1704 XCAST(Initialize)IDirectInputDevice2AImpl_Initialize,
1705 XCAST(CreateEffect)IDirectInputDevice2AImpl_CreateEffect,
1706 IDirectInputDevice2WImpl_EnumEffects,
1707 IDirectInputDevice2WImpl_GetEffectInfo,
1708 XCAST(GetForceFeedbackState)IDirectInputDevice2AImpl_GetForceFeedbackState,
1709 XCAST(SendForceFeedbackCommand)IDirectInputDevice2AImpl_SendForceFeedbackCommand,
1710 XCAST(EnumCreatedEffectObjects)IDirectInputDevice2AImpl_EnumCreatedEffectObjects,
1711 XCAST(Escape)IDirectInputDevice2AImpl_Escape,
1712 XCAST(Poll)JoystickAImpl_Poll,
1713 XCAST(SendDeviceData)IDirectInputDevice2AImpl_SendDeviceData,
1714 IDirectInputDevice7WImpl_EnumEffectsInFile,
1715 IDirectInputDevice7WImpl_WriteEffectToFile,
1716 IDirectInputDevice8WImpl_BuildActionMap,
1717 IDirectInputDevice8WImpl_SetActionMap,
1718 IDirectInputDevice8WImpl_GetImageInfo
1719 };
1720 #undef XCAST
1721
1722 #else /* HAVE_LINUX_22_JOYSTICK_API */
1723
1724 const struct dinput_device joystick_linux_device = {
1725 "Wine Linux joystick driver",
1726 NULL,
1727 NULL,
1728 NULL,
1729 NULL
1730 };
1731
1732 #endif /* HAVE_LINUX_22_JOYSTICK_API */
Quick hack tree for wine patches julliard doesn't want to commit