able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/multimedia/directx/dinput/dx8/dll/dihid.c

4432 lines
133 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*****************************************************************************
*
* DIHid.c
*
* Copyright (c) 1996 Microsoft Corporation. All Rights Reserved.
*
* Abstract:
*
* The HID device callback.
*
* Contents:
*
* CHid_New
*
*****************************************************************************/
#include "dinputpr.h"
/*****************************************************************************
*
* The sqiffle for this file.
*
*****************************************************************************/
#define sqfl sqflHidDev
/*****************************************************************************
*
* Declare the interfaces we will be providing.
*
*****************************************************************************/
Primary_Interface(CHid, IDirectInputDeviceCallback);
Interface_Template_Begin(CHid)
Primary_Interface_Template(CHid, IDirectInputDeviceCallback)
Interface_Template_End(CHid)
/*****************************************************************************
*
* Forward declarations
*
* These are out of laziness, not out of necessity.
*
*****************************************************************************/
LRESULT CALLBACK
CHid_SubclassProc(HWND hwnd, UINT wm, WPARAM wp, LPARAM lp,
UINT_PTR uid, ULONG_PTR dwRef);
STDMETHODIMP_(DWORD) CHid_GetUsage(PDICB pdcb, int iobj);
/*****************************************************************************
*
* Hid devices are totally arbitrary, so there is nothing static we
* can cook up to describe them. We generate all the information on
* the fly.
*
*****************************************************************************/
/*****************************************************************************
*
* Auxiliary helper definitions for CHid.
*
*****************************************************************************/
#define ThisClass CHid
#define ThisInterface IDirectInputDeviceCallback
#define riidExpected &IID_IDirectInputDeviceCallback
/*****************************************************************************
*
* CHid::QueryInterface (from IUnknown)
* CHid::AddRef (from IUnknown)
* CHid::Release (from IUnknown)
*
*****************************************************************************/
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CHid | QueryInterface |
*
* Gives a client access to other interfaces on an object.
*
* @cwrap LPDIRECTINPUT | lpDirectInput
*
* @parm IN REFIID | riid |
*
* The requested interface's IID.
*
* @parm OUT LPVOID * | ppvObj |
*
* Receives a pointer to the obtained interface.
*
* @returns
*
* Returns a COM error code.
*
* @xref OLE documentation for <mf IUnknown::QueryInterface>.
*
*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CHid | AddRef |
*
* Increments the reference count for the interface.
*
* @cwrap LPDIRECTINPUT | lpDirectInput
*
* @returns
*
* Returns the object reference count.
*
* @xref OLE documentation for <mf IUnknown::AddRef>.
*
*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CHid | Release |
*
* Decrements the reference count for the interface.
* If the reference count on the object falls to zero,
* the object is freed from memory.
*
* @cwrap LPDIRECTINPUT | lpDirectInput
*
* @returns
*
* Returns the object reference count.
*
* @xref OLE documentation for <mf IUnknown::Release>.
*
*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CHid | QIHelper |
*
* We don't have any dynamic interfaces and simply forward
* to <f Common_QIHelper>.
*
*
* @parm IN REFIID | riid |
*
* The requested interface's IID.
*
* @parm OUT LPVOID * | ppvObj |
*
* Receives a pointer to the obtained interface.
*
*****************************************************************************/
#ifdef DEBUG
Default_QueryInterface(CHid)
Default_AddRef(CHid)
Default_Release(CHid)
#else
#define CHid_QueryInterface Common_QueryInterface
#define CHid_AddRef Common_AddRef
#define CHid_Release Common_Release
#endif
#define CHid_QIHelper Common_QIHelper
/*****************************************************************************
*
* @doc INTERNAL
*
* @method void | CHid | RemoveSubclass |
*
* Remove our subclass hook on the window.
*
*****************************************************************************/
void INTERNAL
CHid_RemoveSubclass(PCHID this)
{
/*
* !! All the comments in CJoy_RemoveSubclass apply here !!
*/
if(this->hwnd)
{
HWND hwnd = this->hwnd;
this->hwnd = 0;
if(!RemoveWindowSubclass(hwnd, CHid_SubclassProc, 0))
{
/*
* The RemoveWindowSubclass can fail if the window
* was destroyed behind our back.
*/
// AssertF(!IsWindow(hwnd));
}
Sleep(0); /* Let the worker thread drain */
Common_Unhold(this);
}
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CHid | Unacquire |
*
* Tell the device driver to stop data acquisition.
*
* It is the caller's responsibility to call this only
* when the device has been acquired.
*
* Warning! We require that the device critical section be
* held so we don't race against our worker thread.
*
* @returns
*
* Returns a COM error code. The following error codes are
* intended to be illustrative and not necessarily comprehensive.
*
* <c DI_OK> = <c S_OK>: The operation completed successfully.
*
* <c S_FALSE>: The operation was begun and should be completed
* by the caller by communicating with the <t VXDINSTANCE>.
*
*****************************************************************************/
STDMETHODIMP
CHid_Unacquire(PDICB pdcb)
{
HRESULT hres;
PCHID this;
EnterProcI(IDirectInputDeviceCallback::HID::Unacquire,
(_ "p", pdcb));
/*
* This is an internal interface, so we can skimp on validation.
*/
this = _thisPvNm(pdcb, dcb);
AssertF(this->pvi);
AssertF(this->pvi->pdd);
AssertF(CDIDev_InCrit(this->pvi->pdd));
hres = S_FALSE; /* Please finish for me */
ExitOleProcR();
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @func void | CHid_Finalize |
*
* Releases the resources of the device after all references
* (both strong and weak) are gone.
*
* @parm PV | pvObj |
*
* Object being released. Note that it may not have been
* completely initialized, so everything should be done
* carefully.
*
*****************************************************************************/
void INTERNAL
CHid_Finalize(PV pvObj)
{
UINT iType;
PCHID this = pvObj;
if(this->hkInstType)
{
RegCloseKey(this->hkInstType);
}
if(this->hkType)
{
RegCloseKey(this->hkType);
}
if( this->hkProp)
{
RegCloseKey(this->hkProp);
}
AssertF(this->hdev == INVALID_HANDLE_VALUE);
AssertF(this->hdevEm == INVALID_HANDLE_VALUE);
if(this->ppd)
{
HidD_FreePreparsedData(this->ppd);
}
/*
*
* Free group 2 memory:
*
* hriIn.pvReport Input data
* hriIn.rgdata
*
* hriOut.pvReport Output data
* hriOut.rgdata
*
* hriFea.pvReport Feature data (both in and out)
* hriFea.rgdata
*
* pvPhys Used by ED
* pvStage
*/
FreePpv(&this->pvGroup2);
/*
* Freeing df.rgodf also frees rgpvCaps, rgvcaps, rgbcaps, rgcoll.
*/
FreePpv(&this->df.rgodf);
FreePpv(&this->rgbaxissemflags);
FreePpv(&this->rgiobj);
FreePpv(&this->ptszPath);
FreePpv(&this->ptszId);
FreePpv(&this->rgpbButtonMasks);
for(iType = 0x0; iType < HidP_Max; iType++)
{
FreePpv(&this->pEnableReportId[iType]);
}
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CHid | AppFinalize |
*
* The client <t VXDINSTANCE> contains a weak pointer back
* to us so that that it can party on the data format we
* collected.
*
* @parm PV | pvObj |
*
* Object being released from the application's perspective.
*
*****************************************************************************/
void INTERNAL
CHid_AppFinalize(PV pvObj)
{
PCHID this = pvObj;
if(this->pvi)
{
HRESULT hres;
CHid_RemoveSubclass(this);
/*
* Prefix warns that "this" may have been freed (mb:34570) however
* in AppFinalize we should always have our internal reference to
* keep it around. As long as refcounting is not broken, we are OK
* and any refcount bug has to be fixed so don't hide it here.
*/
hres = Hel_DestroyInstance(this->pvi);
AssertF(SUCCEEDED(hres));
}
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @func LRESULT | CHid_SubclassProc |
*
* Window subclass procedure which watches for
* joystick configuration change notifications.
*
* Even if we are not a joystick, we still listen to
* this, in case somebody recalibrated a remote control
* or some other wacky thing like that.
*
* However, if our device has no calibratable controls,
* then there's no point in watching for recalibration
* notifications.
*
* @parm HWND | hwnd |
*
* The victim window.
*
* @parm UINT | wm |
*
* Window message.
*
* @parm WPARAM | wp |
*
* Message-specific data.
*
* @parm LPARAM | lp |
*
* Message-specific data.
*
* @parm UINT | uid |
*
* Callback identification number, always zero.
*
* @parm DWORD | dwRef |
*
* Reference data, a pointer to our joystick device callback.
*
*****************************************************************************/
LRESULT CALLBACK
CHid_SubclassProc(HWND hwnd, UINT wm, WPARAM wp, LPARAM lp,
UINT_PTR uid, ULONG_PTR dwRef)
{
#ifdef XDEBUG
static CHAR s_szProc[] = "";
#endif
PCHID this = (PCHID)dwRef;
AssertF(uid == 0);
/*
* Wacky subtlety going on here to avoid race conditions.
* See the mondo comment block in CJoy_RemoveSubclass [sic]
* for details.
*
* We can get faked out if the memory associated with the
* CHid is still physically allocated, the vtbl is magically
* still there and the hwnd field somehow matches our hwnd.
*/
if(SUCCEEDED(hresPv(this)) && this->hwnd == hwnd)
{
switch(wm)
{
case WM_POWERBROADCAST :
// 7/18/2000(a-JiTay): IA64: Use %p format specifier for 32/64-bit pointers.
SquirtSqflPtszV( sqfl | sqflError,
TEXT("WM_POWERBROADCAST(0x%x) for 0x%p"), wp, this);
if(wp == PBT_APMSUSPEND )
{
CEm_ForceDeviceUnacquire(pemFromPvi(this->pvi)->ped, 0x0 );
}
else if(wp == PBT_APMRESUMESUSPEND )
{
CEm_ForceDeviceUnacquire(pemFromPvi(this->pvi)->ped, 0x0 );
DIBus_BuildList(TRUE);
}
break;
default:
if( wm == g_wmJoyChanged )
{
/*
* Once we receive this notification message, we need to rebuild
* our list, because sometimes the user has just changed the device's ID.
* See manbug: 35445
*/
DIHid_BuildHidList(TRUE);
Common_Hold(this);
CHid_LoadCalibrations(this);
Common_Unhold(this);
}
// 7/18/2000(a-JiTay): IA64: Use %p format specifier for 32/64-bit pointers.
SquirtSqflPtszV( sqfl | sqflVerbose,
TEXT("wp(0x%x) wm(0x%x) for 0x%p"), wm, wp, this);
break;
}
}
return DefSubclassProc(hwnd, wm, wp, lp);
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method void | CHid | GetPhysicalState |
*
* Read the physical device state into <p pmstOut>.
*
* Note that it doesn't matter if this is not atomic.
* If a device report arrives while we are reading it,
* we will get a mix of old and new data. No big deal.
*
* @parm PCHID | this |
*
* The object in question.
*
* @parm PV | pvOut |
*
* Where to put the device state.
*
* @returns
* None.
*
*****************************************************************************/
void INLINE
CHid_GetPhysicalState(PCHID this, PV pvOut)
{
AssertF(this->pvPhys);
AssertF(this->cbPhys);
CopyMemory(pvOut, this->pvPhys, this->cbPhys);
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CHid | Acquire |
*
* Tell the device driver to begin data acquisition.
* We create a handle to the device so we can talk to it again.
* We must create each time so we can survive in the
* "unplug/replug" case. When a device is unplugged,
* its <t HANDLE> becomes permanently invalid and must be
* re-opened for it to work again.
*
* Warning! We require that the device critical section be
* held so we don't race against our worker thread.
*
* @returns
*
* Returns a COM error code. The following error codes are
* intended to be illustrative and not necessarily comprehensive.
*
* <c DI_OK> = <c S_OK>: The operation completed successfully.
*
* <c S_FALSE>: The operation was begun and should be completed
* by the caller by communicating with the <t VXDINSTANCE>.
*
*****************************************************************************/
STDMETHODIMP
CHid_Acquire(PDICB pdcb)
{
HRESULT hres;
HANDLE h;
PCHID this;
EnterProcI(IDirectInputDeviceCallback::HID::Acquire,
(_ "p", pdcb));
/*
* This is an internal interface, so we can skimp on validation.
*/
this = _thisPvNm(pdcb, dcb);
AssertF(this->pvi);
AssertF(this->pvi->pdd);
AssertF(CDIDev_InCrit(this->pvi->pdd));
AssertF(this->hdev == INVALID_HANDLE_VALUE);
/*
* We must check connectivity by opening the device, because NT
* leaves the device in the info list even though it has
* been unplugged.
*/
h = CHid_OpenDevicePath(this, FILE_FLAG_OVERLAPPED);
if(h != INVALID_HANDLE_VALUE)
{
NTSTATUS stat;
DWORD dwFlags2 = 0;
/*
* Obtain Flags2 to find out if input report is disabled for this device,
* if we haven't done so.
*/
if (!this->fFlags2Checked)
{
JoyReg_GetValue( this->hkProp, REGSTR_VAL_FLAGS2, REG_BINARY,
&dwFlags2, cbX(dwFlags2) );
this->fFlags2Checked = TRUE;
this->fEnableInputReport = ( (dwFlags2 & JOYTYPE_ENABLEINPUTREPORT) != 0 );
}
if ( this->fEnableInputReport )
{
BYTE id;
for (id = 0; id < this->wMaxReportId[HidP_Input]; ++id)
if ( this->pEnableReportId[HidP_Input][id] )
{
BOOL bRet;
*(BYTE*)this->hriIn.pvReport = id;
bRet = HidD_GetInputReport(h, this->hriIn.pvReport, this->hriIn.cbReport);
if (bRet)
{
stat = CHid_ParseData(this, HidP_Input, &this->hriIn);
if (SUCCEEDED(stat))
{
this->pvi->fl |= VIFL_INITIALIZE; /* Set the flag so the event can be buffered.
since VIFL_ACQUIRED isn't set yet. */
CEm_AddState(&this->ed, this->pvStage, GetTickCount());
this->pvi->fl &= ~VIFL_INITIALIZE; /* Clear the flag when done. */
}
} else
{
DWORD dwError = GetLastError();
// ERROR_SEM_TIMEOUT means the device has timed out.
if (dwError == ERROR_SEM_TIMEOUT)
{
/*
* Timed out. The device does not support input report. We need to record
* the fact in registry so that GetInputReport() does not ever get called
* again for this device, since each failed call takes five seconds to
* complete.
*/
this->fEnableInputReport = TRUE;
dwFlags2 &= ~JOYTYPE_ENABLEINPUTREPORT;
hres = JoyReg_SetValue( this->hkProp, REGSTR_VAL_FLAGS2,
REG_BINARY, (PV)&dwFlags2, cbX( dwFlags2 ) );
break;
}
RPF("CHid_InitParse: Unable to read HID input report LastError(0x%X)", dwError );
}
}
}
CloseHandle(h);
/* Please finish for me */
hres = S_FALSE;
} else
{
hres = DIERR_UNPLUGGED;
}
ExitOleProcR();
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CHid | GetInstance |
*
* Obtains the DirectInput instance handle.
*
* @parm OUT PPV | ppvi |
*
* Receives the instance handle.
*
*****************************************************************************/
STDMETHODIMP
CHid_GetInstance(PDICB pdcb, PPV ppvi)
{
HRESULT hres;
PCHID this;
EnterProcI(IDirectInputDeviceCallback::Hid::GetInstance, (_ "p", pdcb));
/*
* This is an internal interface, so we can skimp on validation.
*/
this = _thisPvNm(pdcb, dcb);
AssertF(this->pvi);
*ppvi = (PV)this->pvi;
hres = S_OK;
ExitOleProcPpvR(ppvi);
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CHid | GetDataFormat |
*
* Obtains the device's preferred data format.
*
* @parm OUT LPDIDEVICEFORMAT * | ppdf |
*
* <t LPDIDEVICEFORMAT> to receive pointer to device format.
*
* @returns
*
* Returns a COM error code. The following error codes are
* intended to be illustrative and not necessarily comprehensive.
*
* <c DI_OK> = <c S_OK>: The operation completed successfully.
*
* <c DIERR_INVALIDPARAM> = <c E_INVALIDARG>: The
* <p lpmdr> parameter is not a valid pointer.
*
*****************************************************************************/
STDMETHODIMP
CHid_GetDataFormat(PDICB pdcb, LPDIDATAFORMAT *ppdf)
{
HRESULT hres;
PCHID this;
EnterProcI(IDirectInputDeviceCallback::Hid::GetDataFormat,
(_ "p", pdcb));
/*
* This is an internal interface, so we can skimp on validation.
*/
this = _thisPvNm(pdcb, dcb);
*ppdf = &this->df;
hres = S_OK;
ExitOleProcPpvR(ppdf);
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @func HRESULT | DIHid_GetParentRegistryProperty |
*
* @parm LPTSTR | ptszId |
*
* Device Instance ID.
*
* @parm DWORD | dwProperty |
*
* The property being queried.
*
* @parm LPDIPROPHEADER | diph |
*
* Property data to be set.
*
* @parm BOOL | diph |
*
* Get from parent or grand parent.
*
*****************************************************************************/
HRESULT INTERNAL
DIHid_GetParentRegistryProperty(LPTSTR ptszId, DWORD dwProperty, LPDIPROPHEADER pdiph, BOOL bGrandParent)
{
HDEVINFO hdev;
LPDIPROPSTRING pstr = (PV)pdiph;
TCHAR tsz[MAX_PATH];
HRESULT hres = E_FAIL;
ZeroX(tsz);
hdev = SetupDiCreateDeviceInfoList(NULL, NULL);
if(hdev != INVALID_HANDLE_VALUE)
{
SP_DEVINFO_DATA dinf;
/*
* For the instance name, use the friendly name if possible.
* Else, use the device description.
*/
dinf.cbSize = cbX(SP_DEVINFO_DATA);
if(SetupDiOpenDeviceInfo(hdev, ptszId, NULL, 0, &dinf))
{
DEVINST DevInst;
CONFIGRET cr;
if( (cr = CM_Get_Parent(&DevInst, dinf.DevInst, 0x0)) == CR_SUCCESS )
{
ULONG ulLength;
CAssertF( SPDRP_DEVICEDESC +1 == CM_DRP_DEVICEDESC );
CAssertF( SPDRP_FRIENDLYNAME +1 == CM_DRP_FRIENDLYNAME );
if(bGrandParent)
{
cr = CM_Get_Parent(&DevInst, DevInst, 0x0);
if( cr != CR_SUCCESS )
{
// No GrandParent ??
}
}
ulLength = MAX_PATH * cbX(TCHAR);
if( cr == CR_SUCCESS &&
( cr = CM_Get_DevNode_Registry_Property(
DevInst,
dwProperty+1,
NULL,
tsz,
&ulLength,
0x0 ) ) == CR_SUCCESS )
{
// Success
hres = S_OK;
#ifdef UNICODE
lstrcpyW(pstr->wsz, tsz);
#else
TToU(pstr->wsz, MAX_PATH, tsz);
#endif
} else
{
SquirtSqflPtszV(sqfl | sqflVerbose,
TEXT("CM_Get_DevNode_Registry_Property FAILED") );
}
} else
{
SquirtSqflPtszV(sqfl | sqflVerbose,
TEXT("CM_Get_Parent FAILED") );
}
}
SetupDiDestroyDeviceInfoList(hdev);
} else
{
SquirtSqflPtszV(sqfl | sqflError,
TEXT("SetupDiCreateDeviceInfoList FAILED, le = %d"), GetLastError() );
}
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @func HRESULT | DIHid_GetRegistryProperty |
*
* @parm LPTSTR | ptszId |
*
* Device Instance ID.
*
* @parm DWORD | dwProperty |
*
* The property being queried.
*
* @parm LPDIPROPHEADER | diph |
*
* Property data to be set.
*
*****************************************************************************/
HRESULT EXTERNAL
DIHid_GetRegistryProperty(LPTSTR ptszId, DWORD dwProperty, LPDIPROPHEADER pdiph)
{
HDEVINFO hdev;
LPDIPROPSTRING pstr = (PV)pdiph;
TCHAR tsz[MAX_PATH];
HRESULT hres = E_FAIL;
ZeroX(tsz);
hdev = SetupDiCreateDeviceInfoList(NULL, NULL);
if(hdev != INVALID_HANDLE_VALUE)
{
SP_DEVINFO_DATA dinf;
/*
* For the instance name, use the friendly name if possible.
* Else, use the device description.
*/
dinf.cbSize = cbX(SP_DEVINFO_DATA);
if(SetupDiOpenDeviceInfo(hdev, ptszId, NULL, 0, &dinf))
{
if(SetupDiGetDeviceRegistryProperty(hdev, &dinf, dwProperty, NULL,
(LPBYTE)tsz, MAX_PATH, NULL) )
{
hres = S_OK;
#ifdef UNICODE
lstrcpyW(pstr->wsz, tsz);
#else
TToU(pstr->wsz, MAX_PATH, tsz);
#endif
} else
{
SquirtSqflPtszV(sqfl | sqflVerbose,
TEXT("SetupDiOpenDeviceInfo FAILED, le = %d"), GetLastError() );
}
} else
{
SquirtSqflPtszV(sqfl | sqflError,
TEXT("SetupDiOpenDeviceInfo FAILED, le = %d"), GetLastError() );
}
SetupDiDestroyDeviceInfoList(hdev);
} else
{
SquirtSqflPtszV(sqfl | sqflError,
TEXT("SetupDiCreateDeviceInfoList FAILED, le = %d"), GetLastError() );
}
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CHid | GetGuidAndPath |
*
* Get a Hid device's class GUID (namely, the HID guid)
* and device interface (path).
*
* @parm PCHID | this |
*
* The Hid object.
*
* @parm LPDIPROPHEADER | pdiph |
*
* Structure to receive property value.
*
*****************************************************************************/
HRESULT INTERNAL
CHid_GetGuidAndPath(PCHID this, LPDIPROPHEADER pdiph)
{
HRESULT hres;
LPDIPROPGUIDANDPATH pgp = (PV)pdiph;
pgp->guidClass = GUID_HIDClass;
TToU(pgp->wszPath, cA(pgp->wszPath), this->ptszPath);
hres = S_OK;
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method BOOLEAN | CHid | CHidInsertScanCodes |
*
*
* @parm
*
* ISSUE-2001/03/29-timgill function needs documenting
*
*
*****************************************************************************/
BOOLEAN CHidInsertScanCodes
(
IN PVOID Context, // Some caller supplied context.
IN PCHAR NewScanCodes, // A list of i8042 scan codes.
IN ULONG Length // the length of the scan codes.
)
{
int Idx;
/*
* This is not inner loop code so don't rush it
*/
AssertF( Length <= cbX( DWORD ) );
for( Idx = 0; Idx < cbX( DWORD ); Idx++ )
{
if( Length-- )
{
*(((PCHAR)Context)++) = *(NewScanCodes++);
}
else
{
*(((PCHAR)Context)++) = '\0';
}
}
return TRUE;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @func BOOL | fHasSpecificHardwareMatch |
*
* Find out from SetupAPI whether the device was matched with a
* specific hardware ID match or generic match.
* A specific match should have caused a device description to be
* installed which is likely to be at least as good as what HID could
* get from a product string in firmware. (a. because it's easier to
* update an INF after release than firmware; b. because HID can only
* get us an English string.) Generic matches on the other hand are,
* by definition, all the same so cannot be used to tell two devices
* apart.
*
* @parm LPTSTR | ptszId |
*
* Device Instance ID.
*
* @returns
* <c TRUE> if the device was installed using a specific match.
* <c FALSE> if it was not or if installation info was unobtainable.
*
* @comm
* This is used on Win2k for game controllers and Win9x for mice and
* keyboards. Win2k we can't read HID mice and keyboards and on
* Win9x VJoyD should always create device names before DInput.dll.
* On Win9x this is less of a big deal for game controllers because
* IHVs are accoustomed to adding their display name to
* MediaProperties.
*
*****************************************************************************/
BOOL fHasSpecificHardwareMatch( LPTSTR ptszId )
{
HDEVINFO hInfo;
BOOL fRc = FALSE;
EnterProcI(fHasSpecificHardwareMatch,(_ "s", ptszId));
hInfo = SetupDiCreateDeviceInfoList(NULL, NULL);
if( hInfo != INVALID_HANDLE_VALUE )
{
SP_DEVINFO_DATA dinf;
dinf.cbSize = cbX(SP_DEVINFO_DATA);
if( SetupDiOpenDeviceInfo(hInfo, ptszId, NULL, 0, &dinf) )
{
CONFIGRET cr;
DEVINST DevInst;
cr = CM_Get_Parent( &DevInst, dinf.DevInst, 0x0 );
if( cr == CR_SUCCESS )
{
TCHAR tszDevInst[MAX_PATH];
cr = CM_Get_Device_ID( DevInst, (DEVINSTID)tszDevInst, MAX_PATH, 0 );
if( cr == CR_SUCCESS )
{
if( SetupDiOpenDeviceInfo(hInfo, tszDevInst, NULL, 0, &dinf) )
{
HKEY hkDrv;
hkDrv = SetupDiOpenDevRegKey( hInfo, &dinf, DICS_FLAG_GLOBAL, 0,
DIREG_DRV, MAXIMUM_ALLOWED );
if( hkDrv != INVALID_HANDLE_VALUE )
{
PTCHAR tszHardwareID = NULL;
PTCHAR tszMatchingID = NULL;
ULONG ulLength = 0;
cr = CM_Get_DevNode_Registry_Property(DevInst,
CM_DRP_HARDWAREID,
NULL,
NULL,
&ulLength,
0x0 );
/*
* Win2k returns CR_BUFFER_SMALL but
* Win9x returns CR_SUCCESS so allow both.
*/
if( ( ( cr == CR_BUFFER_SMALL ) || ( cr == CR_SUCCESS ) )
&& ulLength )
{
#ifndef WINNT
/*
* Need to allocate extra for terminator on Win9x
*/
ulLength++;
#endif
if( SUCCEEDED( AllocCbPpv( ulLength + ( MAX_PATH * cbX(tszMatchingID[0]) ), &tszMatchingID ) ) )
{
cr = CM_Get_DevNode_Registry_Property(DevInst,
CM_DRP_HARDWAREID,
NULL,
(PBYTE)&tszMatchingID[MAX_PATH],
&ulLength,
0x0 );
if( cr == CR_SUCCESS )
{
tszHardwareID = &tszMatchingID[MAX_PATH];
}
else
{
SquirtSqflPtszV(sqfl | sqflError,
TEXT("CR error %d getting HW ID"), cr );
}
}
else
{
SquirtSqflPtszV(sqfl | sqflError,
TEXT("No memory requesting %d bytes for HW ID"), ulLength );
}
}
else
{
SquirtSqflPtszV(sqfl | sqflError,
TEXT("Unexpected CR error %d getting HW ID size"), cr );
}
if( tszHardwareID )
{
ulLength = MAX_PATH * cbX(tszMatchingID[0]);
cr = RegQueryValueEx( hkDrv, REGSTR_VAL_MATCHINGDEVID, 0, 0, (PBYTE)tszMatchingID, &ulLength );
if( CR_SUCCESS == cr )
{
while( ulLength = lstrlen( tszHardwareID ) )
{
if( !lstrcmpi( tszHardwareID, tszMatchingID ) )
{
fRc = TRUE;
break;
}
tszHardwareID += ulLength + 1;
}
}
else
{
SquirtSqflPtszV(sqfl | sqflError,
TEXT("No matching ID!, cr = %d"), cr );
}
}
if( tszMatchingID )
{
FreePv( tszMatchingID );
}
RegCloseKey( hkDrv );
}
else
{
SquirtSqflPtszV(sqfl | sqflError,
TEXT("SetupDiOpenDevRegKey failed, le = %d"), GetLastError() );
}
}
else
{
SquirtSqflPtszV(sqfl | sqflError,
TEXT("SetupDiOpenDeviceInfo failed for %S (parent), le = %d"),
tszDevInst, GetLastError() );
}
}
else
{
SquirtSqflPtszV(sqfl | sqflError,
TEXT("CM_Get_Device_ID FAILED %d"), cr );
}
}
else
{
SquirtSqflPtszV(sqfl | sqflError,
TEXT("CM_Get_Parent FAILED %d"), cr );
}
}
else
{
SquirtSqflPtszV(sqfl | sqflError,
TEXT("SetupDiOpenDeviceInfo failed for %S (child), le = %d"),
ptszId, GetLastError() );
}
SetupDiDestroyDeviceInfoList(hInfo);
}
else
{
SquirtSqflPtszV(sqfl | sqflError,
TEXT("SetupDiCreateDeviceInfoList failed, le = %d"), GetLastError() );
}
ExitProc();
return fRc;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @func BOOL | fGetProductStringFromDevice |
*
* Try getting the product name from HID.
* If the device has one of these, this is what is displayed
* when the device is initially recognized. Unfortunately
* this name does not land up in the friendly name registry
* entry so in case this gets fixed we go directly to HID.
*
* @parm PCHID | this |
*
* The Hid object.
*
* @parm PWCHAR | wszBuffer |
*
* Where to put the product string if found.
*
* @parm ULONG | ulBufferLen |
*
* How big the string buffer is in bytes
*
* @returns
* <c TRUE> if a string has been placed in the buffer
* <c FALSE> if no string was retrieved
*
*****************************************************************************/
BOOL fGetProductStringFromDevice
(
PCHID this,
PWCHAR wszBuffer,
ULONG ulBufferLen
)
{
BOOL fRc;
/*
* If we already have a handle open (device is acquired), use
* it, otherwise open one just for now.
*/
if( this->hdev != INVALID_HANDLE_VALUE )
{
fRc = HidD_GetProductString( this->hdev, wszBuffer, ulBufferLen );
}
else
{
HANDLE hdev;
hdev = CHid_OpenDevicePath(this, FILE_FLAG_OVERLAPPED);
if(hdev != INVALID_HANDLE_VALUE)
{
wszBuffer[0] = 0;
fRc = HidD_GetProductString( hdev, wszBuffer, ulBufferLen );
fRc = (fRc)?(wszBuffer[0] != 0):FALSE;
CloseHandle(hdev);
}
else
{
fRc = FALSE;
}
}
return fRc;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CHid | GetProperty |
*
* Get a Hid device property.
*
* @parm PCHID | this |
*
* The Hid object.
*
* @parm IN LPCDIPROPINFO | ppropi |
*
* Information describing the property being retrieved.
*
* @parm LPDIPROPHEADER | pdiph |
*
* Structure to receive property value.
*
* @returns
*
* <c E_NOTIMPL> nothing happened. The caller will do
* the default thing in response to <c E_NOTIMPL>.
*
*****************************************************************************/
#ifdef WINNT
TCHAR g_wszDefaultHIDName[80];
UINT g_uLenDefaultHIDSize;
#endif
STDMETHODIMP
CHid_GetProperty(PDICB pdcb, LPCDIPROPINFO ppropi, LPDIPROPHEADER pdiph)
{
HRESULT hres;
PCHID this;
EnterProcI(IDirectInputDeviceCallback::Hid::GetProperty,
(_ "pxxp", pdcb, ppropi->pguid, ppropi->iobj, pdiph));
/*
* This is an internal interface, so we can skimp on validation.
*/
this = _thisPvNm(pdcb, dcb);
if(ppropi->iobj < this->df.dwNumObjs)
{ /* Object property */
AssertF(ppropi->dwDevType == this->df.rgodf[ppropi->iobj].dwType);
switch((DWORD)(UINT_PTR)(ppropi->pguid))
{
case (DWORD)(UINT_PTR)(DIPROP_ENABLEREPORTID):
{
LPDIPROPDWORD ppropdw = CONTAINING_RECORD(pdiph, DIPROPDWORD, diph);
PHIDGROUPCAPS pcaps = this->rghoc[ppropi->iobj].pcaps;
AssertF(fLimpFF(pcaps,
pcaps->dwSignature == HIDGROUPCAPS_SIGNATURE));
ppropdw->dwData = 0x0;
AssertF(pcaps->wReportId < this->wMaxReportId[pcaps->type]);
AssertF(this->pEnableReportId[pcaps->type]);
(UCHAR)ppropdw->dwData = *(this->pEnableReportId[pcaps->type] + pcaps->wReportId);
hres = S_OK;
}
break;
case (DWORD)(UINT_PTR)(DIPROP_PHYSICALRANGE):
{
LPDIPROPRANGE pdiprg = CONTAINING_RECORD(pdiph, DIPROPRANGE, diph);
PHIDGROUPCAPS pcaps = this->rghoc[ppropi->iobj].pcaps;
pdiprg->lMin = pcaps->Physical.Min;
pdiprg->lMax = pcaps->Physical.Max;
hres = S_OK;
break;
}
break;
case (DWORD)(UINT_PTR)(DIPROP_LOGICALRANGE):
{
LPDIPROPRANGE pdiprg = CONTAINING_RECORD(pdiph, DIPROPRANGE, diph);
PHIDGROUPCAPS pcaps = this->rghoc[ppropi->iobj].pcaps;
pdiprg->lMin = pcaps->Logical.Min;
pdiprg->lMax = pcaps->Logical.Max;
hres = S_OK;
}
break;
case (DWORD)(UINT_PTR)(DIPROP_KEYNAME):
{
LPDIPROPSTRING pdipstr = (PV)pdiph;
UINT uiInstance = ppropi->iobj;
PHIDGROUPCAPS pcaps;
AssertF(uiInstance == CHid_ObjFromType(this, ppropi->dwDevType));
pcaps = this->rghoc[uiInstance].pcaps;
/*
* pcaps might be NULL if HID messed up and left gaps
* in the index lists.
*/
if(pcaps)
{
UINT duiInstance;
AssertF(pcaps->dwSignature == HIDGROUPCAPS_SIGNATURE);
if(ppropi->dwDevType & DIDFT_COLLECTION)
{
duiInstance = 0;
} else
{
/*
* Now convert the uiInstance to a duiInstance,
* giving the index of this object into the group.
*/
AssertF(HidP_IsValidReportType(pcaps->type));
duiInstance = uiInstance - (this->rgdwBase[pcaps->type] +
pcaps->DataIndexMin);
}
if(GetHIDString(pcaps->UsageMin + duiInstance,
pcaps->UsagePage,
pdipstr->wsz, cA(pdipstr->wsz)))
{
hres = S_OK;
}
else
{
hres = DIERR_OBJECTNOTFOUND;
}
} else
{
hres = DIERR_NOTFOUND;
}
}
break;
case (DWORD)(UINT_PTR)(DIPROP_SCANCODE):
{
LPDIPROPDWORD pdipdw = (PV)pdiph;
UINT uiInstance = ppropi->iobj;
PHIDGROUPCAPS pcaps;
AssertF(uiInstance == CHid_ObjFromType(this, ppropi->dwDevType));
pcaps = this->rghoc[uiInstance].pcaps;
/*
* pcaps might be NULL if HID messed up and left gaps
* in the index lists.
*/
if(pcaps )
{
if ( pcaps->UsagePage == HID_USAGE_PAGE_KEYBOARD )
//ISSUE-2001/03/29-timgill unable to access keyboard consumer keys
//can't do this || pcaps->UsagePage == HID_USAGE_PAGE_CONSUMER )
{
UINT duiInstance;
HIDP_KEYBOARD_MODIFIER_STATE modifiers;
USAGE us;
AssertF(pcaps->dwSignature == HIDGROUPCAPS_SIGNATURE);
if(ppropi->dwDevType & DIDFT_COLLECTION)
{
duiInstance = 0;
} else
{
/*
* Now convert the uiInstance to a duiInstance,
* giving the index of this object into the group.
*/
AssertF(HidP_IsValidReportType(pcaps->type));
duiInstance = uiInstance - (this->rgdwBase[pcaps->type] +
pcaps->DataIndexMin);
}
us = pcaps->UsageMin + duiInstance;
CAssertF( cbX( modifiers ) == cbX( modifiers.ul ) );
modifiers.ul = 0; // Use no modifiers for translation
if( SUCCEEDED(HidP_TranslateUsagesToI8042ScanCodes( &us, 1, HidP_Keyboard_Make, &modifiers,
CHidInsertScanCodes,
&pdipdw->dwData
) ) )
{
hres = S_OK;
} else
{
hres = E_FAIL;
}
} else
{
hres = E_NOTIMPL;
}
} else
{
hres = DIERR_NOTFOUND;
}
}
break;
default:
if(ppropi->dwDevType & DIDFT_POV)
{
PHIDGROUPCAPS pcaps = this->rghoc[ppropi->iobj].pcaps;
AssertF(fLimpFF(pcaps,
pcaps->dwSignature == HIDGROUPCAPS_SIGNATURE));
#ifdef WINNT
if( pcaps && pcaps->IsPolledPOV && ppropi->pguid == DIPROP_CALIBRATIONMODE ) {
PJOYRANGECONVERT pjrc = this->rghoc[ppropi->iobj].pjrc;
if(pjrc)
{
hres = CCal_GetProperty(pjrc, ppropi->pguid, pdiph);
} else
{
hres = E_NOTIMPL;
}
} else
#endif
{
if(pcaps && ppropi->pguid == DIPROP_GRANULARITY)
{
LPDIPROPDWORD pdipdw = (PV)pdiph;
pdipdw->dwData = pcaps->usGranularity;
hres = S_OK;
} else
{
hres = E_NOTIMPL;
}
}
} else if(ppropi->dwDevType & DIDFT_RELAXIS)
{
/*
* All relative axes have a full range by default,
* so we don't need to do anything.
*/
hres = E_NOTIMPL;
} else if(ppropi->dwDevType & DIDFT_ABSAXIS)
{
PJOYRANGECONVERT pjrc = this->rghoc[ppropi->iobj].pjrc;
/*
* Theoretically, every absolute axis will have
* calibration info. But test just in case something
* impossible happens.
*/
if(pjrc)
{
hres = CCal_GetProperty(pjrc, ppropi->pguid, pdiph);
} else
{
hres = E_NOTIMPL;
}
} else
{
SquirtSqflPtszV(sqflHidDev | sqflError,
TEXT("CHid_GetProperty(iobj=%08x): E_NOTIMPL on guid: %08x"),
ppropi->iobj, ppropi->pguid);
hres = E_NOTIMPL;
}
}
} else if(ppropi->iobj == 0xFFFFFFFF)
{ /* Device property */
switch((DWORD)(UINT_PTR)ppropi->pguid)
{
case (DWORD)(UINT_PTR)DIPROP_GUIDANDPATH:
hres = CHid_GetGuidAndPath(this, pdiph);
break;
case (DWORD)(UINT_PTR)DIPROP_INSTANCENAME:
{
/*
* Friendly names cause all manner of problems with devices that
* use auto detection so only allow non-predefined analog devices
* to use them.
*/
if( ( this->VendorID == MSFT_SYSTEM_VID )
&& ( this->ProductID >= MSFT_SYSTEM_PID + JOY_HW_PREDEFMAX )
&& ( ( this->ProductID & 0xff00 ) == MSFT_SYSTEM_PID ) )
{
AssertF(this->hkType);
if( this->hkType )
{
LPDIPROPSTRING pstr = (PV)pdiph;
hres = JoyReg_GetValue(this->hkType,
REGSTR_VAL_JOYOEMNAME, REG_SZ,
pstr->wsz,
cbX(pstr->wsz));
if( SUCCEEDED(hres ) )
{
SquirtSqflPtszV(sqflHid | sqflVerbose,
TEXT( "Got instance name %s"), pstr->wsz );
if( ( this->diHacks.nMaxDeviceNameLength < MAX_PATH )
&& ( this->diHacks.nMaxDeviceNameLength < lstrlenW(pstr->wsz) ) )
{
pstr->wsz[this->diHacks.nMaxDeviceNameLength] = L'\0';
}
hres = S_OK;
break;
}
}
}
/*
* Fall through to catch the product name
*/
}
case (DWORD)(UINT_PTR)DIPROP_PRODUCTNAME:
{
LPDIPROPSTRING pdipstr = (PV)pdiph;
/*
* For now, don't deal with mice and keyboard names on NT
*/
#ifdef WINNT
AssertF( ( GET_DIDEVICE_TYPE( this->dwDevType ) != DI8DEVTYPE_KEYBOARD )
&& ( GET_DIDEVICE_TYPE( this->dwDevType ) != DI8DEVTYPE_MOUSE ) );
#endif
if( GET_DIDEVICE_TYPE( this->dwDevType ) < DI8DEVTYPE_GAMEMIN )
{
AssertF( GET_DIDEVICE_TYPE( this->dwDevType ) >= DI8DEVTYPE_DEVICE );
if( fHasSpecificHardwareMatch( this->ptszId )
&& SUCCEEDED( hres = DIHid_GetParentRegistryProperty(this->ptszId, SPDRP_DEVICEDESC, pdiph, 0x0 ) ) )
{
SquirtSqflPtszV(sqflHid | sqflVerbose,
TEXT("Got sys dev description %S"), pdipstr->wsz );
}
else if( fGetProductStringFromDevice( this, pdipstr->wsz, cbX( pdipstr->wsz ) ) )
{
SquirtSqflPtszV(sqflHid | sqflVerbose,
TEXT( "Got sys dev name from device %S"), pdipstr->wsz );
hres = S_OK;
}
else
{
if( SUCCEEDED( hres = DIHid_GetRegistryProperty(this->ptszId, SPDRP_DEVICEDESC, pdiph ) ) )
{
SquirtSqflPtszV(sqflHid | sqflVerbose,
TEXT( "Got sys dev name from devnode registry %S"), pdipstr->wsz );
}
else
{
UINT uDefName;
switch( GET_DIDEVICE_TYPE( this->dwDevType ) )
{
case DI8DEVTYPE_MOUSE:
uDefName = IDS_STDMOUSE;
break;
case DI8DEVTYPE_KEYBOARD:
uDefName = IDS_STDKEYBOARD;
break;
default:
uDefName = IDS_DEVICE_NAME;
break;
}
if( LoadStringW(g_hinst, uDefName, pdipstr->wsz, cbX( pdipstr->wsz ) ) )
{
SquirtSqflPtszV(sqflHid | sqflVerbose,
TEXT( "Loaded default sys dev name %S"), pdipstr->wsz );
hres = S_OK;
}
else
{
/*
* Give up, this machine is toast if we can't
* even load a string from our own resources.
*/
SquirtSqflPtszV(sqflHidDev | sqflError,
TEXT("CHid_GetProperty(guid:%08x) failed to get name"),
ppropi->pguid);
hres = E_FAIL;
}
}
}
}
else
{
/*
* For game controllers, first look in MediaProperties.
* This is the most likely place to find a localized string
* free from corruption by the setup process.
* This should only fail before the type key is created when
* it first used so other paths are rare.
*/
DIJOYTYPEINFO dijti;
WCHAR wszType[cbszVIDPID];
/* Check the type key or get predefined name */
ZeroX(dijti);
dijti.dwSize = cbX(dijti);
if( ( this->VendorID == MSFT_SYSTEM_VID )
&&( ( this->ProductID >= MSFT_SYSTEM_PID + JOY_HW_PREDEFMIN )
&&( this->ProductID < MSFT_SYSTEM_PID + JOY_HW_PREDEFMAX ) ) )
{
wszType[0] = L'#';
wszType[1] = L'0' + (WCHAR)(this->ProductID-MSFT_SYSTEM_PID);
wszType[2] = L'\0';
hres = JoyReg_GetPredefTypeInfo( wszType, &dijti, DITC_DISPLAYNAME);
AssertF( SUCCEEDED( hres ) );
AssertF( dijti.wszDisplayName[0] != L'\0' );
lstrcpyW(pdipstr->wsz, dijti.wszDisplayName);
SquirtSqflPtszV(sqflHid | sqflVerbose,
TEXT( "Got name as predefined %s"), pdipstr->wsz );
}
else
{
#ifndef WINNT
static WCHAR wszDefHIDName[] = L"HID Game Controller";
#endif
BOOL fOverwriteDeviceName = FALSE;
#ifndef UNICODE
TCHAR tszType[cbszVIDPID];
wsprintf(tszType, VID_PID_TEMPLATE, this->VendorID, this->ProductID);
TToU( wszType, cA(wszType), tszType );
#else
wsprintf(wszType, VID_PID_TEMPLATE, this->VendorID, this->ProductID);
#endif
#ifdef WINNT
#define INPUT_INF_FILENAME L"\\INF\\INPUT.INF"
if( g_wszDefaultHIDName[0] == L'\0' )
{
WCHAR wszInputINF[MAX_PATH];
UINT uLen;
uLen = GetWindowsDirectoryW( wszInputINF, cA( wszInputINF ) );
/*
* If the path is too long, don't set the filename
* so the the default string gets used when the
* GetPrivateProfileString fails.
*/
if( uLen < cA(wszInputINF) - cA(INPUT_INF_FILENAME) )
{
memcpy( (PBYTE)&wszInputINF[uLen], (PBYTE)INPUT_INF_FILENAME, cbX( INPUT_INF_FILENAME ) );
}
/*
* Remember the length, if the string was too long to
* fit in the buffer there will be plenty to make a
* reasonable comparison.
*/
g_uLenDefaultHIDSize = 2 * GetPrivateProfileStringW(
L"strings", L"HID.DeviceDesc", L"USB Human Interface Device",
g_wszDefaultHIDName, cA( g_wszDefaultHIDName ) - 1, wszInputINF );
}
#undef INPUT_INF_FILENAME
#endif
if( SUCCEEDED(hres = JoyReg_GetTypeInfo(wszType, &dijti, DITC_DISPLAYNAME))
&& (dijti.wszDisplayName[0] != L'\0')
#ifdef WINNT
&& ( (g_uLenDefaultHIDSize == 0)
|| memcmp(dijti.wszDisplayName, g_wszDefaultHIDName, g_uLenDefaultHIDSize) ) // not equal
#else
&& memcmp(dijti.wszDisplayName, wszDefHIDName, cbX(wszDefHIDName)-2) //not equal
#endif
)
{
LPDIPROPSTRING pdipstr = (PV)pdiph;
lstrcpyW(pdipstr->wsz, dijti.wszDisplayName);
SquirtSqflPtszV(sqflHid | sqflVerbose,
TEXT("Got name from type info %s"), pdipstr->wsz );
}
#ifdef WINNT
else if( fHasSpecificHardwareMatch( this->ptszId )
&& SUCCEEDED( hres = DIHid_GetParentRegistryProperty(this->ptszId, SPDRP_DEVICEDESC, pdiph, 0x0 ) ) )
{
fOverwriteDeviceName = TRUE;
SquirtSqflPtszV(sqflHid | sqflVerbose,
TEXT("Got device description %s"), pdipstr->wsz );
}
#endif
else
{
if( fGetProductStringFromDevice( this, pdipstr->wsz, cbX( pdipstr->wsz ) ) )
{
fOverwriteDeviceName = TRUE;
SquirtSqflPtszV(sqflHid | sqflVerbose,
TEXT("Got description %s from device"), pdipstr->wsz );
}
else
{
/*
* Just make up a name from the caps
*/
CType_MakeGameCtrlName( pdipstr->wsz,
this->dwDevType, this->dwAxes, this->dwButtons, this->dwPOVs );
fOverwriteDeviceName = TRUE;
SquirtSqflPtszV(sqflHid | sqflVerbose,
TEXT("Made up name %s"), pdipstr->wsz );
}
hres = S_OK;
}
if( fOverwriteDeviceName ) {
/*
* If we have a better name, overwrite the old one with this better one.
* See manbug 46438.
*/
AssertF(this->hkType);
AssertF(pdipstr->wsz[0]);
hres = JoyReg_SetValue(this->hkType,
REGSTR_VAL_JOYOEMNAME, REG_SZ,
pdipstr->wsz,
cbX(pdipstr->wsz));
if( FAILED(hres) ){
SquirtSqflPtszV(sqflHid | sqflVerbose,
TEXT("Unable to overwrite generic device name with %s"), pdipstr->wsz );
// This failure (unlikely) doesn't matter.
hres = S_OK;
}
}
}
}
if( SUCCEEDED(hres)
&& ( this->diHacks.nMaxDeviceNameLength < MAX_PATH )
&& ( this->diHacks.nMaxDeviceNameLength < lstrlenW(pdipstr->wsz) ) )
{
pdipstr->wsz[this->diHacks.nMaxDeviceNameLength] = L'\0';
}
break;
}
case (DWORD)(UINT_PTR)DIPROP_JOYSTICKID:
if( ( GET_DIDEVICE_TYPE( this->dwDevType ) >= DI8DEVTYPE_GAMEMIN )
&& ( this->dwDevType & DIDEVTYPE_HID ) )
{
LPDIPROPDWORD pdipdw = (PV)pdiph;
pdipdw->dwData = this->idJoy;
hres = S_OK;
} else
{
hres = E_NOTIMPL;
}
break;
case (DWORD)(UINT_PTR)DIPROP_GETPORTDISPLAYNAME:
#ifdef WINNT
/* For HID devices Port Display Name is the grand parent name */
hres = DIHid_GetParentRegistryProperty(this->ptszId, SPDRP_FRIENDLYNAME, pdiph, TRUE);
if( FAILED(hres) )
{
/* Maybe we can use the Product Name */
hres = DIHid_GetParentRegistryProperty(this->ptszId, SPDRP_DEVICEDESC, pdiph, TRUE);
if( SUCCEEDED(hres) )
{
/* We only sort of succeeded */
hres = S_FALSE;
}
}
if( SUCCEEDED(hres)
&& ( this->diHacks.nMaxDeviceNameLength < MAX_PATH ) )
{
LPDIPROPSTRING pdipstr = (PV)pdiph;
if( this->diHacks.nMaxDeviceNameLength < lstrlenW(pdipstr->wsz) )
{
pdipstr->wsz[this->diHacks.nMaxDeviceNameLength] = L'\0';
}
}
#else
// Not sure how this works on Win9x
hres = E_NOTIMPL;
#endif
break;
case (DWORD)(UINT_PTR)(DIPROP_ENABLEREPORTID):
hres = E_NOTIMPL;
break;
case (DWORD)(UINT_PTR)DIPROP_VIDPID:
{
LPDIPROPDWORD pdipdw = (PV)pdiph;
/* Assert that a DWORD copy is all that is needed */
CAssertF( FIELD_OFFSET( CHID, VendorID ) + cbX( this->VendorID )
== FIELD_OFFSET( CHID, ProductID ) );
pdipdw->dwData = *((PDWORD)(&this->VendorID));
hres = S_OK;
}
break;
case (DWORD)(UINT_PTR)(DIPROP_MAPFILE):
if( ( this->dwDevType == DI8DEVTYPE_MOUSE )
|| ( this->dwDevType == DI8DEVTYPE_KEYBOARD ) )
{
hres = E_NOTIMPL;
}
else
{
LPDIPROPSTRING pdipstr = (PV)pdiph;
LONG lRes;
DWORD dwBufferSize = cbX(pdipstr->wsz);
lRes = RegQueryStringValueW( this->hkProp, REGSTR_VAL_JOYOEMMAPFILE, pdipstr->wsz, &dwBufferSize );
hres = ( pdipstr->wsz[0] && ( lRes == ERROR_SUCCESS ) ) ? S_OK : DIERR_OBJECTNOTFOUND;
}
break;
case (DWORD)(UINT_PTR)(DIPROP_TYPENAME):
if( ( this->dwDevType == DI8DEVTYPE_MOUSE )
|| ( this->dwDevType == DI8DEVTYPE_KEYBOARD ) )
{
hres = E_NOTIMPL;
}
else
{
LPDIPROPSTRING pdipstr = (PV)pdiph;
if( ( this->VendorID == MSFT_SYSTEM_VID )
&&( ( this->ProductID >= MSFT_SYSTEM_PID + JOY_HW_PREDEFMIN )
&&( this->ProductID < MSFT_SYSTEM_PID + JOY_HW_PREDEFMAX ) ) )
{
pdipstr->wsz[0] = L'#';
pdipstr->wsz[1] = L'0' + (WCHAR)(this->ProductID-MSFT_SYSTEM_PID);
pdipstr->wsz[2] = L'\0';
}
else
{
#ifndef UNICODE
TCHAR tszType[cbszVIDPID];
wsprintf(tszType, VID_PID_TEMPLATE, this->VendorID, this->ProductID);
TToU( pdipstr->wsz, cA(pdipstr->wsz), tszType );
#else
wsprintf(pdipstr->wsz, VID_PID_TEMPLATE, this->VendorID, this->ProductID);
#endif
}
hres = S_OK;
}
break;
default:
SquirtSqflPtszV(sqflHid | sqflBenign ,
TEXT("CHid_GetProperty(iobj=0xFFFFFFFF): E_NOTIMPL on guid: %08x"),
ppropi->pguid);
hres = E_NOTIMPL;
break;
}
} else
{
SquirtSqflPtszV(sqflHidDev | sqflError,
TEXT("CHid_GetProperty(iobj=%08x): E_NOTIMPL on guid: %08x"),
ppropi->iobj, ppropi->pguid);
hres = E_NOTIMPL;
}
ExitOleProcR();
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @func LONG | CHid_CoordinateTransform |
*
* Convert numbers from logical to physical or vice versa.
*
* If either the To or From values look suspicious, then
* ignore them and leave the values alone.
*
* @parm PLMINMAX | Dst |
*
* Destination min/max information.
*
* @parm PLMINMAX | Src |
*
* Source min/max information.
*
* @parm LONG | lVal |
*
* Source value to be converted.
*
* @returns
*
* The destination value after conversion.
*
*****************************************************************************/
LONG EXTERNAL
CHid_CoordinateTransform(PLMINMAX Dst, PLMINMAX Src, LONG lVal)
{
/*
* Note that the sanity check is symmetric in Src and Dst.
* This is important, so that we never get into a weird
* case where we can convert one way but can't convert back.
*/
if(Dst->Min < Dst->Max && Src->Min < Src->Max)
{
/*
* We need to perform a straight linear interpolation.
* The math comes out like this:
*
* x - x0 y - y0
* ------- = -------
* x1 - x0 y1 - y0
*
* If you now do a "solve for y", you get
*
*
* y1 - y0
* y = (x - x0) ------- + y0
* x1 - x0
*
* where "x" is Src, "y" is Dst, 0 is Min, and 1 is Max.
*
*
*/
lVal = MulDiv(lVal - Src->Min, Dst->Max - Dst->Min,
Src->Max - Src->Min) + Dst->Min;
}
return lVal;
}
#ifndef WINNT
/*****************************************************************************
*
* @doc INTERNAL
*
* @method int | CHid | IsMatchingJoyDevice |
*
* Does the cached joystick ID match us?
*
* @parm OUT PVXDINITPARMS | pvip |
*
* On success, contains parameter values.
*
* @returns
*
* Nonzero on success.
*
*****************************************************************************/
BOOL INTERNAL
CHid_IsMatchingJoyDevice(PCHID this, PVXDINITPARMS pvip)
{
CHAR sz[MAX_PATH];
LPSTR pszPath;
BOOL fRc;
pszPath = JoyReg_JoyIdToDeviceInterface_95(this->idJoy, pvip, sz);
if(pszPath)
{
SquirtSqflPtszV(sqfl | sqflTrace,
TEXT("CHid_IsMatchingJoyDevice: %d -> %s"),
this->idJoy, pszPath);
#ifdef UNICODE
{
CHAR szpath[MAX_PATH];
UToA( szpath, cA(szpath), (LPWSTR)this->ptszPath);
fRc = ( lstrcmpiA(pszPath, szpath) == 0x0 );
}
#else
fRc = ( lstrcmpiA(pszPath, (PCHAR)this->ptszPath) == 0x0 );
#endif
} else
{
fRc = FALSE;
}
return fRc;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method void | CHid | FindJoyDevice |
*
* Look for the VJOYD device that matches us, if any.
*
* On return, the <e CHID.idJoy> field contains the
* matching joystick number, or -1 if not found.
*
* @parm OUT PVXDINITPARMS | pvip |
*
* On success, contains parameter values.
*
*****************************************************************************/
void INTERNAL
CHid_FindJoyDevice(PCHID this, PVXDINITPARMS pvip)
{
/*
* If we have a cached value, and it still works, then
* our job is done.
*/
if(this->idJoy >= 0 &&
CHid_IsMatchingJoyDevice(this, pvip))
{
} else
{
/*
* Need to keep looking. (Or start looking.)
*
* A countdown loop is nicer, but for efficiency, we count
* upwards, since the joystick we want tends to be near the
* beginning.
*/
for(this->idJoy = 0; this->idJoy < cJoyMax; this->idJoy++)
{
if(CHid_IsMatchingJoyDevice(this, pvip))
{
goto done;
}
}
this->idJoy = -1;
}
done:;
}
#endif
/*****************************************************************************
*
* @doc INTERNAL
*
* @method int | CHid | MapAxis |
*
* Find VJOYD axis from HID axis, if one.
*
* @parm PVXDINITPARMS | pvip |
*
* Parameter values that let us known which axes VJOYD
* has mapped to which HID Axes.
*
* @parm UINT | iobj |
*
* Object index of the object whose axis value changed.
*
* @returns
*
* The VJOYD axis number that changed (0 to 5), or -1
* if there is no matching axis. There will be no matching
* axis if, for example, the device has something that is
* not expressible via VJOYD (e.g., a temperature sensor).
*
*****************************************************************************/
int INTERNAL
CHid_MapAxis(PCHID this, PVXDINITPARMS pvip, UINT iobj)
{
int iAxis;
DWORD dwUsage;
AssertF(this->dcb.lpVtbl->GetUsage == CHid_GetUsage);
dwUsage = CHid_GetUsage(&this->dcb, (int)iobj);
if(dwUsage)
{
/*
* A countdown loop lets us fall out with the correct failure
* code (namely, -1).
*/
iAxis = cJoyPosAxisMax;
while(--iAxis >= 0)
{
if(pvip->Usages[iAxis] == dwUsage)
{
break;
}
}
} else
{
/*
* Eek! No usage information for the axis. Then it certainly
* isn't a VJOYD axis.
*/
iAxis = -1;
}
return iAxis;
}
#ifndef WINNT
/*****************************************************************************
*
* @doc INTERNAL
*
* @method void | CHid | UpdateVjoydCalibration |
*
* Somebody changed the calibration on a single axis. If we
* are shadowing a joystick, then look for the VJOYD alias of
* our device and update its registry settings, too.
*
*
* @parm UINT | iobj |
*
* Object index of the object whose calibration changed.
*
*****************************************************************************/
void EXTERNAL
CHid_UpdateVjoydCalibration(PCHID this, UINT iobj)
{
HRESULT hres;
int iAxis;
VXDINITPARMS vip;
DIJOYCONFIG cfg;
PHIDGROUPCAPS pcaps;
PJOYRANGECONVERT pjrc;
AssertF(iobj < this->df.dwNumObjs);
/*
* Proceed if...
*
* - We can find the VJOYD device we correspond to.
* - We can find the axis that got updated.
* - The indicated axis has capability information.
* - The indicated axis has calibration information.
* - We can read the old calibration information.
*/
CHid_FindJoyDevice(this, &vip);
if(this->idJoy >= 0 &&
(iAxis = CHid_MapAxis(this, &vip, iobj)) >= 0 &&
(pcaps = this->rghoc[iobj].pcaps) != NULL &&
(pjrc = this->rghoc[iobj].pjrc) != NULL &&
SUCCEEDED(hres = JoyReg_GetConfig(this->idJoy, &cfg,
DIJC_REGHWCONFIGTYPE)))
{
PLMINMAX Dst = &pcaps->Physical;
PLMINMAX Src = &pcaps->Logical;
AssertF(iAxis < cJoyPosAxisMax);
#define JoyPosValue(phwc, f, i) \
*(LPDWORD)pvAddPvCb(&(phwc)->hwv.jrvHardware.f, \
ibJoyPosAxisFromPosAxis(i))
/*
* We use logical coordinates, but VJOYD wants physical
* coordinates, so do the conversion while we copy the
* values.
*/
#define ConvertValue(f1, f2) \
JoyPosValue(&cfg.hwc, f1, iAxis) = \
CHid_CoordinateTransform(Dst, Src, pjrc->f2) \
ConvertValue(jpMin , dwPmin);
ConvertValue(jpMax , dwPmax);
ConvertValue(jpCenter, dwPc );
#undef ConvertValue
#undef JoyPosValue
/*
* Notice that we do *not* pass the DIJC_UPDATEALIAS flag
* because WE ARE THE ALIAS! If we had passed the flag,
* then JoyReg would create us and attempt to update our
* calibration which we don't want it to do because the
* whole thing was our idea in the first place.
*/
hres = JoyReg_SetConfig(this->idJoy, &cfg.hwc, &cfg,
DIJC_REGHWCONFIGTYPE);
}
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method void | CHid | UpdateCalibrationFromVjoyd |
*
* This function is only for Win9x. Joy.cpl uses winmm (through vjoyd)
* to calibrate the device, and save calibration information directly into
* registry without notifying HID. ANother issue is: vjoyd only use unsigned
* data (physical data), while HID also use signed data. When we read
* calibration information from VJOYD, we need do conversion.
*
* @parm UINT | iobj |
*
* Object index of the object whose calibration changed.
*
*****************************************************************************/
void EXTERNAL
CHid_UpdateCalibrationFromVjoyd(PCHID this, UINT iobj, LPDIOBJECTCALIBRATION pCal)
{
HRESULT hres;
int iAxis;
VXDINITPARMS vip;
DIJOYCONFIG cfg;
PHIDGROUPCAPS pcaps;
PJOYRANGECONVERT pjrc;
AssertF(iobj < this->df.dwNumObjs);
/*
* Proceed if...
*
* - We can find the VJOYD device we correspond to.
* - We can find the axis that got updated.
* - The indicated axis has capability information.
* - The indicated axis has calibration information.
* - We can read the calibration information.
*/
CHid_FindJoyDevice(this, &vip);
if(this->idJoy >= 0 &&
(iAxis = CHid_MapAxis(this, &vip, iobj)) >= 0 &&
(pcaps = this->rghoc[iobj].pcaps) != NULL &&
(pjrc = this->rghoc[iobj].pjrc) != NULL &&
SUCCEEDED(hres = JoyReg_GetConfig(this->idJoy, &cfg,
DIJC_REGHWCONFIGTYPE)))
{
PLMINMAX Src = &pcaps->Physical;
PLMINMAX Dst = &pcaps->Logical;
AssertF(iAxis < cJoyPosAxisMax);
#define JoyPosValue(phwc, f, i) \
*(LPDWORD)pvAddPvCb(&(phwc)->hwv.jrvHardware.f, \
ibJoyPosAxisFromPosAxis(i))
/*
* We use logical coordinates, but VJOYD wants physical
* coordinates, so do the conversion while we copy the
* values.
*/
#define ConvertValue(f1, f2) \
pCal->f2 = CHid_CoordinateTransform(Dst, Src, \
JoyPosValue(&cfg.hwc, f1, iAxis) )
ConvertValue(jpMin , lMin);
ConvertValue(jpMax , lMax);
ConvertValue(jpCenter, lCenter);
#undef ConvertValue
#undef JoyPosValue
}
}
#endif
#ifdef WINNT
/*****************************************************************************
*
* @doc INTERNAL
*
* @func HRESULT | DIHid_SetParentRegistryProperty |
*
* Wrapper around <f SetupDiSetDeviceRegistryProperty>
* that handles character set issues.
*
* @parm LPTSTR ptszId
*
* Device Instance ID.
*
* @parm DWORD | dwProperty |
*
* The property being queried.
*
* @parm LPCDIPROPHEADER | diph |
*
* Property data to be set.
*
*****************************************************************************/
HRESULT INTERNAL
DIHid_SetParentRegistryProperty(LPTSTR ptszId, DWORD dwProperty, LPCDIPROPHEADER pdiph)
{
HDEVINFO hdev;
TCHAR tsz[MAX_PATH];
LPDIPROPSTRING pstr = (PV)pdiph;
HRESULT hres = E_FAIL;
hdev = SetupDiCreateDeviceInfoList(NULL, NULL);
if(hdev != INVALID_HANDLE_VALUE)
{
SP_DEVINFO_DATA dinf;
ZeroX(tsz);
#ifdef UNICODE
lstrcpyW(tsz, pstr->wsz);
#else
UToA(tsz, cA(tsz), pstr->wsz);
#endif
dinf.cbSize = cbX(SP_DEVINFO_DATA);
if(SetupDiOpenDeviceInfo(hdev, ptszId, NULL, 0, &dinf))
{
CONFIGRET cr;
DEVINST DevInst;
if( (cr = CM_Get_Parent(&DevInst, dinf.DevInst, 0x0) ) == CR_SUCCESS )
{
CAssertF( SPDRP_DEVICEDESC +1 == CM_DRP_DEVICEDESC );
CAssertF( SPDRP_FRIENDLYNAME +1 == CM_DRP_FRIENDLYNAME );
if( ( cr = CM_Set_DevNode_Registry_Property(
DevInst,
dwProperty+1,
(LPBYTE)tsz,
MAX_PATH *cbX(TCHAR),
0x0 ) ) == CR_SUCCESS )
{
hres = S_OK;
} else
{
SquirtSqflPtszV(sqfl | sqflVerbose,
TEXT("CM_Get_DevNode_Registry_Property FAILED") );
}
} else
{
SquirtSqflPtszV(sqfl | sqflVerbose,
TEXT("CM_Get_Parent FAILED") );
}
} else
{
SquirtSqflPtszV(sqfl | sqflVerbose,
TEXT("SetupDiOpenDeviceInfo FAILED, le = %d"), GetLastError() );
}
SetupDiDestroyDeviceInfoList(hdev);
} else
{
SquirtSqflPtszV(sqfl | sqflError,
TEXT("SetupDiCreateDeviceInfoList FAILED, le = %d"), GetLastError() );
}
return hres;
}
#else
/*****************************************************************************
*
* @doc INTERNAL
*
* @func HRESULT | DIHid_SetRegistryProperty |
*
* Wrapper around <f SetupDiSetDeviceRegistryProperty>
* that handles character set issues.
*
* @parm LPTSTR ptszId
*
* Device Instance ID.
*
* @parm DWORD | dwProperty |
*
* The property being queried.
*
* @parm LPCDIPROPHEADER | diph |
*
* Property data to be set.
*
*****************************************************************************/
HRESULT INTERNAL
DIHid_SetRegistryProperty(LPTSTR ptszId, DWORD dwProperty, LPCDIPROPHEADER pdiph)
{
HDEVINFO hdev;
TCHAR tsz[MAX_PATH];
LPDIPROPSTRING pstr = (PV)pdiph;
HRESULT hres;
hdev = SetupDiCreateDeviceInfoList(NULL, NULL);
if(hdev != INVALID_HANDLE_VALUE)
{
SP_DEVINFO_DATA dinf;
ZeroX(tsz);
#ifdef UNICODE
lstrcpyW(tsz, pstr->wsz);
#else
UToA(tsz, cA(tsz), pstr->wsz);
#endif
dinf.cbSize = cbX(SP_DEVINFO_DATA);
if(SetupDiOpenDeviceInfo(hdev, ptszId, NULL, 0, &dinf))
{
if(SetupDiSetDeviceRegistryProperty(hdev, &dinf, dwProperty,
(LPBYTE)tsz, MAX_PATH*cbX(TCHAR)) )
{
hres = S_OK;
} else
{
hres = E_FAIL;
}
} else
{
hres = E_FAIL;
}
SetupDiDestroyDeviceInfoList(hdev);
} else
{
hres = E_FAIL;
}
return hres;
}
#endif
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CHid | SetAxisProperty |
*
* Set the appropriate axis property (or return E_NOTIMPL if the
* property is not an axis property).
* If the request is to set a property on the device,
* then convert it into separate requests, one for each
* axis.
*
* @parm PDCHID | this |
*
* The device object.
*
* @parm IN LPCDIPROPINFO | ppropi |
*
* Information describing the property being set.
*
* @parm LPCDIPROPHEADER | pdiph |
*
* Structure containing property value.
*
* @returns
*
* Returns a COM error code. The following error codes are
* intended to be illustrative and not necessarily comprehensive.
*
* <c DI_OK> = <c S_OK>: The operation completed successfully.
*
* <c E_NOTIMPL> nothing happened. The caller will do
* the default thing in response to <c E_NOTIMPL>.
*
*****************************************************************************/
STDMETHODIMP
CHid_SetAxisProperty
(
PCHID this,
LPCDIPROPINFO ppropi,
LPCDIPROPHEADER pdiph
)
{
HRESULT hres;
INT iObjLimit;
INT iObj;
if (ppropi->dwDevType == 0)
{ /* For device try every object */
iObj = 0;
iObjLimit = this->df.dwNumObjs;
}
else
{ /* For axis just do the requested one */
iObj = ppropi->iobj;
iObjLimit = ppropi->iobj + 1;
}
hres = S_OK;
for( ; iObj < iObjLimit; iObj++ )
{
PJOYRANGECONVERT pjrc;
if( pjrc = this->rghoc[iObj].pjrc )
{
if( (this->df.rgodf[iObj].dwType &
(DIDFT_ALIAS | DIDFT_VENDORDEFINED | DIDFT_OUTPUT | DIDFT_ABSAXIS)) == DIDFT_ABSAXIS)
{
PHIDGROUPCAPS pcaps = this->rghoc[iObj].pcaps;
DIPROPCAL cal;
/*
* Specific calibrations arrive in VJOYD coordinates.
* We need to convert them to DirectInput (logical)
* coordinates if so.
*/
if(ppropi->pguid == DIPROP_SPECIFICCALIBRATION)
{
if( pcaps )
{
PLMINMAX Dst = &pcaps->Logical;
PLMINMAX Src = &pcaps->Physical;
LPDIPROPCAL pcal = CONTAINING_RECORD(pdiph, DIPROPCAL, diph);
cal.lMin = CHid_CoordinateTransform(Dst, Src, pcal->lMin);
cal.lCenter = CHid_CoordinateTransform(Dst, Src, pcal->lCenter);
cal.lMax = CHid_CoordinateTransform(Dst, Src, pcal->lMax);
pdiph = &cal.diph;
}
else
{
AssertF( ppropi->dwDevType == 0 );
/*
* Ignore the error. If this is an object set
* property validation should have caught this
* already and the DX7 patch code for device set
* property special cased E_NOTIMPL so that one bad
* axis would not cause the whole call to fail when
* other axes may be OK.
* A bit flakey but "this should never happen"
*/
continue;
}
}
hres = CCal_SetProperty( pjrc, ppropi, pdiph, this->hkInstType );
#ifndef WINNT
/*
* If we successfully changed the calibration of a game
* controller device, then see if it's a VJOYD device.
*/
if(SUCCEEDED(hres) &&
ppropi->pguid == DIPROP_CALIBRATION &&
GET_DIDEVICE_TYPE(this->dwDevType) >= DI8DEVTYPE_GAMEMIN)
{
CHid_UpdateVjoydCalibration(this, ppropi->iobj);
}
#endif
}
#ifdef WINNT
else if( (this->df.rgodf[iObj].dwType &
(DIDFT_ALIAS | DIDFT_VENDORDEFINED | DIDFT_OUTPUT | DIDFT_POV)) == DIDFT_POV)
{
PHIDGROUPCAPS pcaps = this->rghoc[iObj].pcaps;
if( pcaps )
{
if( pcaps->IsPolledPOV )
{
hres = CCal_SetProperty(pjrc, ppropi, pdiph, this->hkInstType);
if( SUCCEEDED(hres) ) {
CHid_LoadCalibrations(this);
CHid_InitParseData( this );
}
}
else
{
if( ppropi->dwDevType != 0 )
{
hres = E_NOTIMPL;
}
}
}
else
{
AssertF( ppropi->dwDevType == 0 );
/*
* Ignore the error. If this is an object set
* property validation should have caught this
* already and the DX7 patch code for device set
* property special cased E_NOTIMPL so that one bad
* axis would not cause the whole call to fail when
* other axes may be OK.
* A bit flakey but "this should never happen"
*/
continue;
}
}
#endif
}
else
{
/*
* If the object cannot have an axis property set, the DX7 code
* returned E_NOTIMPL when it should have returned some parameter
* error. For a device, this is not an error as we are iterating
* all objects looking for absolute axes.
* If it is an absolute axis but has no range conversion, return
* E_NOTIMPL to match previous versions for an object but ignore
* for the device. This probably should be an E_FAIL...
*/
if( ppropi->dwDevType != 0 )
{
hres = E_NOTIMPL;
}
}
}
/*
* Don't need to hold/unhold here because the app called us so it should
* not be releasing us at the same time. (mb:34570)
*/
CHid_LoadCalibrations(this);
if( SUCCEEDED(hres) )
{
/*
* Until such time as CHid_InitParseData returns anything other than
* S_OK, don't update a possibly more informative result with this.
*/
D( HRESULT hresDbg = )
CHid_InitParseData( this );
D( AssertF( hresDbg == S_OK ); )
}
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CHid | SetProperty |
*
* Set a hid device property.
*
* @parm PCHID | this |
*
* The hid object.
*
* @parm IN LPCDIPROPINFO | ppropi |
*
* Information describing the property being set.
*
* @parm LPCDIPROPHEADER | pdiph |
*
* Structure containing property value.
*
* @returns
*
* Returns a COM error code. The following error codes are
* intended to be illustrative and not necessarily comprehensive.
*
* <c DI_OK> = <c S_OK>: The operation completed successfully.
*
* <c E_NOTIMPL> nothing happened. The caller will do
* the default thing in response to <c E_NOTIMPL>.
*
*****************************************************************************/
STDMETHODIMP
CHid_SetProperty(PDICB pdcb, LPCDIPROPINFO ppropi, LPCDIPROPHEADER pdiph)
{
HRESULT hres;
PCHID this;
EnterProcI(IDirectInputDeviceCallback::Hid::SetProperty,
(_ "pxxp", pdcb, ppropi->pguid, ppropi->iobj, pdiph));
/*
* This is an internal interface, so we can skimp on validation.
*/
this = _thisPvNm(pdcb, dcb);
if(ppropi->iobj < this->df.dwNumObjs)
{
/*
* Object Property
*/
PHIDGROUPCAPS pcaps;
AssertF(ppropi->dwDevType == this->df.rgodf[ppropi->iobj].dwType);
AssertF(ppropi->iobj == CHid_ObjFromType(this, ppropi->dwDevType));
if( pcaps = this->rghoc[ppropi->iobj].pcaps )
{
switch((DWORD)(UINT_PTR)ppropi->pguid)
{
case (DWORD)(UINT_PTR)(DIPROP_ENABLEREPORTID):
{
LPDIPROPDWORD ppropdw = CONTAINING_RECORD(pdiph, DIPROPDWORD, diph);
AssertF(pcaps->wReportId < this->wMaxReportId[pcaps->type]);
AssertF(this->pEnableReportId[pcaps->type]);
hres = S_OK;
if( ppropdw->dwData == 0x1 )
{
*(this->pEnableReportId[pcaps->type] + pcaps->wReportId) = 0x1;
pcaps->fReportDisabled = FALSE;
} else
{
*(this->pEnableReportId[pcaps->type] + pcaps->wReportId) = 0x0;
pcaps->fReportDisabled = TRUE;
}
}
break;
default:
AssertF(ppropi->dwDevType == this->df.rgodf[ppropi->iobj].dwType);
AssertF(ppropi->iobj == CHid_ObjFromType(this, ppropi->dwDevType));
hres = CHid_SetAxisProperty( this, ppropi, pdiph );
}
} else
{
SquirtSqflPtszV(sqflHidDev | sqflError,
TEXT("CHid_SetProperty FAILED due to missing caps for type 0x%08x, obj %d"),
ppropi->dwDevType, ppropi->iobj );
hres = E_NOTIMPL;
}
} else if(ppropi->iobj == 0xFFFFFFFF)
{ /* Device property */
switch((DWORD)(UINT_PTR)ppropi->pguid)
{
case (DWORD)(UINT_PTR)DIPROP_GUIDANDPATH:
SquirtSqflPtszV(sqflHidDev | sqflError,
TEXT("CHid_SetProperty(iobj=%08x): PROP_GUIDANDPATH is read only.") );
hres = E_NOTIMPL;
break;
case (DWORD)(UINT_PTR)DIPROP_INSTANCENAME:
/*
* Friendly names cause all manner of problems with devices that
* use auto detection so only allow non-predefined analog devices
* to use them.
*/
if( ( this->VendorID == MSFT_SYSTEM_VID )
&& ( this->ProductID >= MSFT_SYSTEM_PID + JOY_HW_PREDEFMAX )
&& ( ( this->ProductID & 0xff00 ) == MSFT_SYSTEM_PID ) )
{
AssertF(this->hkType);
if( this->hkType )
{
LPDIPROPSTRING pstr = (PV)pdiph;
hres = JoyReg_SetValue(this->hkType,
REGSTR_VAL_JOYOEMNAME, REG_SZ,
pstr->wsz,
cbX(pstr->wsz));
if( SUCCEEDED(hres ) )
{
SquirtSqflPtszV(sqflHid | sqflVerbose,
TEXT( "Set instance name %s"), pstr->wsz );
hres = S_OK;
} else {
hres = E_FAIL;
}
} else {
hres = E_FAIL;
}
}
else
{
/*
* GenJ returns E_NOTIMPL for this property so do the same
*/
hres = E_NOTIMPL;
}
break;
case (DWORD)(UINT_PTR)DIPROP_PRODUCTNAME:
#ifdef WINNT
hres = DIHid_SetParentRegistryProperty(this->ptszId, SPDRP_DEVICEDESC, pdiph);
#else
hres = DIHid_SetRegistryProperty(this->ptszId, SPDRP_DEVICEDESC, pdiph);
#endif
break;
case (DWORD)(UINT_PTR)(DIPROP_ENABLEREPORTID):
{
LPDIPROPDWORD ppropdw = CONTAINING_RECORD(pdiph, DIPROPDWORD, diph);
UINT iType;
if( ppropdw->dwData == 0x0 )
{
for( iType = 0x0; iType < HidP_Max; iType++)
{
ZeroBuf(this->pEnableReportId[iType], this->wMaxReportId[iType]);
}
} else
{
for( iType = 0x0; iType < HidP_Max; iType++)
{
memset(this->pEnableReportId[iType], 0x1, this->wMaxReportId[iType]);
}
}
hres = S_OK;
}
break;
case (DWORD)(UINT_PTR)DIPROP_RANGE:
case (DWORD)(UINT_PTR)DIPROP_DEADZONE:
case (DWORD)(UINT_PTR)DIPROP_SATURATION:
case (DWORD)(UINT_PTR)DIPROP_CALIBRATIONMODE:
case (DWORD)(UINT_PTR)DIPROP_CALIBRATION:
hres = CHid_SetAxisProperty( this, ppropi, pdiph );
break;
default:
SquirtSqflPtszV(sqflHidDev| sqflBenign,
TEXT("CHid_SetProperty(iobj=%08x): E_NOTIMPL on guid: %08x"),
ppropi->iobj, ppropi->pguid);
hres = E_NOTIMPL;
break;
}
} else
{
SquirtSqflPtszV(sqflHidDev | sqflError,
TEXT("CHid_SetProperty(iobj=%08x): E_NOTIMPL on guid: %08x"),
ppropi->iobj, ppropi->pguid);
hres = E_NOTIMPL;
}
ExitOleProcR();
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method void | CHid | GetCapabilities |
*
* Get Hid device capabilities.
*
* @parm LPDIDEVCAPS | pdc |
*
* Device capabilities structure to receive result.
*
* @returns
* <c S_OK> on success.
*
*****************************************************************************/
STDMETHODIMP
CHid_GetCapabilities(PDICB pdcb, LPDIDEVCAPS pdc)
{
HRESULT hres;
PCHID this;
HANDLE h;
DWORD dwFlags2 = 0;
EnterProcI(IDirectInputDeviceCallback::Hid::GetCapabilities,
(_ "pp", pdcb, pdc));
/*
* This is an internal interface, so we can skimp on validation.
*/
this = _thisPvNm(pdcb, dcb);
/*
* We must check connectivity by opening the device, because NT
* leaves the device in the info list even though it has
* been unplugged.
*/
h = CHid_OpenDevicePath(this, FILE_FLAG_OVERLAPPED);
if(h != INVALID_HANDLE_VALUE)
{
#ifndef WINNT
if( this->hkType )
{
VXDINITPARMS vip;
CHid_FindJoyDevice(this, &vip);
if( TRUE == CHid_IsMatchingJoyDevice( this, &vip ) )
{
DWORD dwFlags1;
if( SUCCEEDED( JoyReg_GetValue( this->hkType,
REGSTR_VAL_FLAGS1, REG_BINARY,
&dwFlags1,
cbX(dwFlags1) ) ) )
{
if( dwFlags1 & JOYTYPE_NOHIDDIRECT )
{
pdc->dwFlags |= DIDC_ALIAS;
}
}
}
}
#endif // !WINNT
CloseHandle(h);
if( this->pvi->fl & VIFL_UNPLUGGED )
{
pdc->dwFlags &= ~DIDC_ATTACHED;
} else
{
pdc->dwFlags |= DIDC_ATTACHED;
}
} else
{
pdc->dwFlags &= ~DIDC_ATTACHED;
}
if( this->IsPolledInput )
{
pdc->dwFlags |= DIDC_POLLEDDEVICE;
}
if( this->hkProp )
{
JoyReg_GetValue( this->hkProp, REGSTR_VAL_FLAGS2, REG_BINARY,
&dwFlags2, cbX(dwFlags2) );
}
if( !( dwFlags2 & JOYTYPE_HIDEACTIVE ) )
{
// Currently we only hide "fictional" keyboards and mice.
if( ( GET_DIDEVICE_TYPE( this->dwDevType ) == DI8DEVTYPE_MOUSE )
||( GET_DIDEVICE_TYPE( this->dwDevType ) == DI8DEVTYPE_KEYBOARD )
)
{
dwFlags2 = DIHid_DetectHideAndRevealFlags(this) ;
}
}
if( dwFlags2 & JOYTYPE_HIDEACTIVE )
{
switch( GET_DIDEVICE_TYPE( this->dwDevType ) )
{
case DI8DEVTYPE_DEVICE:
if( dwFlags2 & JOYTYPE_DEVICEHIDE )
{
pdc->dwFlags |= DIDC_HIDDEN;
}
break;
case DI8DEVTYPE_MOUSE:
if( dwFlags2 & JOYTYPE_MOUSEHIDE )
{
pdc->dwFlags |= DIDC_HIDDEN;
}
break;
case DI8DEVTYPE_KEYBOARD:
if( dwFlags2 & JOYTYPE_KEYBHIDE )
{
pdc->dwFlags |= DIDC_HIDDEN;
}
break;
default:
if( dwFlags2 & JOYTYPE_GAMEHIDE )
{
pdc->dwFlags |= DIDC_HIDDEN;
}
break;
}
}
pdc->dwDevType = this->dwDevType;
pdc->dwAxes = this->dwAxes;
pdc->dwButtons = this->dwButtons;
pdc->dwPOVs = this->dwPOVs;
hres = S_OK;
ExitOleProcR();
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CHid | GetDeviceState |
*
* Obtains the state of the Hid device.
*
* It is the caller's responsibility to have validated all the
* parameters and ensure that the device has been acquired.
*
* @parm OUT LPVOID | lpvData |
*
* Hid data in the preferred data format.
*
* @returns
*
* Returns a COM error code. The following error codes are
* intended to be illustrative and not necessarily comprehensive.
*
* <c DI_OK> = <c S_OK>: The operation completed successfully.
*
* <c DIERR_INVALIDPARAM> = <c E_INVALIDARG>: The
* <p lpmdr> parameter is not a valid pointer.
*
*****************************************************************************/
STDMETHODIMP
CHid_GetDeviceState(PDICB pdcb, LPVOID pvData)
{
HRESULT hres;
PCHID this;
EnterProcI(IDirectInputDeviceCallback::Hid::GetDeviceState,
(_ "pp", pdcb, pvData));
/*
* This is an internal interface, so we can skimp on validation.
*/
this = _thisPvNm(pdcb, dcb);
AssertF(this->pvi);
AssertF(this->pvPhys);
AssertF(this->cbPhys);
if(this->pvi->fl & VIFL_ACQUIRED)
{
CHid_GetPhysicalState(this, pvData);
hres = S_OK;
} else
{
hres = DIERR_INPUTLOST;
}
ExitOleProcR();
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CHid | GetObjectInfo |
*
* Obtain the friendly name and FF/HID information
* of an object.
*
* @parm IN LPCDIPROPINFO | ppropi |
*
* Information describing the object being accessed.
*
* @parm IN OUT LPDIDEVICEOBJECTINSTANCEW | pdidioiW |
*
* Structure to receive information. All fields have been
* filled in up to the <e DIDEVICEOBJECTINSTANCE.tszObjName>.
*
* @returns
*
* Returns a COM error code.
*
*****************************************************************************/
STDMETHODIMP
CHid_GetObjectInfo(PDICB pdcb, LPCDIPROPINFO ppropi,
LPDIDEVICEOBJECTINSTANCEW pdidoiW)
{
HRESULT hres;
PCHID this;
EnterProcI(IDirectInputDeviceCallback::Hid::GetObjectInfo,
(_ "pxp", pdcb, ppropi->iobj, pdidoiW));
/*
* This is an internal interface, so we can skimp on validation.
*/
this = _thisPvNm(pdcb, dcb);
AssertF((int) ppropi->iobj >= 0);
if(ppropi->iobj < this->df.dwNumObjs)
{
UINT uiInstance = ppropi->iobj;
PHIDGROUPCAPS pcaps;
AssertF(ppropi->dwDevType == this->df.rgodf[uiInstance].dwType);
AssertF(uiInstance == CHid_ObjFromType(this, ppropi->dwDevType));
pcaps = this->rghoc[uiInstance].pcaps;
/*
* pcaps might be NULL if HID messed up and left gaps
* in the index lists.
*/
if(pcaps)
{
UINT ids, duiInstance;
AssertF(pcaps->dwSignature == HIDGROUPCAPS_SIGNATURE);
/*
* See if there's anything in the registry that will help.
*/
CType_RegGetObjectInfo(this->hkType, ppropi->dwDevType, pdidoiW);
if(ppropi->dwDevType & DIDFT_COLLECTION)
{
ids = IDS_COLLECTIONTEMPLATE;
duiInstance = 0;
} else
{
if(ppropi->dwDevType & DIDFT_BUTTON)
{
ids = IDS_BUTTONTEMPLATE;
} else if(ppropi->dwDevType & DIDFT_AXIS)
{
ids = IDS_AXISTEMPLATE;
} else if(ppropi->dwDevType & DIDFT_POV)
{
ids = IDS_POVTEMPLATE;
} else
{
ids = IDS_UNKNOWNTEMPLATE;
}
/*
* Now convert the uiInstance to a duiInstance,
* giving the index of this object into the group.
*/
AssertF(HidP_IsValidReportType(pcaps->type));
duiInstance = uiInstance -
(this->rgdwBase[pcaps->type] +
pcaps->DataIndexMin);
}
/*
* Okay, now we have all the info we need to proceed.
*/
/*
* If there was no overriding name in the registry, then
* try to get a custom name from the usage page/usage.
* If even that fails, then use the generic name.
* Note, generic names will contain zero based numbers
* which can look wrong if some objects have names and
* others take defaults.
*/
if(pdidoiW->tszName[0])
{
} else
if(GetHIDString(pcaps->UsageMin + duiInstance,
pcaps->UsagePage,
pdidoiW->tszName, cA(pdidoiW->tszName)))
{
if(ppropi->dwDevType & DIDFT_COLLECTION)
{
InsertCollectionNumber(DIDFT_GETINSTANCE( ppropi->dwDevType ),
pdidoiW->tszName);
}
} else
{
GetNthString(pdidoiW->tszName, ids,
DIDFT_GETINSTANCE( ppropi->dwDevType ));
}
if(pdidoiW->dwSize >= cbX(DIDEVICEOBJECTINSTANCE_DX5W))
{
pdidoiW->wCollectionNumber = pcaps->LinkCollection;
pdidoiW->wDesignatorIndex = pcaps->DesignatorMin + duiInstance;
if(pdidoiW->wDesignatorIndex > pcaps->DesignatorMax)
{
pdidoiW->wDesignatorIndex = pcaps->DesignatorMax;
}
/*
* Much as you may try, you cannot override the usage
* page and usage. Doing so would mess up the GUID
* selection code that happens in DIHIDINI.C.
*
* If you change your mind and allow overridden usage
* pages and usages, then you'll also have to change
* CHid_GetUsage.
*
* At this point, the registry overrides have already
* been read so defeat the override here.
*/
pdidoiW->wUsagePage = pcaps->UsagePage;
pdidoiW->wUsage = pcaps->UsageMin + duiInstance;
pdidoiW->dwDimension = pcaps->Units;
pdidoiW->wExponent = pcaps->Exponent;
pdidoiW->wReportId = pcaps->wReportId;
}
hres = S_OK;
} else
{
hres = E_INVALIDARG;
}
} else
{
hres = E_INVALIDARG;
}
ExitOleProcR();
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method DWORD | CHid | GetUsage |
*
* Given an object index, return the usage and usage page,
* packed into a single <t DWORD>.
*
* @parm int | iobj |
*
* The object index to convert.
*
* @returns
*
* Returns a <c DIMAKEUSAGEDWORD> of the resulting usage and
* usage page, or zero on error.
*
*****************************************************************************/
STDMETHODIMP_(DWORD)
CHid_GetUsage(PDICB pdcb, int iobj)
{
PCHID this;
PHIDGROUPCAPS pcaps;
DWORD dwRc;
EnterProcI(IDirectInputDeviceCallback::Hid::GetUsage,
(_ "pu", pdcb, iobj));
/*
* This is an internal interface, so we can skimp on validation.
*/
this = _thisPvNm(pdcb, dcb);
AssertF(iobj >= 0);
AssertF((UINT)iobj < this->df.dwNumObjs);
pcaps = this->rghoc[iobj].pcaps;
/*
* pcaps might be NULL if HID messed up and left gaps
* in the index lists.
*/
if(pcaps)
{
UINT duiInstance;
AssertF(pcaps->dwSignature == HIDGROUPCAPS_SIGNATURE);
if(this->df.rgodf[iobj].dwType & DIDFT_COLLECTION)
{
duiInstance = 0;
} else
{
/*
* Now convert the iobj to a duiInstance,
* giving the index of this object into the group.
*/
AssertF(HidP_IsValidReportType(pcaps->type));
duiInstance = iobj -
(this->rgdwBase[pcaps->type] +
pcaps->DataIndexMin);
}
/*
* CHid_GetObjectInfo also assumes that there is no way
* to override the usage page and usage values in the
* registry.
*/
dwRc = DIMAKEUSAGEDWORD(pcaps->UsagePage,
pcaps->UsageMin + duiInstance);
} else
{
dwRc = 0;
}
ExitProcX(dwRc);
return dwRc;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CHid | MapUsage |
*
*
* Given a usage and usage page (munged into a single
* <t DWORD>), find a device object that matches it.
*
* @parm DWORD | dwUsage |
*
* The usage page and usage combined into a single <t DWORD>
* with the <f DIMAKEUSAGEDWORD> macro.
*
* @parm PINT | piOut |
*
* Receives the object index of the found object, if successful.
*
* @returns
*
* Returns a COM error code.
*
* <c S_OK> if an object was found.
*
* <c DIERR_NOTFOUND> if no matching object was found.
*
*****************************************************************************/
STDMETHODIMP
CHid_MapUsage(PDICB pdcb, DWORD dwUsage, PINT piOut)
{
HRESULT hres;
PCHID this;
UINT icaps;
UINT uiObj;
UINT duiObj;
EnterProcI(IDirectInputDeviceCallback::Hid::MapUsage,
(_ "px", pdcb, dwUsage));
/*
* This is an internal interface, so we can skimp on validation.
*/
this = _thisPvNm(pdcb, dcb);
for(icaps = 0; icaps < this->ccaps; icaps++)
{
PHIDGROUPCAPS pcaps = &this->rgcaps[icaps];
/*
* Shall we support mapping HidP_Output usage?
* If we should, it is easy to add it later.
*/
uiObj = this->rgdwBase[HidP_Input] + pcaps->DataIndexMin;
for(duiObj = 0; duiObj < pcaps->cObj; duiObj++)
{
if( dwUsage == DIMAKEUSAGEDWORD(pcaps->UsagePage, pcaps->UsageMin+duiObj) )
{
*piOut = uiObj+duiObj;
AssertF(*piOut < (INT)this->df.dwNumObjs);
hres = S_OK;
goto done;
}
}
}
hres = DIERR_NOTFOUND;
done:;
ExitBenignOleProcR();
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CHid | SetCooperativeLevel |
*
* Notify the device of the cooperative level.
*
* @parm IN HWND | hwnd |
*
* The window handle.
*
* @parm IN DWORD | dwFlags |
*
* The cooperativity level.
*
* @returns
*
* Returns a COM error code.
*
*****************************************************************************/
STDMETHODIMP
CHid_SetCooperativeLevel(PDICB pdcb, HWND hwnd, DWORD dwFlags)
{
HRESULT hres;
PCHID this;
EnterProcI(IDirectInputDeviceCallback::Hid::SetCooperativityLevel,
(_ "pxx", pdcb, hwnd, dwFlags));
/*
* This is an internal interface, so we can skimp on validation.
*/
this = _thisPvNm(pdcb, dcb);
/*
* We won't subclass Motocross Madness. See NT bug 262280.
* Use the app hacks for MCM and any app like it.
*/
if( !this->diHacks.fNoSubClass )
{
AssertF(this->pvi);
/*
* First get out of the old window.
*/
CHid_RemoveSubclass(this);
/*
* Prefix warns that "this" may have been freed (mb:34570) however
* If you're in SetCooperativeLevel and you have a window subclassed
* then there must be a hold for the subclassed window as well as
* one for the unreleased interface so the Common_Unhold won't free
* the pointer.
*/
/*
* If a new window is passed, then subclass it so we can
* watch for joystick configuration change messages.
*
* If we can't, don't worry. All it means that we won't
* be able to catch when the user recalibrates a device,
* which isn't very often.
*/
if(hwnd)
{
if(SetWindowSubclass(hwnd, CHid_SubclassProc, 0x0, (ULONG_PTR)this))
{
this->hwnd = hwnd;
Common_Hold(this);
}
} else
{
RPF("SetCooperativeLevel: You really shouldn't pass hwnd = 0; "
"device calibration may be dodgy");
}
}
hres = S_OK;
ExitOleProcR();
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CHid | RunControlPanel |
*
* Run the Hid control panel.
*
* @parm IN HWND | hwndOwner |
*
* The owner window.
*
* @parm DWORD | dwFlags |
*
* Flags.
*
*****************************************************************************/
STDMETHODIMP
CHid_RunControlPanel(PDICB pdcb, HWND hwnd, DWORD dwFlags)
{
HRESULT hres;
PCHID this;
EnterProcI(IDirectInputDeviceCallback::Hid::RunControlPanel,
(_ "pxx", pdcb, hwnd, dwFlags));
/*
* This is an internal interface, so we can skimp on validation.
*/
this = _thisPvNm(pdcb, dcb);
/*
* How to invoke HID cpl?
*
* Currently, we just launch joy.cpl. If more HID devices show up
* which don't belong to game control panel, we may change it to
* proper cpl.
*
* on NT hresRunControlPanel(TEXT("srcmgr.cpl,@2"));
* on 9x hresRunControlPanel(TEXT("sysdm.cpl,@0,1"));
*
*/
hres = hresRunControlPanel(TEXT("joy.cpl"));
ExitOleProcR();
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CHid | GetFFConfigKey |
*
* Open and return the registry key that contains
* force feedback configuration information.
*
* @parm DWORD | sam |
*
* Security access mask.
*
* @parm PHKEY | phk |
*
* Receives the registry key.
*
*****************************************************************************/
STDMETHODIMP
CHid_GetFFConfigKey(PDICB pdcb, DWORD sam, PHKEY phk)
{
HRESULT hres;
PCHID this;
EnterProcI(IDirectInputDeviceCallback::HID::GetFFConfigKey,
(_ "px", pdcb, sam));
/*
* This is an internal interface, so we can skimp on validation.
*/
this = _thisPvNm(pdcb, dcb);
hres = JoyReg_OpenFFKey(this->hkType, sam, phk);
AssertF(fLeqvFF(SUCCEEDED(hres), *phk));
if(FAILED(hres) && this->fPIDdevice )
{
*phk = NULL;
hres = S_FALSE;
}
ExitBenignOleProcPpvR(phk);
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CHid | GetDeviceInfo |
*
* Obtain general information about the device.
*
* @parm OUT LPDIDEVICEINSTANCEW | pdiW |
*
* <t DEVICEINSTANCE> to be filled in. The
* <e DEVICEINSTANCE.dwSize> and <e DEVICEINSTANCE.guidInstance>
* have already been filled in.
*
* Secret convenience: <e DEVICEINSTANCE.guidProduct> is equal
* to <e DEVICEINSTANCE.guidInstance>.
*
*****************************************************************************/
STDMETHODIMP
CHid_GetDeviceInfo(PDICB pdcb, LPDIDEVICEINSTANCEW pdiW)
{
HRESULT hres;
PCHID this;
DIPROPINFO propi;
DIPROPSTRING dips;
EnterProcI(IDirectInputDeviceCallback::Hid::GetDeviceInfo,
(_ "pp", pdcb, pdiW));
/*
* This is an internal interface, so we can skimp on validation.
*/
this = _thisPvNm(pdcb, dcb);
AssertF(IsValidSizeDIDEVICEINSTANCEW(pdiW->dwSize));
DICreateStaticGuid(&pdiW->guidProduct, this->ProductID, this->VendorID);
pdiW->dwDevType = this->dwDevType;
if(pdiW->dwSize >= cbX(DIDEVICEINSTANCE_DX5W))
{
pdiW->wUsagePage = this->caps.UsagePage;
pdiW->wUsage = this->caps.Usage;
}
propi.dwDevType = DIPH_DEVICE;
propi.iobj = 0xFFFFFFFF;
propi.pguid = DIPROP_PRODUCTNAME;
if(SUCCEEDED(hres = pdcb->lpVtbl->GetProperty(pdcb, &propi, &dips.diph)) )
{
lstrcpyW(pdiW->tszProductName, dips.wsz);
}
propi.pguid = DIPROP_INSTANCENAME;
if( FAILED(pdcb->lpVtbl->GetProperty(pdcb, &propi, &dips.diph)))
{
// Use Product Name
}
lstrcpyW(pdiW->tszInstanceName, dips.wsz);
if(pdiW->dwSize >= cbX(DIDEVICEINSTANCE_DX5W))
{
HKEY hkFF;
HRESULT hresFF;
/*
* If there is a force feedback driver, then fetch the driver CLSID
* as the FF GUID.
*/
hresFF = CHid_GetFFConfigKey(pdcb, KEY_QUERY_VALUE, &hkFF);
if(SUCCEEDED(hresFF))
{
LONG lRc;
TCHAR tszClsid[ctchGuid];
lRc = RegQueryString(hkFF, TEXT("CLSID"), tszClsid, cA(tszClsid));
if(lRc == ERROR_SUCCESS &&
ParseGUID(&pdiW->guidFFDriver, tszClsid))
{
} else
{
ZeroX(pdiW->guidFFDriver);
}
RegCloseKey(hkFF);
}
}
ExitOleProcR();
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CHid | CreateEffect |
*
*
* Create an <i IDirectInputEffectDriver> interface.
*
* @parm LPDIRECTINPUTEFFECTSHEPHERD * | ppes |
*
* Receives the shepherd for the effect driver.
*
*****************************************************************************/
STDMETHODIMP
CHid_CreateEffect(PDICB pdcb, LPDIRECTINPUTEFFECTSHEPHERD *ppes)
{
HRESULT hres;
PCHID this;
HKEY hk;
EnterProcI(IDirectInputDeviceCallback::HID::CreateEffect, (_ "p", pdcb));
/*
* This is an internal interface, so we can skimp on validation.
*/
this = _thisPvNm(pdcb, dcb);
hres = CHid_GetFFConfigKey(pdcb, KEY_QUERY_VALUE, &hk);
if(SUCCEEDED(hres))
{
DIHIDFFINITINFO init;
PHIDDEVICEINFO phdi;
hres = CEShep_New(hk, 0, &IID_IDirectInputEffectShepherd, ppes);
if(SUCCEEDED(hres))
{
#ifndef UNICODE
WCHAR wszPath[MAX_PATH];
#endif
init.dwSize = cbX(init);
#ifdef UNICODE
init.pwszDeviceInterface = this->ptszPath;
#else
init.pwszDeviceInterface = wszPath;
TToU(wszPath, cA(wszPath), this->ptszPath);
#endif
DllEnterCrit();
phdi = phdiFindHIDDeviceInterface(this->ptszPath);
if( phdi )
{
init.GuidInstance = phdi->guid;
} else
{
ZeroX(init.GuidInstance);
}
DllLeaveCrit();
hres = (*ppes)->lpVtbl->DeviceID((*ppes), this->idJoy, TRUE, &init);
if(SUCCEEDED(hres))
{
} else
{
Invoke_Release(ppes);
}
}
RegCloseKey(hk);
} else
{
hres = E_NOTIMPL;
*ppes = 0;
}
ExitOleProcPpvR(ppes);
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CHid | SendOutputReport |
*
* Actually send the report as an output report.
*
* @parm PHIDREPORTINFO | phri |
*
* The report being sent.
*
* @returns
*
* Returns a COM error code.
*
*****************************************************************************/
void CALLBACK
CHid_DummyCompletion(DWORD dwError, DWORD cbRead, LPOVERLAPPED po)
{
}
STDMETHODIMP
CHid_SendOutputReport(PCHID this, PHIDREPORTINFO phri)
{
HRESULT hres;
OVERLAPPED o;
AssertF(phri == &this->hriOut);
ZeroX(o);
/*
* Annoying API: Since this->hdev was opened
* as FILE_FLAG_OVERLAPPED, *all* I/O must be overlapped.
* So we simulate a synchronous I/O by issuing an
* overlapped I/O and waiting for the completion.
*/
if(WriteFileEx(this->hdev, phri->pvReport,
phri->cbReport, &o, CHid_DummyCompletion))
{
do
{
SleepEx(INFINITE, TRUE);
} while(!HasOverlappedIoCompleted(&o));
if(phri->cbReport == o.InternalHigh)
{
hres = S_OK;
} else
{
RPF("SendDeviceData: Wrong HID output report size?");
hres = E_FAIL; /* Aigh! HID lied to me! */
}
} else
{
hres = hresLe(GetLastError());
/*
* Note, we have not broken the read loop so there is no need to
* force the device unaquired (though dinput.dll does).
*
* If this causes problems revert to the old behavior.
* CEm_ForceDeviceUnacquire(pemFromPvi(this->pvi)->ped, 0x0);
*/
}
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CHid | SendFeatureReport |
*
* Actually send the report as an feature report.
*
* @parm PHIDREPORTINFO | phri |
*
* The report being sent.
*
* @returns
*
* Returns a COM error code.
*
*****************************************************************************/
STDMETHODIMP
CHid_SendFeatureReport(PCHID this, PHIDREPORTINFO phri)
{
HRESULT hres;
AssertF(phri == &this->hriFea);
if(HidD_SetFeature(this->hdev, phri->pvReport, phri->cbReport))
{
hres = S_OK;
} else
{
RPF("SendDeviceData: Unable to set HID feature");
hres = hresLe(GetLastError());
}
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CHid | SendDeviceData |
*
* Spew some data to the device.
*
* @parm DWORD | cbdod |
*
* Size of each object.
*
* @parm IN LPCDIDEVICEOBJECTDATA | rgdod |
*
* Array of <t DIDEVICEOBJECTDATA> structures.
*
* @parm INOUT LPDWORD | pdwInOut |
*
* On entry, number of items to send;
* on exit, number of items actually sent.
*
* @parm DWORD | fl |
*
* Flags.
*
* @returns
*
* Returns a COM error code. The following error codes are
* intended to be illustrative and not necessarily comprehensive.
*
* <c DI_OK> = <c S_OK>: The operation completed successfully.
*
* <c DIERR_REPORTFULL>: Too many items are set in the report.
* (More than can be sent to the device)
*
*****************************************************************************/
STDMETHODIMP
CHid_SendDeviceData(PDICB pdcb, DWORD cbdod, LPCDIDEVICEOBJECTDATA rgdod,
LPDWORD pdwInOut, DWORD fl)
{
HRESULT hres;
PCHID this;
DWORD dwIn, dw;
const BYTE * pbcod;
EnterProcI(IDirectInputDeviceCallback::Hid::SendDeviceData,
(_ "xpux", cbdod, pdcb, *pdwInOut, fl));
/*
* This is an internal interface, so we can skimp on validation.
*/
this = _thisPvNm(pdcb, dcb);
dwIn = *pdwInOut;
*pdwInOut = 0;
if(fl & DISDD_CONTINUE)
{
} else
{
CHid_ResetDeviceData(this, &this->hriOut, HidP_Output);
CHid_ResetDeviceData(this, &this->hriFea, HidP_Feature);
}
for(dw = 0, pbcod = (const BYTE*)rgdod; dw < dwIn; dw++)
{
DWORD dwType = ((LPDIDEVICEOBJECTDATA)pbcod)->dwOfs;
UINT uiObj = CHid_ObjFromType(this, dwType);
if(uiObj < this->df.dwNumObjs &&
DIDFT_FINDMATCH(this->df.rgodf[uiObj].dwType, dwType))
{
hres = CHid_AddDeviceData(this, uiObj, ((LPDIDEVICEOBJECTDATA)pbcod)->dwData);
if(FAILED(hres))
{
*pdwInOut = dw;
goto done;
}
} else
{
hres = E_INVALIDARG;
goto done;
}
pbcod += cbdod;
}
/*
* All the items made it into the buffer.
*/
*pdwInOut = dw;
/*
* Now send it all out.
*/
if(SUCCEEDED(hres = CHid_SendHIDReport(this, &this->hriOut, HidP_Output,
CHid_SendOutputReport)) &&
SUCCEEDED(hres = CHid_SendHIDReport(this, &this->hriFea, HidP_Feature,
CHid_SendFeatureReport)))
{
}
done:;
ExitOleProcR();
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CHid | Poll |
*
* Read any polled input and features to see what's there.
*
* @returns
*
* <c S_OK> if we pinged okay.
* <c S_FALSE> doesn't require polling
* <c DIERR_UNPLUGGED> the device requires polling and is unplugged
* Other errors returned from HID are possible for a polled device.
*
*****************************************************************************/
STDMETHODIMP
CHid_Poll(PDICB pdcb)
{
//Prefix: 45082
HRESULT hres = S_FALSE; //We need use S_FALSE as default. See manbug 31874.
PCHID this;
EnterProcI(IDirectInputDeviceCallback::Hid::Poll, (_ "p", pdcb));
/*
* This is an internal interface, so we can skimp on validation.
*/
this = _thisPvNm(pdcb, dcb);
if( this->IsPolledInput )
{
hres = DIERR_UNPLUGGED;
if(ReadFileEx(this->hdev, this->hriIn.pvReport,
this->hriIn.cbReport, &this->o, CHid_DummyCompletion))
{
do
{
SleepEx( INFINITE, TRUE);
} while(!HasOverlappedIoCompleted(&this->o));
if(this->hriIn.cbReport == this->o.InternalHigh)
{
NTSTATUS stat;
CopyMemory(this->pvStage, this->pvPhys, this->cbPhys);
stat = CHid_ParseData(this, HidP_Input, &this->hriIn);
if(SUCCEEDED(stat))
{
CEm_AddState(&this->ed, this->pvStage, GetTickCount());
this->pvi->fl &= ~VIFL_UNPLUGGED;
hres = S_OK;
} else
{
RPF( "CHid_ParseData failed in Poll, status = 0x%08x", stat );
hres = stat;
}
}
}
if( FAILED(hres) )
{
/*
* Note, we have not broken the read loop so there is no need to
* force the device unaquired (though dinput.dll does).
*
* If this causes problems revert to the old behavior.
* CEm_ForceDeviceUnacquire(pemFromPvi(this->pvi)->ped, 0x0);
*/
hres = DIERR_UNPLUGGED;
this->pvi->fl |= VIFL_UNPLUGGED;
}
}
if( this->hriFea.cbReport )
{
UINT uReport;
/*
* We should never get here unless there really are any
* features that need to be polled.
*/
AssertF(this->hriFea.cbReport);
AssertF(this->hriFea.pvReport);
/*
* Read the new features and parse/process them.
*
* Notice that we read the features into the same buffer
* that we log them into. That's okay; the "live" parts
* of the two buffers never actually overlap.
*/
for( uReport = 0x0; uReport < this->wMaxReportId[HidP_Feature]; uReport++ )
{
if( *(this->pEnableReportId[HidP_Feature] + uReport ) == TRUE )
{
*((UCHAR*)(this->hriFea.pvReport)) = (UCHAR)uReport;
/*
* Wipe out all the old goo because we're taking over.
*/
CHid_ResetDeviceData(this, &this->hriFea, HidP_Feature);
if(HidD_GetFeature(this->hdev, this->hriFea.pvReport,
this->hriFea.cbReport))
{
NTSTATUS stat;
stat = CHid_ParseData(this, HidP_Feature, &this->hriFea);
AssertF(SUCCEEDED(stat));
if(SUCCEEDED(stat))
{
CEm_AddState(&this->ed, this->pvStage, GetTickCount());
}
hres = stat;
} else
{
RPF("CHid_Poll: Unable to read HID features (ReportID%d) LastError(0x%x)", uReport, GetLastError() );
hres = hresLe(GetLastError());
}
}
}
}
ExitOleProcR();
return hres;
}
/*****************************************************************************
*
* CHid_New (constructor)
*
* Fail the create if we can't open the device.
*
*****************************************************************************/
STDMETHODIMP
CHid_New(PUNK punkOuter, REFGUID rguid, RIID riid, PPV ppvObj)
{
HRESULT hres;
EnterProcI(IDirectInputDeviceCallback::Hid::<constructor>,
(_ "Gp", riid, ppvObj));
hres = Common_NewRiid(CHid, punkOuter, riid, ppvObj);
if(SUCCEEDED(hres))
{
/* Must use _thisPv in case of aggregation */
PCHID this = _thisPv(*ppvObj);
if(SUCCEEDED(hres = CHid_Init(this, rguid)))
{
} else
{
Invoke_Release(ppvObj);
}
}
ExitOleProcPpvR(ppvObj);
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CHid | SetDIData |
*
* Set DirectInput version and apphack data from CDIDev *.
*
* @parm DWORD | dwVer |
*
* DirectInput version
*
* @parm LPVOID | lpdihacks |
*
* AppHack data
*
* @returns
*
* <c E_NOTIMPL> because we don't support usages.
*
*****************************************************************************/
STDMETHODIMP
CHid_SetDIData(PDICB pdcb, DWORD dwVer, LPVOID lpdihacks)
{
HRESULT hres;
PCHID this;
EnterProcI(IDirectInputDeviceCallback::Hid::SetDIData,
(_ "pup", pdcb, dwVer, lpdihacks));
/*
* This is an internal interface, so we can skimp on validation.
*/
this = _thisPvNm(pdcb, dcb);
this->dwVersion = dwVer;
CopyMemory(&this->diHacks, (LPDIAPPHACKS)lpdihacks, sizeof(this->diHacks));
hres = S_OK;
ExitOleProcR();
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CHid | BuildDefaultActionMap |
*
* Generate default mappings for the objects on this device.
*
* @parm LPDIACTIONFORMATW | pActionFormat |
*
* Actions to map.
*
* @parm DWORD | dwFlags |
*
* Flags used to indicate mapping preferences.
*
* @parm REFGUID | guidInst |
*
* Device instance GUID.
*
* @returns
*
* <c E_NOTIMPL>
*
*****************************************************************************/
STDMETHODIMP
CHid_BuildDefaultActionMap
(
PDICB pdcb,
LPDIACTIONFORMATW paf,
DWORD dwFlags,
REFGUID guidInst
)
{
HRESULT hres;
PCHID this;
DWORD dwPhysicalGenre;
/*
* This is an internal interface, so we can skimp on validation.
*/
EnterProcI(IDirectInputDeviceCallback::Hid::BuildDefaultActionMap,
(_ "ppxG", pdcb, paf, dwFlags, guidInst));
this = _thisPvNm(pdcb, dcb);
switch( GET_DIDEVICE_TYPE( this->dwDevType ) )
{
case DI8DEVTYPE_DEVICE:
hres = S_FALSE;
goto ExitBuildDefaultActionMap;
case DI8DEVTYPE_MOUSE:
dwPhysicalGenre = DIPHYSICAL_MOUSE;
break;
case DI8DEVTYPE_KEYBOARD:
dwPhysicalGenre = DIPHYSICAL_KEYBOARD;
break;
default:
dwPhysicalGenre = 0;
break;
}
if( dwPhysicalGenre )
{
hres = CMap_BuildDefaultSysActionMap( paf, dwFlags, dwPhysicalGenre,
guidInst, &this->df, 0 /* HID mice buttons start at instance zero */ );
}
else
{
PDIDOBJDEFSEM rgObjSem;
if( SUCCEEDED( hres = AllocCbPpv(cbCxX(
(this->dwAxes + this->dwPOVs + this->dwButtons ), DIDOBJDEFSEM),
&rgObjSem) ) )
{
PDIDOBJDEFSEM pAxis;
PDIDOBJDEFSEM pPOV;
PDIDOBJDEFSEM pButton;
BYTE rgbIndex[DISEM_FLAGS_GET(DISEM_FLAGS_S)];
UINT ObjIdx;
pAxis = rgObjSem;
pPOV = &pAxis[this->dwAxes];
pButton = &pPOV[this->dwPOVs];
ZeroMemory( rgbIndex, cbX(rgbIndex) );
for( ObjIdx = 0; ObjIdx < this->df.dwNumObjs; ObjIdx++ )
{
if( this->df.rgodf[ObjIdx].dwType & DIDFT_NODATA )
{
continue;
}
if( this->df.rgodf[ObjIdx].dwType & DIDFT_AXIS )
{
PHIDGROUPCAPS pcaps;
pcaps = this->rghoc[ObjIdx].pcaps;
pAxis->dwID = this->df.rgodf[ObjIdx].dwType;
if( this->rgbaxissemflags[DIDFT_GETINSTANCE( pAxis->dwID )] )
{
pAxis->dwSemantic = DISEM_TYPE_AXIS | DISEM_FLAGS_SET ( this->rgbaxissemflags[DIDFT_GETINSTANCE( pAxis->dwID )] );
/*
* The index is zero so that a real index can be ORed in.
* Also, assert that the rgbIndex is big enough and
* that subtracting 1 won't give a negative index!
*/
AssertF( DISEM_INDEX_GET(pAxis->dwSemantic) == 0 );
AssertF( DISEM_FLAGS_GET(pAxis->dwSemantic) > 0 );
AssertF( DISEM_FLAGS_GET(pAxis->dwSemantic) <= DISEM_FLAGS_GET(DISEM_FLAGS_S) );
CAssertF( DISEM_FLAGS_GET(DISEM_FLAGS_X) == 1 );
pAxis->dwSemantic |= DISEM_INDEX_SET( rgbIndex[DISEM_FLAGS_GET(pAxis->dwSemantic)-1]++ );
}
else
{
/*
* If the axis has no semantic flags, it is
* unrecognized so short cut the above to produce
* a plain axis that can be matched only with "ANY".
*/
pAxis->dwSemantic = DISEM_TYPE_AXIS;
}
if( !pcaps->IsAbsolute )
{
pAxis->dwSemantic |= DIAXIS_RELATIVE;
}
pAxis++;
}
else if( this->df.rgodf[ObjIdx].dwType & DIDFT_POV )
{
pPOV->dwID = this->df.rgodf[ObjIdx].dwType;
pPOV->dwSemantic = DISEM_TYPE_POV;
pPOV++;
}
else if( this->df.rgodf[ObjIdx].dwType & DIDFT_BUTTON )
{
pButton->dwID = this->df.rgodf[ObjIdx].dwType;
pButton->dwSemantic = DISEM_TYPE_BUTTON;
pButton++;
}
}
AssertF( pAxis == &rgObjSem[this->dwAxes] );
AssertF( pPOV == &rgObjSem[this->dwAxes + this->dwPOVs] );
AssertF( pButton == &rgObjSem[this->dwAxes + this->dwPOVs + this->dwButtons] );
hres = CMap_BuildDefaultDevActionMap( paf, dwFlags, guidInst, rgObjSem,
this->dwAxes, this->dwPOVs, this->dwButtons );
FreePv( rgObjSem );
}
}
ExitBuildDefaultActionMap:;
ExitOleProcR();
return hres;
}
/*****************************************************************************
*
* The long-awaited vtbls and templates
*
*****************************************************************************/
#pragma BEGIN_CONST_DATA
#define CHid_Signature 0x20444948 /* "HID " */
Primary_Interface_Begin(CHid, IDirectInputDeviceCallback)
CHid_GetInstance,
CDefDcb_GetVersions,
CHid_GetDataFormat,
CHid_GetObjectInfo,
CHid_GetCapabilities,
CHid_Acquire,
CHid_Unacquire,
CHid_GetDeviceState,
CHid_GetDeviceInfo,
CHid_GetProperty,
CHid_SetProperty,
CDefDcb_SetEventNotification,
#ifdef WINNT
CHid_SetCooperativeLevel,
#else
CDefDcb_SetCooperativeLevel,
#endif
CHid_RunControlPanel,
CDefDcb_CookDeviceData,
CHid_CreateEffect,
CHid_GetFFConfigKey,
CHid_SendDeviceData,
CHid_Poll,
CHid_GetUsage,
CHid_MapUsage,
CHid_SetDIData,
CHid_BuildDefaultActionMap,
Primary_Interface_End(CHid, IDirectInputDeviceCallback)
Reference in a new issue Copy permalink