?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Release 20030408.
[wine/gsoc-2012-control.git] / dlls / dinput / mouse / main.c
blob2450cba1f8190d3d57136885bd57bde6b9c520d4
1 /* DirectInput Mouse 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 #include "config.h"
23 #include "wine/port.h"
24
25 #include <string.h>
26
27 #include "winbase.h"
28 #include "wingdi.h"
29 #include "winuser.h"
30 #include "winerror.h"
31 #include "dinput.h"
32
33 #include "dinput_private.h"
34 #include "device_private.h"
35 #include "wine/debug.h"
36
37 #define MOUSE_HACK
38
39 WINE_DEFAULT_DEBUG_CHANNEL(dinput);
40
41 /* Wine mouse driver object instances */
42 #define WINE_MOUSE_X_AXIS_INSTANCE 0x0001
43 #define WINE_MOUSE_Y_AXIS_INSTANCE 0x0002
44 #define WINE_MOUSE_Z_AXIS_INSTANCE 0x0004
45 #define WINE_MOUSE_L_BUTTON_INSTANCE 0x0008
46 #define WINE_MOUSE_R_BUTTON_INSTANCE 0x0010
47 #define WINE_MOUSE_M_BUTTON_INSTANCE 0x0020
48
49 /* ------------------------------- */
50 /* Wine mouse internal data format */
51 /* ------------------------------- */
52
53 /* Constants used to access the offset array */
54 #define WINE_MOUSE_X_POSITION 0
55 #define WINE_MOUSE_Y_POSITION 1
56 #define WINE_MOUSE_Z_POSITION 2
57 #define WINE_MOUSE_L_POSITION 3
58 #define WINE_MOUSE_R_POSITION 4
59 #define WINE_MOUSE_M_POSITION 5
60
61 typedef struct {
62 LONG lX;
63 LONG lY;
64 LONG lZ;
65 BYTE rgbButtons[4];
66 } Wine_InternalMouseData;
67
68 #define WINE_INTERNALMOUSE_NUM_OBJS 6
69
70 static DIOBJECTDATAFORMAT Wine_InternalMouseObjectFormat[WINE_INTERNALMOUSE_NUM_OBJS] = {
71 { &GUID_XAxis, FIELD_OFFSET(Wine_InternalMouseData, lX),
72 DIDFT_MAKEINSTANCE(WINE_MOUSE_X_AXIS_INSTANCE) | DIDFT_RELAXIS, 0 },
73 { &GUID_YAxis, FIELD_OFFSET(Wine_InternalMouseData, lY),
74 DIDFT_MAKEINSTANCE(WINE_MOUSE_Y_AXIS_INSTANCE) | DIDFT_RELAXIS, 0 },
75 { &GUID_ZAxis, FIELD_OFFSET(Wine_InternalMouseData, lZ),
76 DIDFT_MAKEINSTANCE(WINE_MOUSE_Z_AXIS_INSTANCE) | DIDFT_RELAXIS, 0 },
77 { &GUID_Button, (FIELD_OFFSET(Wine_InternalMouseData, rgbButtons)) + 0,
78 DIDFT_MAKEINSTANCE(WINE_MOUSE_L_BUTTON_INSTANCE) | DIDFT_PSHBUTTON, 0 },
79 { &GUID_Button, (FIELD_OFFSET(Wine_InternalMouseData, rgbButtons)) + 1,
80 DIDFT_MAKEINSTANCE(WINE_MOUSE_R_BUTTON_INSTANCE) | DIDFT_PSHBUTTON, 0 },
81 { &GUID_Button, (FIELD_OFFSET(Wine_InternalMouseData, rgbButtons)) + 2,
82 DIDFT_MAKEINSTANCE(WINE_MOUSE_M_BUTTON_INSTANCE) | DIDFT_PSHBUTTON, 0 }
83 };
84
85 static DIDATAFORMAT Wine_InternalMouseFormat = {
86 0, /* dwSize - unused */
87 0, /* dwObjsize - unused */
88 0, /* dwFlags - unused */
89 sizeof(Wine_InternalMouseData),
90 WINE_INTERNALMOUSE_NUM_OBJS, /* dwNumObjs */
91 Wine_InternalMouseObjectFormat
92 };
93
94 static ICOM_VTABLE(IDirectInputDevice8A) SysMouseAvt;
95 typedef struct SysMouseAImpl SysMouseAImpl;
96
97 typedef enum {
98 WARP_NEEDED, /* Warping is needed */
99 WARP_STARTED, /* Warping has been done, waiting for the warp event */
100 WARP_DONE /* Warping has been done */
101 } WARP_STATUS;
102
103 struct SysMouseAImpl
104 {
105 LPVOID lpVtbl;
106 DWORD ref;
107 GUID guid;
108
109 IDirectInputAImpl *dinput;
110
111 /* The current data format and the conversion between internal
112 and external data formats */
113 LPDIDATAFORMAT df;
114 DataFormat *wine_df;
115 int offset_array[WINE_INTERNALMOUSE_NUM_OBJS];
116
117 /* SysMouseAImpl */
118 BYTE absolute;
119 /* Previous position for relative moves */
120 LONG prevX, prevY;
121 HHOOK hook;
122 HWND win;
123 DWORD dwCoopLevel;
124 POINT mapped_center;
125 DWORD win_centerX, win_centerY;
126 LPDIDEVICEOBJECTDATA data_queue;
127 int queue_head, queue_tail, queue_len;
128 /* warping: whether we need to move mouse back to middle once we
129 * reach window borders (for e.g. shooters, "surface movement" games) */
130 WARP_STATUS need_warp;
131 int acquired;
132 HANDLE hEvent;
133 CRITICAL_SECTION crit;
134
135 /* This is for mouse reporting. */
136 Wine_InternalMouseData m_state;
137 };
138
139 static GUID DInput_Wine_Mouse_GUID = { /* 9e573ed8-7734-11d2-8d4a-23903fb6bdf7 */
140 0x9e573ed8,
141 0x7734,
142 0x11d2,
143 {0x8d, 0x4a, 0x23, 0x90, 0x3f, 0xb6, 0xbd, 0xf7}
144 };
145
146 /* FIXME: This is ugly and not thread safe :/ */
147 static IDirectInputDevice8A* current_lock = NULL;
148
149
150 static BOOL mousedev_enum_device(DWORD dwDevType, DWORD dwFlags, LPDIDEVICEINSTANCEA lpddi)
151 {
152 if ((dwDevType == 0) || (dwDevType == DIDEVTYPE_MOUSE)) {
153 TRACE("Enumerating the mouse device\n");
154
155 /* Return mouse */
156 lpddi->guidInstance = GUID_SysMouse;/* DInput's GUID */
157 lpddi->guidProduct = DInput_Wine_Mouse_GUID; /* Vendor's GUID */
158 lpddi->dwDevType = DIDEVTYPE_MOUSE | (DIDEVTYPEMOUSE_UNKNOWN << 8);
159 strcpy(lpddi->tszInstanceName, "Mouse");
160 strcpy(lpddi->tszProductName, "Wine Mouse");
161
162 return TRUE;
163 }
164
165 return FALSE;
166 }
167
168 static SysMouseAImpl *alloc_device(REFGUID rguid, LPVOID mvt, IDirectInputAImpl *dinput)
169 {
170 int offset_array[WINE_INTERNALMOUSE_NUM_OBJS] = {
171 FIELD_OFFSET(Wine_InternalMouseData, lX),
172 FIELD_OFFSET(Wine_InternalMouseData, lY),
173 FIELD_OFFSET(Wine_InternalMouseData, lZ),
174 FIELD_OFFSET(Wine_InternalMouseData, rgbButtons) + 0,
175 FIELD_OFFSET(Wine_InternalMouseData, rgbButtons) + 1,
176 FIELD_OFFSET(Wine_InternalMouseData, rgbButtons) + 2
177 };
178 SysMouseAImpl* newDevice;
179 newDevice = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(SysMouseAImpl));
180 newDevice->ref = 1;
181 newDevice->lpVtbl = mvt;
182 InitializeCriticalSection(&(newDevice->crit));
183 memcpy(&(newDevice->guid),rguid,sizeof(*rguid));
184
185 /* Per default, Wine uses its internal data format */
186 newDevice->df = &Wine_InternalMouseFormat;
187 memcpy(newDevice->offset_array, offset_array, WINE_INTERNALMOUSE_NUM_OBJS * sizeof(int));
188 newDevice->wine_df = (DataFormat *) HeapAlloc(GetProcessHeap(), 0, sizeof(DataFormat));
189 newDevice->wine_df->size = 0;
190 newDevice->wine_df->internal_format_size = Wine_InternalMouseFormat.dwDataSize;
191 newDevice->wine_df->dt = NULL;
192 newDevice->dinput = dinput;
193
194 return newDevice;
195 }
196
197 static HRESULT mousedev_create_device(IDirectInputAImpl *dinput, REFGUID rguid, REFIID riid, LPDIRECTINPUTDEVICEA* pdev)
198 {
199 if ((IsEqualGUID(&GUID_SysMouse,rguid)) || /* Generic Mouse */
200 (IsEqualGUID(&DInput_Wine_Mouse_GUID,rguid))) { /* Wine Mouse */
201 if ((riid == NULL) ||
202 IsEqualGUID(&IID_IDirectInputDeviceA,riid) ||
203 IsEqualGUID(&IID_IDirectInputDevice2A,riid) ||
204 IsEqualGUID(&IID_IDirectInputDevice7A,riid) ||
205 IsEqualGUID(&IID_IDirectInputDevice8A,riid)) {
206 *pdev=(IDirectInputDeviceA*) alloc_device(rguid, &SysMouseAvt, dinput);
207 TRACE("Creating a Mouse device (%p)\n", *pdev);
208 return DI_OK;
209 } else
210 return DIERR_NOINTERFACE;
211 }
212
213 return DIERR_DEVICENOTREG;
214 }
215
216 static dinput_device mousedev = {
217 100,
218 mousedev_enum_device,
219 mousedev_create_device
220 };
221
222 DECL_GLOBAL_CONSTRUCTOR(mousedev_register) { dinput_register_device(&mousedev); }
223
224 /******************************************************************************
225 * SysMouseA (DInput Mouse support)
226 */
227
228 /******************************************************************************
229 * Release : release the mouse buffer.
230 */
231 static ULONG WINAPI SysMouseAImpl_Release(LPDIRECTINPUTDEVICE8A iface)
232 {
233 ICOM_THIS(SysMouseAImpl,iface);
234
235 This->ref--;
236 if (This->ref)
237 return This->ref;
238
239 /* Free the data queue */
240 if (This->data_queue != NULL)
241 HeapFree(GetProcessHeap(),0,This->data_queue);
242
243 if (This->hook) {
244 UnhookWindowsHookEx( This->hook );
245 if (This->dwCoopLevel & DISCL_EXCLUSIVE)
246 ShowCursor(TRUE); /* show cursor */
247 }
248 DeleteCriticalSection(&(This->crit));
249
250 /* Free the DataFormat */
251 if (This->df != &(Wine_InternalMouseFormat)) {
252 HeapFree(GetProcessHeap(), 0, This->df->rgodf);
253 HeapFree(GetProcessHeap(), 0, This->df);
254 }
255
256 HeapFree(GetProcessHeap(),0,This);
257 return 0;
258 }
259
260
261 /******************************************************************************
262 * SetCooperativeLevel : store the window in which we will do our
263 * grabbing.
264 */
265 static HRESULT WINAPI SysMouseAImpl_SetCooperativeLevel(
266 LPDIRECTINPUTDEVICE8A iface,HWND hwnd,DWORD dwflags
267 )
268 {
269 ICOM_THIS(SysMouseAImpl,iface);
270
271 TRACE("(this=%p,0x%08lx,0x%08lx)\n",This,(DWORD)hwnd,dwflags);
272
273 if (TRACE_ON(dinput)) {
274 TRACE(" cooperative level : ");
275 _dump_cooperativelevel_DI(dwflags);
276 }
277
278 /* Store the window which asks for the mouse */
279 if (!hwnd)
280 hwnd = GetDesktopWindow();
281 This->win = hwnd;
282 This->dwCoopLevel = dwflags;
283
284 return 0;
285 }
286
287
288 /******************************************************************************
289 * SetDataFormat : the application can choose the format of the data
290 * the device driver sends back with GetDeviceState.
291 *
292 * For the moment, only the "standard" configuration (c_dfDIMouse) is supported
293 * in absolute and relative mode.
294 */
295 static HRESULT WINAPI SysMouseAImpl_SetDataFormat(
296 LPDIRECTINPUTDEVICE8A iface,LPCDIDATAFORMAT df
297 )
298 {
299 ICOM_THIS(SysMouseAImpl,iface);
300 int i;
301
302 TRACE("(this=%p,%p)\n",This,df);
303
304 TRACE("(df.dwSize=%ld)\n",df->dwSize);
305 TRACE("(df.dwObjsize=%ld)\n",df->dwObjSize);
306 TRACE("(df.dwFlags=0x%08lx)\n",df->dwFlags);
307 TRACE("(df.dwDataSize=%ld)\n",df->dwDataSize);
308 TRACE("(df.dwNumObjs=%ld)\n",df->dwNumObjs);
309
310 for (i=0;i<df->dwNumObjs;i++) {
311
312 TRACE("df.rgodf[%d].guid %s (%p)\n",i, debugstr_guid(df->rgodf[i].pguid), df->rgodf[i].pguid);
313 TRACE("df.rgodf[%d].dwOfs %ld\n",i,df->rgodf[i].dwOfs);
314 TRACE("dwType 0x%02x,dwInstance %d\n",DIDFT_GETTYPE(df->rgodf[i].dwType),DIDFT_GETINSTANCE(df->rgodf[i].dwType));
315 TRACE("df.rgodf[%d].dwFlags 0x%08lx\n",i,df->rgodf[i].dwFlags);
316 }
317
318 /* Check if the mouse is in absolute or relative mode */
319 if (df->dwFlags == DIDF_ABSAXIS)
320 This->absolute = 1;
321 else if (df->dwFlags == DIDF_RELAXIS)
322 This->absolute = 0;
323 else
324 ERR("Neither absolute nor relative flag set\n");
325
326 /* Store the new data format */
327 This->df = HeapAlloc(GetProcessHeap(),0,df->dwSize);
328 memcpy(This->df, df, df->dwSize);
329 This->df->rgodf = HeapAlloc(GetProcessHeap(),0,df->dwNumObjs*df->dwObjSize);
330 memcpy(This->df->rgodf,df->rgodf,df->dwNumObjs*df->dwObjSize);
331
332 /* Prepare all the data-conversion filters */
333 This->wine_df = create_DataFormat(&(Wine_InternalMouseFormat), df, This->offset_array);
334
335 return 0;
336 }
337
338 /* low-level mouse hook */
339 static LRESULT CALLBACK dinput_mouse_hook( int code, WPARAM wparam, LPARAM lparam )
340 {
341 LRESULT ret;
342 MSLLHOOKSTRUCT *hook = (MSLLHOOKSTRUCT *)lparam;
343 SysMouseAImpl* This = (SysMouseAImpl*) current_lock;
344 DWORD dwCoop;
345 static long last_event = 0;
346 int wdata;
347
348 if (code != HC_ACTION) return CallNextHookEx( This->hook, code, wparam, lparam );
349
350 EnterCriticalSection(&(This->crit));
351 dwCoop = This->dwCoopLevel;
352
353 /* Only allow mouse events every 10 ms.
354 * This is to allow the cursor to start acceleration before
355 * the warps happen. But if it involves a mouse button event we
356 * allow it since we dont want to loose the clicks.
357 */
358 if (((GetCurrentTime() - last_event) < 10)
359 && wparam == WM_MOUSEMOVE)
360 goto end;
361 else last_event = GetCurrentTime();
362
363 /* Mouse moved -> send event if asked */
364 if (This->hEvent)
365 SetEvent(This->hEvent);
366
367 if (wparam == WM_MOUSEMOVE) {
368 if (This->absolute) {
369 if (hook->pt.x != This->prevX)
370 GEN_EVENT(This->offset_array[WINE_MOUSE_X_POSITION], hook->pt.x, hook->time, 0);
371 if (hook->pt.y != This->prevY)
372 GEN_EVENT(This->offset_array[WINE_MOUSE_Y_POSITION], hook->pt.y, hook->time, 0);
373 } else {
374 /* Now, warp handling */
375 if ((This->need_warp == WARP_STARTED) &&
376 (hook->pt.x == This->mapped_center.x) && (hook->pt.y == This->mapped_center.y)) {
377 /* Warp has been done... */
378 This->need_warp = WARP_DONE;
379 goto end;
380 }
381
382 /* Relative mouse input with absolute mouse event : the real fun starts here... */
383 if ((This->need_warp == WARP_NEEDED) ||
384 (This->need_warp == WARP_STARTED)) {
385 if (hook->pt.x != This->prevX)
386 GEN_EVENT(This->offset_array[WINE_MOUSE_X_POSITION], hook->pt.x - This->prevX, hook->time, (This->dinput->evsequence)++);
387 if (hook->pt.y != This->prevY)
388 GEN_EVENT(This->offset_array[WINE_MOUSE_Y_POSITION], hook->pt.y - This->prevY, hook->time, (This->dinput->evsequence)++);
389 } else {
390 /* This is the first time the event handler has been called after a
391 GetDeviceData or GetDeviceState. */
392 if (hook->pt.x != This->mapped_center.x) {
393 GEN_EVENT(This->offset_array[WINE_MOUSE_X_POSITION], hook->pt.x - This->mapped_center.x, hook->time, (This->dinput->evsequence)++);
394 This->need_warp = WARP_NEEDED;
395 }
396
397 if (hook->pt.y != This->mapped_center.y) {
398 GEN_EVENT(This->offset_array[WINE_MOUSE_Y_POSITION], hook->pt.y - This->mapped_center.y, hook->time, (This->dinput->evsequence)++);
399 This->need_warp = WARP_NEEDED;
400 }
401 }
402 }
403
404 This->prevX = hook->pt.x;
405 This->prevY = hook->pt.y;
406
407 if (This->absolute) {
408 This->m_state.lX = hook->pt.x;
409 This->m_state.lY = hook->pt.y;
410 } else {
411 This->m_state.lX = hook->pt.x - This->mapped_center.x;
412 This->m_state.lY = hook->pt.y - This->mapped_center.y;
413 }
414 }
415
416 TRACE(" msg %x pt %ld %ld (W=%d)\n",
417 wparam, hook->pt.x, hook->pt.y, (!This->absolute) && This->need_warp );
418
419 switch(wparam)
420 {
421 case WM_LBUTTONDOWN:
422 GEN_EVENT(This->offset_array[WINE_MOUSE_L_POSITION], 0xFF,
423 hook->time, This->dinput->evsequence++);
424 This->m_state.rgbButtons[0] = 0xFF;
425 break;
426 case WM_LBUTTONUP:
427 GEN_EVENT(This->offset_array[WINE_MOUSE_L_POSITION], 0x00,
428 hook->time, This->dinput->evsequence++);
429 This->m_state.rgbButtons[0] = 0x00;
430 break;
431 case WM_RBUTTONDOWN:
432 GEN_EVENT(This->offset_array[WINE_MOUSE_R_POSITION], 0xFF,
433 hook->time, This->dinput->evsequence++);
434 This->m_state.rgbButtons[1] = 0xFF;
435 break;
436 case WM_RBUTTONUP:
437 GEN_EVENT(This->offset_array[WINE_MOUSE_R_POSITION], 0x00,
438 hook->time, This->dinput->evsequence++);
439 This->m_state.rgbButtons[1] = 0x00;
440 break;
441 case WM_MBUTTONDOWN:
442 GEN_EVENT(This->offset_array[WINE_MOUSE_M_POSITION], 0xFF,
443 hook->time, This->dinput->evsequence++);
444 This->m_state.rgbButtons[2] = 0xFF;
445 break;
446 case WM_MBUTTONUP:
447 GEN_EVENT(This->offset_array[WINE_MOUSE_M_POSITION], 0x00,
448 hook->time, This->dinput->evsequence++);
449 This->m_state.rgbButtons[2] = 0x00;
450 break;
451 case WM_MOUSEWHEEL:
452 wdata = (short)HIWORD(hook->mouseData);
453 GEN_EVENT(This->offset_array[WINE_MOUSE_Z_POSITION], wdata,
454 hook->time, This->dinput->evsequence++);
455 This->m_state.lZ += wdata;
456 break;
457 }
458
459 TRACE("(X: %ld - Y: %ld L: %02x M: %02x R: %02x)\n",
460 This->m_state.lX, This->m_state.lY,
461 This->m_state.rgbButtons[0], This->m_state.rgbButtons[2], This->m_state.rgbButtons[1]);
462
463 end:
464 LeaveCriticalSection(&(This->crit));
465
466 if (dwCoop & DISCL_NONEXCLUSIVE)
467 { /* pass the events down to previous handlers (e.g. win32 input) */
468 ret = CallNextHookEx( This->hook, code, wparam, lparam );
469 }
470 else ret = 1; /* ignore message */
471 return ret;
472 }
473
474
475 static void dinput_window_check(SysMouseAImpl* This)
476 {
477 RECT rect;
478 DWORD centerX, centerY;
479
480 /* make sure the window hasn't moved */
481 GetWindowRect(This->win, &rect);
482 centerX = (rect.right - rect.left) / 2;
483 centerY = (rect.bottom - rect.top ) / 2;
484 if (This->win_centerX != centerX || This->win_centerY != centerY) {
485 This->win_centerX = centerX;
486 This->win_centerY = centerY;
487 }
488 This->mapped_center.x = This->win_centerX;
489 This->mapped_center.y = This->win_centerY;
490 MapWindowPoints(This->win, HWND_DESKTOP, &This->mapped_center, 1);
491 }
492
493
494 /******************************************************************************
495 * Acquire : gets exclusive control of the mouse
496 */
497 static HRESULT WINAPI SysMouseAImpl_Acquire(LPDIRECTINPUTDEVICE8A iface)
498 {
499 ICOM_THIS(SysMouseAImpl,iface);
500 RECT rect;
501
502 TRACE("(this=%p)\n",This);
503
504 if (This->acquired == 0) {
505 POINT point;
506
507 /* Store (in a global variable) the current lock */
508 current_lock = (IDirectInputDevice8A*)This;
509
510 /* Init the mouse state */
511 if (This->absolute) {
512 GetCursorPos( &point );
513 This->m_state.lX = point.x;
514 This->m_state.lY = point.y;
515 This->prevX = point.x;
516 This->prevY = point.y;
517 } else {
518 This->m_state.lX = 0;
519 This->m_state.lY = 0;
520 }
521 This->m_state.lZ = 0;
522 This->m_state.rgbButtons[0] = (GetKeyState(VK_LBUTTON) ? 0xFF : 0x00);
523 This->m_state.rgbButtons[1] = (GetKeyState(VK_MBUTTON) ? 0xFF : 0x00);
524 This->m_state.rgbButtons[2] = (GetKeyState(VK_RBUTTON) ? 0xFF : 0x00);
525
526 /* Install our mouse hook */
527 if (This->dwCoopLevel & DISCL_EXCLUSIVE)
528 ShowCursor(FALSE); /* hide cursor */
529 This->hook = SetWindowsHookExA( WH_MOUSE_LL, dinput_mouse_hook, DINPUT_instance, 0 );
530
531 /* Get the window dimension and find the center */
532 GetWindowRect(This->win, &rect);
533 This->win_centerX = (rect.right - rect.left) / 2;
534 This->win_centerY = (rect.bottom - rect.top ) / 2;
535
536 /* Warp the mouse to the center of the window */
537 if (This->absolute == 0) {
538 This->mapped_center.x = This->win_centerX;
539 This->mapped_center.y = This->win_centerY;
540 MapWindowPoints(This->win, HWND_DESKTOP, &This->mapped_center, 1);
541 TRACE("Warping mouse to %ld - %ld\n", This->mapped_center.x, This->mapped_center.y);
542 SetCursorPos( This->mapped_center.x, This->mapped_center.y );
543 #ifdef MOUSE_HACK
544 This->need_warp = WARP_DONE;
545 #else
546 This->need_warp = WARP_STARTED;
547 #endif
548 }
549
550 This->acquired = 1;
551 return DI_OK;
552 }
553 return S_FALSE;
554 }
555
556 /******************************************************************************
557 * Unacquire : frees the mouse
558 */
559 static HRESULT WINAPI SysMouseAImpl_Unacquire(LPDIRECTINPUTDEVICE8A iface)
560 {
561 ICOM_THIS(SysMouseAImpl,iface);
562
563 TRACE("(this=%p)\n",This);
564
565 if (This->acquired)
566 {
567 /* Reinstall previous mouse event handler */
568 if (This->hook) {
569 UnhookWindowsHookEx( This->hook );
570 This->hook = 0;
571 if (This->dwCoopLevel & DISCL_EXCLUSIVE)
572 ShowCursor(TRUE); /* show cursor */
573 }
574
575 /* No more locks */
576 current_lock = NULL;
577
578 /* Unacquire device */
579 This->acquired = 0;
580 }
581 else
582 ERR("Unacquiring a not-acquired device !!!\n");
583
584 return DI_OK;
585 }
586
587 /******************************************************************************
588 * GetDeviceState : returns the "state" of the mouse.
589 *
590 * For the moment, only the "standard" return structure (DIMOUSESTATE) is
591 * supported.
592 */
593 static HRESULT WINAPI SysMouseAImpl_GetDeviceState(
594 LPDIRECTINPUTDEVICE8A iface,DWORD len,LPVOID ptr
595 ) {
596 ICOM_THIS(SysMouseAImpl,iface);
597
598 EnterCriticalSection(&(This->crit));
599 TRACE("(this=%p,0x%08lx,%p): \n",This,len,ptr);
600
601 /* Copy the current mouse state */
602 fill_DataFormat(ptr, &(This->m_state), This->wine_df);
603
604 /* Initialize the buffer when in relative mode */
605 if (This->absolute == 0) {
606 This->m_state.lX = 0;
607 This->m_state.lY = 0;
608 This->m_state.lZ = 0;
609 }
610
611 /* Check if we need to do a mouse warping */
612 if (This->need_warp == WARP_NEEDED) {
613 dinput_window_check(This);
614 TRACE("Warping mouse to %ld - %ld\n", This->mapped_center.x, This->mapped_center.y);
615 SetCursorPos( This->mapped_center.x, This->mapped_center.y );
616
617 #ifdef MOUSE_HACK
618 This->need_warp = WARP_DONE;
619 #else
620 This->need_warp = WARP_STARTED;
621 #endif
622 }
623
624 LeaveCriticalSection(&(This->crit));
625
626 TRACE("(X: %ld - Y: %ld L: %02x M: %02x R: %02x)\n",
627 This->m_state.lX, This->m_state.lY,
628 This->m_state.rgbButtons[0], This->m_state.rgbButtons[2], This->m_state.rgbButtons[1]);
629
630 return 0;
631 }
632
633 /******************************************************************************
634 * GetDeviceState : gets buffered input data.
635 */
636 static HRESULT WINAPI SysMouseAImpl_GetDeviceData(LPDIRECTINPUTDEVICE8A iface,
637 DWORD dodsize,
638 LPDIDEVICEOBJECTDATA dod,
639 LPDWORD entries,
640 DWORD flags
641 ) {
642 ICOM_THIS(SysMouseAImpl,iface);
643 DWORD len, nqtail;
644
645 TRACE("(%p)->(dods=%ld,entries=%ld,fl=0x%08lx)\n",This,dodsize,*entries,flags);
646
647 if (This->acquired == 0) {
648 WARN(" application tries to get data from an unacquired device !\n");
649 return DIERR_NOTACQUIRED;
650 }
651
652 EnterCriticalSection(&(This->crit));
653
654 len = ((This->queue_head < This->queue_tail) ? This->queue_len : 0)
655 + (This->queue_head - This->queue_tail);
656 if (len > *entries) len = *entries;
657
658 if (dod == NULL) {
659 if (len)
660 TRACE("Application discarding %ld event(s).\n", len);
661
662 *entries = len;
663 nqtail = This->queue_tail + len;
664 while (nqtail >= This->queue_len) nqtail -= This->queue_len;
665 } else {
666 if (dodsize < sizeof(DIDEVICEOBJECTDATA)) {
667 ERR("Wrong structure size !\n");
668 LeaveCriticalSection(&(This->crit));
669 return DIERR_INVALIDPARAM;
670 }
671
672 if (len)
673 TRACE("Application retrieving %ld event(s).\n", len);
674
675 *entries = 0;
676 nqtail = This->queue_tail;
677 while (len) {
678 DWORD span = ((This->queue_head < nqtail) ? This->queue_len : This->queue_head)
679 - nqtail;
680 if (span > len) span = len;
681 /* Copy the buffered data into the application queue */
682 memcpy(dod + *entries, This->data_queue + nqtail, span * dodsize);
683 /* Advance position */
684 nqtail += span;
685 if (nqtail >= This->queue_len) nqtail -= This->queue_len;
686 *entries += span;
687 len -= span;
688 }
689 }
690 if (!(flags & DIGDD_PEEK))
691 This->queue_tail = nqtail;
692
693 LeaveCriticalSection(&(This->crit));
694
695 /* Check if we need to do a mouse warping */
696 if (This->need_warp == WARP_NEEDED) {
697 dinput_window_check(This);
698 TRACE("Warping mouse to %ld - %ld\n", This->mapped_center.x, This->mapped_center.y);
699 SetCursorPos( This->mapped_center.x, This->mapped_center.y );
700
701 #ifdef MOUSE_HACK
702 This->need_warp = WARP_DONE;
703 #else
704 This->need_warp = WARP_STARTED;
705 #endif
706 }
707 return 0;
708 }
709
710 /******************************************************************************
711 * SetProperty : change input device properties
712 */
713 static HRESULT WINAPI SysMouseAImpl_SetProperty(LPDIRECTINPUTDEVICE8A iface,
714 REFGUID rguid,
715 LPCDIPROPHEADER ph)
716 {
717 ICOM_THIS(SysMouseAImpl,iface);
718
719 TRACE("(this=%p,%s,%p)\n",This,debugstr_guid(rguid),ph);
720
721 if (!HIWORD(rguid)) {
722 switch ((DWORD)rguid) {
723 case (DWORD) DIPROP_BUFFERSIZE: {
724 LPCDIPROPDWORD pd = (LPCDIPROPDWORD)ph;
725
726 TRACE("buffersize = %ld\n",pd->dwData);
727
728 This->data_queue = (LPDIDEVICEOBJECTDATA)HeapAlloc(GetProcessHeap(),0,
729 pd->dwData * sizeof(DIDEVICEOBJECTDATA));
730 This->queue_head = 0;
731 This->queue_tail = 0;
732 This->queue_len = pd->dwData;
733 break;
734 }
735 case (DWORD) DIPROP_AXISMODE: {
736 LPCDIPROPDWORD pd = (LPCDIPROPDWORD)ph;
737 This->absolute = !(pd->dwData);
738 TRACE("Using %s coordinates mode now\n", This->absolute ? "absolute" : "relative");
739 break;
740 }
741 default:
742 FIXME("Unknown type %ld (%s)\n",(DWORD)rguid,debugstr_guid(rguid));
743 break;
744 }
745 }
746
747 return 0;
748 }
749
750 /******************************************************************************
751 * GetProperty : get input device properties
752 */
753 static HRESULT WINAPI SysMouseAImpl_GetProperty(LPDIRECTINPUTDEVICE8A iface,
754 REFGUID rguid,
755 LPDIPROPHEADER pdiph)
756 {
757 ICOM_THIS(SysMouseAImpl,iface);
758
759 TRACE("(this=%p,%s,%p): stub!\n",
760 iface, debugstr_guid(rguid), pdiph);
761
762 if (TRACE_ON(dinput))
763 _dump_DIPROPHEADER(pdiph);
764
765 if (!HIWORD(rguid)) {
766 switch ((DWORD)rguid) {
767 case (DWORD) DIPROP_BUFFERSIZE: {
768 LPDIPROPDWORD pd = (LPDIPROPDWORD)pdiph;
769
770 TRACE(" return buffersize = %d\n",This->queue_len);
771 pd->dwData = This->queue_len;
772 break;
773 }
774
775 case (DWORD) DIPROP_GRANULARITY: {
776 LPDIPROPDWORD pr = (LPDIPROPDWORD) pdiph;
777
778 /* We'll just assume that the app asks about the Z axis */
779 pr->dwData = WHEEL_DELTA;
780
781 break;
782 }
783
784 case (DWORD) DIPROP_RANGE: {
785 LPDIPROPRANGE pr = (LPDIPROPRANGE) pdiph;
786
787 if ((pdiph->dwHow == DIPH_BYID) &&
788 ((pdiph->dwObj == (DIDFT_MAKEINSTANCE(WINE_MOUSE_X_AXIS_INSTANCE) | DIDFT_RELAXIS)) ||
789 (pdiph->dwObj == (DIDFT_MAKEINSTANCE(WINE_MOUSE_Y_AXIS_INSTANCE) | DIDFT_RELAXIS)))) {
790 /* Querying the range of either the X or the Y axis. As I do
791 not know the range, do as if the range were
792 unrestricted...*/
793 pr->lMin = DIPROPRANGE_NOMIN;
794 pr->lMax = DIPROPRANGE_NOMAX;
795 }
796
797 break;
798 }
799
800 default:
801 FIXME("Unknown type %ld (%s)\n",(DWORD)rguid,debugstr_guid(rguid));
802 break;
803 }
804 }
805
806
807 return DI_OK;
808 }
809
810
811
812 /******************************************************************************
813 * SetEventNotification : specifies event to be sent on state change
814 */
815 static HRESULT WINAPI SysMouseAImpl_SetEventNotification(LPDIRECTINPUTDEVICE8A iface,
816 HANDLE hnd) {
817 ICOM_THIS(SysMouseAImpl,iface);
818
819 TRACE("(this=%p,0x%08lx)\n",This,(DWORD)hnd);
820
821 This->hEvent = hnd;
822
823 return DI_OK;
824 }
825
826 /******************************************************************************
827 * GetCapabilities : get the device capablitites
828 */
829 static HRESULT WINAPI SysMouseAImpl_GetCapabilities(
830 LPDIRECTINPUTDEVICE8A iface,
831 LPDIDEVCAPS lpDIDevCaps)
832 {
833 ICOM_THIS(SysMouseAImpl,iface);
834
835 TRACE("(this=%p,%p)\n",This,lpDIDevCaps);
836
837 if (lpDIDevCaps->dwSize == sizeof(DIDEVCAPS)) {
838 lpDIDevCaps->dwFlags = DIDC_ATTACHED;
839 lpDIDevCaps->dwDevType = DIDEVTYPE_MOUSE;
840 lpDIDevCaps->dwAxes = 3;
841 lpDIDevCaps->dwButtons = 3;
842 lpDIDevCaps->dwPOVs = 0;
843 lpDIDevCaps->dwFFSamplePeriod = 0;
844 lpDIDevCaps->dwFFMinTimeResolution = 0;
845 lpDIDevCaps->dwFirmwareRevision = 100;
846 lpDIDevCaps->dwHardwareRevision = 100;
847 lpDIDevCaps->dwFFDriverVersion = 0;
848 } else {
849 /* DirectX 3.0 */
850 FIXME("DirectX 3.0 not supported....\n");
851 }
852
853 return DI_OK;
854 }
855
856
857 /******************************************************************************
858 * EnumObjects : enumerate the different buttons and axis...
859 */
860 static HRESULT WINAPI SysMouseAImpl_EnumObjects(
861 LPDIRECTINPUTDEVICE8A iface,
862 LPDIENUMDEVICEOBJECTSCALLBACKA lpCallback,
863 LPVOID lpvRef,
864 DWORD dwFlags)
865 {
866 ICOM_THIS(SysMouseAImpl,iface);
867 DIDEVICEOBJECTINSTANCEA ddoi;
868
869 TRACE("(this=%p,%p,%p,%08lx)\n", This, lpCallback, lpvRef, dwFlags);
870 if (TRACE_ON(dinput)) {
871 TRACE(" - flags = ");
872 _dump_EnumObjects_flags(dwFlags);
873 TRACE("\n");
874 }
875
876 /* Only the fields till dwFFMaxForce are relevant */
877 memset(&ddoi, 0, sizeof(ddoi));
878 ddoi.dwSize = FIELD_OFFSET(DIDEVICEOBJECTINSTANCEA, dwFFMaxForce);
879
880 /* In a mouse, we have : two relative axis and three buttons */
881 if ((dwFlags == DIDFT_ALL) ||
882 (dwFlags & DIDFT_AXIS)) {
883 /* X axis */
884 ddoi.guidType = GUID_XAxis;
885 ddoi.dwOfs = This->offset_array[WINE_MOUSE_X_POSITION];
886 ddoi.dwType = DIDFT_MAKEINSTANCE(WINE_MOUSE_X_AXIS_INSTANCE) | DIDFT_RELAXIS;
887 strcpy(ddoi.tszName, "X-Axis");
888 _dump_OBJECTINSTANCEA(&ddoi);
889 if (lpCallback(&ddoi, lpvRef) != DIENUM_CONTINUE) return DI_OK;
890
891 /* Y axis */
892 ddoi.guidType = GUID_YAxis;
893 ddoi.dwOfs = This->offset_array[WINE_MOUSE_Y_POSITION];
894 ddoi.dwType = DIDFT_MAKEINSTANCE(WINE_MOUSE_Y_AXIS_INSTANCE) | DIDFT_RELAXIS;
895 strcpy(ddoi.tszName, "Y-Axis");
896 _dump_OBJECTINSTANCEA(&ddoi);
897 if (lpCallback(&ddoi, lpvRef) != DIENUM_CONTINUE) return DI_OK;
898
899 /* Z axis */
900 ddoi.guidType = GUID_ZAxis;
901 ddoi.dwOfs = This->offset_array[WINE_MOUSE_Z_POSITION];
902 ddoi.dwType = DIDFT_MAKEINSTANCE(WINE_MOUSE_Z_AXIS_INSTANCE) | DIDFT_RELAXIS;
903 strcpy(ddoi.tszName, "Z-Axis");
904 _dump_OBJECTINSTANCEA(&ddoi);
905 if (lpCallback(&ddoi, lpvRef) != DIENUM_CONTINUE) return DI_OK;
906 }
907
908 if ((dwFlags == DIDFT_ALL) ||
909 (dwFlags & DIDFT_BUTTON)) {
910 ddoi.guidType = GUID_Button;
911
912 /* Left button */
913 ddoi.dwOfs = This->offset_array[WINE_MOUSE_L_POSITION];
914 ddoi.dwType = DIDFT_MAKEINSTANCE(WINE_MOUSE_L_BUTTON_INSTANCE) | DIDFT_PSHBUTTON;
915 strcpy(ddoi.tszName, "Left-Button");
916 _dump_OBJECTINSTANCEA(&ddoi);
917 if (lpCallback(&ddoi, lpvRef) != DIENUM_CONTINUE) return DI_OK;
918
919 /* Right button */
920 ddoi.dwOfs = This->offset_array[WINE_MOUSE_R_POSITION];
921 ddoi.dwType = DIDFT_MAKEINSTANCE(WINE_MOUSE_R_BUTTON_INSTANCE) | DIDFT_PSHBUTTON;
922 strcpy(ddoi.tszName, "Right-Button");
923 _dump_OBJECTINSTANCEA(&ddoi);
924 if (lpCallback(&ddoi, lpvRef) != DIENUM_CONTINUE) return DI_OK;
925
926 /* Middle button */
927 ddoi.dwOfs = This->offset_array[WINE_MOUSE_M_POSITION];
928 ddoi.dwType = DIDFT_MAKEINSTANCE(WINE_MOUSE_M_BUTTON_INSTANCE) | DIDFT_PSHBUTTON;
929 strcpy(ddoi.tszName, "Middle-Button");
930 _dump_OBJECTINSTANCEA(&ddoi);
931 if (lpCallback(&ddoi, lpvRef) != DIENUM_CONTINUE) return DI_OK;
932 }
933
934 return DI_OK;
935 }
936
937
938 static ICOM_VTABLE(IDirectInputDevice8A) SysMouseAvt =
939 {
940 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
941 IDirectInputDevice2AImpl_QueryInterface,
942 IDirectInputDevice2AImpl_AddRef,
943 SysMouseAImpl_Release,
944 SysMouseAImpl_GetCapabilities,
945 SysMouseAImpl_EnumObjects,
946 SysMouseAImpl_GetProperty,
947 SysMouseAImpl_SetProperty,
948 SysMouseAImpl_Acquire,
949 SysMouseAImpl_Unacquire,
950 SysMouseAImpl_GetDeviceState,
951 SysMouseAImpl_GetDeviceData,
952 SysMouseAImpl_SetDataFormat,
953 SysMouseAImpl_SetEventNotification,
954 SysMouseAImpl_SetCooperativeLevel,
955 IDirectInputDevice2AImpl_GetObjectInfo,
956 IDirectInputDevice2AImpl_GetDeviceInfo,
957 IDirectInputDevice2AImpl_RunControlPanel,
958 IDirectInputDevice2AImpl_Initialize,
959 IDirectInputDevice2AImpl_CreateEffect,
960 IDirectInputDevice2AImpl_EnumEffects,
961 IDirectInputDevice2AImpl_GetEffectInfo,
962 IDirectInputDevice2AImpl_GetForceFeedbackState,
963 IDirectInputDevice2AImpl_SendForceFeedbackCommand,
964 IDirectInputDevice2AImpl_EnumCreatedEffectObjects,
965 IDirectInputDevice2AImpl_Escape,
966 IDirectInputDevice2AImpl_Poll,
967 IDirectInputDevice2AImpl_SendDeviceData,
968 IDirectInputDevice7AImpl_EnumEffectsInFile,
969 IDirectInputDevice7AImpl_WriteEffectToFile,
970 IDirectInputDevice8AImpl_BuildActionMap,
971 IDirectInputDevice8AImpl_SetActionMap,
972 IDirectInputDevice8AImpl_GetImageInfo
973 };
GSOC 2012 project to enhance the control panel