git.oblomov.eu Git - wine/blob - dlls/dinput/mouse/main.c

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