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