Changeset 2499 for trunk/src


Ignore:
Timestamp:
Jan 22, 2000, 11:31:06 AM (26 years ago)
Author:
sandervl
Message:

Michal Necasek's updates

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/dinput/dinput.cpp

    r2462 r2499  
    1 /* $Id: dinput.cpp,v 1.3 2000-01-17 17:18:38 sandervl Exp $ */
    2 /*              DirectInput
     1/* $Id: dinput.cpp,v 1.4 2000-01-22 10:31:06 sandervl Exp $ */
     2/*              DirectInput
    33 *
    44 * Copyright 1998 Marcus Meissner
    … …  
    1212 * - WingCommander Prophecy Demo:
    1313 *   Doesn't get Input Focus.
    14  * 
     14 *
    1515 * - Fallout : works great in X and DGA mode
    1616 *
    1717 * FIXME: The keyboard handling needs to (and will) be merged into keyboard.c
    18  *        (The current implementation is currently only a proof of concept and
    19  *         an utter mess.)
     18 *        (The current implementation is currently only a proof of concept and
     19 *         an utter mess.)
    2020 */
    2121#ifdef __WIN32OS2__
    … …  
    4444#ifdef HAVE_LINUX_JOYSTICK_H
    4545# include <linux/joystick.h>
    46 # define JOYDEV "/dev/js0"
     46# define JOYDEV "/dev/js0"
    4747#endif
    4848#include "wine/obj_base.h"
    … …  
    6666DEFAULT_DEBUG_CHANNEL(dinput)
    6767
     68extern VOID WIN32API KEYBOARD_Enable(WNDPROC handler);
    6869
    6970extern BYTE InputKeyStateTable[256];
    … …  
    9495        GUID                            guid;
    9596        /* SysKeyboardAImpl */
     97        LPDIDEVICEOBJECTDATA            data_queue;
     98        int                             queue_pos, queue_len;
     99        CRITICAL_SECTION                crit;
     100        int                             acquired;
    96101        BYTE                            keystate[256];
    97102};
    … …  
    107112        GUID                            guid;
    108113
    109         /* joystick private */
    110         int                             joyfd;
    111         LPDIDATAFORMAT                  df;
    112         HANDLE                          hEvent;
    113         LONG                            lMin,lMax,deadzone;
    114         LPDIDEVICEOBJECTDATA            data_queue;
    115         int                             queue_pos, queue_len;
    116         DIJOYSTATE                      js;
     114        /* joystick private */
     115        int                             joyfd;
     116        LPDIDATAFORMAT                  df;
     117        HANDLE                          hEvent;
     118        LONG                            lMin,lMax,deadzone;
     119        LPDIDEVICEOBJECTDATA            data_queue;
     120        int                             queue_pos, queue_len;
     121        DIJOYSTATE                      js;
    117122};
    118123#endif
    … …  
    125130        GUID                            guid;
    126131
    127         LPDIDATAFORMAT                  df;
     132        LPDIDATAFORMAT                  df;
    128133        /* SysMouseAImpl */
    129134        BYTE                            absolute;
    130135        /* Previous position for relative moves */
    131         LONG                            prevX, prevY;
    132         LPMOUSE_EVENT_PROC              prev_handler;
    133         HWND                            win;
    134         DWORD                           win_centerX, win_centerY;
    135         LPDIDEVICEOBJECTDATA            data_queue;
    136         int                             queue_pos, queue_len;
    137         int                             need_warp;
    138         int                             acquired;
    139         HANDLE                          hEvent;
    140         CRITICAL_SECTION                crit;
     136        LONG                            prevX, prevY;
     137        LPMOUSE_EVENT_PROC              prev_handler;
     138        HWND                            win;
     139        DWORD                           win_centerX, win_centerY;
     140        LPDIDEVICEOBJECTDATA            data_queue;
     141        int                             queue_pos, queue_len;
     142        int                             need_warp;
     143        int                             acquired;
     144        HANDLE                          hEvent;
     145        CRITICAL_SECTION                crit;
    141146};
    142147
    … …  
    170175
    171176/* FIXME: This is ugly and not thread safe :/ */
    172 static IDirectInputDevice2A* current_lock = NULL;
    173 
    174 /******************************************************************************
    175  *      Various debugging tools
     177static IDirectInputDevice2A* current_lock   = NULL;
     178static IDirectInputDeviceA* current_keylock = NULL;
     179
     180/******************************************************************************
     181 *      Various debugging tools
    176182 */
    177183static void _dump_cooperativelevel(DWORD dwFlags) {
    … …  
    200206
    201207/******************************************************************************
    202  *      DirectInputCreate32A
     208 *      DirectInputCreate32A
    203209 */
    204210HRESULT WINAPI DirectInputCreateA(HINSTANCE hinst, DWORD dwVersion, LPDIRECTINPUTA *ppDI, LPUNKNOWN punkOuter)
    205211{
    206         IDirectInputAImpl* This;
    207         TRACE("(0x%08lx,%04lx,%p,%p)\n",
    208                 (DWORD)hinst,dwVersion,ppDI,punkOuter
    209         );
    210         This = (IDirectInputAImpl*)HeapAlloc(GetProcessHeap(),0,sizeof(IDirectInputAImpl));
    211         This->ref = 1;
    212         ICOM_VTBL(This) = &ddiavt;
    213         *ppDI=(IDirectInputA*)This;
    214         return 0;
    215 }
    216 /******************************************************************************
    217  *      IDirectInputA_EnumDevices
     212        IDirectInputAImpl* This;
     213        TRACE("(0x%08lx,%04lx,%p,%p)\n",
     214                (DWORD)hinst,dwVersion,ppDI,punkOuter
     215        );
     216        This = (IDirectInputAImpl*)HeapAlloc(GetProcessHeap(),0,sizeof(IDirectInputAImpl));
     217        This->ref = 1;
     218        ICOM_VTBL(This) = &ddiavt;
     219        *ppDI=(IDirectInputA*)This;
     220        return 0;
     221}
     222/******************************************************************************
     223 *      IDirectInputA_EnumDevices
    218224 */
    219225static HRESULT WINAPI IDirectInputAImpl_EnumDevices(
    220         LPDIRECTINPUTA iface, DWORD dwDevType, LPDIENUMDEVICESCALLBACKA lpCallback,
    221         LPVOID pvRef, DWORD dwFlags
     226        LPDIRECTINPUTA iface, DWORD dwDevType, LPDIENUMDEVICESCALLBACKA lpCallback,
     227        LPVOID pvRef, DWORD dwFlags
    222228)
    223229{
    224         ICOM_THIS(IDirectInputAImpl,iface);
    225         DIDEVICEINSTANCEA devInstance;
    226         int ret;
    227 
    228         TRACE("(this=%p,0x%04lx,%p,%p,%04lx)\n", This, dwDevType, lpCallback, pvRef, dwFlags);
    229 
    230         devInstance.dwSize = sizeof(DIDEVICEINSTANCEA);
    231         if ((dwDevType == 0) || (dwDevType == DIDEVTYPE_KEYBOARD)) {
    232                 /* Return keyboard */
    233                 devInstance.guidInstance = GUID_SysKeyboard;/* DInput's GUID */
    234                 devInstance.guidProduct = DInput_Wine_Keyboard_GUID; /* Vendor's GUID */
    235                 devInstance.dwDevType = DIDEVTYPE_KEYBOARD | (DIDEVTYPEKEYBOARD_UNKNOWN << 8);
    236                 strcpy(devInstance.tszInstanceName, "Keyboard");
    237                 strcpy(devInstance.tszProductName, "Wine Keyboard");
    238 
    239                 ret = lpCallback(&devInstance, pvRef);
    240                 TRACE("Keyboard registered\n");
    241                 if (ret == DIENUM_STOP)
    242                         return 0;
    243         }
    244  
    245         if ((dwDevType == 0) || (dwDevType == DIDEVTYPE_MOUSE)) {
    246                 /* Return mouse */
    247                 devInstance.guidInstance = GUID_SysMouse;/* DInput's GUID */
    248                 devInstance.guidProduct = DInput_Wine_Mouse_GUID; /* Vendor's GUID */
    249                 devInstance.dwDevType = DIDEVTYPE_MOUSE | (DIDEVTYPEMOUSE_UNKNOWN << 8);
    250                 strcpy(devInstance.tszInstanceName, "Mouse");
    251                 strcpy(devInstance.tszProductName, "Wine Mouse");
    252 
    253                 ret = lpCallback(&devInstance, pvRef);
    254                 TRACE("Mouse registered\n");
    255                 if (ret == DIENUM_STOP)
    256                         return 0;
    257         }
    258         if ((dwDevType == 0) || (dwDevType == DIDEVTYPE_JOYSTICK)) {
    259                 /* check whether we have a joystick */
     230        ICOM_THIS(IDirectInputAImpl,iface);
     231        DIDEVICEINSTANCEA devInstance;
     232        int ret;
     233
     234        TRACE("(this=%p,0x%04lx,%p,%p,%04lx)\n", This, dwDevType, lpCallback, pvRef, dwFlags);
     235
     236        devInstance.dwSize = sizeof(DIDEVICEINSTANCEA);
     237        if ((dwDevType == 0) || (dwDevType == DIDEVTYPE_KEYBOARD)) {
     238                /* Return keyboard */
     239                devInstance.guidInstance = GUID_SysKeyboard;/* DInput's GUID */
     240                devInstance.guidProduct = DInput_Wine_Keyboard_GUID; /* Vendor's GUID */
     241                devInstance.dwDevType = DIDEVTYPE_KEYBOARD | (DIDEVTYPEKEYBOARD_UNKNOWN << 8);
     242                strcpy(devInstance.tszInstanceName, "Keyboard");
     243                strcpy(devInstance.tszProductName, "Wine Keyboard");
     244
     245                ret = lpCallback(&devInstance, pvRef);
     246                TRACE("Keyboard registered\n");
     247                if (ret == DIENUM_STOP)
     248                        return 0;
     249        }
     250
     251        if ((dwDevType == 0) || (dwDevType == DIDEVTYPE_MOUSE)) {
     252                /* Return mouse */
     253                devInstance.guidInstance = GUID_SysMouse;/* DInput's GUID */
     254                devInstance.guidProduct = DInput_Wine_Mouse_GUID; /* Vendor's GUID */
     255                devInstance.dwDevType = DIDEVTYPE_MOUSE | (DIDEVTYPEMOUSE_UNKNOWN << 8);
     256                strcpy(devInstance.tszInstanceName, "Mouse");
     257                strcpy(devInstance.tszProductName, "Wine Mouse");
     258
     259                ret = lpCallback(&devInstance, pvRef);
     260                TRACE("Mouse registered\n");
     261                if (ret == DIENUM_STOP)
     262                        return 0;
     263        }
     264        if ((dwDevType == 0) || (dwDevType == DIDEVTYPE_JOYSTICK)) {
     265                /* check whether we have a joystick */
    260266#ifdef HAVE_LINUX_22_JOYSTICK_API
    261                 if (    (access(JOYDEV,O_RDONLY)!=-1)           ||
    262                         (errno!=ENODEV && errno!=ENOENT)
    263                 ) {
    264                     /* Return joystick */
    265                     devInstance.guidInstance    = GUID_Joystick;
    266                     devInstance.guidProduct     = DInput_Wine_Joystick_GUID;
    267                     /* we only support traditional joysticks for now */
    268                     devInstance.dwDevType       = DIDEVTYPE_JOYSTICK | DIDEVTYPEJOYSTICK_TRADITIONAL;
    269                     strcpy(devInstance.tszInstanceName, "Joystick");
    270                     /* ioctl JSIOCGNAME(len) */
    271                     strcpy(devInstance.tszProductName,  "Wine Joystick");
    272 
    273                     ret = lpCallback(&devInstance,pvRef);
    274                     TRACE("Joystick registered\n");
    275                     if (ret == DIENUM_STOP)
    276                             return 0;
    277                 }
    278 #endif
    279         }
    280         return 0;
     267                if (    (access(JOYDEV,O_RDONLY)!=-1)           ||
     268                        (errno!=ENODEV && errno!=ENOENT)
     269                ) {
     270                    /* Return joystick */
     271                    devInstance.guidInstance    = GUID_Joystick;
     272                    devInstance.guidProduct     = DInput_Wine_Joystick_GUID;
     273                    /* we only support traditional joysticks for now */
     274                    devInstance.dwDevType       = DIDEVTYPE_JOYSTICK | DIDEVTYPEJOYSTICK_TRADITIONAL;
     275                    strcpy(devInstance.tszInstanceName, "Joystick");
     276                    /* ioctl JSIOCGNAME(len) */
     277                    strcpy(devInstance.tszProductName,  "Wine Joystick");
     278
     279                    ret = lpCallback(&devInstance,pvRef);
     280                    TRACE("Joystick registered\n");
     281                    if (ret == DIENUM_STOP)
     282                            return 0;
     283                }
     284#endif
     285        }
     286        return 0;
    281287}
    282288
    283289static ULONG WINAPI IDirectInputAImpl_AddRef(LPDIRECTINPUTA iface)
    284290{
    285         ICOM_THIS(IDirectInputAImpl,iface);
    286         return ++(This->ref);
     291        ICOM_THIS(IDirectInputAImpl,iface);
     292        return ++(This->ref);
    287293}
    288294
    289295static ULONG WINAPI IDirectInputAImpl_Release(LPDIRECTINPUTA iface)
    290296{
    291         ICOM_THIS(IDirectInputAImpl,iface);
    292         if (!(--This->ref)) {
    293                 HeapFree(GetProcessHeap(),0,This);
    294                 return 0;
    295         }
    296         return This->ref;
     297        ICOM_THIS(IDirectInputAImpl,iface);
     298        if (!(--This->ref)) {
     299                HeapFree(GetProcessHeap(),0,This);
     300                return 0;
     301        }
     302        return This->ref;
    297303}
    298304
    299305static HRESULT WINAPI IDirectInputAImpl_CreateDevice(
    300         LPDIRECTINPUTA iface,REFGUID rguid,LPDIRECTINPUTDEVICEA* pdev,
    301         LPUNKNOWN punk
     306        LPDIRECTINPUTA iface,REFGUID rguid,LPDIRECTINPUTDEVICEA* pdev,
     307        LPUNKNOWN punk
    302308) {
    303         ICOM_THIS(IDirectInputAImpl,iface);
    304         char    xbuf[50];
    305        
    306         WINE_StringFromCLSID(rguid,xbuf);
    307         FIXME("(this=%p,%s,%p,%p): stub\n",This,xbuf,pdev,punk);
    308         if ((!memcmp(&GUID_SysKeyboard,rguid,sizeof(GUID_SysKeyboard))) ||          /* Generic Keyboard */
    309             (!memcmp(&DInput_Wine_Keyboard_GUID,rguid,sizeof(GUID_SysKeyboard)))) { /* Wine Keyboard */
     309        ICOM_THIS(IDirectInputAImpl,iface);
     310        char    xbuf[50];
     311
     312        WINE_StringFromCLSID(rguid,xbuf);
     313        FIXME("(this=%p,%s,%p,%p): stub\n",This,xbuf,pdev,punk);
     314        if ((!memcmp(&GUID_SysKeyboard,rguid,sizeof(GUID_SysKeyboard))) ||          /* Generic Keyboard */
     315            (!memcmp(&DInput_Wine_Keyboard_GUID,rguid,sizeof(GUID_SysKeyboard)))) { /* Wine Keyboard */
    310316                SysKeyboardAImpl* newDevice;
    311                 newDevice = (SysKeyboardAImpl*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(SysKeyboardAImpl));
    312                 newDevice->ref = 1;
    313                 ICOM_VTBL(newDevice) = &SysKeyboardAvt;
    314                 memcpy(&(newDevice->guid),rguid,sizeof(*rguid));
    315                 memset(newDevice->keystate,0,256);
     317                newDevice = (SysKeyboardAImpl*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(SysKeyboardAImpl));
     318                newDevice->ref = 1;
     319                ICOM_VTBL(newDevice) = &SysKeyboardAvt;
     320                InitializeCriticalSection(&(newDevice->crit));
     321                MakeCriticalSectionGlobal(&(newDevice->crit));
     322                memcpy(&(newDevice->guid),rguid,sizeof(*rguid));
     323                memset(newDevice->keystate,0,256);
    316324                *pdev=(IDirectInputDeviceA*)newDevice;
    317                 return DI_OK;
    318         }
    319         if ((!memcmp(&GUID_SysMouse,rguid,sizeof(GUID_SysMouse))) ||             /* Generic Mouse */
    320             (!memcmp(&DInput_Wine_Mouse_GUID,rguid,sizeof(GUID_SysMouse)))) { /* Wine Mouse */
     325                return DI_OK;
     326        }
     327        if ((!memcmp(&GUID_SysMouse,rguid,sizeof(GUID_SysMouse))) ||             /* Generic Mouse */
     328            (!memcmp(&DInput_Wine_Mouse_GUID,rguid,sizeof(GUID_SysMouse)))) { /* Wine Mouse */
    321329                SysMouseAImpl* newDevice;
    322                 newDevice = (SysMouseAImpl*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(SysMouseAImpl));
    323                 newDevice->ref = 1;
    324                 ICOM_VTBL(newDevice) = &SysMouseAvt;
    325                 InitializeCriticalSection(&(newDevice->crit));
    326                 MakeCriticalSectionGlobal(&(newDevice->crit));
    327                 memcpy(&(newDevice->guid),rguid,sizeof(*rguid));
     330                newDevice = (SysMouseAImpl*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(SysMouseAImpl));
     331                newDevice->ref = 1;
     332                ICOM_VTBL(newDevice) = &SysMouseAvt;
     333                InitializeCriticalSection(&(newDevice->crit));
     334                MakeCriticalSectionGlobal(&(newDevice->crit));
     335                memcpy(&(newDevice->guid),rguid,sizeof(*rguid));
    328336                *pdev=(IDirectInputDeviceA*)newDevice;
    329                 return DI_OK;
    330         }
     337                return DI_OK;
     338        }
    331339#ifdef HAVE_LINUX_22_JOYSTICK_API
    332         if ((!memcmp(&GUID_Joystick,rguid,sizeof(GUID_Joystick))) ||
    333             (!memcmp(&DInput_Wine_Joystick_GUID,rguid,sizeof(GUID_Joystick)))) {
     340        if ((!memcmp(&GUID_Joystick,rguid,sizeof(GUID_Joystick))) ||
     341            (!memcmp(&DInput_Wine_Joystick_GUID,rguid,sizeof(GUID_Joystick)))) {
    334342                JoystickAImpl* newDevice;
    335                 newDevice = (JoystickAImpl*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(JoystickAImpl));
    336                 newDevice->ref          = 1;
    337                 ICOM_VTBL(newDevice)    = &JoystickAvt;
    338                 newDevice->joyfd        = -1;
    339                 memcpy(&(newDevice->guid),rguid,sizeof(*rguid));
     343                newDevice = (JoystickAImpl*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(JoystickAImpl));
     344                newDevice->ref          = 1;
     345                ICOM_VTBL(newDevice)    = &JoystickAvt;
     346                newDevice->joyfd        = -1;
     347                memcpy(&(newDevice->guid),rguid,sizeof(*rguid));
    340348                *pdev=(IDirectInputDeviceA*)newDevice;
    341                 return DI_OK;
    342         }
    343 #endif
    344         return E_FAIL;
     349                return DI_OK;
     350        }
     351#endif
     352        return E_FAIL;
    345353}
    346354
    347355static HRESULT WINAPI IDirectInputAImpl_QueryInterface(
    348         LPDIRECTINPUTA iface,REFIID riid,LPVOID *ppobj
     356        LPDIRECTINPUTA iface,REFIID riid,LPVOID *ppobj
    349357) {
    350         ICOM_THIS(IDirectInputAImpl,iface);
    351         char    xbuf[50];
    352 
    353         WINE_StringFromCLSID(riid,xbuf);
    354         TRACE("(this=%p,%s,%p)\n",This,xbuf,ppobj);
    355         if (!memcmp(&IID_IUnknown,riid,sizeof(*riid))) {
    356                 IDirectInputA_AddRef(iface);
    357                 *ppobj = This;
    358                 return 0;
    359         }
    360         if (!memcmp(&IID_IDirectInputA,riid,sizeof(*riid))) {
    361                 IDirectInputA_AddRef(iface);
    362                 *ppobj = This;
    363                 return 0;
    364         }
    365         return E_FAIL;
     358        ICOM_THIS(IDirectInputAImpl,iface);
     359        char    xbuf[50];
     360
     361        WINE_StringFromCLSID(riid,xbuf);
     362        TRACE("(this=%p,%s,%p)\n",This,xbuf,ppobj);
     363        if (!memcmp(&IID_IUnknown,riid,sizeof(*riid))) {
     364                IDirectInputA_AddRef(iface);
     365                *ppobj = This;
     366                return 0;
     367        }
     368        if (!memcmp(&IID_IDirectInputA,riid,sizeof(*riid))) {
     369                IDirectInputA_AddRef(iface);
     370                *ppobj = This;
     371                return 0;
     372        }
     373        return E_FAIL;
    366374}
    367375
    368376static HRESULT WINAPI IDirectInputAImpl_Initialize(
    369         LPDIRECTINPUTA iface,HINSTANCE hinst,DWORD x
     377        LPDIRECTINPUTA iface,HINSTANCE hinst,DWORD x
    370378) {
    371         return DIERR_ALREADYINITIALIZED;
     379        return DIERR_ALREADYINITIALIZED;
    372380}
    373381
    374382static HRESULT WINAPI IDirectInputAImpl_GetDeviceStatus(LPDIRECTINPUTA iface,
    375                                                         REFGUID rguid) {
     383                                                        REFGUID rguid) {
    376384  ICOM_THIS(IDirectInputAImpl,iface);
    377385  char xbuf[50];
    378  
     386
    379387  WINE_StringFromCLSID(rguid,xbuf);
    380388  FIXME("(%p)->(%s): stub\n",This,xbuf);
    381  
     389
    382390  return DI_OK;
    383391}
    384392
    385393static HRESULT WINAPI IDirectInputAImpl_RunControlPanel(LPDIRECTINPUTA iface,
    386                                                         HWND hwndOwner,
    387                                                         DWORD dwFlags) {
     394                                                        HWND hwndOwner,
     395                                                        DWORD dwFlags) {
    388396  ICOM_THIS(IDirectInputAImpl,iface);
    389397  FIXME("(%p)->(%08lx,%08lx): stub\n",This, (DWORD) hwndOwner, dwFlags);
    390  
     398
    391399  return DI_OK;
    392400}
    393401
    394 ICOM_VTABLE(IDirectInputA) ddiavt = 
    395 {
    396         ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
    397         IDirectInputAImpl_QueryInterface,
    398         IDirectInputAImpl_AddRef,
    399         IDirectInputAImpl_Release,
    400         IDirectInputAImpl_CreateDevice,
    401         IDirectInputAImpl_EnumDevices,
    402         IDirectInputAImpl_GetDeviceStatus,
    403         IDirectInputAImpl_RunControlPanel,
    404         IDirectInputAImpl_Initialize
     402ICOM_VTABLE(IDirectInputA) ddiavt =
     403{
     404        ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
     405        IDirectInputAImpl_QueryInterface,
     406        IDirectInputAImpl_AddRef,
     407        IDirectInputAImpl_Release,
     408        IDirectInputAImpl_CreateDevice,
     409        IDirectInputAImpl_EnumDevices,
     410        IDirectInputAImpl_GetDeviceStatus,
     411        IDirectInputAImpl_RunControlPanel,
     412        IDirectInputAImpl_Initialize
    405413};
    406414
    407415/******************************************************************************
    408  *      IDirectInputDeviceA
     416 *      IDirectInputDeviceA
    409417 */
    410418
    411419static HRESULT WINAPI IDirectInputDevice2AImpl_SetDataFormat(
    412         LPDIRECTINPUTDEVICE2A iface,LPCDIDATAFORMAT df
     420        LPDIRECTINPUTDEVICE2A iface,LPCDIDATAFORMAT df
    413421) {
    414         /*
    415         int i;
    416         TRACE(dinput,"(this=%p,%p)\n",This,df);
    417 
    418         TRACE(dinput,"df.dwSize=%ld\n",df->dwSize);
    419         TRACE(dinput,"(df.dwObjsize=%ld)\n",df->dwObjSize);
    420         TRACE(dinput,"(df.dwFlags=0x%08lx)\n",df->dwFlags);
    421         TRACE(dinput,"(df.dwDataSize=%ld)\n",df->dwDataSize);
    422         TRACE(dinput,"(df.dwNumObjs=%ld)\n",df->dwNumObjs);
    423 
    424         for (i=0;i<df->dwNumObjs;i++) {
    425                 char    xbuf[50];
    426 
    427                 if (df->rgodf[i].pguid)
    428                         WINE_StringFromCLSID(df->rgodf[i].pguid,xbuf);
    429                 else
    430                         strcpy(xbuf,"<no guid>");
    431                 TRACE(dinput,"df.rgodf[%d].guid %s\n",i,xbuf);
    432                 TRACE(dinput,"df.rgodf[%d].dwOfs %ld\n",i,df->rgodf[i].dwOfs);
    433                 TRACE(dinput,"dwType 0x%02lx,dwInstance %ld\n",DIDFT_GETTYPE(df->rgodf[i].dwType),DIDFT_GETINSTANCE(df->rgodf[i].dwType));
    434                 TRACE(dinput,"df.rgodf[%d].dwFlags 0x%08lx\n",i,df->rgodf[i].dwFlags);
    435         }
    436         */
    437         return 0;
     422        /*
     423        int i;
     424        TRACE(dinput,"(this=%p,%p)\n",This,df);
     425
     426        TRACE(dinput,"df.dwSize=%ld\n",df->dwSize);
     427        TRACE(dinput,"(df.dwObjsize=%ld)\n",df->dwObjSize);
     428        TRACE(dinput,"(df.dwFlags=0x%08lx)\n",df->dwFlags);
     429        TRACE(dinput,"(df.dwDataSize=%ld)\n",df->dwDataSize);
     430        TRACE(dinput,"(df.dwNumObjs=%ld)\n",df->dwNumObjs);
     431
     432        for (i=0;i<df->dwNumObjs;i++) {
     433                char    xbuf[50];
     434
     435                if (df->rgodf[i].pguid)
     436                        WINE_StringFromCLSID(df->rgodf[i].pguid,xbuf);
     437                else
     438                        strcpy(xbuf,"<no guid>");
     439                TRACE(dinput,"df.rgodf[%d].guid %s\n",i,xbuf);
     440                TRACE(dinput,"df.rgodf[%d].dwOfs %ld\n",i,df->rgodf[i].dwOfs);
     441                TRACE(dinput,"dwType 0x%02lx,dwInstance %ld\n",DIDFT_GETTYPE(df->rgodf[i].dwType),DIDFT_GETINSTANCE(df->rgodf[i].dwType));
     442                TRACE(dinput,"df.rgodf[%d].dwFlags 0x%08lx\n",i,df->rgodf[i].dwFlags);
     443        }
     444        */
     445        return 0;
    438446}
    439447
    440448static HRESULT WINAPI IDirectInputDevice2AImpl_SetCooperativeLevel(
    441         LPDIRECTINPUTDEVICE2A iface,HWND hwnd,DWORD dwflags
     449        LPDIRECTINPUTDEVICE2A iface,HWND hwnd,DWORD dwflags
    442450) {
    443         ICOM_THIS(IDirectInputDevice2AImpl,iface);
    444         FIXME("(this=%p,0x%08lx,0x%08lx): stub\n",This,(DWORD)hwnd,dwflags);
    445 //      if (TRACE_ON(dinput))
    446 //        _dump_cooperativelevel(dwflags);
    447         return 0;
     451        ICOM_THIS(IDirectInputDevice2AImpl,iface);
     452        FIXME("(this=%p,0x%08lx,0x%08lx): stub\n",This,(DWORD)hwnd,dwflags);
     453//      if (TRACE_ON(dinput))
     454//        _dump_cooperativelevel(dwflags);
     455        return 0;
    448456}
    449457
    450458static HRESULT WINAPI IDirectInputDevice2AImpl_SetEventNotification(
    451         LPDIRECTINPUTDEVICE2A iface,HANDLE hnd
     459        LPDIRECTINPUTDEVICE2A iface,HANDLE hnd
    452460) {
    453         ICOM_THIS(IDirectInputDevice2AImpl,iface);
    454         FIXME("(this=%p,0x%08lx): stub\n",This,(DWORD)hnd);
    455         return 0;
     461        ICOM_THIS(IDirectInputDevice2AImpl,iface);
     462        FIXME("(this=%p,0x%08lx): stub\n",This,(DWORD)hnd);
     463        return 0;
    456464}
    457465
    458466static ULONG WINAPI IDirectInputDevice2AImpl_Release(LPDIRECTINPUTDEVICE2A iface)
    459467{
    460         ICOM_THIS(IDirectInputDevice2AImpl,iface);
    461         This->ref--;
    462         if (This->ref)
    463                 return This->ref;
    464         HeapFree(GetProcessHeap(),0,This);
    465         return 0;
     468        ICOM_THIS(IDirectInputDevice2AImpl,iface);
     469        This->ref--;
     470        if (This->ref)
     471                return This->ref;
     472        HeapFree(GetProcessHeap(),0,This);
     473        return 0;
    466474}
    467475
    468476static HRESULT WINAPI SysKeyboardAImpl_SetProperty(
    469         LPDIRECTINPUTDEVICE2A iface,REFGUID rguid,LPCDIPROPHEADER ph
     477        LPDIRECTINPUTDEVICE2A iface,REFGUID rguid,LPCDIPROPHEADER ph
    470478)
    471479{
    472         ICOM_THIS(SysKeyboardAImpl,iface);
    473         char                    xbuf[50];
    474 
    475         if (HIWORD(rguid))
    476                 WINE_StringFromCLSID(rguid,xbuf);
    477         else
    478                 sprintf(xbuf,"<special guid %ld>",(DWORD)rguid);
    479         TRACE("(this=%p,%s,%p)\n",This,xbuf,ph);
    480         TRACE("(size=%ld,headersize=%ld,obj=%ld,how=%ld\n",
     480        ICOM_THIS(SysKeyboardAImpl,iface);
     481        char                    xbuf[50];
     482
     483        if (HIWORD(rguid))
     484                WINE_StringFromCLSID(rguid,xbuf);
     485        else
     486                sprintf(xbuf,"<special guid %ld>",(DWORD)rguid);
     487        TRACE("DINPUT-SKAI: SetProperty (this=%p,%s,%p)\n",This,xbuf,ph);
     488        TRACE("(size=%ld,headersize=%ld,obj=%ld,how=%ld\n",
    481489            ph->dwSize,ph->dwHeaderSize,ph->dwObj,ph->dwHow);
    482         if (!HIWORD(rguid)) {
     490        if (!HIWORD(rguid)) {
    483491#ifdef __WIN32OS2__
    484                 if(rguid == DIPROP_BUFFERSIZE) {
    485                         LPCDIPROPDWORD  pd = (LPCDIPROPDWORD)ph;
    486 
    487                         TRACE("(buffersize=%ld)\n",pd->dwData);
    488                 }
    489                 else    WARN("Unknown type %ld\n",(DWORD)rguid);
     492                if(rguid == DIPROP_BUFFERSIZE) {
     493                        LPCDIPROPDWORD  pd = (LPCDIPROPDWORD)ph;
     494
     495                        This->data_queue = (LPDIDEVICEOBJECTDATA)HeapAlloc(GetProcessHeap(),0,
     496                                            pd->dwData * sizeof(DIDEVICEOBJECTDATA));
     497                        This->queue_pos  = 0;
     498                        This->queue_len  = pd->dwData;
     499
     500                        TRACE("(buffersize=%ld)\n",pd->dwData);
     501                }
     502                else    WARN("Unknown type %ld\n",(DWORD)rguid);
    490503
    491504#else
    492                 switch ((DWORD)rguid) {
    493                 case (DWORD) DIPROP_BUFFERSIZE: {
    494                         LPCDIPROPDWORD  pd = (LPCDIPROPDWORD)ph;
    495 
    496                         TRACE("(buffersize=%ld)\n",pd->dwData);
    497                         break;
    498                 }
    499                 default:
    500                         WARN("Unknown type %ld\n",(DWORD)rguid);
    501                         break;
    502                 }
    503 #endif
    504         }
    505         return 0;
     505                switch ((DWORD)rguid) {
     506                case (DWORD) DIPROP_BUFFERSIZE: {
     507                        LPCDIPROPDWORD  pd = (LPCDIPROPDWORD)ph;
     508
     509                        TRACE("(buffersize=%ld)\n",pd->dwData);
     510                        break;
     511                }
     512                default:
     513                        WARN("Unknown type %ld\n",(DWORD)rguid);
     514                        break;
     515                }
     516#endif
     517        }
     518        return 0;
    506519}
    507520
    508521static HRESULT WINAPI SysKeyboardAImpl_GetDeviceState(
    509         LPDIRECTINPUTDEVICE2A iface,DWORD len,LPVOID ptr
     522        LPDIRECTINPUTDEVICE2A iface,DWORD len,LPVOID ptr
    510523)
    511524{
    512525#ifdef __WIN32OS2__
    513         return OSLibGetDIState(len, ptr) ? DI_OK : E_FAIL;
     526        return OSLibGetDIState(len, ptr) ? DI_OK : E_FAIL;
    514527#else
    515         return KEYBOARD_Driver->pGetDIState(len, ptr)?DI_OK:E_FAIL;
     528        return KEYBOARD_Driver->pGetDIState(len, ptr)?DI_OK:E_FAIL;
    516529#endif
    517530}
    518531
    519532static HRESULT WINAPI SysKeyboardAImpl_GetDeviceData(
    520         LPDIRECTINPUTDEVICE2A iface,DWORD dodsize,LPDIDEVICEOBJECTDATA dod,
    521         LPDWORD entries,DWORD flags
     533        LPDIRECTINPUTDEVICE2A iface,DWORD dodsize,LPDIDEVICEOBJECTDATA dod,
     534        LPDWORD entries,DWORD flags
    522535)
    523536{
    524         ICOM_THIS(SysKeyboardAImpl,iface);
    525         HRESULT ret;
    526         int     i;
    527 
    528         TRACE("(this=%p,%ld,%p,%p(%ld)),0x%08lx)\n",
    529               This,dodsize,dod,entries,entries?*entries:0,flags);
    530 
    531 #ifdef __WIN32OS2__
    532 //Copied this from the X11 keyboard driver (991031)
    533 {
    534         int keyc,n,xentries;
    535         BYTE win32keys[256];
    536 
    537         OSLibGetDIState(256, &win32keys);   
    538         /* FIXME !!! */
    539  
    540         if (entries)
    541             xentries = *entries;
    542         else
    543             xentries = 1;
    544          
    545         n = 0;
    546  
    547         for (int i=0;i<256 && (n<xentries);i++)
    548         {
    549               if (This->keystate[i] == (win32keys[i]&0x80))
    550                 continue;
    551               if (dod) {
    552                 /* add an entry */
    553                 dod[n].dwOfs            = i; /* scancode */
    554                 dod[n].dwData           = win32keys[i]&0x80;
    555                 dod[n].dwTimeStamp      = time(NULL);
    556                 dod[n].dwSequence       = evsequence++;
    557                 n++;
    558               }
    559               if (!(flags & DIGDD_PEEK))
    560                 This->keystate[i] = win32keys[i]&0x80;
    561              
    562         }
    563  
    564         if(entries) *entries = n;
    565         ret = DI_OK;
    566 }
    567 #else
    568         ret=KEYBOARD_Driver->pGetDIData(
    569                 This->keystate, dodsize, dod, entries, flags)?DI_OK:E_FAIL;
    570 
    571         for (i=0;i<*entries;i++) {
    572                 dod[i].dwTimeStamp = time(NULL);
    573                 dod[i].dwSequence = evsequence++;
    574         }
    575 #endif
    576         return ret;
     537        ICOM_THIS(SysKeyboardAImpl,iface);
     538        HRESULT ret;
     539        int     i;
     540
     541        TRACE("DINPUT-SKAI: GetDeviceData (this=%p,%ld,%p,%p(%ld)),0x%08lx)\n",
     542              This,dodsize,dod,entries,entries?*entries:0,flags);
     543
     544        EnterCriticalSection(&(This->crit));
     545        TRACE("(%p)->(dods=%ld,entries=%ld,fl=0x%08lx)\n",This,dodsize,*entries,flags);
     546
     547        if (flags & DIGDD_PEEK)
     548            FIXME("DIGDD_PEEK\n");
     549
     550        if (dod == NULL) {
     551           *entries = This->queue_pos;
     552           This->queue_pos = 0;
     553        } else {
     554          /* Check for buffer overflow */
     555          if (This->queue_pos > *entries) {
     556            WARN("Buffer overflow not handled properly yet...\n");
     557            This->queue_pos = *entries;
     558          }
     559          if (dodsize != sizeof(DIDEVICEOBJECTDATA)) {
     560            ERR("Wrong structure size !\n");
     561            LeaveCriticalSection(&(This->crit));
     562            return DIERR_INVALIDPARAM;
     563          }
     564
     565          if (This->queue_pos)
     566            TRACE("Application retrieving %d event(s).\n", This->queue_pos);
     567
     568          /* Copy the buffered data into the application queue */
     569          memcpy(dod, This->data_queue, This->queue_pos * dodsize);
     570          *entries = This->queue_pos;
     571
     572          /* Reset the event queue */
     573          This->queue_pos = 0;
     574        }
     575        LeaveCriticalSection(&(This->crit));
     576        ret = DI_OK;
     577
     578        return ret;
     579}
     580
     581#define GEN_KEYEVENT(offset,data,xtime,seq)                     \
     582{                                                               \
     583  if (This->queue_pos < This->queue_len) {                      \
     584    This->data_queue[This->queue_pos].dwOfs = offset;           \
     585    This->data_queue[This->queue_pos].dwData = data;            \
     586    This->data_queue[This->queue_pos].dwTimeStamp = xtime;      \
     587    This->data_queue[This->queue_pos].dwSequence = seq;         \
     588    This->queue_pos++;                                          \
     589  }                                                             \
     590}
     591
     592LRESULT CALLBACK event_keyHandler(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) {
     593   TRACE("DINPUT-SKAI: keyHandler (msg=%x wParam=0x%X, lParam=0x%lX)\n", msg, wParam, lParam);
     594
     595   SysKeyboardAImpl* This = (SysKeyboardAImpl*) current_keylock;
     596
     597   // fake a key up transition for typematic repeat
     598   if (msg == WM_KEYDOWN)
     599      if (lParam & 0x40000000) {              // key was down before
     600         dprintf(("Repeat\n"));
     601         GEN_KEYEVENT((lParam >> 16) & 0xFF,  // scancode
     602                      0,                      // key up
     603                      time(NULL), evsequence++);
     604      }
     605   GEN_KEYEVENT((lParam >> 16) & 0xFF,  // scancode
     606                (lParam & 0x80000000) ? 0 : 0x80,
     607                time(NULL), evsequence++);
     608   return TRUE;
    577609}
    578610
    579611static HRESULT WINAPI SysKeyboardAImpl_Acquire(LPDIRECTINPUTDEVICE2A iface)
    580612{
    581         ICOM_THIS(SysKeyboardAImpl,iface);
    582         TRACE("(this=%p): stub\n",This);
    583         return 0;
     613    ICOM_THIS(SysKeyboardAImpl,iface);
     614    TRACE("DINPUT-SKAI: Acquire (this=%p)\n",This);
     615
     616    if (This->acquired == 0) {
     617        /* Store (in a global variable) the current lock */
     618        current_keylock = (IDirectInputDeviceA*)This;
     619
     620        /* register the keyboard event callback */
     621        KEYBOARD_Enable(event_keyHandler);
     622        This->acquired = 1;
     623    }
     624    return 0;
    584625}
    585626
    586627static HRESULT WINAPI SysKeyboardAImpl_Unacquire(LPDIRECTINPUTDEVICE2A iface)
    587628{
    588         ICOM_THIS(SysKeyboardAImpl,iface);
    589         TRACE("(this=%p): stub\n",This);
    590         return 0;
     629        ICOM_THIS(SysKeyboardAImpl,iface);
     630        TRACE("DINPUT-SKAI: Unacquire (this=%p)\n",This);
     631
     632        /* unregister the callback */
     633        KEYBOARD_Enable(NULL);
     634
     635        /* Free the data queue */
     636        if (This->data_queue != NULL)
     637          HeapFree(GetProcessHeap(),0,This->data_queue);
     638
     639        /* No more locks */
     640        current_keylock = NULL;
     641
     642        This->acquired = 0;
     643        return 0;
    591644}
    592645
    593646static HRESULT WINAPI IDirectInputDevice2AImpl_QueryInterface(
    594         LPDIRECTINPUTDEVICE2A iface,REFIID riid,LPVOID *ppobj
     647        LPDIRECTINPUTDEVICE2A iface,REFIID riid,LPVOID *ppobj
    595648)
    596649{
    597         ICOM_THIS(IDirectInputDevice2AImpl,iface);
    598         char    xbuf[50];
    599 
    600         WINE_StringFromCLSID(riid,xbuf);
    601         TRACE("(this=%p,%s,%p)\n",This,xbuf,ppobj);
    602         if (!memcmp(&IID_IUnknown,riid,sizeof(*riid))) {
    603                 IDirectInputDevice2_AddRef(iface);
    604                 *ppobj = This;
    605                 return 0;
    606         }
    607         if (!memcmp(&IID_IDirectInputDeviceA,riid,sizeof(*riid))) {
    608                 IDirectInputDevice2_AddRef(iface);
    609                 *ppobj = This;
    610                 return 0;
    611         }
    612         if (!memcmp(&IID_IDirectInputDevice2A,riid,sizeof(*riid))) {
    613                 IDirectInputDevice2_AddRef(iface);
    614                 *ppobj = This;
    615                 return 0;
    616         }
    617         return E_FAIL;
     650        ICOM_THIS(IDirectInputDevice2AImpl,iface);
     651        char    xbuf[50];
     652
     653        WINE_StringFromCLSID(riid,xbuf);
     654        TRACE("(this=%p,%s,%p)\n",This,xbuf,ppobj);
     655        if (!memcmp(&IID_IUnknown,riid,sizeof(*riid))) {
     656                IDirectInputDevice2_AddRef(iface);
     657                *ppobj = This;
     658                return 0;
     659        }
     660        if (!memcmp(&IID_IDirectInputDeviceA,riid,sizeof(*riid))) {
     661                IDirectInputDevice2_AddRef(iface);
     662                *ppobj = This;
     663                return 0;
     664        }
     665        if (!memcmp(&IID_IDirectInputDevice2A,riid,sizeof(*riid))) {
     666                IDirectInputDevice2_AddRef(iface);
     667                *ppobj = This;
     668                return 0;
     669        }
     670        return E_FAIL;
    618671}
    619672
    620673static ULONG WINAPI IDirectInputDevice2AImpl_AddRef(
    621         LPDIRECTINPUTDEVICE2A iface)
    622 {
    623         ICOM_THIS(IDirectInputDevice2AImpl,iface);
    624         return ++This->ref;
     674        LPDIRECTINPUTDEVICE2A iface)
     675{
     676        ICOM_THIS(IDirectInputDevice2AImpl,iface);
     677        return ++This->ref;
    625678}
    626679
    627680static HRESULT WINAPI IDirectInputDevice2AImpl_GetCapabilities(
    628         LPDIRECTINPUTDEVICE2A iface,
    629         LPDIDEVCAPS lpDIDevCaps)
    630 {
    631         lpDIDevCaps->dwFlags = DIDC_ATTACHED;
    632         FIXME("stub!\n");
    633         return DI_OK;
     681        LPDIRECTINPUTDEVICE2A iface,
     682        LPDIDEVCAPS lpDIDevCaps)
     683{
     684        lpDIDevCaps->dwFlags = DIDC_ATTACHED;
     685        FIXME("stub!\n");
     686        return DI_OK;
    634687}
    635688
    636689static HRESULT WINAPI IDirectInputDevice2AImpl_EnumObjects(
    637         LPDIRECTINPUTDEVICE2A iface,
    638         LPDIENUMDEVICEOBJECTSCALLBACKA lpCallback,
    639         LPVOID lpvRef,
    640         DWORD dwFlags)
    641 {
    642         FIXME("stub!\n");
     690        LPDIRECTINPUTDEVICE2A iface,
     691        LPDIENUMDEVICEOBJECTSCALLBACKA lpCallback,
     692        LPVOID lpvRef,
     693        DWORD dwFlags)
     694{
     695        FIXME("stub!\n");
    643696#if 0
    644         if (lpCallback)
    645                 lpCallback(NULL, lpvRef);
    646 #endif
    647         return DI_OK;
    648 }
    649        
     697        if (lpCallback)
     698                lpCallback(NULL, lpvRef);
     699#endif
     700        return DI_OK;
     701}
     702
    650703static HRESULT WINAPI IDirectInputDevice2AImpl_GetProperty(
    651         LPDIRECTINPUTDEVICE2A iface,
    652         REFGUID rguid,
    653         LPDIPROPHEADER pdiph)
    654 {
    655         FIXME("stub!\n");
    656         return DI_OK;
     704        LPDIRECTINPUTDEVICE2A iface,
     705        REFGUID rguid,
     706        LPDIPROPHEADER pdiph)
     707{
     708        FIXME("stub!\n");
     709        return DI_OK;
    657710}
    658711
    659712static HRESULT WINAPI IDirectInputDevice2AImpl_GetObjectInfo(
    660         LPDIRECTINPUTDEVICE2A iface,
    661         LPDIDEVICEOBJECTINSTANCEA pdidoi,
    662         DWORD dwObj,
    663         DWORD dwHow)
    664 {
    665         FIXME("stub!\n");
    666         return DI_OK;
    667 }
    668        
     713        LPDIRECTINPUTDEVICE2A iface,
     714        LPDIDEVICEOBJECTINSTANCEA pdidoi,
     715        DWORD dwObj,
     716        DWORD dwHow)
     717{
     718        FIXME("stub!\n");
     719        return DI_OK;
     720}
     721
    669722static HRESULT WINAPI IDirectInputDevice2AImpl_GetDeviceInfo(
    670         LPDIRECTINPUTDEVICE2A iface,
    671         LPDIDEVICEINSTANCEA pdidi)
    672 {
    673         FIXME("stub!\n");
    674         return DI_OK;
    675 }
    676        
     723        LPDIRECTINPUTDEVICE2A iface,
     724        LPDIDEVICEINSTANCEA pdidi)
     725{
     726        FIXME("stub!\n");
     727        return DI_OK;
     728}
     729
    677730static HRESULT WINAPI IDirectInputDevice2AImpl_RunControlPanel(
    678         LPDIRECTINPUTDEVICE2A iface,
    679         HWND hwndOwner,
    680         DWORD dwFlags)
    681 {
    682         FIXME("stub!\n");
    683         return DI_OK;
    684 }
    685        
     731        LPDIRECTINPUTDEVICE2A iface,
     732        HWND hwndOwner,
     733        DWORD dwFlags)
     734{
     735        FIXME("stub!\n");
     736        return DI_OK;
     737}
     738
    686739static HRESULT WINAPI IDirectInputDevice2AImpl_Initialize(
    687         LPDIRECTINPUTDEVICE2A iface,
    688         HINSTANCE hinst,
    689         DWORD dwVersion,
    690         REFGUID rguid)
    691 {
    692         FIXME("stub!\n");
    693         return DI_OK;
    694 }
    695        
    696 /******************************************************************************
    697  *      IDirectInputDevice2A
     740        LPDIRECTINPUTDEVICE2A iface,
     741        HINSTANCE hinst,
     742        DWORD dwVersion,
     743        REFGUID rguid)
     744{
     745        FIXME("stub!\n");
     746        return DI_OK;
     747}
     748
     749/******************************************************************************
     750 *      IDirectInputDevice2A
    698751 */
    699752
    700753static HRESULT WINAPI IDirectInputDevice2AImpl_CreateEffect(
    701         LPDIRECTINPUTDEVICE2A iface,
    702         REFGUID rguid,
    703         LPCDIEFFECT lpeff,
    704         LPDIRECTINPUTEFFECT *ppdef,
    705         LPUNKNOWN pUnkOuter)
    706 {
    707         FIXME("stub!\n");
    708         return DI_OK;
     754        LPDIRECTINPUTDEVICE2A iface,
     755        REFGUID rguid,
     756        LPCDIEFFECT lpeff,
     757        LPDIRECTINPUTEFFECT *ppdef,
     758        LPUNKNOWN pUnkOuter)
     759{
     760        FIXME("stub!\n");
     761        return DI_OK;
    709762}
    710763
    711764static HRESULT WINAPI IDirectInputDevice2AImpl_EnumEffects(
    712         LPDIRECTINPUTDEVICE2A iface,
    713         LPDIENUMEFFECTSCALLBACKA lpCallback,
    714         LPVOID lpvRef,
    715         DWORD dwFlags)
    716 {
    717         FIXME("stub!\n");
    718         if (lpCallback)
    719                 lpCallback(NULL, lpvRef);
    720         return DI_OK;
     765        LPDIRECTINPUTDEVICE2A iface,
     766        LPDIENUMEFFECTSCALLBACKA lpCallback,
     767        LPVOID lpvRef,
     768        DWORD dwFlags)
     769{
     770        FIXME("stub!\n");
     771        if (lpCallback)
     772                lpCallback(NULL, lpvRef);
     773        return DI_OK;
    721774}
    722775
    723776static HRESULT WINAPI IDirectInputDevice2AImpl_GetEffectInfo(
    724         LPDIRECTINPUTDEVICE2A iface,
    725         LPDIEFFECTINFOA lpdei,
    726         REFGUID rguid)
    727 {
    728         FIXME("stub!\n");
    729         return DI_OK;
     777        LPDIRECTINPUTDEVICE2A iface,
     778        LPDIEFFECTINFOA lpdei,
     779        REFGUID rguid)
     780{
     781        FIXME("stub!\n");
     782        return DI_OK;
    730783}
    731784
    732785static HRESULT WINAPI IDirectInputDevice2AImpl_GetForceFeedbackState(
    733         LPDIRECTINPUTDEVICE2A iface,
    734         LPDWORD pdwOut)
    735 {
    736         FIXME("stub!\n");
    737         return DI_OK;
     786        LPDIRECTINPUTDEVICE2A iface,
     787        LPDWORD pdwOut)
     788{
     789        FIXME("stub!\n");
     790        return DI_OK;
    738791}
    739792
    740793static HRESULT WINAPI IDirectInputDevice2AImpl_SendForceFeedbackCommand(
    741         LPDIRECTINPUTDEVICE2A iface,
    742         DWORD dwFlags)
    743 {
    744         FIXME("stub!\n");
    745         return DI_OK;
     794        LPDIRECTINPUTDEVICE2A iface,
     795        DWORD dwFlags)
     796{
     797        FIXME("stub!\n");
     798        return DI_OK;
    746799}
    747800
    748801static HRESULT WINAPI IDirectInputDevice2AImpl_EnumCreatedEffectObjects(
    749         LPDIRECTINPUTDEVICE2A iface,
    750         LPDIENUMCREATEDEFFECTOBJECTSCALLBACK lpCallback,
    751         LPVOID lpvRef,
    752         DWORD dwFlags)
    753 {
    754         FIXME("stub!\n");
    755         if (lpCallback)
    756                 lpCallback(NULL, lpvRef);
    757         return DI_OK;
     802        LPDIRECTINPUTDEVICE2A iface,
     803        LPDIENUMCREATEDEFFECTOBJECTSCALLBACK lpCallback,
     804        LPVOID lpvRef,
     805        DWORD dwFlags)
     806{
     807        FIXME("stub!\n");
     808        if (lpCallback)
     809                lpCallback(NULL, lpvRef);
     810        return DI_OK;
    758811}
    759812
    760813static HRESULT WINAPI IDirectInputDevice2AImpl_Escape(
    761         LPDIRECTINPUTDEVICE2A iface,
    762         LPDIEFFESCAPE lpDIEEsc)
    763 {
    764         FIXME("stub!\n");
    765         return DI_OK;
     814        LPDIRECTINPUTDEVICE2A iface,
     815        LPDIEFFESCAPE lpDIEEsc)
     816{
     817        FIXME("stub!\n");
     818        return DI_OK;
    766819}
    767820
    768821static HRESULT WINAPI IDirectInputDevice2AImpl_Poll(
    769         LPDIRECTINPUTDEVICE2A iface)
    770 {
    771         FIXME("stub!\n");
    772         return DI_OK;
     822        LPDIRECTINPUTDEVICE2A iface)
     823{
     824        FIXME("stub!\n");
     825        return DI_OK;
    773826}
    774827
    775828static HRESULT WINAPI IDirectInputDevice2AImpl_SendDeviceData(
    776         LPDIRECTINPUTDEVICE2A iface,
    777         DWORD cbObjectData,
    778         LPDIDEVICEOBJECTDATA rgdod,
    779         LPDWORD pdwInOut,
    780         DWORD dwFlags)
    781 {
    782         FIXME("stub!\n");
    783         return DI_OK;
    784 }
    785 
    786 /******************************************************************************
    787  *      SysMouseA (DInput Mouse support)
     829        LPDIRECTINPUTDEVICE2A iface,
     830        DWORD cbObjectData,
     831        LPDIDEVICEOBJECTDATA rgdod,
     832        LPDWORD pdwInOut,
     833        DWORD dwFlags)
     834{
     835        FIXME("stub!\n");
     836        return DI_OK;
     837}
     838
     839/******************************************************************************
     840 *      SysMouseA (DInput Mouse support)
    788841 */
    789842
    … …  
    793846static ULONG WINAPI SysMouseAImpl_Release(LPDIRECTINPUTDEVICE2A iface)
    794847{
    795         ICOM_THIS(SysMouseAImpl,iface);
    796 
    797         This->ref--;
    798         if (This->ref)
    799                 return This->ref;
    800 
    801         /* Free the data queue */
    802         if (This->data_queue != NULL)
    803           HeapFree(GetProcessHeap(),0,This->data_queue);
    804 
    805         /* Install the previous event handler (in case of releasing an aquired
    806            mouse device) */
    807         if (This->prev_handler != NULL)
    808           MOUSE_Enable(This->prev_handler);
    809         DeleteCriticalSection(&(This->crit));
    810        
    811         HeapFree(GetProcessHeap(),0,This);
    812         return 0;
     848        ICOM_THIS(SysMouseAImpl,iface);
     849
     850        This->ref--;
     851        if (This->ref)
     852                return This->ref;
     853
     854        /* Free the data queue */
     855        if (This->data_queue != NULL)
     856          HeapFree(GetProcessHeap(),0,This->data_queue);
     857
     858        /* Install the previous event handler (in case of releasing an aquired
     859           mouse device) */
     860        if (This->prev_handler != NULL)
     861          MOUSE_Enable(This->prev_handler);
     862        DeleteCriticalSection(&(This->crit));
     863
     864        HeapFree(GetProcessHeap(),0,This);
     865        return 0;
    813866}
    814867
    … …  
    819872  */
    820873static HRESULT WINAPI SysMouseAImpl_SetCooperativeLevel(
    821         LPDIRECTINPUTDEVICE2A iface,HWND hwnd,DWORD dwflags
     874        LPDIRECTINPUTDEVICE2A iface,HWND hwnd,DWORD dwflags
    822875)
    823876{
    … …  
    831884  /* Store the window which asks for the mouse */
    832885  This->win = hwnd;
    833  
     886
    834887  return 0;
    835888}
    … …  
    844897  */
    845898static HRESULT WINAPI SysMouseAImpl_SetDataFormat(
    846         LPDIRECTINPUTDEVICE2A iface,LPCDIDATAFORMAT df
     899        LPDIRECTINPUTDEVICE2A iface,LPCDIDATAFORMAT df
    847900)
    848901{
    849902  ICOM_THIS(SysMouseAImpl,iface);
    850903  int i;
    851  
     904
    852905  TRACE("(this=%p,%p)\n",This,df);
    853906
    … …  
    859912
    860913  for (i=0;i<df->dwNumObjs;i++) {
    861     char        xbuf[50];
    862    
     914    char        xbuf[50];
     915
    863916    if (df->rgodf[i].pguid)
    864917      WINE_StringFromCLSID(df->rgodf[i].pguid,xbuf);
    … …  
    877930    return DIERR_INVALIDPARAM;
    878931  }
    879  
     932
    880933  /* For the moment, ignore these fields and return always as if
    881934     c_dfDIMouse was passed as format... */
    … …  
    888941  else
    889942    ERR("Neither absolute nor relative flag set.");
    890  
     943
    891944  This->df = (LPCDIDATAFORMAT)HeapAlloc(GetProcessHeap(),0,df->dwSize+(df->dwNumObjs*df->dwObjSize));
    892945  memcpy(This->df,df,df->dwSize+(df->dwNumObjs*df->dwObjSize));
    … …  
    894947}
    895948
    896 #define GEN_EVENT(offset,data,xtime,seq)                        \
    897 {                                                               \
    898   if (This->queue_pos < This->queue_len) {                      \
    899     This->data_queue[This->queue_pos].dwOfs = offset;           \
    900     This->data_queue[This->queue_pos].dwData = data;            \
    901     This->data_queue[This->queue_pos].dwTimeStamp = xtime;      \
    902     This->data_queue[This->queue_pos].dwSequence = seq;         \
    903     This->queue_pos++;                                          \
    904   }                                                             \
    905 }
    906 
    907  
     949#define GEN_EVENT(offset,data,xtime,seq)                        \
     950{                                                               \
     951  if (This->queue_pos < This->queue_len) {                      \
     952    This->data_queue[This->queue_pos].dwOfs = offset;           \
     953    This->data_queue[This->queue_pos].dwData = data;            \
     954    This->data_queue[This->queue_pos].dwTimeStamp = xtime;      \
     955    This->data_queue[This->queue_pos].dwSequence = seq;         \
     956    This->queue_pos++;                                          \
     957  }                                                             \
     958}
     959
     960
    908961/* Our private mouse event handler */
    909962static void WINAPI dinput_mouse_event( DWORD dwFlags, DWORD dx, DWORD dy,
    910                                       DWORD cButtons, DWORD dwExtraInfo )
     963                                      DWORD cButtons, DWORD dwExtraInfo )
    911964{
    912965  DWORD posX, posY, keyState, xtime, extra;
    913966  SysMouseAImpl* This = (SysMouseAImpl*) current_lock;
    914  
     967
    915968  EnterCriticalSection(&(This->crit));
    916969  /* Mouse moved -> send event if asked */
    917970  if (This->hEvent)
    918971    SetEvent(This->hEvent);
    919  
     972
    920973  if (   !IsBadReadPtr( (LPVOID)dwExtraInfo, sizeof(WINE_MOUSEEVENT) )
    921974      && ((WINE_MOUSEEVENT *)dwExtraInfo)->magic == WINE_MOUSEEVENT_MAGIC ) {
    … …  
    924977    xtime = wme->time;
    925978    extra = (DWORD)wme->hWnd;
    926    
     979
    927980    assert( dwFlags & MOUSEEVENTF_ABSOLUTE );
    928981    posX = (dx * GetSystemMetrics(SM_CXSCREEN)) >> 16;
    … …  
    939992    if (This->absolute) {
    940993      if (posX != This->prevX)
    941         GEN_EVENT(DIMOFS_X, posX, xtime, 0);
     994        GEN_EVENT(DIMOFS_X, posX, xtime, 0);
    942995      if (posY != This->prevY)
    943         GEN_EVENT(DIMOFS_Y, posY, xtime, 0);
     996        GEN_EVENT(DIMOFS_Y, posY, xtime, 0);
    944997    } else {
    945998      /* Relative mouse input : the real fun starts here... */
    946999      if (This->need_warp) {
    947         if (posX != This->prevX)
    948           GEN_EVENT(DIMOFS_X, posX - This->prevX, xtime, evsequence++);
    949         if (posY != This->prevY)
    950           GEN_EVENT(DIMOFS_Y, posY - This->prevY, xtime, evsequence++);
     1000        if (posX != This->prevX)
     1001          GEN_EVENT(DIMOFS_X, posX - This->prevX, xtime, evsequence++);
     1002        if (posY != This->prevY)
     1003          GEN_EVENT(DIMOFS_Y, posY - This->prevY, xtime, evsequence++);
    9511004      } else {
    952         /* This is the first time the event handler has been called after a
    953            GetData of GetState. */
    954         if (posX != This->win_centerX) {
    955           GEN_EVENT(DIMOFS_X, posX - This->win_centerX, xtime, evsequence++);
    956           This->need_warp = 1;
    957         }
    958          
    959         if (posY != This->win_centerY) {
    960           GEN_EVENT(DIMOFS_Y, posY - This->win_centerY, xtime, evsequence++);
    961           This->need_warp = 1;
    962         }
     1005        /* This is the first time the event handler has been called after a
     1006           GetData of GetState. */
     1007        if (posX != This->win_centerX) {
     1008          GEN_EVENT(DIMOFS_X, posX - This->win_centerX, xtime, evsequence++);
     1009          This->need_warp = 1;
     1010        }
     1011
     1012        if (posY != This->win_centerY) {
     1013          GEN_EVENT(DIMOFS_Y, posY - This->win_centerY, xtime, evsequence++);
     1014          This->need_warp = 1;
     1015        }
    9631016      }
    9641017    }
    … …  
    10151068{
    10161069  ICOM_THIS(SysMouseAImpl,iface);
    1017   RECT  rect;
    1018  
     1070  RECT  rect;
     1071
    10191072  TRACE("(this=%p)\n",This);
    10201073
    … …  
    10281081    This->prev_handler = mouse_event;
    10291082#endif
    1030  
     1083
    10311084    /* Store (in a global variable) the current lock */
    10321085    current_lock = (IDirectInputDevice2A*)This;
    1033    
     1086
    10341087    /* Install our own mouse event handler */
    10351088    MOUSE_Enable(dinput_mouse_event);
    1036    
     1089
    10371090    /* Get the window dimension and find the center */
    10381091    GetWindowRect(This->win, &rect);
    … …  
    10681121  MOUSE_Enable(This->prev_handler);
    10691122  This->prev_handler = NULL;
    1070  
     1123
    10711124  /* No more locks */
    10721125  current_lock = NULL;
    … …  
    10741127  /* Unacquire device */
    10751128  This->acquired = 0;
    1076  
     1129
    10771130  return 0;
    10781131}
    … …  
    10851138  */
    10861139static HRESULT WINAPI SysMouseAImpl_GetDeviceState(
    1087         LPDIRECTINPUTDEVICE2A iface,DWORD len,LPVOID ptr
     1140        LPDIRECTINPUTDEVICE2A iface,DWORD len,LPVOID ptr
    10881141) {
    10891142  ICOM_THIS(SysMouseAImpl,iface);
    10901143  DWORD rx, ry, state;
    10911144  struct DIMOUSESTATE *mstate = (struct DIMOUSESTATE *) ptr;
    1092  
     1145
    10931146  TRACE("(this=%p,0x%08lx,%p): \n",This,len,ptr);
    1094  
     1147
    10951148  /* Check if the buffer is big enough */
    10961149  if (len < sizeof(struct DIMOUSESTATE)) {
    … …  
    10981151    return DIERR_INVALIDPARAM;
    10991152  }
    1100  
     1153
    11011154  /* Get the mouse position */
    11021155#ifdef __WIN32OS2__
    … …  
    11231176  mstate->rgbButtons[2] = (state & MK_MBUTTON ? 0xFF : 0x00);
    11241177  mstate->rgbButtons[3] = 0x00;
    1125  
     1178
    11261179  /* Check if we need to do a mouse warping */
    11271180  if (This->need_warp) {
    … …  
    11391192    This->need_warp = 0;
    11401193  }
    1141  
     1194
    11421195  TRACE("(X: %ld - Y: %ld   L: %02x M: %02x R: %02x)\n",
    1143         mstate->lX, mstate->lY,
    1144         mstate->rgbButtons[0], mstate->rgbButtons[2], mstate->rgbButtons[1]);
    1145  
     1196        mstate->lX, mstate->lY,
     1197        mstate->rgbButtons[0], mstate->rgbButtons[2], mstate->rgbButtons[1]);
     1198
    11461199  return 0;
    11471200}
    … …  
    11511204  */
    11521205static HRESULT WINAPI SysMouseAImpl_GetDeviceData(LPDIRECTINPUTDEVICE2A iface,
    1153                                               DWORD dodsize,
    1154                                               LPDIDEVICEOBJECTDATA dod,
    1155                                               LPDWORD entries,
    1156                                               DWORD flags
     1206                                              DWORD dodsize,
     1207                                              LPDIDEVICEOBJECTDATA dod,
     1208                                              LPDWORD entries,
     1209                                              DWORD flags
    11571210) {
    11581211  ICOM_THIS(SysMouseAImpl,iface);
    1159  
     1212
    11601213  EnterCriticalSection(&(This->crit));
    11611214  TRACE("(%p)->(dods=%ld,entries=%ld,fl=0x%08lx)\n",This,dodsize,*entries,flags);
    … …  
    11801233
    11811234    if (This->queue_pos)
    1182         TRACE("Application retrieving %d event(s).\n", This->queue_pos);
    1183    
     1235        TRACE("Application retrieving %d event(s).\n", This->queue_pos);
     1236
    11841237    /* Copy the buffered data into the application queue */
    11851238    memcpy(dod, This->data_queue, This->queue_pos * dodsize);
    … …  
    11901243  }
    11911244  LeaveCriticalSection(&(This->crit));
    1192  
     1245
    11931246#if 0 /* FIXME: seems to create motion events, which fire back at us. */
    11941247  /* Check if we need to do a mouse warping */
    … …  
    12171270  */
    12181271static HRESULT WINAPI SysMouseAImpl_SetProperty(LPDIRECTINPUTDEVICE2A iface,
    1219                                             REFGUID rguid,
    1220                                             LPCDIPROPHEADER ph)
     1272                                            REFGUID rguid,
     1273                                            LPCDIPROPHEADER ph)
    12211274{
    12221275  ICOM_THIS(SysMouseAImpl,iface);
    1223   char  xbuf[50];
     1276  char  xbuf[50];
    12241277
    12251278  if (HIWORD(rguid))
    … …  
    12291282
    12301283  TRACE("(this=%p,%s,%p)\n",This,xbuf,ph);
    1231  
     1284
    12321285  if (!HIWORD(rguid)) {
    12331286#ifdef __WIN32OS2__
    12341287    if(rguid == DIPROP_BUFFERSIZE) {
    1235       LPCDIPROPDWORD    pd = (LPCDIPROPDWORD)ph;
    1236      
     1288      LPCDIPROPDWORD    pd = (LPCDIPROPDWORD)ph;
     1289
    12371290      TRACE("buffersize = %ld\n",pd->dwData);
    12381291
    12391292      This->data_queue = (LPDIDEVICEOBJECTDATA)HeapAlloc(GetProcessHeap(),0,
    1240                                                           pd->dwData * sizeof(DIDEVICEOBJECTDATA));
     1293                                                          pd->dwData * sizeof(DIDEVICEOBJECTDATA));
    12411294      This->queue_pos  = 0;
    12421295      This->queue_len  = pd->dwData;
    … …  
    12481301    switch ((DWORD)rguid) {
    12491302    case (DWORD) DIPROP_BUFFERSIZE: {
    1250       LPCDIPROPDWORD    pd = (LPCDIPROPDWORD)ph;
    1251      
     1303      LPCDIPROPDWORD    pd = (LPCDIPROPDWORD)ph;
     1304
    12521305      TRACE("buffersize = %ld\n",pd->dwData);
    12531306
    12541307      This->data_queue = (LPDIDEVICEOBJECTDATA)HeapAlloc(GetProcessHeap(),0,
    1255                                                           pd->dwData * sizeof(DIDEVICEOBJECTDATA));
     1308                                                          pd->dwData * sizeof(DIDEVICEOBJECTDATA));
    12561309      This->queue_pos  = 0;
    12571310      This->queue_len  = pd->dwData;
    … …  
    12641317#endif
    12651318  }
    1266  
     1319
    12671320  return 0;
    12681321}
    … …  
    12721325  */
    12731326static HRESULT WINAPI SysMouseAImpl_SetEventNotification(LPDIRECTINPUTDEVICE2A iface,
    1274                                                         HANDLE hnd) {
     1327                                                        HANDLE hnd) {
    12751328  ICOM_THIS(SysMouseAImpl,iface);
    12761329
    … …  
    12841337#ifdef HAVE_LINUX_22_JOYSTICK_API
    12851338/******************************************************************************
    1286  *      Joystick
     1339 *      Joystick
    12871340 */
    12881341static ULONG WINAPI JoystickAImpl_Release(LPDIRECTINPUTDEVICE2A iface)
    12891342{
    1290         ICOM_THIS(JoystickAImpl,iface);
    1291 
    1292         This->ref--;
    1293         if (This->ref)
    1294                 return This->ref;
    1295         HeapFree(GetProcessHeap(),0,This);
    1296         return 0;
     1343        ICOM_THIS(JoystickAImpl,iface);
     1344
     1345        This->ref--;
     1346        if (This->ref)
     1347                return This->ref;
     1348        HeapFree(GetProcessHeap(),0,This);
     1349        return 0;
    12971350}
    12981351
    … …  
    13021355  */
    13031356static HRESULT WINAPI JoystickAImpl_SetDataFormat(
    1304         LPDIRECTINPUTDEVICE2A iface,LPCDIDATAFORMAT df
     1357        LPDIRECTINPUTDEVICE2A iface,LPCDIDATAFORMAT df
    13051358)
    13061359{
    13071360  ICOM_THIS(JoystickAImpl,iface);
    13081361  int i;
    1309  
     1362
    13101363  TRACE("(this=%p,%p)\n",This,df);
    13111364
    … …  
    13171370
    13181371  for (i=0;i<df->dwNumObjs;i++) {
    1319     char        xbuf[50];
    1320    
     1372    char        xbuf[50];
     1373
    13211374    if (df->rgodf[i].pguid)
    13221375      WINE_StringFromCLSID(df->rgodf[i].pguid,xbuf);
    … …  
    13391392{
    13401393    ICOM_THIS(JoystickAImpl,iface);
    1341  
     1394
    13421395    TRACE("(this=%p)\n",This);
    13431396    if (This->joyfd!=-1)
    1344         return 0;
     1397        return 0;
    13451398    This->joyfd=open(JOYDEV,O_RDONLY);
    13461399    if (This->joyfd==-1)
    1347         return DIERR_NOTFOUND;
     1400        return DIERR_NOTFOUND;
    13481401    return 0;
    13491402}
    … …  
    13581411    TRACE("(this=%p)\n",This);
    13591412    if (This->joyfd!=-1) {
    1360         close(This->joyfd);
    1361         This->joyfd = -1;
     1413        close(This->joyfd);
     1414        This->joyfd = -1;
    13621415    }
    13631416    return 0;
    … …  
    13681421static void joy_polldev(JoystickAImpl *This) {
    13691422    struct timeval tv;
    1370     fd_set      readfds;
    1371     struct      js_event jse;
     1423    fd_set      readfds;
     1424    struct      js_event jse;
    13721425
    13731426    if (This->joyfd==-1)
    1374         return;
     1427        return;
    13751428    while (1) {
    1376         memset(&tv,0,sizeof(tv));
    1377         FD_ZERO(&readfds);FD_SET(This->joyfd,&readfds);
    1378         if (1>select(This->joyfd+1,&readfds,NULL,NULL,&tv))
    1379             return;
    1380         /* we have one event, so we can read */
    1381         if (sizeof(jse)!=read(This->joyfd,&jse,sizeof(jse))) {
    1382             return;
    1383         }
    1384         TRACE("js_event: type 0x%x, number %d, value %d\n",jse.type,jse.number,jse.value);
    1385         if (jse.type & JS_EVENT_BUTTON) {
    1386             GEN_EVENT(DIJOFS_BUTTON(jse.number),jse.value?0x80:0x00,jse.time,evsequence++);
    1387             This->js.rgbButtons[jse.number] = jse.value?0x80:0x00;
    1388         }
    1389         if (jse.type & JS_EVENT_AXIS) {
    1390             switch (jse.number) {
    1391             case 0:
    1392                 GEN_EVENT(jse.number*4,jse.value,jse.time,evsequence++);
    1393                 This->js.lX = map_axis(jse.value);
    1394                 break;
    1395             case 1:
    1396                 GEN_EVENT(jse.number*4,jse.value,jse.time,evsequence++);
    1397                 This->js.lY = map_axis(jse.value);
    1398                 break;
    1399             case 2:
    1400                 GEN_EVENT(jse.number*4,jse.value,jse.time,evsequence++);
    1401                 This->js.lZ = map_axis(jse.value);
    1402                 break;
    1403             default:
    1404                 FIXME("more then 3 axes (%d) not handled!\n",jse.number);
    1405                 break;
    1406             }
    1407         }
     1429        memset(&tv,0,sizeof(tv));
     1430        FD_ZERO(&readfds);FD_SET(This->joyfd,&readfds);
     1431        if (1>select(This->joyfd+1,&readfds,NULL,NULL,&tv))
     1432            return;
     1433        /* we have one event, so we can read */
     1434        if (sizeof(jse)!=read(This->joyfd,&jse,sizeof(jse))) {
     1435            return;
     1436        }
     1437        TRACE("js_event: type 0x%x, number %d, value %d\n",jse.type,jse.number,jse.value);
     1438        if (jse.type & JS_EVENT_BUTTON) {
     1439            GEN_EVENT(DIJOFS_BUTTON(jse.number),jse.value?0x80:0x00,jse.time,evsequence++);
     1440            This->js.rgbButtons[jse.number] = jse.value?0x80:0x00;
     1441        }
     1442        if (jse.type & JS_EVENT_AXIS) {
     1443            switch (jse.number) {
     1444            case 0:
     1445                GEN_EVENT(jse.number*4,jse.value,jse.time,evsequence++);
     1446                This->js.lX = map_axis(jse.value);
     1447                break;
     1448            case 1:
     1449                GEN_EVENT(jse.number*4,jse.value,jse.time,evsequence++);
     1450                This->js.lY = map_axis(jse.value);
     1451                break;
     1452            case 2:
     1453                GEN_EVENT(jse.number*4,jse.value,jse.time,evsequence++);
     1454                This->js.lZ = map_axis(jse.value);
     1455                break;
     1456            default:
     1457                FIXME("more then 3 axes (%d) not handled!\n",jse.number);
     1458                break;
     1459            }
     1460        }
    14081461    }
    14091462}
    … …  
    14141467  */
    14151468static HRESULT WINAPI JoystickAImpl_GetDeviceState(
    1416         LPDIRECTINPUTDEVICE2A iface,DWORD len,LPVOID ptr
     1469        LPDIRECTINPUTDEVICE2A iface,DWORD len,LPVOID ptr
    14171470) {
    14181471    ICOM_THIS(JoystickAImpl,iface);
    1419  
     1472
    14201473    joy_polldev(This);
    14211474    TRACE("(this=%p,0x%08lx,%p)\n",This,len,ptr);
    14221475    if (len != sizeof(DIJOYSTATE)) {
    1423         FIXME("len %ld is not sizeof(DIJOYSTATE), unsupported format.\n",len);
     1476        FIXME("len %ld is not sizeof(DIJOYSTATE), unsupported format.\n",len);
    14241477    }
    14251478    memcpy(ptr,&(This->js),len);
    … …  
    14321485  */
    14331486static HRESULT WINAPI JoystickAImpl_GetDeviceData(LPDIRECTINPUTDEVICE2A iface,
    1434                                               DWORD dodsize,
    1435                                               LPDIDEVICEOBJECTDATA dod,
    1436                                               LPDWORD entries,
    1437                                               DWORD flags
     1487                                              DWORD dodsize,
     1488                                              LPDIDEVICEOBJECTDATA dod,
     1489                                              LPDWORD entries,
     1490                                              DWORD flags
    14381491) {
    14391492  ICOM_THIS(JoystickAImpl,iface);
    1440  
     1493
    14411494  FIXME("(%p)->(dods=%ld,entries=%ld,fl=0x%08lx),STUB!\n",This,dodsize,*entries,flags);
    14421495
    … …  
    14551508  */
    14561509static HRESULT WINAPI JoystickAImpl_SetProperty(LPDIRECTINPUTDEVICE2A iface,
    1457                                             REFGUID rguid,
    1458                                             LPCDIPROPHEADER ph)
     1510                                            REFGUID rguid,
     1511                                            LPCDIPROPHEADER ph)
    14591512{
    14601513  ICOM_THIS(JoystickAImpl,iface);
    1461   char  xbuf[50];
     1514  char  xbuf[50];
    14621515
    14631516  if (HIWORD(rguid))
    … …  
    14681521  FIXME("(this=%p,%s,%p)\n",This,xbuf,ph);
    14691522  FIXME("ph.dwSize = %ld, ph.dwHeaderSize =%ld, ph.dwObj = %ld, ph.dwHow= %ld\n",ph->dwSize, ph->dwHeaderSize,ph->dwObj,ph->dwHow);
    1470  
     1523
    14711524  if (!HIWORD(rguid)) {
    14721525    switch ((DWORD)rguid) {
    14731526    case (DWORD) DIPROP_BUFFERSIZE: {
    1474       LPCDIPROPDWORD    pd = (LPCDIPROPDWORD)ph;
     1527      LPCDIPROPDWORD    pd = (LPCDIPROPDWORD)ph;
    14751528
    14761529      FIXME("buffersize = %ld\n",pd->dwData);
    … …  
    14781531    }
    14791532    case (DWORD)DIPROP_RANGE: {
    1480       LPCDIPROPRANGE    pr = (LPCDIPROPRANGE)ph;
     1533      LPCDIPROPRANGE    pr = (LPCDIPROPRANGE)ph;
    14811534
    14821535      FIXME("proprange(%ld,%ld)\n",pr->lMin,pr->lMax);
    … …  
    14861539    }
    14871540    case (DWORD)DIPROP_DEADZONE: {
    1488       LPCDIPROPDWORD    pd = (LPCDIPROPDWORD)ph;
     1541      LPCDIPROPDWORD    pd = (LPCDIPROPDWORD)ph;
    14891542
    14901543      FIXME("deadzone(%ld)\n",pd->dwData);
    … …  
    15041557  */
    15051558static HRESULT WINAPI JoystickAImpl_SetEventNotification(
    1506         LPDIRECTINPUTDEVICE2A iface, HANDLE hnd
     1559        LPDIRECTINPUTDEVICE2A iface, HANDLE hnd
    15071560) {
    15081561    ICOM_THIS(JoystickAImpl,iface);
    … …  
    15141567
    15151568static HRESULT WINAPI JoystickAImpl_GetCapabilities(
    1516         LPDIRECTINPUTDEVICE2A iface,
    1517         LPDIDEVCAPS lpDIDevCaps)
     1569        LPDIRECTINPUTDEVICE2A iface,
     1570        LPDIDEVCAPS lpDIDevCaps)
    15181571{
    15191572    ICOM_THIS(JoystickAImpl,iface);
    1520     BYTE        axes,buttons;
    1521     int         xfd = This->joyfd;
     1573    BYTE        axes,buttons;
     1574    int         xfd = This->joyfd;
    15221575
    15231576    TRACE("%p->(%p)\n",iface,lpDIDevCaps);
    15241577    if (xfd==-1)
    1525         xfd = open(JOYDEV,O_RDONLY);
    1526     lpDIDevCaps->dwFlags        = DIDC_ATTACHED;
    1527     lpDIDevCaps->dwDevType      = DIDEVTYPE_JOYSTICK;
     1578        xfd = open(JOYDEV,O_RDONLY);
     1579    lpDIDevCaps->dwFlags        = DIDC_ATTACHED;
     1580    lpDIDevCaps->dwDevType      = DIDEVTYPE_JOYSTICK;
    15281581#ifdef JSIOCGAXES
    15291582    if (-1==ioctl(xfd,JSIOCGAXES,&axes))
    1530         axes = 2;
     1583        axes = 2;
    15311584    lpDIDevCaps->dwAxes = axes;
    15321585#endif
    15331586#ifdef JSIOCGBUTTONS
    15341587    if (-1==ioctl(xfd,JSIOCGAXES,&buttons))
    1535         buttons = 2;
     1588        buttons = 2;
    15361589    lpDIDevCaps->dwButtons = buttons;
    15371590#endif
    15381591    if (xfd!=This->joyfd)
    1539         close(xfd);
     1592        close(xfd);
    15401593    return DI_OK;
    15411594}
    … …  
    15521605/****************************************************************************/
    15531606
    1554 ICOM_VTABLE(IDirectInputDevice2A) SysKeyboardAvt = 
    1555 {
    1556         ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
    1557         IDirectInputDevice2AImpl_QueryInterface,
    1558         IDirectInputDevice2AImpl_AddRef,
    1559         IDirectInputDevice2AImpl_Release,
    1560         IDirectInputDevice2AImpl_GetCapabilities,
    1561         IDirectInputDevice2AImpl_EnumObjects,
    1562         IDirectInputDevice2AImpl_GetProperty,
    1563         SysKeyboardAImpl_SetProperty,
    1564         SysKeyboardAImpl_Acquire,
    1565         SysKeyboardAImpl_Unacquire,
    1566         SysKeyboardAImpl_GetDeviceState,
    1567         SysKeyboardAImpl_GetDeviceData,
    1568         IDirectInputDevice2AImpl_SetDataFormat,
    1569         IDirectInputDevice2AImpl_SetEventNotification,
    1570         IDirectInputDevice2AImpl_SetCooperativeLevel,
    1571         IDirectInputDevice2AImpl_GetObjectInfo,
    1572         IDirectInputDevice2AImpl_GetDeviceInfo,
    1573         IDirectInputDevice2AImpl_RunControlPanel,
    1574         IDirectInputDevice2AImpl_Initialize,
    1575         IDirectInputDevice2AImpl_CreateEffect,
    1576         IDirectInputDevice2AImpl_EnumEffects,
    1577         IDirectInputDevice2AImpl_GetEffectInfo,
    1578         IDirectInputDevice2AImpl_GetForceFeedbackState,
    1579         IDirectInputDevice2AImpl_SendForceFeedbackCommand,
    1580         IDirectInputDevice2AImpl_EnumCreatedEffectObjects,
    1581         IDirectInputDevice2AImpl_Escape,
    1582         IDirectInputDevice2AImpl_Poll,
    1583         IDirectInputDevice2AImpl_SendDeviceData,
     1607ICOM_VTABLE(IDirectInputDevice2A) SysKeyboardAvt =
     1608{
     1609        ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
     1610        IDirectInputDevice2AImpl_QueryInterface,
     1611        IDirectInputDevice2AImpl_AddRef,
     1612        IDirectInputDevice2AImpl_Release,
     1613        IDirectInputDevice2AImpl_GetCapabilities,
     1614        IDirectInputDevice2AImpl_EnumObjects,
     1615        IDirectInputDevice2AImpl_GetProperty,
     1616        SysKeyboardAImpl_SetProperty,
     1617        SysKeyboardAImpl_Acquire,
     1618        SysKeyboardAImpl_Unacquire,
     1619        SysKeyboardAImpl_GetDeviceState,
     1620        SysKeyboardAImpl_GetDeviceData,
     1621        IDirectInputDevice2AImpl_SetDataFormat,
     1622        IDirectInputDevice2AImpl_SetEventNotification,
     1623        IDirectInputDevice2AImpl_SetCooperativeLevel,
     1624        IDirectInputDevice2AImpl_GetObjectInfo,
     1625        IDirectInputDevice2AImpl_GetDeviceInfo,
     1626        IDirectInputDevice2AImpl_RunControlPanel,
     1627        IDirectInputDevice2AImpl_Initialize,
     1628        IDirectInputDevice2AImpl_CreateEffect,
     1629        IDirectInputDevice2AImpl_EnumEffects,
     1630        IDirectInputDevice2AImpl_GetEffectInfo,
     1631        IDirectInputDevice2AImpl_GetForceFeedbackState,
     1632        IDirectInputDevice2AImpl_SendForceFeedbackCommand,
     1633        IDirectInputDevice2AImpl_EnumCreatedEffectObjects,
     1634        IDirectInputDevice2AImpl_Escape,
     1635        IDirectInputDevice2AImpl_Poll,
     1636        IDirectInputDevice2AImpl_SendDeviceData,
    15841637};
    15851638
    1586 ICOM_VTABLE(IDirectInputDevice2A) SysMouseAvt = 
    1587 {
    1588         ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
    1589         IDirectInputDevice2AImpl_QueryInterface,
    1590         IDirectInputDevice2AImpl_AddRef,
    1591         SysMouseAImpl_Release,
    1592         IDirectInputDevice2AImpl_GetCapabilities,
    1593         IDirectInputDevice2AImpl_EnumObjects,
    1594         IDirectInputDevice2AImpl_GetProperty,
    1595         SysMouseAImpl_SetProperty,
    1596         SysMouseAImpl_Acquire,
    1597         SysMouseAImpl_Unacquire,
    1598         SysMouseAImpl_GetDeviceState,
    1599         SysMouseAImpl_GetDeviceData,
    1600         SysMouseAImpl_SetDataFormat,
    1601         SysMouseAImpl_SetEventNotification,
    1602         SysMouseAImpl_SetCooperativeLevel,
    1603         IDirectInputDevice2AImpl_GetObjectInfo,
    1604         IDirectInputDevice2AImpl_GetDeviceInfo,
    1605         IDirectInputDevice2AImpl_RunControlPanel,
    1606         IDirectInputDevice2AImpl_Initialize,
    1607         IDirectInputDevice2AImpl_CreateEffect,
    1608         IDirectInputDevice2AImpl_EnumEffects,
    1609         IDirectInputDevice2AImpl_GetEffectInfo,
    1610         IDirectInputDevice2AImpl_GetForceFeedbackState,
    1611         IDirectInputDevice2AImpl_SendForceFeedbackCommand,
    1612         IDirectInputDevice2AImpl_EnumCreatedEffectObjects,
    1613         IDirectInputDevice2AImpl_Escape,
    1614         IDirectInputDevice2AImpl_Poll,
    1615         IDirectInputDevice2AImpl_SendDeviceData,
     1639ICOM_VTABLE(IDirectInputDevice2A) SysMouseAvt =
     1640{
     1641        ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
     1642        IDirectInputDevice2AImpl_QueryInterface,
     1643        IDirectInputDevice2AImpl_AddRef,
     1644        SysMouseAImpl_Release,
     1645        IDirectInputDevice2AImpl_GetCapabilities,
     1646        IDirectInputDevice2AImpl_EnumObjects,
     1647        IDirectInputDevice2AImpl_GetProperty,
     1648        SysMouseAImpl_SetProperty,
     1649        SysMouseAImpl_Acquire,
     1650        SysMouseAImpl_Unacquire,
     1651        SysMouseAImpl_GetDeviceState,
     1652        SysMouseAImpl_GetDeviceData,
     1653        SysMouseAImpl_SetDataFormat,
     1654        SysMouseAImpl_SetEventNotification,
     1655        SysMouseAImpl_SetCooperativeLevel,
     1656        IDirectInputDevice2AImpl_GetObjectInfo,
     1657        IDirectInputDevice2AImpl_GetDeviceInfo,
     1658        IDirectInputDevice2AImpl_RunControlPanel,
     1659        IDirectInputDevice2AImpl_Initialize,
     1660        IDirectInputDevice2AImpl_CreateEffect,
     1661        IDirectInputDevice2AImpl_EnumEffects,
     1662        IDirectInputDevice2AImpl_GetEffectInfo,
     1663        IDirectInputDevice2AImpl_GetForceFeedbackState,
     1664        IDirectInputDevice2AImpl_SendForceFeedbackCommand,
     1665        IDirectInputDevice2AImpl_EnumCreatedEffectObjects,
     1666        IDirectInputDevice2AImpl_Escape,
     1667        IDirectInputDevice2AImpl_Poll,
     1668        IDirectInputDevice2AImpl_SendDeviceData,
    16161669};
    16171670
    16181671#ifdef HAVE_LINUX_22_JOYSTICK_API
    1619 ICOM_VTABLE(IDirectInputDevice2A) JoystickAvt = 
    1620 {
    1621         ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
    1622         IDirectInputDevice2AImpl_QueryInterface,
    1623         IDirectInputDevice2AImpl_AddRef,
    1624         JoystickAImpl_Release,
    1625         JoystickAImpl_GetCapabilities,
    1626         IDirectInputDevice2AImpl_EnumObjects,
    1627         IDirectInputDevice2AImpl_GetProperty,
    1628         JoystickAImpl_SetProperty,
    1629         JoystickAImpl_Acquire,
    1630         JoystickAImpl_Unacquire,
    1631         JoystickAImpl_GetDeviceState,
    1632         JoystickAImpl_GetDeviceData,
    1633         JoystickAImpl_SetDataFormat,
    1634         JoystickAImpl_SetEventNotification,
    1635         IDirectInputDevice2AImpl_SetCooperativeLevel,
    1636         IDirectInputDevice2AImpl_GetObjectInfo,
    1637         IDirectInputDevice2AImpl_GetDeviceInfo,
    1638         IDirectInputDevice2AImpl_RunControlPanel,
    1639         IDirectInputDevice2AImpl_Initialize,
    1640         IDirectInputDevice2AImpl_CreateEffect,
    1641         IDirectInputDevice2AImpl_EnumEffects,
    1642         IDirectInputDevice2AImpl_GetEffectInfo,
    1643         IDirectInputDevice2AImpl_GetForceFeedbackState,
    1644         IDirectInputDevice2AImpl_SendForceFeedbackCommand,
    1645         IDirectInputDevice2AImpl_EnumCreatedEffectObjects,
    1646         IDirectInputDevice2AImpl_Escape,
    1647         JoystickAImpl_Poll,
    1648         IDirectInputDevice2AImpl_SendDeviceData,
     1672ICOM_VTABLE(IDirectInputDevice2A) JoystickAvt =
     1673{
     1674        ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
     1675        IDirectInputDevice2AImpl_QueryInterface,
     1676        IDirectInputDevice2AImpl_AddRef,
     1677        JoystickAImpl_Release,
     1678        JoystickAImpl_GetCapabilities,
     1679        IDirectInputDevice2AImpl_EnumObjects,
     1680        IDirectInputDevice2AImpl_GetProperty,
     1681        JoystickAImpl_SetProperty,
     1682        JoystickAImpl_Acquire,
     1683        JoystickAImpl_Unacquire,
     1684        JoystickAImpl_GetDeviceState,
     1685        JoystickAImpl_GetDeviceData,
     1686        JoystickAImpl_SetDataFormat,
     1687        JoystickAImpl_SetEventNotification,
     1688        IDirectInputDevice2AImpl_SetCooperativeLevel,
     1689        IDirectInputDevice2AImpl_GetObjectInfo,
     1690        IDirectInputDevice2AImpl_GetDeviceInfo,
     1691        IDirectInputDevice2AImpl_RunControlPanel,
     1692        IDirectInputDevice2AImpl_Initialize,
     1693        IDirectInputDevice2AImpl_CreateEffect,
     1694        IDirectInputDevice2AImpl_EnumEffects,
     1695        IDirectInputDevice2AImpl_GetEffectInfo,
     1696        IDirectInputDevice2AImpl_GetForceFeedbackState,
     1697        IDirectInputDevice2AImpl_SendForceFeedbackCommand,
     1698        IDirectInputDevice2AImpl_EnumCreatedEffectObjects,
     1699        IDirectInputDevice2AImpl_Escape,
     1700        JoystickAImpl_Poll,
     1701        IDirectInputDevice2AImpl_SendDeviceData,
    16491702};
    16501703#endif
Note: See TracChangeset for help on using the changeset viewer.