?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Use IsWindowVisible instead of GetWindowLong(GWL_STYLE) & WS_VISIBLE
[wine.git] / dlls / dinput / joystick_linux.c
blob4562ed5c314046ba9e8fb3c45dc30e1c130ac3ad
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 #ifdef HAVE_LINUX_22_JOYSTICK_API
32
33 #include <stdarg.h>
34 #include <stdio.h>
35 #include <string.h>
36 #include <time.h>
37 #include <errno.h>
38 #ifdef HAVE_UNISTD_H
39 # include <unistd.h>
40 #endif
41 #ifdef HAVE_SYS_TIME_H
42 # include <sys/time.h>
43 #endif
44 #include <sys/fcntl.h>
45 #ifdef HAVE_SYS_IOCTL_H
46 # include <sys/ioctl.h>
47 #endif
48 #include <errno.h>
49 #ifdef HAVE_SYS_ERRNO_H
50 # include <sys/errno.h>
51 #endif
52 #ifdef HAVE_LINUX_IOCTL_H
53 # include <linux/ioctl.h>
54 #endif
55 #ifdef HAVE_LINUX_JOYSTICK_H
56 # include <linux/joystick.h>
57 #endif
58 #define JOYDEV "/dev/js"
59
60 #include "wine/debug.h"
61 #include "wine/unicode.h"
62 #include "windef.h"
63 #include "winbase.h"
64 #include "winerror.h"
65 #include "winreg.h"
66 #include "dinput.h"
67
68 #include "dinput_private.h"
69 #include "device_private.h"
70
71 WINE_DEFAULT_DEBUG_CHANNEL(dinput);
72
73 typedef struct {
74 LONG lMin;
75 LONG lMax;
76 LONG lDeadZone;
77 LONG lSaturation;
78 } ObjProps;
79
80 typedef struct {
81 LONG lX;
82 LONG lY;
83 } POV;
84
85 typedef struct JoystickImpl JoystickImpl;
86 static IDirectInputDevice8AVtbl JoystickAvt;
87 static IDirectInputDevice8WVtbl JoystickWvt;
88 struct JoystickImpl
89 {
90 LPVOID lpVtbl;
91 DWORD ref;
92 GUID guid;
93 char dev[32];
94
95 /* The 'parent' DInput */
96 IDirectInputImpl *dinput;
97
98 /* joystick private */
99 int joyfd;
100 DIJOYSTATE2 js; /* wine data */
101 LPDIDATAFORMAT user_df; /* user defined format */
102 DataFormat *transform; /* wine to user format converter */
103 int *offsets; /* object offsets */
104 ObjProps *props;
105 HANDLE hEvent;
106 LPDIDEVICEOBJECTDATA data_queue;
107 int queue_head, queue_tail, queue_len;
108 BOOL acquired;
109 char *name;
110 DIDEVCAPS devcaps;
111 LONG deadzone;
112 int *axis_map;
113 int axes;
114 int buttons;
115 POV povs[4];
116 CRITICAL_SECTION crit;
117 BOOL overflow;
118 };
119
120 static GUID DInput_Wine_Joystick_GUID = { /* 9e573ed9-7734-11d2-8d4a-23903fb6bdf7 */
121 0x9e573ed9,
122 0x7734,
123 0x11d2,
124 {0x8d, 0x4a, 0x23, 0x90, 0x3f, 0xb6, 0xbd, 0xf7}
125 };
126
127 static void _dump_DIDEVCAPS(LPDIDEVCAPS lpDIDevCaps)
128 {
129 TRACE("dwSize: %ld\n", lpDIDevCaps->dwSize);
130 TRACE("dwFlags: %08lx\n",lpDIDevCaps->dwFlags);
131 TRACE("dwDevType: %08lx %s\n", lpDIDevCaps->dwDevType,
132 lpDIDevCaps->dwDevType == DIDEVTYPE_DEVICE ? "DIDEVTYPE_DEVICE" :
133 lpDIDevCaps->dwDevType == DIDEVTYPE_DEVICE ? "DIDEVTYPE_DEVICE" :
134 lpDIDevCaps->dwDevType == DIDEVTYPE_MOUSE ? "DIDEVTYPE_MOUSE" :
135 lpDIDevCaps->dwDevType == DIDEVTYPE_KEYBOARD ? "DIDEVTYPE_KEYBOARD" :
136 lpDIDevCaps->dwDevType == DIDEVTYPE_JOYSTICK ? "DIDEVTYPE_JOYSTICK" :
137 lpDIDevCaps->dwDevType == DIDEVTYPE_HID ? "DIDEVTYPE_HID" : "UNKNOWN");
138 TRACE("dwAxes: %ld\n",lpDIDevCaps->dwAxes);
139 TRACE("dwButtons: %ld\n",lpDIDevCaps->dwButtons);
140 TRACE("dwPOVs: %ld\n",lpDIDevCaps->dwPOVs);
141 if (lpDIDevCaps->dwSize > sizeof(DIDEVCAPS_DX3)) {
142 TRACE("dwFFSamplePeriod: %ld\n",lpDIDevCaps->dwFFSamplePeriod);
143 TRACE("dwFFMinTimeResolution: %ld\n",lpDIDevCaps->dwFFMinTimeResolution);
144 TRACE("dwFirmwareRevision: %ld\n",lpDIDevCaps->dwFirmwareRevision);
145 TRACE("dwHardwareRevision: %ld\n",lpDIDevCaps->dwHardwareRevision);
146 TRACE("dwFFDriverVersion: %ld\n",lpDIDevCaps->dwFFDriverVersion);
147 }
148 }
149
150 static BOOL joydev_enum_deviceA(DWORD dwDevType, DWORD dwFlags, LPDIDEVICEINSTANCEA lpddi, int version, int id)
151 {
152 int fd = -1;
153 char dev[32];
154
155 if (dwFlags & DIEDFL_FORCEFEEDBACK) {
156 WARN("force feedback not supported\n");
157 return FALSE;
158 }
159
160 if ((dwDevType == 0) ||
161 ((dwDevType == DIDEVTYPE_JOYSTICK) && (version < 8)) ||
162 (((dwDevType == DI8DEVCLASS_GAMECTRL) || (dwDevType == DI8DEVTYPE_JOYSTICK)) && (version >= 8))) {
163 /* check whether we have a joystick */
164 sprintf(dev, "%s%d", JOYDEV, id);
165 if ((fd = open(dev,O_RDONLY)) < 0) {
166 WARN("open(%s,O_RDONLY) failed: %s\n", dev, strerror(errno));
167 return FALSE;
168 }
169
170 /* Return joystick */
171 lpddi->guidInstance = DInput_Wine_Joystick_GUID;
172 lpddi->guidInstance.Data3 = id;
173 lpddi->guidProduct = DInput_Wine_Joystick_GUID;
174 /* we only support traditional joysticks for now */
175 if (version >= 8)
176 lpddi->dwDevType = DI8DEVTYPE_JOYSTICK | (DI8DEVTYPEJOYSTICK_STANDARD << 8);
177 else
178 lpddi->dwDevType = DIDEVTYPE_JOYSTICK | (DIDEVTYPEJOYSTICK_TRADITIONAL << 8);
179 sprintf(lpddi->tszInstanceName, "Joystick %d", id);
180 #if defined(JSIOCGNAME)
181 if (ioctl(fd,JSIOCGNAME(sizeof(lpddi->tszProductName)),lpddi->tszProductName) < 0) {
182 WARN("ioctl(%s,JSIOCGNAME) failed: %s\n", dev, strerror(errno));
183 strcpy(lpddi->tszProductName, "Wine Joystick");
184 }
185 #else
186 strcpy(lpddi->tszProductName, "Wine Joystick");
187 #endif
188
189 lpddi->guidFFDriver = GUID_NULL;
190 close(fd);
191 TRACE("Enumerating the linux Joystick device: %s (%s)\n", dev, lpddi->tszProductName);
192 return TRUE;
193 }
194
195 return FALSE;
196 }
197
198 static BOOL joydev_enum_deviceW(DWORD dwDevType, DWORD dwFlags, LPDIDEVICEINSTANCEW lpddi, int version, int id)
199 {
200 int fd = -1;
201 char name[MAX_PATH];
202 char dev[32];
203 char friendly[32];
204
205 if (dwFlags & DIEDFL_FORCEFEEDBACK) {
206 WARN("force feedback not supported\n");
207 return FALSE;
208 }
209
210 if ((dwDevType == 0) ||
211 ((dwDevType == DIDEVTYPE_JOYSTICK) && (version < 8)) ||
212 (((dwDevType == DI8DEVCLASS_GAMECTRL) || (dwDevType == DI8DEVTYPE_JOYSTICK)) && (version >= 8))) {
213 /* check whether we have a joystick */
214 sprintf(dev, "%s%d", JOYDEV, id);
215 if ((fd = open(dev,O_RDONLY)) < 0) {
216 WARN("open(%s,O_RDONLY) failed: %s\n", dev, strerror(errno));
217 return FALSE;
218 }
219
220 /* Return joystick */
221 lpddi->guidInstance = DInput_Wine_Joystick_GUID;
222 lpddi->guidInstance.Data3 = id;
223 lpddi->guidProduct = DInput_Wine_Joystick_GUID;
224 /* we only support traditional joysticks for now */
225 if (version >= 8)
226 lpddi->dwDevType = DI8DEVTYPE_JOYSTICK | (DI8DEVTYPEJOYSTICK_STANDARD << 8);
227 else
228 lpddi->dwDevType = DIDEVTYPE_JOYSTICK | (DIDEVTYPEJOYSTICK_TRADITIONAL << 8);
229 sprintf(friendly, "Joystick %d", id);
230 MultiByteToWideChar(CP_ACP, 0, friendly, -1, lpddi->tszInstanceName, MAX_PATH);
231 #if defined(JSIOCGNAME)
232 if (ioctl(fd,JSIOCGNAME(sizeof(name)),name) < 0) {
233 WARN("ioctl(%s,JSIOCGNAME) failed: %s\n", dev, strerror(errno));
234 strcpy(name, "Wine Joystick");
235 }
236 #else
237 strcpy(name, "Wine Joystick");
238 #endif
239 MultiByteToWideChar(CP_ACP, 0, name, -1, lpddi->tszProductName, MAX_PATH);
240 lpddi->guidFFDriver = GUID_NULL;
241 close(fd);
242 TRACE("Enumerating the linux Joystick device: %s (%s)\n",dev,name);
243 return TRUE;
244 }
245
246 return FALSE;
247 }
248
249 /*
250 * Get a config key from either the app-specific or the default config
251 */
252
253 inline static DWORD get_config_key( HKEY defkey, HKEY appkey, const char *name,
254 char *buffer, DWORD size )
255 {
256 if (appkey && !RegQueryValueExA( appkey, name, 0, NULL, buffer, &size ))
257 return 0;
258
259 if (defkey && !RegQueryValueExA( defkey, name, 0, NULL, buffer, &size ))
260 return 0;
261
262 return ERROR_FILE_NOT_FOUND;
263 }
264
265 /*
266 * Setup the dinput options.
267 */
268
269 static HRESULT setup_dinput_options(JoystickImpl * device)
270 {
271 char buffer[MAX_PATH+1];
272 HKEY hkey, appkey = 0;
273 DWORD len;
274
275 buffer[MAX_PATH]='\0';
276
277 if (RegOpenKeyA( HKEY_LOCAL_MACHINE, "Software\\Wine\\dinput", &hkey)) hkey = 0;
278
279 len = GetModuleFileNameA( 0, buffer, MAX_PATH );
280 if (len && len < MAX_PATH) {
281 HKEY tmpkey;
282
283 if (!RegOpenKeyA( HKEY_LOCAL_MACHINE, "Software\\Wine\\AppDefaults", &tmpkey )) {
284 char appname[MAX_PATH+16];
285 char *p = strrchr( buffer, '\\' );
286 if (p!=NULL) {
287 strcpy(appname,p+1);
288 strcat(appname,"\\dinput");
289 TRACE("appname = [%s] \n",appname);
290 if (RegOpenKeyA( tmpkey, appname, &appkey )) appkey = 0;
291 }
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 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, LPVOID 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->version >= 8)
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 static dinput_device joydev = {
650 10,
651 "Wine Linux joystick driver",
652 joydev_enum_deviceA,
653 joydev_enum_deviceW,
654 joydev_create_deviceA,
655 joydev_create_deviceW
656 };
657
658 DECL_GLOBAL_CONSTRUCTOR(joydev_register) { dinput_register_device(&joydev); }
659
660 /******************************************************************************
661 * Joystick
662 */
663 static ULONG WINAPI JoystickAImpl_Release(LPDIRECTINPUTDEVICE8A iface)
664 {
665 JoystickImpl *This = (JoystickImpl *)iface;
666 ULONG ref;
667
668 ref = InterlockedDecrement((&This->ref));
669 if (ref)
670 return ref;
671
672 /* Free the device name */
673 HeapFree(GetProcessHeap(),0,This->name);
674
675 /* Free the axis map */
676 HeapFree(GetProcessHeap(),0,This->axis_map);
677
678 /* Free the data queue */
679 HeapFree(GetProcessHeap(),0,This->data_queue);
680
681 /* Free the DataFormat */
682 HeapFree(GetProcessHeap(), 0, This->user_df->rgodf);
683 HeapFree(GetProcessHeap(), 0, This->user_df);
684
685 /* Free the properties */
686 HeapFree(GetProcessHeap(), 0, This->props);
687
688 /* Free the offsets array */
689 HeapFree(GetProcessHeap(),0,This->offsets);
690
691 /* release the data transform filter */
692 release_DataFormat(This->transform);
693
694 This->crit.DebugInfo->Spare[1] = 0;
695 DeleteCriticalSection(&(This->crit));
696 IDirectInputDevice_Release((LPDIRECTINPUTDEVICE8A)This->dinput);
697
698 HeapFree(GetProcessHeap(),0,This);
699 return 0;
700 }
701
702 /******************************************************************************
703 * SetDataFormat : the application can choose the format of the data
704 * the device driver sends back with GetDeviceState.
705 */
706 static HRESULT WINAPI JoystickAImpl_SetDataFormat(
707 LPDIRECTINPUTDEVICE8A iface,
708 LPCDIDATAFORMAT df)
709 {
710 JoystickImpl *This = (JoystickImpl *)iface;
711 unsigned int i;
712 LPDIDATAFORMAT new_df = 0;
713 LPDIOBJECTDATAFORMAT new_rgodf = 0;
714 ObjProps * new_props = 0;
715
716 TRACE("(%p,%p)\n",This,df);
717
718 if (This->acquired) {
719 WARN("acquired\n");
720 return DIERR_ACQUIRED;
721 }
722
723 if (TRACE_ON(dinput))
724 _dump_DIDATAFORMAT(df);
725
726 /* Store the new data format */
727 new_df = HeapAlloc(GetProcessHeap(),0,df->dwSize);
728 if (new_df == 0)
729 goto FAILED;
730
731 new_rgodf = HeapAlloc(GetProcessHeap(),0,df->dwNumObjs*df->dwObjSize);
732 if (new_rgodf == 0)
733 goto FAILED;
734
735 new_props = HeapAlloc(GetProcessHeap(),0,df->dwNumObjs*sizeof(ObjProps));
736 if (new_props == 0)
737 goto FAILED;
738
739 HeapFree(GetProcessHeap(),0,This->user_df);
740 HeapFree(GetProcessHeap(),0,This->user_df->rgodf);
741 HeapFree(GetProcessHeap(),0,This->props);
742 release_DataFormat(This->transform);
743
744 This->user_df = new_df;
745 CopyMemory(This->user_df, df, df->dwSize);
746 This->user_df->rgodf = new_rgodf;
747 CopyMemory(This->user_df->rgodf,df->rgodf,df->dwNumObjs*df->dwObjSize);
748 This->props = new_props;
749 for (i = 0; i < df->dwNumObjs; i++) {
750 This->props[i].lMin = 0;
751 This->props[i].lMax = 0xffff;
752 This->props[i].lDeadZone = 1000;
753 This->props[i].lSaturation = 0;
754 }
755 This->transform = create_DataFormat(&c_dfDIJoystick2, This->user_df, This->offsets);
756
757 calculate_ids(This);
758
759 return DI_OK;
760
761 FAILED:
762 WARN("out of memory\n");
763 HeapFree(GetProcessHeap(),0,new_props);
764 HeapFree(GetProcessHeap(),0,new_rgodf);
765 HeapFree(GetProcessHeap(),0,new_df);
766 return DIERR_OUTOFMEMORY;
767 }
768
769 /******************************************************************************
770 * Acquire : gets exclusive control of the joystick
771 */
772 static HRESULT WINAPI JoystickAImpl_Acquire(LPDIRECTINPUTDEVICE8A iface)
773 {
774 JoystickImpl *This = (JoystickImpl *)iface;
775
776 TRACE("(%p)\n",This);
777
778 if (This->acquired) {
779 WARN("already acquired\n");
780 return S_FALSE;
781 }
782
783 /* open the joystick device */
784 if (This->joyfd==-1) {
785 TRACE("opening joystick device %s\n", This->dev);
786
787 This->joyfd=open(This->dev,O_RDONLY);
788 if (This->joyfd==-1) {
789 ERR("open(%s) failed: %s\n", This->dev, strerror(errno));
790 return DIERR_NOTFOUND;
791 }
792 }
793
794 This->acquired = TRUE;
795
796 return DI_OK;
797 }
798
799 /******************************************************************************
800 * Unacquire : frees the joystick
801 */
802 static HRESULT WINAPI JoystickAImpl_Unacquire(LPDIRECTINPUTDEVICE8A iface)
803 {
804 JoystickImpl *This = (JoystickImpl *)iface;
805
806 TRACE("(%p)\n",This);
807
808 if (!This->acquired) {
809 WARN("not acquired\n");
810 return DIERR_NOTACQUIRED;
811 }
812
813 if (This->joyfd!=-1) {
814 TRACE("closing joystick device\n");
815 close(This->joyfd);
816 This->joyfd = -1;
817 This->acquired = FALSE;
818 return DI_OK;
819 }
820
821 This->acquired = FALSE;
822
823 return DI_NOEFFECT;
824 }
825
826 LONG map_axis(JoystickImpl * This, short val, short index)
827 {
828 double fval = val;
829 double fmin = This->props[index].lMin;
830 double fmax = This->props[index].lMax;
831 double fret;
832
833 fret = (((fval + 32767.0) * (fmax - fmin)) / (32767.0*2.0)) + fmin;
834
835 if (fret >= 0.0)
836 fret += 0.5;
837 else
838 fret -= 0.5;
839
840 return fret;
841 }
842
843 /* convert wine format offset to user format object index */
844 int offset_to_object(JoystickImpl *This, int offset)
845 {
846 int i;
847
848 for (i = 0; i < This->user_df->dwNumObjs; i++) {
849 if (This->user_df->rgodf[i].dwOfs == offset)
850 return i;
851 }
852
853 return -1;
854 }
855
856 static LONG calculate_pov(JoystickImpl *This, int index)
857 {
858 if (This->povs[index].lX < 16384) {
859 if (This->povs[index].lY < 16384)
860 This->js.rgdwPOV[index] = 31500;
861 else if (This->povs[index].lY > 49150)
862 This->js.rgdwPOV[index] = 22500;
863 else
864 This->js.rgdwPOV[index] = 27000;
865 } else if (This->povs[index].lX > 49150) {
866 if (This->povs[index].lY < 16384)
867 This->js.rgdwPOV[index] = 4500;
868 else if (This->povs[index].lY > 49150)
869 This->js.rgdwPOV[index] = 13500;
870 else
871 This->js.rgdwPOV[index] = 9000;
872 } else {
873 if (This->povs[index].lY < 16384)
874 This->js.rgdwPOV[index] = 0;
875 else if (This->povs[index].lY > 49150)
876 This->js.rgdwPOV[index] = 18000;
877 else
878 This->js.rgdwPOV[index] = -1;
879 }
880
881 return This->js.rgdwPOV[index];
882 }
883
884 static void joy_polldev(JoystickImpl *This) {
885 struct timeval tv;
886 fd_set readfds;
887 struct js_event jse;
888 TRACE("(%p)\n", This);
889
890 if (This->joyfd==-1) {
891 WARN("no device\n");
892 return;
893 }
894 while (1) {
895 memset(&tv,0,sizeof(tv));
896 FD_ZERO(&readfds);FD_SET(This->joyfd,&readfds);
897 if (1>select(This->joyfd+1,&readfds,NULL,NULL,&tv))
898 return;
899 /* we have one event, so we can read */
900 if (sizeof(jse)!=read(This->joyfd,&jse,sizeof(jse))) {
901 return;
902 }
903 TRACE("js_event: type 0x%x, number %d, value %d\n",
904 jse.type,jse.number,jse.value);
905 if (jse.type & JS_EVENT_BUTTON) {
906 int offset = This->offsets[jse.number + 12];
907 int value = jse.value?0x80:0x00;
908
909 This->js.rgbButtons[jse.number] = value;
910 GEN_EVENT(offset,value,jse.time,(This->dinput->evsequence)++);
911 } else if (jse.type & JS_EVENT_AXIS) {
912 int number = This->axis_map[jse.number]; /* wine format object index */
913 if (number < 12) {
914 int offset = This->offsets[number];
915 int index = offset_to_object(This, offset);
916 LONG value = map_axis(This, jse.value, index);
917
918 /* FIXME do deadzone and saturation here */
919
920 TRACE("changing axis %d => %d\n", jse.number, number);
921 switch (number) {
922 case 0:
923 This->js.lX = value;
924 break;
925 case 1:
926 This->js.lY = value;
927 break;
928 case 2:
929 This->js.lZ = value;
930 break;
931 case 3:
932 This->js.lRx = value;
933 break;
934 case 4:
935 This->js.lRy = value;
936 break;
937 case 5:
938 This->js.lRz = value;
939 break;
940 case 6:
941 This->js.rglSlider[0] = value;
942 break;
943 case 7:
944 This->js.rglSlider[1] = value;
945 break;
946 case 8:
947 /* FIXME don't go off array */
948 if (This->axis_map[jse.number + 1] == number)
949 This->povs[0].lX = value;
950 else if (This->axis_map[jse.number - 1] == number)
951 This->povs[0].lY = value;
952 value = calculate_pov(This, 0);
953 break;
954 case 9:
955 if (This->axis_map[jse.number + 1] == number)
956 This->povs[1].lX = value;
957 else if (This->axis_map[jse.number - 1] == number)
958 This->povs[1].lY = value;
959 value = calculate_pov(This, 1);
960 break;
961 case 10:
962 if (This->axis_map[jse.number + 1] == number)
963 This->povs[2].lX = value;
964 else if (This->axis_map[jse.number - 1] == number)
965 This->povs[2].lY = value;
966 value = calculate_pov(This, 2);
967 break;
968 case 11:
969 if (This->axis_map[jse.number + 1] == number)
970 This->povs[3].lX = value;
971 else if (This->axis_map[jse.number - 1] == number)
972 This->povs[3].lY = value;
973 value = calculate_pov(This, 3);
974 break;
975 }
976
977 GEN_EVENT(offset,value,jse.time,(This->dinput->evsequence)++);
978 } else
979 WARN("axis %d not supported\n", number);
980 }
981 }
982 }
983
984 /******************************************************************************
985 * GetDeviceState : returns the "state" of the joystick.
986 *
987 */
988 static HRESULT WINAPI JoystickAImpl_GetDeviceState(
989 LPDIRECTINPUTDEVICE8A iface,
990 DWORD len,
991 LPVOID ptr)
992 {
993 JoystickImpl *This = (JoystickImpl *)iface;
994
995 TRACE("(%p,0x%08lx,%p)\n",This,len,ptr);
996
997 if (!This->acquired) {
998 WARN("not acquired\n");
999 return DIERR_NOTACQUIRED;
1000 }
1001
1002 /* update joystick state */
1003 joy_polldev(This);
1004
1005 /* convert and copy data to user supplied buffer */
1006 fill_DataFormat(ptr, &This->js, This->transform);
1007
1008 return DI_OK;
1009 }
1010
1011 /******************************************************************************
1012 * GetDeviceData : gets buffered input data.
1013 */
1014 static HRESULT WINAPI JoystickAImpl_GetDeviceData(
1015 LPDIRECTINPUTDEVICE8A iface,
1016 DWORD dodsize,
1017 LPDIDEVICEOBJECTDATA dod,
1018 LPDWORD entries,
1019 DWORD flags)
1020 {
1021 JoystickImpl *This = (JoystickImpl *)iface;
1022 DWORD len;
1023 int nqtail;
1024 HRESULT hr = DI_OK;
1025
1026 TRACE("(%p)->(dods=%ld,entries=%ld,fl=0x%08lx)\n",This,dodsize,*entries,flags);
1027
1028 if (!This->acquired) {
1029 WARN("not acquired\n");
1030 return DIERR_NOTACQUIRED;
1031 }
1032
1033 EnterCriticalSection(&(This->crit));
1034
1035 joy_polldev(This);
1036
1037 len = ((This->queue_head < This->queue_tail) ? This->queue_len : 0)
1038 + (This->queue_head - This->queue_tail);
1039 if (len > *entries)
1040 len = *entries;
1041
1042 if (dod == NULL) {
1043 if (len)
1044 TRACE("Application discarding %ld event(s).\n", len);
1045
1046 *entries = len;
1047 nqtail = This->queue_tail + len;
1048 while (nqtail >= This->queue_len)
1049 nqtail -= This->queue_len;
1050 } else {
1051 if (dodsize < sizeof(DIDEVICEOBJECTDATA_DX3)) {
1052 ERR("Wrong structure size !\n");
1053 LeaveCriticalSection(&(This->crit));
1054 return DIERR_INVALIDPARAM;
1055 }
1056
1057 if (len)
1058 TRACE("Application retrieving %ld event(s).\n", len);
1059
1060 *entries = 0;
1061 nqtail = This->queue_tail;
1062 while (len) {
1063 /* Copy the buffered data into the application queue */
1064 memcpy((char *)dod + *entries * dodsize, This->data_queue + nqtail, dodsize);
1065 /* Advance position */
1066 nqtail++;
1067 if (nqtail >= This->queue_len)
1068 nqtail -= This->queue_len;
1069 (*entries)++;
1070 len--;
1071 }
1072 }
1073
1074 if (This->overflow) {
1075 hr = DI_BUFFEROVERFLOW;
1076 if (!(flags & DIGDD_PEEK)) {
1077 This->overflow = FALSE;
1078 }
1079 }
1080
1081 if (!(flags & DIGDD_PEEK))
1082 This->queue_tail = nqtail;
1083
1084 LeaveCriticalSection(&(This->crit));
1085
1086 return hr;
1087 }
1088
1089 int find_property(JoystickImpl * This, LPCDIPROPHEADER ph)
1090 {
1091 int i;
1092 if (ph->dwHow == DIPH_BYOFFSET) {
1093 return offset_to_object(This, ph->dwObj);
1094 } else if (ph->dwHow == DIPH_BYID) {
1095 for (i = 0; i < This->user_df->dwNumObjs; i++) {
1096 if ((This->user_df->rgodf[i].dwType & 0x00ffffff) == (ph->dwObj & 0x00ffffff)) {
1097 return i;
1098 }
1099 }
1100 }
1101
1102 return -1;
1103 }
1104
1105 /******************************************************************************
1106 * SetProperty : change input device properties
1107 */
1108 static HRESULT WINAPI JoystickAImpl_SetProperty(
1109 LPDIRECTINPUTDEVICE8A iface,
1110 REFGUID rguid,
1111 LPCDIPROPHEADER ph)
1112 {
1113 JoystickImpl *This = (JoystickImpl *)iface;
1114 int i;
1115
1116 TRACE("(%p,%s,%p)\n",This,debugstr_guid(rguid),ph);
1117
1118 if (TRACE_ON(dinput))
1119 _dump_DIPROPHEADER(ph);
1120
1121 if (!HIWORD(rguid)) {
1122 switch ((DWORD)rguid) {
1123 case (DWORD) DIPROP_BUFFERSIZE: {
1124 LPCDIPROPDWORD pd = (LPCDIPROPDWORD)ph;
1125 TRACE("buffersize = %ld\n",pd->dwData);
1126 if (This->data_queue)
1127 This->data_queue = HeapReAlloc(GetProcessHeap(),0, This->data_queue, pd->dwData * sizeof(DIDEVICEOBJECTDATA));
1128 else
1129 This->data_queue = HeapAlloc(GetProcessHeap(),0, pd->dwData * sizeof(DIDEVICEOBJECTDATA));
1130 This->queue_head = 0;
1131 This->queue_tail = 0;
1132 This->queue_len = pd->dwData;
1133 break;
1134 }
1135 case (DWORD)DIPROP_RANGE: {
1136 LPCDIPROPRANGE pr = (LPCDIPROPRANGE)ph;
1137 if (ph->dwHow == DIPH_DEVICE) {
1138 TRACE("proprange(%ld,%ld) all\n",pr->lMin,pr->lMax);
1139 for (i = 0; i < This->user_df->dwNumObjs; i++) {
1140 This->props[i].lMin = pr->lMin;
1141 This->props[i].lMax = pr->lMax;
1142 }
1143 } else {
1144 int obj = find_property(This, ph);
1145 TRACE("proprange(%ld,%ld) obj=%d\n",pr->lMin,pr->lMax,obj);
1146 if (obj >= 0) {
1147 This->props[obj].lMin = pr->lMin;
1148 This->props[obj].lMax = pr->lMax;
1149 return DI_OK;
1150 }
1151 }
1152 break;
1153 }
1154 case (DWORD)DIPROP_DEADZONE: {
1155 LPCDIPROPDWORD pd = (LPCDIPROPDWORD)ph;
1156 if (ph->dwHow == DIPH_DEVICE) {
1157 TRACE("deadzone(%ld) all\n",pd->dwData);
1158 for (i = 0; i < This->user_df->dwNumObjs; i++)
1159 This->props[i].lDeadZone = pd->dwData;
1160 } else {
1161 int obj = find_property(This, ph);
1162 TRACE("deadzone(%ld) obj=%d\n",pd->dwData,obj);
1163 if (obj >= 0) {
1164 This->props[obj].lDeadZone = pd->dwData;
1165 return DI_OK;
1166 }
1167 }
1168 break;
1169 }
1170 case (DWORD)DIPROP_SATURATION: {
1171 LPCDIPROPDWORD pd = (LPCDIPROPDWORD)ph;
1172 if (ph->dwHow == DIPH_DEVICE) {
1173 TRACE("saturation(%ld) all\n",pd->dwData);
1174 for (i = 0; i < This->user_df->dwNumObjs; i++)
1175 This->props[i].lSaturation = pd->dwData;
1176 } else {
1177 int obj = find_property(This, ph);
1178 TRACE("saturation(%ld) obj=%d\n",pd->dwData,obj);
1179 if (obj >= 0) {
1180 This->props[obj].lSaturation = pd->dwData;
1181 return DI_OK;
1182 }
1183 }
1184 break;
1185 }
1186 default:
1187 FIXME("Unknown type %ld (%s)\n",(DWORD)rguid,debugstr_guid(rguid));
1188 break;
1189 }
1190 }
1191
1192 return DI_OK;
1193 }
1194
1195 /******************************************************************************
1196 * SetEventNotification : specifies event to be sent on state change
1197 */
1198 static HRESULT WINAPI JoystickAImpl_SetEventNotification(
1199 LPDIRECTINPUTDEVICE8A iface, HANDLE hnd
1200 ) {
1201 JoystickImpl *This = (JoystickImpl *)iface;
1202
1203 TRACE("(this=%p,0x%08lx)\n",This,(DWORD)hnd);
1204 This->hEvent = hnd;
1205 return DI_OK;
1206 }
1207
1208 static HRESULT WINAPI JoystickAImpl_GetCapabilities(
1209 LPDIRECTINPUTDEVICE8A iface,
1210 LPDIDEVCAPS lpDIDevCaps)
1211 {
1212 JoystickImpl *This = (JoystickImpl *)iface;
1213 int size;
1214
1215 TRACE("%p->(%p)\n",iface,lpDIDevCaps);
1216
1217 if (lpDIDevCaps == NULL) {
1218 WARN("invalid parameter: lpDIDevCaps = NULL\n");
1219 return DIERR_INVALIDPARAM;
1220 }
1221
1222 size = lpDIDevCaps->dwSize;
1223 CopyMemory(lpDIDevCaps, &This->devcaps, size);
1224 lpDIDevCaps->dwSize = size;
1225
1226 if (TRACE_ON(dinput))
1227 _dump_DIDEVCAPS(lpDIDevCaps);
1228
1229 return DI_OK;
1230 }
1231
1232 static HRESULT WINAPI JoystickAImpl_Poll(LPDIRECTINPUTDEVICE8A iface)
1233 {
1234 JoystickImpl *This = (JoystickImpl *)iface;
1235
1236 TRACE("(%p)\n",This);
1237
1238 if (!This->acquired) {
1239 WARN("not acquired\n");
1240 return DIERR_NOTACQUIRED;
1241 }
1242
1243 joy_polldev(This);
1244 return DI_OK;
1245 }
1246
1247 /******************************************************************************
1248 * EnumObjects : enumerate the different buttons and axis...
1249 */
1250 static HRESULT WINAPI JoystickAImpl_EnumObjects(
1251 LPDIRECTINPUTDEVICE8A iface,
1252 LPDIENUMDEVICEOBJECTSCALLBACKA lpCallback,
1253 LPVOID lpvRef,
1254 DWORD dwFlags)
1255 {
1256 JoystickImpl *This = (JoystickImpl *)iface;
1257 DIDEVICEOBJECTINSTANCEA ddoi;
1258 BYTE i;
1259 int user_offset;
1260 int user_object;
1261
1262 TRACE("(this=%p,%p,%p,%08lx)\n", This, lpCallback, lpvRef, dwFlags);
1263 if (TRACE_ON(dinput)) {
1264 TRACE(" - flags = ");
1265 _dump_EnumObjects_flags(dwFlags);
1266 TRACE("\n");
1267 }
1268
1269 /* Only the fields till dwFFMaxForce are relevant */
1270 ddoi.dwSize = FIELD_OFFSET(DIDEVICEOBJECTINSTANCEA, dwFFMaxForce);
1271
1272 /* For the joystick, do as is done in the GetCapabilities function */
1273 if ((dwFlags == DIDFT_ALL) ||
1274 (dwFlags & DIDFT_AXIS) ||
1275 (dwFlags & DIDFT_POV)) {
1276 int pov[4] = { 0, 0, 0, 0 };
1277 int axes = 0;
1278 int povs = 0;
1279
1280 for (i = 0; i < This->axes; i++) {
1281 int wine_obj = This->axis_map[i];
1282 BOOL skip = FALSE;
1283
1284 switch (wine_obj) {
1285 case 0:
1286 ddoi.guidType = GUID_XAxis;
1287 break;
1288 case 1:
1289 ddoi.guidType = GUID_YAxis;
1290 break;
1291 case 2:
1292 ddoi.guidType = GUID_ZAxis;
1293 break;
1294 case 3:
1295 ddoi.guidType = GUID_RxAxis;
1296 break;
1297 case 4:
1298 ddoi.guidType = GUID_RyAxis;
1299 break;
1300 case 5:
1301 ddoi.guidType = GUID_RzAxis;
1302 break;
1303 case 6:
1304 ddoi.guidType = GUID_Slider;
1305 break;
1306 case 7:
1307 ddoi.guidType = GUID_Slider;
1308 break;
1309 case 8:
1310 pov[0]++;
1311 ddoi.guidType = GUID_POV;
1312 break;
1313 case 9:
1314 pov[1]++;
1315 ddoi.guidType = GUID_POV;
1316 break;
1317 case 10:
1318 pov[2]++;
1319 ddoi.guidType = GUID_POV;
1320 break;
1321 case 11:
1322 pov[3]++;
1323 ddoi.guidType = GUID_POV;
1324 break;
1325 default:
1326 ddoi.guidType = GUID_Unknown;
1327 }
1328 if (wine_obj < 8) {
1329 user_offset = This->offsets[wine_obj]; /* get user offset from wine index */
1330 user_object = offset_to_object(This, user_offset);
1331
1332 ddoi.dwType = This->user_df->rgodf[user_object].dwType & 0x00ffffff;
1333 ddoi.dwOfs = This->user_df->rgodf[user_object].dwOfs;
1334 sprintf(ddoi.tszName, "Axis %d", axes);
1335 axes++;
1336 } else {
1337 if (pov[wine_obj - 8] < 2) {
1338 user_offset = This->offsets[wine_obj]; /* get user offset from wine index */
1339 user_object = offset_to_object(This, user_offset);
1340
1341 ddoi.dwType = This->user_df->rgodf[user_object].dwType & 0x00ffffff;
1342 ddoi.dwOfs = This->user_df->rgodf[user_object].dwOfs;
1343 sprintf(ddoi.tszName, "POV %d", povs);
1344 povs++;
1345 } else
1346 skip = TRUE;
1347 }
1348 if (!skip) {
1349 _dump_OBJECTINSTANCEA(&ddoi);
1350 if (lpCallback(&ddoi, lpvRef) != DIENUM_CONTINUE)
1351 return DI_OK;
1352 }
1353 }
1354 }
1355
1356 if ((dwFlags == DIDFT_ALL) ||
1357 (dwFlags & DIDFT_BUTTON)) {
1358
1359 /* The DInput SDK says that GUID_Button is only for mouse buttons but well... */
1360 ddoi.guidType = GUID_Button;
1361
1362 for (i = 0; i < This->buttons; i++) {
1363 user_offset = This->offsets[i + 12]; /* get user offset from wine index */
1364 user_object = offset_to_object(This, user_offset);
1365 ddoi.guidType = GUID_Button;
1366 ddoi.dwType = This->user_df->rgodf[user_object].dwType & 0x00ffffff;
1367 ddoi.dwOfs = This->user_df->rgodf[user_object].dwOfs;
1368 sprintf(ddoi.tszName, "Button %d", i);
1369 _dump_OBJECTINSTANCEA(&ddoi);
1370 if (lpCallback(&ddoi, lpvRef) != DIENUM_CONTINUE) return DI_OK;
1371 }
1372 }
1373
1374 return DI_OK;
1375 }
1376
1377 /******************************************************************************
1378 * EnumObjects : enumerate the different buttons and axis...
1379 */
1380 static HRESULT WINAPI JoystickWImpl_EnumObjects(
1381 LPDIRECTINPUTDEVICE8W iface,
1382 LPDIENUMDEVICEOBJECTSCALLBACKW lpCallback,
1383 LPVOID lpvRef,
1384 DWORD dwFlags)
1385 {
1386 JoystickImpl *This = (JoystickImpl *)iface;
1387
1388 device_enumobjects_AtoWcb_data data;
1389
1390 data.lpCallBack = lpCallback;
1391 data.lpvRef = lpvRef;
1392
1393 return JoystickAImpl_EnumObjects((LPDIRECTINPUTDEVICE8A) This, (LPDIENUMDEVICEOBJECTSCALLBACKA) DIEnumDevicesCallbackAtoW, (LPVOID) &data, dwFlags);
1394 }
1395
1396 /******************************************************************************
1397 * GetProperty : get input device properties
1398 */
1399 static HRESULT WINAPI JoystickAImpl_GetProperty(
1400 LPDIRECTINPUTDEVICE8A iface,
1401 REFGUID rguid,
1402 LPDIPROPHEADER pdiph)
1403 {
1404 JoystickImpl *This = (JoystickImpl *)iface;
1405
1406 TRACE("(%p,%s,%p)\n", iface, debugstr_guid(rguid), pdiph);
1407
1408 if (TRACE_ON(dinput))
1409 _dump_DIPROPHEADER(pdiph);
1410
1411 if (!HIWORD(rguid)) {
1412 switch ((DWORD)rguid) {
1413 case (DWORD) DIPROP_BUFFERSIZE: {
1414 LPDIPROPDWORD pd = (LPDIPROPDWORD)pdiph;
1415 TRACE(" return buffersize = %d\n",This->queue_len);
1416 pd->dwData = This->queue_len;
1417 break;
1418 }
1419 case (DWORD) DIPROP_RANGE: {
1420 LPDIPROPRANGE pr = (LPDIPROPRANGE) pdiph;
1421 int obj = find_property(This, pdiph);
1422 /* The app is querying the current range of the axis
1423 * return the lMin and lMax values */
1424 if (obj >= 0) {
1425 pr->lMin = This->props[obj].lMin;
1426 pr->lMax = This->props[obj].lMax;
1427 TRACE("range(%ld, %ld) obj=%d\n", pr->lMin, pr->lMax, obj);
1428 return DI_OK;
1429 }
1430 break;
1431 }
1432 case (DWORD) DIPROP_DEADZONE: {
1433 LPDIPROPDWORD pd = (LPDIPROPDWORD)pdiph;
1434 int obj = find_property(This, pdiph);
1435 if (obj >= 0) {
1436 pd->dwData = This->props[obj].lDeadZone;
1437 TRACE("deadzone(%ld) obj=%d\n", pd->dwData, obj);
1438 return DI_OK;
1439 }
1440 break;
1441 }
1442 case (DWORD) DIPROP_SATURATION: {
1443 LPDIPROPDWORD pd = (LPDIPROPDWORD)pdiph;
1444 int obj = find_property(This, pdiph);
1445 if (obj >= 0) {
1446 pd->dwData = This->props[obj].lSaturation;
1447 TRACE("saturation(%ld) obj=%d\n", pd->dwData, obj);
1448 return DI_OK;
1449 }
1450 break;
1451 }
1452 default:
1453 FIXME("Unknown type %ld (%s)\n",(DWORD)rguid,debugstr_guid(rguid));
1454 break;
1455 }
1456 }
1457
1458 return DI_OK;
1459 }
1460
1461 /******************************************************************************
1462 * GetObjectInfo : get object info
1463 */
1464 HRESULT WINAPI JoystickAImpl_GetObjectInfo(
1465 LPDIRECTINPUTDEVICE8A iface,
1466 LPDIDEVICEOBJECTINSTANCEA pdidoi,
1467 DWORD dwObj,
1468 DWORD dwHow)
1469 {
1470 JoystickImpl *This = (JoystickImpl *)iface;
1471 DIDEVICEOBJECTINSTANCEA didoiA;
1472 unsigned int i;
1473
1474 TRACE("(%p,%p,%ld,0x%08lx(%s))\n",
1475 iface, pdidoi, dwObj, dwHow,
1476 dwHow == DIPH_BYOFFSET ? "DIPH_BYOFFSET" :
1477 dwHow == DIPH_BYID ? "DIPH_BYID" :
1478 dwHow == DIPH_BYUSAGE ? "DIPH_BYUSAGE" :
1479 "UNKNOWN");
1480
1481 if (pdidoi == NULL) {
1482 WARN("invalid parameter: pdidoi = NULL\n");
1483 return DIERR_INVALIDPARAM;
1484 }
1485
1486 if ((pdidoi->dwSize != sizeof(DIDEVICEOBJECTINSTANCEA)) &&
1487 (pdidoi->dwSize != sizeof(DIDEVICEOBJECTINSTANCE_DX3A))) {
1488 WARN("invalid parameter: pdidoi->dwSize = %ld != %d or %d\n",
1489 pdidoi->dwSize, sizeof(DIDEVICEOBJECTINSTANCEA),
1490 sizeof(DIDEVICEOBJECTINSTANCE_DX3A));
1491 return DIERR_INVALIDPARAM;
1492 }
1493
1494 ZeroMemory(&didoiA, sizeof(didoiA));
1495 didoiA.dwSize = pdidoi->dwSize;
1496
1497 switch (dwHow) {
1498 case DIPH_BYOFFSET: {
1499 int axis = 0;
1500 int pov = 0;
1501 int button = 0;
1502 for (i = 0; i < This->user_df->dwNumObjs; i++) {
1503 if (This->user_df->rgodf[i].dwOfs == dwObj) {
1504 if (This->user_df->rgodf[i].pguid)
1505 didoiA.guidType = *This->user_df->rgodf[i].pguid;
1506 else
1507 didoiA.guidType = GUID_NULL;
1508
1509 didoiA.dwOfs = dwObj;
1510 didoiA.dwType = This->user_df->rgodf[i].dwType;
1511 didoiA.dwFlags = This->user_df->rgodf[i].dwFlags;
1512
1513 if (DIDFT_GETTYPE(This->user_df->rgodf[i].dwType) & DIDFT_AXIS)
1514 sprintf(didoiA.tszName, "Axis %d", axis);
1515 else if (DIDFT_GETTYPE(This->user_df->rgodf[i].dwType) & DIDFT_POV)
1516 sprintf(didoiA.tszName, "POV %d", pov);
1517 else if (DIDFT_GETTYPE(This->user_df->rgodf[i].dwType) & DIDFT_BUTTON)
1518 sprintf(didoiA.tszName, "Button %d", button);
1519
1520 CopyMemory(pdidoi, &didoiA, pdidoi->dwSize);
1521 return DI_OK;
1522 }
1523
1524 if (DIDFT_GETTYPE(This->user_df->rgodf[i].dwType) & DIDFT_AXIS)
1525 axis++;
1526 else if (DIDFT_GETTYPE(This->user_df->rgodf[i].dwType) & DIDFT_POV)
1527 pov++;
1528 else if (DIDFT_GETTYPE(This->user_df->rgodf[i].dwType) & DIDFT_BUTTON)
1529 button++;
1530 }
1531 break;
1532 }
1533 case DIPH_BYID:
1534 FIXME("dwHow = DIPH_BYID not implemented\n");
1535 break;
1536 case DIPH_BYUSAGE:
1537 FIXME("dwHow = DIPH_BYUSAGE not implemented\n");
1538 break;
1539 default:
1540 WARN("invalid parameter: dwHow = %08lx\n", dwHow);
1541 return DIERR_INVALIDPARAM;
1542 }
1543
1544 CopyMemory(pdidoi, &didoiA, pdidoi->dwSize);
1545
1546 return DI_OK;
1547 }
1548
1549 /******************************************************************************
1550 * GetDeviceInfo : get information about a device's identity
1551 */
1552 HRESULT WINAPI JoystickAImpl_GetDeviceInfo(
1553 LPDIRECTINPUTDEVICE8A iface,
1554 LPDIDEVICEINSTANCEA pdidi)
1555 {
1556 JoystickImpl *This = (JoystickImpl *)iface;
1557
1558 TRACE("(%p,%p)\n", iface, pdidi);
1559
1560 if ((pdidi->dwSize != sizeof(DIDEVICEINSTANCE_DX3A)) &&
1561 (pdidi->dwSize != sizeof(DIDEVICEINSTANCEA))) {
1562 WARN("invalid parameter: pdidi->dwSize = %ld != %d or %d\n",
1563 pdidi->dwSize, sizeof(DIDEVICEINSTANCE_DX3A),
1564 sizeof(DIDEVICEINSTANCEA));
1565 return DIERR_INVALIDPARAM;
1566 }
1567
1568 /* Return joystick */
1569 pdidi->guidInstance = GUID_Joystick;
1570 pdidi->guidProduct = DInput_Wine_Joystick_GUID;
1571 /* we only support traditional joysticks for now */
1572 pdidi->dwDevType = This->devcaps.dwDevType;
1573 strcpy(pdidi->tszInstanceName, "Joystick");
1574 strcpy(pdidi->tszProductName, This->name);
1575 if (pdidi->dwSize > sizeof(DIDEVICEINSTANCE_DX3A)) {
1576 pdidi->guidFFDriver = GUID_NULL;
1577 pdidi->wUsagePage = 0;
1578 pdidi->wUsage = 0;
1579 }
1580
1581 return DI_OK;
1582 }
1583
1584 /******************************************************************************
1585 * GetDeviceInfo : get information about a device's identity
1586 */
1587 HRESULT WINAPI JoystickWImpl_GetDeviceInfo(
1588 LPDIRECTINPUTDEVICE8W iface,
1589 LPDIDEVICEINSTANCEW pdidi)
1590 {
1591 JoystickImpl *This = (JoystickImpl *)iface;
1592
1593 TRACE("(%p,%p)\n", iface, pdidi);
1594
1595 if ((pdidi->dwSize != sizeof(DIDEVICEINSTANCE_DX3W)) &&
1596 (pdidi->dwSize != sizeof(DIDEVICEINSTANCEW))) {
1597 WARN("invalid parameter: pdidi->dwSize = %ld != %d or %d\n",
1598 pdidi->dwSize, sizeof(DIDEVICEINSTANCE_DX3W),
1599 sizeof(DIDEVICEINSTANCEW));
1600 return DIERR_INVALIDPARAM;
1601 }
1602
1603 /* Return joystick */
1604 pdidi->guidInstance = GUID_Joystick;
1605 pdidi->guidProduct = DInput_Wine_Joystick_GUID;
1606 /* we only support traditional joysticks for now */
1607 pdidi->dwDevType = This->devcaps.dwDevType;
1608 MultiByteToWideChar(CP_ACP, 0, "Joystick", -1, pdidi->tszInstanceName, MAX_PATH);
1609 MultiByteToWideChar(CP_ACP, 0, This->name, -1, pdidi->tszProductName, MAX_PATH);
1610 if (pdidi->dwSize > sizeof(DIDEVICEINSTANCE_DX3W)) {
1611 pdidi->guidFFDriver = GUID_NULL;
1612 pdidi->wUsagePage = 0;
1613 pdidi->wUsage = 0;
1614 }
1615
1616 return DI_OK;
1617 }
1618
1619 static IDirectInputDevice8AVtbl JoystickAvt =
1620 {
1621 IDirectInputDevice2AImpl_QueryInterface,
1622 IDirectInputDevice2AImpl_AddRef,
1623 JoystickAImpl_Release,
1624 JoystickAImpl_GetCapabilities,
1625 JoystickAImpl_EnumObjects,
1626 JoystickAImpl_GetProperty,
1627 JoystickAImpl_SetProperty,
1628 JoystickAImpl_Acquire,
1629 JoystickAImpl_Unacquire,
1630 JoystickAImpl_GetDeviceState,
1631 JoystickAImpl_GetDeviceData,
1632 JoystickAImpl_SetDataFormat,
1633 JoystickAImpl_SetEventNotification,
1634 IDirectInputDevice2AImpl_SetCooperativeLevel,
1635 JoystickAImpl_GetObjectInfo,
1636 JoystickAImpl_GetDeviceInfo,
1637 IDirectInputDevice2AImpl_RunControlPanel,
1638 IDirectInputDevice2AImpl_Initialize,
1639 IDirectInputDevice2AImpl_CreateEffect,
1640 IDirectInputDevice2AImpl_EnumEffects,
1641 IDirectInputDevice2AImpl_GetEffectInfo,
1642 IDirectInputDevice2AImpl_GetForceFeedbackState,
1643 IDirectInputDevice2AImpl_SendForceFeedbackCommand,
1644 IDirectInputDevice2AImpl_EnumCreatedEffectObjects,
1645 IDirectInputDevice2AImpl_Escape,
1646 JoystickAImpl_Poll,
1647 IDirectInputDevice2AImpl_SendDeviceData,
1648 IDirectInputDevice7AImpl_EnumEffectsInFile,
1649 IDirectInputDevice7AImpl_WriteEffectToFile,
1650 IDirectInputDevice8AImpl_BuildActionMap,
1651 IDirectInputDevice8AImpl_SetActionMap,
1652 IDirectInputDevice8AImpl_GetImageInfo
1653 };
1654
1655 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
1656 # define XCAST(fun) (typeof(SysJoystickWvt.fun))
1657 #else
1658 # define XCAST(fun) (void*)
1659 #endif
1660
1661 static IDirectInputDevice8WVtbl SysJoystickWvt =
1662 {
1663 IDirectInputDevice2WImpl_QueryInterface,
1664 XCAST(AddRef)IDirectInputDevice2AImpl_AddRef,
1665 XCAST(Release)JoystickAImpl_Release,
1666 XCAST(GetCapabilities)JoystickAImpl_GetCapabilities,
1667 JoystickWImpl_EnumObjects,
1668 XCAST(GetProperty)JoystickAImpl_GetProperty,
1669 XCAST(SetProperty)JoystickAImpl_SetProperty,
1670 XCAST(Acquire)JoystickAImpl_Acquire,
1671 XCAST(Unacquire)JoystickAImpl_Unacquire,
1672 XCAST(GetDeviceState)JoystickAImpl_GetDeviceState,
1673 XCAST(GetDeviceData)JoystickAImpl_GetDeviceData,
1674 XCAST(SetDataFormat)JoystickAImpl_SetDataFormat,
1675 XCAST(SetEventNotification)JoystickAImpl_SetEventNotification,
1676 XCAST(SetCooperativeLevel)IDirectInputDevice2AImpl_SetCooperativeLevel,
1677 IDirectInputDevice2WImpl_GetObjectInfo,
1678 JoystickWImpl_GetDeviceInfo,
1679 XCAST(RunControlPanel)IDirectInputDevice2AImpl_RunControlPanel,
1680 XCAST(Initialize)IDirectInputDevice2AImpl_Initialize,
1681 XCAST(CreateEffect)IDirectInputDevice2AImpl_CreateEffect,
1682 IDirectInputDevice2WImpl_EnumEffects,
1683 IDirectInputDevice2WImpl_GetEffectInfo,
1684 XCAST(GetForceFeedbackState)IDirectInputDevice2AImpl_GetForceFeedbackState,
1685 XCAST(SendForceFeedbackCommand)IDirectInputDevice2AImpl_SendForceFeedbackCommand,
1686 XCAST(EnumCreatedEffectObjects)IDirectInputDevice2AImpl_EnumCreatedEffectObjects,
1687 XCAST(Escape)IDirectInputDevice2AImpl_Escape,
1688 XCAST(Poll)JoystickAImpl_Poll,
1689 XCAST(SendDeviceData)IDirectInputDevice2AImpl_SendDeviceData,
1690 IDirectInputDevice7WImpl_EnumEffectsInFile,
1691 IDirectInputDevice7WImpl_WriteEffectToFile,
1692 IDirectInputDevice8WImpl_BuildActionMap,
1693 IDirectInputDevice8WImpl_SetActionMap,
1694 IDirectInputDevice8WImpl_GetImageInfo
1695 };
1696 #undef XCAST
1697
1698 #endif /* HAVE_LINUX_22_JOYSTICK_API */
Windows API implementation