Microsoft/Windows2003-3790
Microsoft/Windows2003-3790
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
50969b0ea2
Windows2003-3790/multimedia/directx/dinput/dx8/dll/didevdf.c
Microsoft 50969b0ea2 First commit
2020-09-30 16:53:55 +02:00

6339 lines
214 KiB
C
Raw Blame History

/*****************************************************************************
*
* DIDevDf.c
*
* Copyright (c) 1996 - 2000 Microsoft Corporation. All Rights Reserved.
*
* Abstract:
*
* The part of IDirectInputDevice that worries about
* data formats and reading device data.
*
*****************************************************************************/
#include "dinputpr.h"
#include "didev.h"
#undef sqfl
#define sqfl sqflDf
int INTERNAL
CDIDev_OffsetToIobj(PDD this, DWORD dwOfs);
/*****************************************************************************
*
* @doc INTERNAL
*
* @func HRESULT | CDIDev_GetAbsDeviceState |
*
* Get the absolute device state.
*
* @parm OUT LPVOID | pvData |
*
* Application-provided output buffer.
*
*****************************************************************************/
STDMETHODIMP
CDIDev_GetAbsDeviceState(PDD this, LPVOID pvData)
{
return this->pdcb->lpVtbl->GetDeviceState(this->pdcb, pvData);
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @func HRESULT | CDIDev_GetRelDeviceState |
*
* Get the relative device state.
*
* @parm OUT LPVOID | pvData |
*
* Application-provided output buffer.
*
*****************************************************************************/
STDMETHODIMP
CDIDev_GetRelDeviceState(PDD this, LPVOID pvData)
{
HRESULT hres;
hres = this->pdcb->lpVtbl->GetDeviceState(this->pdcb, pvData);
if ( SUCCEEDED(hres) ) {
UINT iaxis;
AssertF(fLimpFF(this->cAxes, this->pvLastBuffer && this->rgdwAxesOfs));
/*
* For each axis, replace the app's buffer with the delta,
* and save the old value.
*/
for ( iaxis = 0; iaxis < this->cAxes; iaxis++ ) {
LONG UNALIGNED *plApp = pvAddPvCb(pvData, this->rgdwAxesOfs[iaxis]);
LONG UNALIGNED *plLast = pvAddPvCb(this->pvLastBuffer,
this->rgdwAxesOfs[iaxis]);
LONG lNew = *plApp;
*plApp -= *plLast;
*plLast = lNew;
}
hres = S_OK;
}
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @func HRESULT | CDIDev_GetDeviceStateSlow |
*
* Obtains data from the DirectInput device the slow way.
*
* Read the data into the private buffer, then copy it
* bit by bit into the application's buffer.
*
* @parm OUT LPVOID | lpvData |
*
* Application-provided output buffer.
*
*****************************************************************************/
STDMETHODIMP
CDIDev_GetDeviceStateSlow(PDD this, LPVOID pvData)
{
HRESULT hres;
EnterProcR(IDirectInputDevice8::GetDeviceStateSlow, (_ "pp", this, pvData));
AssertF(this->diopt == dioptNone);
AssertF(this->pvBuffer);
AssertF(this->pdcb);
hres = this->GetDeviceState(this, this->pvBuffer);
if ( SUCCEEDED(hres) ) {
int iobj;
ZeroMemory(pvData, this->dwDataSize);
for ( iobj = this->df.dwNumObjs; --iobj >= 0; ) {
if ( this->pdix[iobj].dwOfs != 0xFFFFFFFF ) { /* Data was requested */
DWORD UNALIGNED *pdwOut = pvAddPvCb(pvData, this->pdix[iobj].dwOfs);
DWORD UNALIGNED *pdwIn = pvAddPvCb(this->pvBuffer, this->df.rgodf[iobj].dwOfs);
if ( this->df.rgodf[iobj].dwType & DIDFT_DWORDOBJS ) {
*pdwOut = *pdwIn;
} else {
*(LPBYTE)pdwOut = *(LPBYTE)pdwIn;
}
}
}
}
ExitOleProc();
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @func HRESULT | CDIDev_GetDeviceStateMatched |
*
* Obtains data from the DirectInput device in the case
* where the data formats are matched.
*
* Read the data into the private buffer, then block copy it
* into the application's buffer.
*
* @parm OUT LPVOID | lpvData |
*
* Application-provided output buffer.
*
*****************************************************************************/
STDMETHODIMP
CDIDev_GetDeviceStateMatched(PDD this, LPVOID pvData)
{
HRESULT hres;
EnterProcR(IDirectInputDevice8::GetDeviceStateMatched, (_ "pp", this, pvData));
AssertF(this->diopt == dioptMatch);
AssertF(this->pvBuffer);
AssertF(this->pdcb);
hres = this->GetDeviceState(this, this->pvBuffer);
if ( SUCCEEDED(hres) ) {
/*
* To keep keyboard clients happy: Zero out the fore and aft.
* No need to optimize the perfect match case, because that
* gets a different optimization level.
*/
ZeroMemory(pvData, this->dwDataSize);
memcpy(pvAddPvCb(pvData, this->ibDelta + this->ibMin),
pvAddPvCb(this->pvBuffer, this->ibMin), this->cbMatch);
}
ExitOleProc();
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @func HRESULT | CDIDev_GetDeviceStateDirect |
*
* Obtains data from the DirectInput device in the case
* where we can read the data directly into the client buffer.
*
* @parm OUT LPVOID | lpvData |
*
* Application-provided output buffer.
*
*****************************************************************************/
STDMETHODIMP
CDIDev_GetDeviceStateDirect(PDD this, LPVOID pvData)
{
HRESULT hres;
EnterProcR(IDirectInputDevice8::GetDeviceStateDirect, (_ "pp", this, pvData));
AssertF(this->diopt == dioptDirect);
AssertF(!this->pvBuffer);
AssertF(this->pdcb);
/*
* To keep keyboard clients happy: Zero out the fore and aft.
*/
ZeroBuf(pvData, this->dwDataSize);
hres = this->GetDeviceState(this, pvAddPvCb(pvData, this->ibDelta));
ExitOleProc();
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @func HRESULT | CDIDev_GetDeviceStateEqual |
*
* Obtains data from the DirectInput device in the case
* where the two data formats are completely identical.
*
* @parm OUT LPVOID | lpvData |
*
* Application-provided output buffer.
*
*****************************************************************************/
STDMETHODIMP
CDIDev_GetDeviceStateEqual(PDD this, LPVOID pvData)
{
HRESULT hres;
EnterProcR(IEqualInputDevice::GetDeviceStateEqual, (_ "pp", this, pvData));
AssertF(this->diopt == dioptEqual);
AssertF(this->ibDelta == 0);
AssertF(this->dwDataSize == this->df.dwDataSize);
AssertF(!this->pvBuffer);
AssertF(this->pdcb);
/*
* Note that this->ibMin is not necessarily zero if the device
* data format doesn't begin at zero (which keyboards don't).
*/
hres = this->GetDeviceState(this, pvData);
ExitOleProc();
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method BOOL | CDIDev | IsMatchingGUID |
*
* Helper function that checks if a <t GUID> counts as
* a match when parsing the data format.
*
* @parm PCGUID | pguidSrc |
*
* The <t GUID> to check.
*
* @parm PCGUID | pguidDst |
*
* The <t GUID> it should match.
*
* @returns
*
* Nonzero if this counts as a success.
*
*****************************************************************************/
#pragma BEGIN_CONST_DATA
GUID GUID_Null; /* A zero-filled guid */
#pragma END_CONST_DATA
BOOL INLINE
CDIDev_IsMatchingGUID(PDD this, PCGUID pguidSrc, PCGUID pguidDst)
{
UNREFERENCED_PARAMETER( this );
return IsEqualGUID(pguidSrc, &GUID_Null) ||
IsEqualGUID(pguidSrc, pguidDst);
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method BOOL | CDIDev | IsMatchingUsage |
*
* Helper function that checks if a <f DIMAKEUSAGEDWORD>
* counts as a match when parsing the data format.
*
* @parm DWORD | dwUsage |
*
* The <f DIMAKEUSAGEDWORD> to check.
*
* @parm int | iobj |
*
* The index of hte object to check for a match.
*
* @returns
*
* Nonzero if this counts as a success.
*
*****************************************************************************/
BOOL INLINE
CDIDev_IsMatchingUsage(PDD this, DWORD dwUsage, int iobj)
{
AssertF(this->pdcb);
return dwUsage == this->pdcb->lpVtbl->GetUsage(this->pdcb, iobj);
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method int | CDIDev | FindDeviceObjectFormat |
*
* Search the device object format table for the one that
* matches the guid in question.
*
* @parm PCODF | podf |
*
* The object to locate. If the <e DIOBJECTDATAFORMAT.rguid>
* is null, then the field is a wildcard.
*
* If the <e DIOBJECTDATAFORMAT.dwType> specifies
* <c DIDFT_ANYINSTANCE>, then any instance will be accepted.
*
* @parm PDIXLAT | pdix |
*
* The partial translation table so far. This is used to find
* an empty slot in case of wildcards.
*
* @returns
*
* Returns the index of the object that matches, or -1 if
* the object is not supported by the device.
*
* Someday: Should fall back to best match if types don't match.
*
*****************************************************************************/
int INTERNAL
CDIDev_FindDeviceObjectFormat(PDD this, PCODF podf, PDIXLAT pdix)
{
PCODF podfD; /* The format in the device */
UINT iobj;
/*
* We must count upwards, so that first-fit chooses the smallest one.
*/
for ( iobj = 0; iobj < this->df.dwNumObjs; iobj++ ) {
podfD = &this->df.rgodf[iobj];
if (
/*
* Type needs to match.
*
* Note that works for output-only actuators:
* Since you cannot read from an output-only
* actuator, you can't put it in a data format.
*
*/
(podf->dwType & DIDFT_TYPEVALID & podfD->dwType)
/*
* Attributes need to match.
*/
&& fHasAllBitsFlFl(podfD->dwType, podf->dwType & DIDFT_ATTRVALID)
/*
* Slot needs to be empty.
*/
&& pdix[iobj].dwOfs == 0xFFFFFFFF
/*
* "If there is a guid/usage, it must match."
*
* If pguid is NULL, then the match is vacuous.
*
* If DIDOI_GUIDISUSAGE is clear, then pguid points to
* a real GUID. GUID_NULL means "Don't care" and matches
* anything. Otherwise, it must match the actual GUID.
*
* If DIDOI_GUIDISUSAGE is set, then pguid is really
* a DIMAKEUSAGEDWORD of the usage and usage page,
* which we compare against the same in the object.
*/
&& (podf->pguid == 0 ||
((podf->dwFlags & DIDOI_GUIDISUSAGE) ?
CDIDev_IsMatchingUsage(this, (DWORD)(UINT_PTR)podf->pguid, iobj) :
CDIDev_IsMatchingGUID(this, podf->pguid, podfD->pguid)))
/*
* If there is an instance number, it must match.
*/
&& fLimpFF((podf->dwType & DIDFT_ANYINSTANCE) !=
DIDFT_ANYINSTANCE,
fEqualMaskFlFl(DIDFT_ANYINSTANCE,
podf->dwType, podfD->dwType))
/*
* If there is an aspect, it must match.
*
* If the device data format doesn't specify an aspect,
* then that counts as a free match too.
*/
&& fLimpFF((podf->dwFlags & DIDOI_ASPECTMASK) &&
(podfD->dwFlags & DIDOI_ASPECTMASK),
fEqualMaskFlFl(DIDOI_ASPECTMASK,
podf->dwFlags, podfD->dwFlags))
) { /* Criterion matches, woo-hoo */
return iobj;
}
}
return -1;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CDIDev | ParseDataFormat |
*
* Parse the data format passed by the application and
* convert it into a format that we can use to translate
* the device data into application data.
*
* @parm IN LPDIDATAFORMAT | lpdf |
*
* Points to a structure that describes the format of the data
* the DirectInputDevice should return.
*
* @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 lpvData> parameter is not a valid pointer.
*
* <c DIERR_ACQUIRED>: Cannot change the data format while the
* device is acquired.
*
*
*****************************************************************************/
STDMETHODIMP
CDIDev_ParseDataFormat(PDD this, const DIDATAFORMAT *lpdf)
{
PDIXLAT pdix;
// Prefix: Whistler 45081
PINT rgiobj = NULL;
HRESULT hres;
DIPROPDWORD dipdw;
VXDDATAFORMAT vdf;
#ifdef DEBUG
EnterProc(CDIDev_ParseDataFormat, (_ "pp", this, lpdf));
#else
EnterProcR(IDirectInputDevice8::SetDataFormat, (_ "pp", this, lpdf));
#endif
/*
* Caller should've nuked the old translation table.
*/
AssertF(this->pdix == 0);
AssertF(this->rgiobj == 0);
AssertF(this->cdwPOV == 0);
vdf.cbData = this->df.dwDataSize;
vdf.pDfOfs = 0;
if ( SUCCEEDED(hres = AllocCbPpv(cbCxX(this->df.dwNumObjs, DIXLAT), &pdix)) &&
SUCCEEDED(hres = AllocCbPpv(cbCdw(this->df.dwDataSize), &vdf.pDfOfs)) &&
SUCCEEDED(hres = AllocCbPpv(cbCdw(lpdf->dwDataSize), &rgiobj)) &&
SUCCEEDED(hres =
ReallocCbPpv(cbCdw(lpdf->dwNumObjs), &this->rgdwPOV)) ) {
UINT iobj;
/*
* Pre-init all the translation tags to -1,
* which means "not in use"
*/
memset(pdix, 0xFF, cbCxX(this->df.dwNumObjs, DIXLAT));
memset(vdf.pDfOfs, 0xFF, cbCdw(this->df.dwDataSize));
memset(rgiobj, 0xFF, cbCdw(lpdf->dwDataSize));
SquirtSqflPtszV(sqflDf | sqflVerbose, TEXT("Begin parse data format"));
for ( iobj = 0; iobj < lpdf->dwNumObjs; iobj++ ) {
PCODF podf = &lpdf->rgodf[iobj];
SquirtSqflPtszV(sqflDf | sqflVerbose, TEXT("Object %2d: offset %08x"),
iobj, podf->dwOfs);
/*
* Note that the podf->dwOfs < lpdf->dwDataSize test is safe
* even for DWORD objects, since we also check that both
* values are DWORD multiples.
*/
if ( ((podf->dwFlags & DIDOI_GUIDISUSAGE) ||
fLimpFF(podf->pguid,
SUCCEEDED(hres = hresFullValidGuid(podf->pguid, 1)))) &&
podf->dwOfs < lpdf->dwDataSize ) {
int iobjDev = CDIDev_FindDeviceObjectFormat(this, podf, pdix);
if ( iobjDev != -1 ) {
PCODF podfFound = &this->df.rgodf[iobjDev];
if ( podfFound->dwType & DIDFT_DWORDOBJS ) {
if ( (podf->dwOfs & 3) == 0 ) {
} else {
RPF("%s: Dword objects must be aligned", s_szProc);
goto fail;
}
}
pdix[iobjDev].dwOfs = podf->dwOfs;
rgiobj[podf->dwOfs] = iobjDev;
vdf.pDfOfs[podfFound->dwOfs] = iobjDev;
if ( podfFound->dwFlags & DIDOI_POLLED ) {
this->fPolledDataFormat = TRUE;
}
dipdw.diph.dwSize = sizeof(DIPROPDWORD);
dipdw.diph.dwHeaderSize = sizeof(DIPROPHEADER);
dipdw.diph.dwObj = podfFound->dwType;
dipdw.diph.dwHow = DIPH_BYID;
dipdw.dwData = 0x1; // Enable this report ID
hres = CDIDev_RealSetProperty(this, DIPROP_ENABLEREPORTID, &dipdw.diph);
if ( hres == E_NOTIMPL )
{
hres = S_OK;
}
else if( FAILED( hres ) )
{
SquirtSqflPtszV(sqflDf | sqflError,
TEXT("Could not set DIPROP_ENABLEREPORTID for offset %d"),
iobj);
}
} else if ( podf->dwType & DIDFT_OPTIONAL ) {
SquirtSqflPtszV(sqflDf | sqflVerbose,
TEXT("Object %2d: Skipped (optional)"),
iobj);
/*
* We need to remember where the failed POVs live
* so we can neutralize them in GetDeviceState().
*/
if ( podf->dwType & DIDFT_POV ) {
AssertF(this->cdwPOV < lpdf->dwNumObjs);
this->rgdwPOV[this->cdwPOV++] = podf->dwOfs;
}
} else {
RPF("%s: Format not compatible with device", s_szProc);
goto fail;
}
} else {
if ( podf->dwOfs >= lpdf->dwDataSize ) {
RPF("%s: rgodf[%d].dwOfs of 0x%08x out of range in data format",
s_szProc, iobj, podf->dwOfs );
}
fail:;
hres = E_INVALIDARG;
goto done;
}
}
#ifdef DEBUG
/*
* Double-check the lookup tables just to preserve our sanity.
*/
{
UINT dwOfs;
for ( dwOfs = 0; dwOfs < lpdf->dwDataSize; dwOfs++ ) {
if ( rgiobj[dwOfs] >= 0 ) {
AssertF(pdix[rgiobj[dwOfs]].dwOfs == dwOfs);
} else {
AssertF(rgiobj[dwOfs] == -1);
}
}
}
#endif
/*
* Shrink the "failed POV" array to its actual size.
* The shrink "should" always succeed. Note also that
* even if it fails, we're okay; we just waste a little
* memory.
*/
hres = ReallocCbPpv(cbCdw(this->cdwPOV), &this->rgdwPOV);
AssertF(SUCCEEDED(hres));
/*
* If we are using cooked data, then we actually hand the
* device driver a different translation table which
* combines the offset and dwDevType so data cooking can
* happen safely.
*/
vdf.pvi = this->pvi;
if ( fLimpFF(this->pvi,
SUCCEEDED(hres = Hel_SetDataFormat(&vdf))) ) {
this->pdix = pdix;
pdix = 0;
this->rgiobj = rgiobj;
rgiobj = 0;
this->dwDataSize = lpdf->dwDataSize;
hres = S_OK;
} else {
AssertF(FAILED(hres));
}
} else {
/* Out of memory */
}
done:;
FreePpv(&pdix);
FreePpv(&rgiobj);
FreePpv(&vdf.pDfOfs);
ExitOleProc();
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CDIDev | OptimizeDataFormat |
*
* Study the parsed data format to determine whether we can
* used an optimized <mf CDIDev::GetDeviceState> to obtain
* the data more quickly.
*
* The data format is considered optimized if it matches the
* device data format, modulo possible shifting due to insertion
* of bonus fields at the beginning or end, and modulo missing
* fields.
*
* The data format is considered fully-optimized if it
* optimized, and no shifting is necessary, and the structure size
* is exactly the same. This means the buffer can be passed
* straight through to the driver.
*
*
*****************************************************************************/
HRESULT INTERNAL
CDIDev_OptimizeDataFormat(PDD this)
{
int ib;
DWORD ibMax; /* One past highest match point */
DWORD ibMin; /* Lowest match point */
int iobj;
DWORD dwDataSize;
HRESULT hres;
EnterProc(CDIDev_OptimizeDataFormat, (_ "p", this));
ib = (int)0x8000000; /* Not yet known */
ibMin = 0xFFFFFFFF;
ibMax = 0;
for ( iobj = this->df.dwNumObjs; --iobj >= 0; ) {
DWORD ibMaxThis;
if ( this->pdix[iobj].dwOfs != 0xFFFFFFFF ) { /* Data was requested */
int ibExpected = (int)(this->pdix[iobj].dwOfs -
this->df.rgodf[iobj].dwOfs);
if ( fLimpFF(ib != (int)0x8000000, ib == ibExpected) ) {
ib = ibExpected;
} else {
SquirtSqflPtszV(sqfl | sqflMajor,
TEXT("IDirectInputDevice: Optimization level 0, translation needed") );
this->diopt = dioptNone;
this->GetState = CDIDev_GetDeviceStateSlow;
goto done;
}
if ( ibMin > this->df.rgodf[iobj].dwOfs ) {
ibMin = this->df.rgodf[iobj].dwOfs;
}
if ( this->df.rgodf[iobj].dwType & DIDFT_DWORDOBJS ) {
ibMaxThis = this->df.rgodf[iobj].dwOfs + sizeof(DWORD);
} else {
ibMaxThis = this->df.rgodf[iobj].dwOfs + sizeof(BYTE);
}
if ( ibMax < ibMaxThis ) {
ibMax = ibMaxThis;
}
}
}
/*
* Make sure we actually found something.
*/
if ( ib != (int)0x8000000 ) { /* Data format is matched */
AssertF(ibMin < ibMax);
AssertF(ib + (int)ibMin >= 0);
AssertF(ib + ibMax <= this->dwDataSize);
this->ibDelta = ib;
this->ibMin = ibMin;
this->cbMatch = ibMax - ibMin;
if ( ib >= 0 && ib + this->df.dwDataSize <= this->dwDataSize ) {
/* We can go direct */
if ( ib == 0 && this->dwDataSize == this->df.dwDataSize ) {
/* Data formats are equal! */
this->diopt = dioptEqual;
this->GetState = CDIDev_GetDeviceStateEqual;
SquirtSqflPtszV(sqfl | sqflMajor,
TEXT("IDirectInputDevice: Optimization level 3, full speed ahead!") );
} else {
this->diopt = dioptDirect;
this->GetState = CDIDev_GetDeviceStateDirect;
SquirtSqflPtszV(sqfl | sqflMajor,
TEXT("IDirectInputDevice: Optimization level 2, direct access") );
}
} else {
SquirtSqflPtszV(sqfl | sqflMajor,
TEXT("IDirectInputDevice: Optimization level 1, okay") );
this->diopt = dioptMatch;
this->GetState = CDIDev_GetDeviceStateMatched;
}
} else { /* No data in data format! */
RPF("IDirectInputDevice: Null data format; if that's what you want...");
this->diopt = dioptNone;
this->GetState = CDIDev_GetDeviceStateSlow;
}
done:;
if ( this->diopt >= dioptDirect ) { /* Can go direct; don't need buf */
dwDataSize = 0;
} else {
dwDataSize = this->df.dwDataSize;
}
hres = ReallocCbPpv(dwDataSize, &this->pvBuffer);
if ( SUCCEEDED(hres) ) {
AssertF(this->GetState);
} else {
FreePpv(&this->pdix);
D(this->GetState = 0);
}
return hres;
}
/*****************************************************************************
*
* @doc EXTERNAL
*
* @method HRESULT | IDirectInputDevice | SetDataFormat |
*
* Set the data format for the DirectInput device.
*
* The data format must be set before the device can be
* acquired.
*
* It is necessary to set the data format only once.
*
* The data format may not be changed while the device
* is acquired.
*
* If the attempt to set the data format fails, all data
* format information is lost, and a valid data format
* must be set before the device may be acquired.
*
* @cwrap LPDIRECTINPUTDEVICE | lpDirectInputDevice
*
* @parm IN LPDIDATAFORMAT | lpdf |
*
* Points to a structure that describes the format of the data
* the DirectInputDevice should return.
*
* @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 lpvData> parameter is not a valid pointer.
*
* <c DIERR_ACQUIRED>: Cannot change the data format while the
* device is acquired.
*
*
*****************************************************************************/
HRESULT INLINE
CDIDev_SetDataFormat_IsValidDataSize(LPCDIDATAFORMAT lpdf)
{
HRESULT hres;
if ( lpdf->dwDataSize % 4 == 0 ) {
hres = S_OK;
} else {
RPF("IDirectInputDevice::SetDataFormat: "
"dwDataSize must be a multiple of 4");
hres = E_INVALIDARG;
}
return hres;
}
HRESULT INLINE
CDIDev_SetDataFormat_IsValidObjectSize(LPCDIDATAFORMAT lpdf)
{
HRESULT hres;
if ( lpdf->dwObjSize == cbX(ODF) ) {
hres = S_OK;
} else {
RPF("IDirectInputDevice::SetDataFormat: Invalid dwObjSize");
hres = E_INVALIDARG;
}
return hres;
}
STDMETHODIMP
CDIDev_SetDataFormat(PV pdd, LPCDIDATAFORMAT lpdf _THAT)
{
HRESULT hres;
EnterProcR(IDirectInputDevice8::SetDataFormat, (_ "pp", pdd, lpdf));
if ( SUCCEEDED(hres = hresPvT(pdd)) &&
SUCCEEDED(hres = hresFullValidReadPxCb(lpdf, DIDATAFORMAT, 1)) &&
SUCCEEDED(hres = hresFullValidFl(lpdf->dwFlags, DIDF_VALID, 1)) &&
SUCCEEDED(hres = CDIDev_SetDataFormat_IsValidDataSize(lpdf)) &&
SUCCEEDED(hres = CDIDev_SetDataFormat_IsValidObjectSize(lpdf)) &&
SUCCEEDED(hres = hresFullValidReadPvCb(lpdf->rgodf,
cbCxX(lpdf->dwNumObjs, ODF), 1)) ) {
PDD this = _thisPv(pdd);
/*
* Must protect with the critical section to prevent two people
* from changing the format simultaneously, or one person from
* changing the data format while somebody else is reading data.
*/
CDIDev_EnterCrit(this);
AssertF( this->dwVersion );
if ( !this->fAcquired ) {
DIPROPDWORD dipdw;
/*
* Nuke the old data format stuff before proceeding.
*/
FreePpv(&this->pdix);
FreePpv(&this->rgiobj);
this->cdwPOV = 0;
D(this->GetState = 0);
this->fPolledDataFormat = FALSE;
/*
* Wipe out the report IDs
*/
dipdw.diph.dwSize = sizeof(DIPROPDWORD);
dipdw.diph.dwHeaderSize = sizeof(DIPROPHEADER);
dipdw.diph.dwObj = 0x0;
dipdw.diph.dwHow = DIPH_DEVICE;
dipdw.dwData = 0; // Nuke all knowledge of reportId's
hres = CDIDev_RealSetProperty(this, DIPROP_ENABLEREPORTID, &dipdw.diph);
if ( SUCCEEDED(hres) || hres == E_NOTIMPL )
{
hres = CDIDev_ParseDataFormat(this, lpdf);
if ( SUCCEEDED(hres) ) {
hres = CDIDev_OptimizeDataFormat(this);
/*
* Now set the axis mode, as a convenience.
*/
CAssertF(DIDF_VALID == (DIDF_RELAXIS | DIDF_ABSAXIS));
switch ( lpdf->dwFlags ) {
case 0:
hres = S_OK;
goto axisdone;
case DIDF_RELAXIS:
dipdw.dwData = DIPROPAXISMODE_REL;
break;
case DIDF_ABSAXIS:
dipdw.dwData = DIPROPAXISMODE_ABS;
break;
default:
RPF("%s: Cannot combine DIDF_RELAXIS with DIDF_ABSAXIS",
s_szProc);
hres = E_INVALIDARG;
goto axisdone;
}
dipdw.diph.dwSize = sizeof(DIPROPDWORD);
dipdw.diph.dwHeaderSize = sizeof(DIPROPHEADER);
dipdw.diph.dwObj = 0;
dipdw.diph.dwHow = DIPH_DEVICE;
hres = CDIDev_RealSetProperty(this, DIPROP_AXISMODE, &dipdw.diph);
if ( SUCCEEDED(hres) ) {
hres = S_OK;
}
}
} else
{
SquirtSqflPtszV(sqflDf,
TEXT("Could not set DIPROP_ENABLEREPORTID to 0x0"));
}
axisdone:;
} else { /* Already acquired */
hres = DIERR_ACQUIRED;
}
CDIDev_LeaveCrit(this);
}
ExitOleProcR();
return hres;
}
#define BEGIN_CONST_DATA data_seg(".text", "CODE")
BYTE c_SemTypeToDFType[8] = { 0, 0,
DIDFT_GETTYPE(DIDFT_ABSAXIS), DIDFT_GETTYPE(DIDFT_RELAXIS),
DIDFT_GETTYPE(DIDFT_BUTTON), 0,
DIDFT_GETTYPE(DIDFT_POV), 0 };
#define END_CONST_DATA data_seg(".data", "DATA")
/*****************************************************************************
*
* @doc INTERNAL
*
* @struct DEVICETOUSER |
*
* Structure to hold a device to user assignment.
*
* @field GUID | guidDevice |
*
* The device.
*
* @field WCHAR | wszOwner[MAX_PATH] |
*
* Name of the user who currently owns the device.
*
*****************************************************************************/
typedef struct _DEVICETOUSER
{
GUID guidDevice;
WCHAR wszOwner[MAX_PATH];
} DEVICETOUSER, *PDEVICETOUSER;
#define DELTA_DTO_COUNT 4
// ISSUE-2001/03/29-MarcAnd CMap usage is inconsistant
// CMap code should be split out into separate source file
/*****************************************************************************
*
* @doc INTERNAL
*
* @func HRESULT | CMap_SetDeviceUserName |
*
* Set the passed device to be associated with the passed user name.
* If the device is already associated with a user or with no user
* that association is replaced with the new one. If the device is
* not yet in the array, it is added. Memory is allocated as
* necessary to increase the array size.
*
* @parm REFGUID | guidDevInst |
*
* A pointer to the device instance GUID to be added/modified.
*
* @parm LPCWSTR | wszOwner |
*
* A UNICODE user name.
*
* @returns
*
* <c S_OK> if the name was set
* <c DI_NOEFFECT> if nothing was set because nothing needed to be
* A memory allocation error if such occured.
*
*****************************************************************************/
HRESULT CMap_SetDeviceUserName
(
REFGUID guidDevInst,
LPCWSTR wszOwner
)
{
HRESULT hres = S_OK;
PDEVICETOUSER pdto;
CAssertF( DELTA_DTO_COUNT > 1 );
AssertF( !IsEqualGUID( guidDevInst, &GUID_Null ) );
AssertF( !InCrit() );
DllEnterCrit();
/*
* Note g_pdto will be NULL until the first name is set
* however, g_cdtoMax will be zero so this loop should
* fall through to allocate more memory.
*/
for( pdto = g_pdto; pdto < &g_pdto[ g_cdtoMax ]; pdto++ )
{
if( IsEqualGUID( guidDevInst, &pdto->guidDevice ) )
{
break;
}
}
if( !wszOwner )
{
if( pdto < &g_pdto[ g_cdtoMax ] )
{
ZeroMemory( &pdto->guidDevice, cbX( pdto->guidDevice ) );
g_cdto--;
AssertF( g_cdto >= 0 );
}
else
{
/*
* Could not find device, since we were removing, don't worry
*/
hres = DI_NOEFFECT;
}
}
else
{
if( pdto >= &g_pdto[ g_cdtoMax ] )
{
/*
* Need to add a new entry
*/
if( g_cdto == g_cdtoMax )
{
/*
* If all entries are used try to get more
*/
hres = ReallocCbPpv( ( g_cdtoMax + DELTA_DTO_COUNT ) * cbX( *g_pdto ), &g_pdto );
if( FAILED( hres ) )
{
goto exit_SetDeviceUserName;
}
g_cdtoMax += DELTA_DTO_COUNT;
/*
* The first new element is sure to be free
*/
pdto = &g_pdto[ g_cdto ];
}
else
{
/*
* There's an empty one in the array somewhere
*/
for( pdto = g_pdto; pdto < &g_pdto[ g_cdtoMax ]; pdto++ )
{
if( IsEqualGUID( &GUID_Null, &pdto->guidDevice ) )
{
break;
}
}
}
pdto->guidDevice = *guidDevInst;
}
g_cdto++;
AssertF( pdto < &g_pdto[ g_cdtoMax ] );
AssertF( lstrlenW( wszOwner ) < cbX( pdto->wszOwner ) );
#ifdef WINNT
lstrcpyW( pdto->wszOwner, wszOwner );
#else
memcpy( pdto->wszOwner, wszOwner, ( 1 + lstrlenW( wszOwner ) ) * cbX( *wszOwner ) );
#endif
}
exit_SetDeviceUserName:;
DllLeaveCrit();
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @func HRESULT | CMap_IsNewDeviceUserName |
*
* Searches the array of device to user associations for the passed
* device GUID. If the device GUID is matched the name is tested
* to see if it is the same as the passed name.
*
* @parm REFGUID | guidDevInst |
*
* A pointer to the device instance GUID to be tested.
*
* @parm LPCWSTR | wszOwner |
*
* A UNICODE user name to be tested.
*
* @returns
*
* <c FALSE> if a the device was found and the user matches
* <c TRUE> if not
*
*****************************************************************************/
HRESULT CMap_IsNewDeviceUserName
(
REFGUID guidDevInst,
LPWSTR wszTest
)
{
BOOL fres = TRUE;
PDEVICETOUSER pdto;
AssertF( !IsEqualGUID( guidDevInst, &GUID_Null ) );
AssertF( wszTest != L'\0' );
AssertF( !InCrit() );
DllEnterCrit();
if( g_pdto )
{
for( pdto = g_pdto; pdto < &g_pdto[ g_cdtoMax ]; pdto++ )
{
if( IsEqualGUID( guidDevInst, &pdto->guidDevice ) )
{
#ifdef WINNT
if( !lstrcmpW( wszTest, pdto->wszOwner ) )
#else
if( ( pdto->wszOwner[0] != L'\0' )
&&( !memcmp( wszTest, pdto->wszOwner,
lstrlenW( wszTest ) * cbX( *wszTest ) ) ) )
#endif
{
fres = FALSE;
}
break;
}
}
}
DllLeaveCrit();
return fres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @func HRESULT | CMap_GetDeviceUserName |
*
* Searches the array of device to user associations for the passed
* device GUID. If the device GUID is matched and has an associated
* user name, that is copied into wszOwner. If the GUID is not
* matched or the match has a NULL string associated with it,
* wszOwner is set to a NULL string.
*
* @parm REFGUID | guidDevInst |
*
* A pointer to the device instance GUID to be added/modified.
*
* @parm LPCWSTR | wszOwner |
*
* A UNICODE user name.
*
* @returns
*
* <c S_OK> if a user name has been copied into wszOwner
* <c DI_NOEFFECT> if wszOwner has been set to a NULL string
*
*****************************************************************************/
HRESULT CMap_GetDeviceUserName
(
REFGUID guidDevInst,
LPWSTR wszOwner
)
{
HRESULT hres = DI_NOEFFECT;
PDEVICETOUSER pdto;
AssertF( !IsEqualGUID( guidDevInst, &GUID_Null ) );
AssertF( !InCrit() );
/*
* Assume nothing is found
*/
wszOwner[0] = L'\0';
DllEnterCrit();
if( g_pdto )
{
for( pdto = g_pdto; pdto < &g_pdto[ g_cdtoMax ]; pdto++ )
{
if( IsEqualGUID( guidDevInst, &pdto->guidDevice ) )
{
if( pdto->wszOwner[0] != L'\0' )
{
#ifdef WINNT
lstrcpyW( wszOwner, pdto->wszOwner );
#else
memcpy( wszOwner, pdto->wszOwner,
( 1 + lstrlenW( pdto->wszOwner ) ) * cbX( *wszOwner ) );
#endif
hres = S_OK;
}
break;
}
}
}
DllLeaveCrit();
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CMap | ValidateActionMapSemantics |
*
* Validate the semantics in an action map for overall sanity.
*
* @parm LPDIACTIONFORMATW | pActionFormat |
*
* Actions to map.
*
* @parm DWORD | dwFlags |
*
* Flags to modify the validation behavior.
* Currently these are the <c DIDBAM_*> flags as the only
* <mf IDirectInputDevice::SetActionMap> flag is the default
* <c DIDSAM_DEFAULT>.
*
* @returns
*
* <c DI_OK> = <c S_OK>: The operation completed successfully.
*
*
*****************************************************************************/
int __stdcall CompareActions
(
PV pv1,
PV pv2
)
{
int iRes;
LPDIACTION pAct1 = (LPDIACTION)pv1;
LPDIACTION pAct2 = (LPDIACTION)pv2;
iRes = memcmp( &pAct1->guidInstance, &pAct2->guidInstance, cbX(pAct1->guidInstance) );
if( !iRes )
{
if( pAct1->dwFlags & DIA_APPMAPPED )
{
if( pAct2->dwFlags & DIA_APPMAPPED )
{
iRes = pAct1->dwObjID - pAct2->dwObjID;
}
else
{
iRes = -1;
}
}
else
{
if( pAct2->dwFlags & DIA_APPMAPPED )
{
iRes = 1;
}
else
{
iRes = pAct1->dwSemantic - pAct2->dwSemantic;
}
}
}
return iRes;
}
STDMETHODIMP
CMap_ValidateActionMapSemantics
(
LPDIACTIONFORMATW paf,
DWORD dwFlags
)
{
HRESULT hres;
LPDIACTIONW pAction;
LPDIACTIONW *pWorkSpace;
LPDIACTIONW *pCurr;
LPDIACTIONW *pLast;
EnterProcI(IDirectInputDeviceCallback::CMap::ValidateActionMapSemantics,
(_ "px", paf, dwFlags ));
/*
* Create a pointer array to the actions, sort it then look for duplicates
*/
if( SUCCEEDED( hres = AllocCbPpv( cbCxX(paf->dwNumActions,PV), &pWorkSpace) ) )
{
/*
* Fill work space from action array discarding unmappable elements
*/
pCurr = pWorkSpace;
for( pAction = paf->rgoAction; pAction < &paf->rgoAction[paf->dwNumActions]; pAction++ )
{
if( dwFlags & ( DIDBAM_INITIALIZE | DIDBAM_HWDEFAULTS ) )
{
pAction->dwFlags = 0;
pAction->guidInstance = GUID_Null;
pAction->dwHow = 0;
}
else
{
if( pAction->dwFlags & ~DIA_VALID )
{
RPF( "ERROR Invalid action: rgoAction[%d].dwFlags 0x%08x",
pAction - paf->rgoAction, pAction->dwFlags & ~DIA_VALID );
pAction->dwHow = DIAH_ERROR;
hres = DIERR_INVALIDPARAM;
goto free_and_exit;
}
if( pAction->dwFlags & DIA_APPNOMAP )
{
continue;
}
if( dwFlags & DIDBAM_PRESERVE )
{
switch( pAction->dwHow )
{
case DIAH_UNMAPPED:
break;
case DIAH_USERCONFIG:
case DIAH_APPREQUESTED:
case DIAH_HWAPP:
case DIAH_HWDEFAULT:
case DIAH_OTHERAPP:
case DIAH_DEFAULT:
if( IsEqualGUID( &pAction->guidInstance, &GUID_Null ) )
{
RPF("ERROR Invalid action: rgoAction[%d].dwHow is mapped as 0x%08x but has no device",
pAction - paf->rgoAction, pAction->dwHow );
hres = DIERR_INVALIDPARAM;
goto free_and_exit;
}
break;
case DIAH_ERROR:
RPF("ERROR Invalid action: rgoAction[%d].dwHow has DIAH_ERROR",
pAction - paf->rgoAction );
hres = DIERR_INVALIDPARAM;
goto free_and_exit;
default:
if( pAction->dwHow & ~DIAH_VALID )
{
RPF("ERROR Invalid action: rgoAction[%d].dwHow has invalid flags 0x%08x",
pAction - paf->rgoAction, pAction->dwHow & ~DIAH_VALID );
}
else
{
RPF("ERROR Invalid action: rgoAction[%d].dwHow has invalid combination of map flags 0x%08x",
pAction - paf->rgoAction, pAction->dwHow & ~DIAH_VALID );
}
pAction->dwHow = DIAH_ERROR;
hres = DIERR_INVALIDPARAM;
goto free_and_exit;
}
}
else
{
if(!( pAction->dwFlags & DIA_APPMAPPED ) )
{
pAction->guidInstance = GUID_Null;
}
pAction->dwHow = 0;
}
}
if( ( pAction->dwSemantic ^ paf->dwGenre ) & DISEM_GENRE_MASK )
{
switch( DISEM_GENRE_GET( pAction->dwSemantic ) )
{
case DISEM_GENRE_GET( DIPHYSICAL_KEYBOARD ):
case DISEM_GENRE_GET( DIPHYSICAL_MOUSE ):
case DISEM_GENRE_GET( DIPHYSICAL_VOICE ):
case DISEM_GENRE_GET( DISEMGENRE_ANY ):
break;
default:
RPF("ERROR Invalid action: rgoAction[%d].dwSemantic 0x%08x for genre 0x%08x",
pAction - paf->rgoAction, pAction->dwSemantic, paf->dwGenre );
pAction->dwHow = DIAH_ERROR;
hres = DIERR_INVALIDPARAM;
goto free_and_exit;
}
}
/*
* Note, the SEM_FLAGS are not tested, this is only to save time
* as nothing depends upon their value. This could be added.
* Semantic index 0xFF used to mean ANY so don't allow it any more
*/
if(!( pAction->dwFlags & DIA_APPMAPPED )
&& ( ( pAction->dwSemantic & ~DISEM_VALID )
|| ( DISEM_INDEX_GET( pAction->dwSemantic ) == 0xFF )
||!c_SemTypeToDFType[ DISEM_TYPEANDMODE_GET( pAction->dwSemantic ) ] ) )
{
RPF("ERROR Invalid action: rgoAction[%d].dwSemantic 0x%08x is invalid",
pAction - paf->rgoAction, pAction->dwSemantic );
pAction->dwHow = DIAH_ERROR;
hres = DIERR_INVALIDPARAM;
goto free_and_exit;
}
*pCurr = pAction;
pCurr++;
}
if( pCurr == pWorkSpace )
{
SquirtSqflPtszV(sqflDf | sqflBenign,
TEXT("Action map contains no mappable actions") );
hres = S_FALSE;
}
else
{
hres = S_OK;
pLast = pCurr - 1;
ptrPartialQSort( (PV)pWorkSpace, (PV)pLast, &CompareActions );
ptrInsertSort( (PV)pWorkSpace, (PV)pLast, &CompareActions );
/*
* Now we have an ordered list, see there are duplicate actions.
*/
for( pCurr = pWorkSpace + 1; pCurr <= pLast; pCurr++ )
{
if( !CompareActions( *(pCurr-1), *pCurr )
&& !( (*pCurr)->dwFlags & DIA_APPMAPPED ) )
{
RPF( "ERROR Invalid DIACTIONFORMAT: rgoAction contains duplicates" );
hres = DIERR_INVALIDPARAM;
#ifndef XDEBUG
/*
* In retail, any bad is bad. In debug report how bad.
*/
break;
#else
SquirtSqflPtszV(sqflDf | sqflError,
TEXT("Actions %d and %d are the same"),
*(pCurr-1) - paf->rgoAction, *pCurr - paf->rgoAction );
#endif
}
}
}
free_and_exit:;
FreePv( pWorkSpace );
}
ExitOleProcR();
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @func HRESULT | CMap_TestSysObject |
*
* Test the passed object to see if it is a reasonable thing to exist
* on a mouse or keyboard depending on the physical genre.
*
* @parm DWORD | dwPhysicalGenre |
*
* Mouse, keyboard or voice as DIPHYSICAL_*
*
* @parm DWORD | dwObject |
*
* The object in question
*
* @returns
*
* <c S_OK> if the object could be expected on the class of device
* or <c DIERR_INVALIDPARAM> if not
*
*****************************************************************************/
HRESULT CMap_TestSysObject
(
DWORD dwPhysicalGenre,
DWORD dwObject
)
{
HRESULT hres = S_OK;
if( dwPhysicalGenre == DIPHYSICAL_KEYBOARD )
{
/*
* Anything but a button with an 8 bit offset is invalid.
*/
if( ( dwObject & DIDFT_BUTTON )
&& ( ( DIDFT_GETINSTANCE( dwObject ) & 0xFF00 ) == 0 ) )
{
SquirtSqflPtszV(sqflDf | sqflBenign,
TEXT("Key 0x%02 not defined on this keyboard (id)"),
dwObject );
}
else
{
SquirtSqflPtszV(sqflDf | sqflError,
TEXT("Object type 0x%08 invalid for keyboard (id)"),
dwObject );
hres = DIERR_INVALIDPARAM;
}
}
else if( dwPhysicalGenre == DIPHYSICAL_MOUSE )
{
/*
* Allow buttons 1 to 8 and axes 1 to 3
*/
if( ( dwObject & DIDFT_PSHBUTTON )
&& ( DIDFT_GETINSTANCE( dwObject ) < 8 ) )
{
SquirtSqflPtszV(sqflDf | sqflBenign,
TEXT("Button %d not defined on this mouse (id)"),
DIDFT_GETINSTANCE( dwObject ) );
}
else if( ( dwObject & DIDFT_AXIS )
&& ( DIDFT_GETINSTANCE( dwObject ) < 3 ) )
{
SquirtSqflPtszV(sqflDf | sqflBenign,
TEXT("Axis %d not defined on this mouse (id)"),
DIDFT_GETINSTANCE( dwObject ) );
}
else
{
SquirtSqflPtszV(sqflDf | sqflError,
TEXT("Bad control object 0x%08x for mouse (id)"),
dwObject );
hres = DIERR_INVALIDPARAM;
}
}
else if( dwPhysicalGenre == DIPHYSICAL_VOICE )
{
if( dwObject & DIDFT_PSHBUTTON )
{
switch( DIDFT_GETINSTANCE( dwObject ) )
{
case DIVOICE_CHANNEL1:
case DIVOICE_CHANNEL2:
case DIVOICE_CHANNEL3:
case DIVOICE_CHANNEL4:
case DIVOICE_CHANNEL5:
case DIVOICE_CHANNEL6:
case DIVOICE_CHANNEL7:
case DIVOICE_CHANNEL8:
case DIVOICE_TEAM:
case DIVOICE_ALL:
case DIVOICE_RECORDMUTE:
case DIVOICE_PLAYBACKMUTE:
case DIVOICE_TRANSMIT:
case DIVOICE_VOICECOMMAND:
SquirtSqflPtszV(sqflDf | sqflBenign,
TEXT("Button %d not defined on this comms device (id)"),
DIDFT_GETINSTANCE( dwObject ) );
break;
default:
SquirtSqflPtszV(sqflDf | sqflError,
TEXT("Bad control object 0x%08x for comms device (id)"),
dwObject );
hres = DIERR_INVALIDPARAM;
}
}
else
{
SquirtSqflPtszV(sqflDf | sqflError,
TEXT("Comms control object 0x%08x not a button (id)"),
dwObject );
hres = DIERR_INVALIDPARAM;
}
}
else
{
AssertF( !"Physical genre not keyboard, mouse or voice (id)" );
}
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @func HRESULT | CMap_TestSysOffset |
*
* Test the passed offset to see if it is a reasonable one for the
* default data format of the physical genre.
*
* @parm DWORD | dwPhysicalGenre |
*
* Mouse, keyboard or voice as DIPHYSICAL_*
*
* @parm DWORD | dwOffset |
*
* The offset in question
*
* @returns
*
* <c S_OK> if the offset could be expected on the class of device
* or <c DIERR_INVALIDPARAM> if not
*
*****************************************************************************/
HRESULT CMap_TestSysOffset
(
DWORD dwPhysicalGenre,
DWORD dwOffset
)
{
HRESULT hres = S_OK;
if( dwPhysicalGenre == DIPHYSICAL_KEYBOARD )
{
/*
* Anything but a button with an 8 bit offset is invalid.
*/
if( dwOffset <= 0xFF )
{
SquirtSqflPtszV(sqflDf | sqflBenign,
TEXT("Key 0x%02 not defined on this keyboard (ofs)"),
dwOffset );
}
else
{
SquirtSqflPtszV(sqflDf | sqflError,
TEXT("Key offset 0x%08 invalid for keyboard (ofs)"),
dwOffset );
hres = DIERR_INVALIDPARAM;
}
}
else if( dwPhysicalGenre == DIPHYSICAL_MOUSE )
{
CAssertF( DIMOFS_X == 0 );
if( dwOffset > DIMOFS_BUTTON7 )
{
SquirtSqflPtszV(sqflDf | sqflError,
TEXT("Bad control offset 0x%08x for mouse (ofs)"),
dwOffset );
hres = DIERR_INVALIDPARAM;
}
else
{
/*
* Allow buttons 1 to 8
*/
if( dwOffset >= DIMOFS_BUTTON0 )
{
SquirtSqflPtszV(sqflDf | sqflBenign,
TEXT("Button %d not defined on this mouse (ofs)"),
dwOffset - DIMOFS_BUTTON0 );
}
else
{
SquirtSqflPtszV(sqflDf | sqflBenign,
TEXT("Axis %d not defined on this mouse (ofs)"),
(dwOffset - DIMOFS_X)>>2 );
}
}
}
else
{
AssertF( !"Physical genre not keyboard, mouse or voice" );
}
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CMap | DeviceValidateActionMap |
*
* Validate an action map for a device.
*
* @parm LPDIACTIONFORMATW | pActionFormat |
*
* Actions to map.
*
* @parm DWORD | dwDevGenre |
*
* Device genre to match or zero for device that are not physical
* devices.
*
* @parm REFGUID | guidInstace |
*
* Instance guid of device to match.
*
* @parm LPCDIDATAFORMAT | dfDev |
*
* Ponter to device data format.
*
* @parm DWORD | dwFlags |
*
* A valid combination of <c DVAM_*> flags to describe optional
* validation behavior.
*
* @returns
*
* <c DI_OK> = <c S_OK>: The operation completed successfully.
*
*
*****************************************************************************/
#define DVAM_DEFAULT 0x00000000
#define DVAM_GETEXACTMAPPINGS 0x00000001
STDMETHODIMP
CMap_DeviceValidateActionMap
(
PV pdd,
LPDIACTIONFORMATW paf,
DWORD dwFlags,
PDWORD pdwOut
)
{
HRESULT hres;
LPDIDATAFORMAT dfDev;
DWORD dwPhysicalGenre;
LPDIACTIONW pAction;
PBYTE pMatch;
UINT idxObj;
BOOL bHasMap = FALSE;
BOOL bNewMap = FALSE;
DWORD dwCommsType = 0;
PDD this;
EnterProcI(IDirectInputDeviceCallback::CMap::DeviceValidateActionMap,
(_ "ppx", pdd, paf, dwFlags));
this = _thisPv(pdd);
/*
* Note, hres is tested before anything is done with dwPhysicalGenre
*/
switch( GET_DIDEVICE_TYPE(this->dc3.dwDevType) )
{
case DI8DEVTYPE_MOUSE:
dwPhysicalGenre = DIPHYSICAL_MOUSE;
break;
case DI8DEVTYPE_KEYBOARD:
dwPhysicalGenre = DIPHYSICAL_KEYBOARD;
break;
case DI8DEVTYPE_DEVICECTRL:
if( ( GET_DIDEVICE_SUBTYPE( this->dc3.dwDevType ) == DI8DEVTYPEDEVICECTRL_COMMSSELECTION_HARDWIRED )
|| ( GET_DIDEVICE_SUBTYPE( this->dc3.dwDevType ) == DI8DEVTYPEDEVICECTRL_COMMSSELECTION ) )
{
dwCommsType = GET_DIDEVICE_SUBTYPE( this->dc3.dwDevType );
dwPhysicalGenre = DIPHYSICAL_VOICE;
}
else
{
dwPhysicalGenre = 0;
}
break;
default:
dwPhysicalGenre = 0;
break;
}
if( SUCCEEDED( hres = this->pdcb->lpVtbl->GetDataFormat(this->pdcb, &dfDev) )
&& SUCCEEDED( hres = AllocCbPpv( dfDev->dwNumObjs, &pMatch) ) )
{
enum eMap
{
eMapTestMatches,
eMapDeviceExact,
eMapClassExact,
eMapEnd
} iMap, ValidationLimit;
/*
* Set the limit on iterations depending on the checks required
*/
ValidationLimit = ( dwFlags & DVAM_GETEXACTMAPPINGS )
? ( dwPhysicalGenre ) ? eMapClassExact : eMapDeviceExact
: eMapTestMatches;
for( iMap = eMapTestMatches; SUCCEEDED( hres ) && ( iMap <= ValidationLimit ); iMap++ )
{
for( pAction = paf->rgoAction;
SUCCEEDED( hres ) && ( pAction < &paf->rgoAction[paf->dwNumActions] );
pAction++ )
{
DWORD dwObject;
if( pAction->dwFlags & DIA_APPNOMAP )
{
continue;
}
/*
* If we are mapping exact matches this time, only care
* about unmapped actions with app mappings.
*/
if( ( iMap != eMapTestMatches )
&& (!( pAction->dwFlags & DIA_APPMAPPED )
|| ( pAction->dwHow & DIAH_MAPMASK ) ) )
{
continue;
}
switch( iMap )
{
case eMapTestMatches:
/*
* These flags have already been validated during semantic
* validation so just assert them on the first iteration.
*/
AssertF( ( pAction->dwHow & ~DIAH_VALID ) == 0 );
AssertF( ( pAction->dwHow & DIAH_ERROR ) == 0 );
AssertF( ( pAction->dwFlags & ~DIA_VALID ) == 0 );
/*
* Only care about pre-existing matches
*/
if( !( pAction->dwHow & DIAH_MAPMASK ) )
{
continue;
}
/*
* Fall through for a GUID match
*/
case eMapDeviceExact:
if( !IsEqualGUID( &pAction->guidInstance, &this->guid ) )
{
continue;
}
break;
case eMapClassExact:
if( ( DISEM_GENRE_GET( pAction->dwSemantic ) != DISEM_GENRE_GET( dwPhysicalGenre ) ) )
{
continue;
}
break;
default:
AssertF( !"Invalid iMap" );
}
if( ( iMap != eMapTestMatches )
&& ( dwCommsType == DI8DEVTYPEDEVICECTRL_COMMSSELECTION_HARDWIRED ) )
{
if( !( pAction->dwHow & DIAH_MAPMASK ) )
{
RPF( "ERROR: rgoAction[%d] is trying to map on a hardwired device", pAction - paf->rgoAction );
hres = DIERR_INVALIDPARAM;
}
else if( pAction->dwFlags & DIA_APPMAPPED )
{
RPF( "ERROR: rgoAction[%d] is trying to app map on a hardwired device", pAction - paf->rgoAction );
hres = DIERR_INVALIDPARAM;
}
}
else
{
dwObject = pAction->dwObjID;
/*
* Now try to find the object.
* Note, we can't rely on the application data format goo
* because a data format has probably not been set.
*/
for( idxObj = 0; idxObj < dfDev->dwNumObjs; idxObj++ )
{
/*
* Ignore FF flags so a FF device can be matched for non-FF
*/
if( ( ( dwObject ^ dfDev->rgodf[idxObj].dwType )
&~( DIDFT_FFACTUATOR | DIDFT_FFEFFECTTRIGGER ) ) == 0 )
{
break;
}
}
if( idxObj < dfDev->dwNumObjs )
{
/*
* Application mapped controls don't need to have
* semantics so we cannot test them.
*/
if( pAction->dwFlags & DIA_APPMAPPED )
{
if( pMatch[idxObj] )
{
RPF( "ERROR: rgoAction[%d] maps to control 0x%08x which is already mapped",
pAction - paf->rgoAction, pAction->dwObjID );
hres = DIERR_INVALIDPARAM;
break;
}
else
{
if(!( pAction->dwFlags & DIA_FORCEFEEDBACK )
|| ( dfDev->rgodf[idxObj].dwType & ( DIDFT_FFACTUATOR | DIDFT_FFEFFECTTRIGGER ) ) )
{
pMatch[idxObj] = TRUE;
SquirtSqflPtszV(sqflDf | sqflVerbose,
TEXT("rgoAction[%d] application mapped to object 0x%08x"),
pAction - paf->rgoAction, dwObject );
bHasMap = TRUE;
if( iMap != eMapTestMatches )
{
bNewMap = TRUE;
pAction->dwHow = DIAH_APPREQUESTED;
pAction->dwObjID = dwObject;
if( iMap == eMapClassExact )
{
pAction->guidInstance = this->guid;
}
}
}
else
{
RPF( "ERROR: rgoAction[%d] need force feedback but object 0x%08x has none",
pAction - paf->rgoAction, dwObject );
hres = DIERR_INVALIDPARAM;
break;
}
}
}
else
{
AssertF( iMap == eMapTestMatches );
/*
* Check the object type matches the semantic
*/
if( ( c_SemTypeToDFType[ DISEM_TYPEANDMODE_GET( pAction->dwSemantic ) ]
& DIDFT_GETTYPE( dwObject ) ) )
{
if( pMatch[idxObj] )
{
RPF( "ERROR: rgoAction[%d] pre-mapped to control 0x%08x which is already mapped",
pAction - paf->rgoAction, pAction->dwObjID );
hres = DIERR_INVALIDPARAM;
break;
}
else
{
pMatch[idxObj] = TRUE;
bHasMap = TRUE;
SquirtSqflPtszV(sqflDf | sqflVerbose,
TEXT("rgoAction[%d] mapping verifed to object 0x%08x"),
pAction - paf->rgoAction, dwObject );
continue;
}
}
else
{
RPF( "ERROR: rgoAction[%d] has object type 0x%08x but semantic type 0x%08x",
pAction - paf->rgoAction, DIDFT_GETTYPE( dwObject ),
c_SemTypeToDFType[ DISEM_TYPEANDMODE_GET( pAction->dwSemantic ) ] );
hres = DIERR_INVALIDPARAM;
break;
}
}
}
else
{
switch( iMap )
{
case eMapTestMatches:
RPF( "ERROR: rgoAction[%d] was mapped (how:0x%08x) to undefined object 0x%08x",
pAction - paf->rgoAction, pAction->dwHow, pAction->dwObjID );
hres = DIERR_INVALIDPARAM;
break;
case eMapDeviceExact:
RPF( "ERROR: rgoAction[%d] has application map to undefined object 0x%08x",
pAction - paf->rgoAction, pAction->dwObjID );
hres = DIERR_INVALIDPARAM;
break;
case eMapClassExact:
/*
* If a device class was specified and no match was
* found it is only an error if the object is
* invalid for the class.
*/
hres = CMap_TestSysObject( dwPhysicalGenre, pAction->dwObjID );
if( FAILED( hres ) )
{
RPF( "ERROR: rgoAction[%d] was mapped to object 0x%08x, not valid for device",
pAction - paf->rgoAction, pAction->dwObjID );
}
else
{
continue; /* Don't break the loop */
}
}
break;
}
}
}
if( FAILED( hres ) )
{
pAction->dwHow = DIAH_ERROR;
AssertF( hres == DIERR_INVALIDPARAM );
break;
}
}
FreePv( pMatch );
}
if( SUCCEEDED( hres ) )
{
AssertF( hres == S_OK );
if( dwCommsType == DI8DEVTYPEDEVICECTRL_COMMSSELECTION_HARDWIRED )
{
hres = DI_WRITEPROTECT;
}
else if(dwFlags == DVAM_DEFAULT)
{
//in default case we want to know if there are ANY mappings
if (!bHasMap)
hres = DI_NOEFFECT;
}
else if(!bNewMap)
{
//in non-default case we are interested in ANY NEW mappings
hres = DI_NOEFFECT;
}
}
*pdwOut = dwCommsType;
ExitOleProcR();
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CMap | BuildDefaultDevActionMap |
*
* Get default action map from the action format non system devices.
*
* @parm LPDIACTIONFORMATW | pActionFormat |
*
* Actions to map.
*
* @parm DWORD | dwFlags |
*
* Flags used to indicate mapping preferences.
*
* @parm REFGUID | guidInstace |
*
* Instance guid of device to match.
*
* @parm PDIDOBJDEFSEM | rgObjSem |
*
* Array of default device object to semantic mappings.
*
* @parm DWORD | dwNumAxes |
*
* Number of axes in the rgObjSem.
*
* @parm DWORD | dwNumPOVs |
*
* Number of POVs in the rgObjSem.
*
* @parm DWORD | dwNumAxes |
*
* Number of buttons in the rgObjSem.
*
* @returns
*
* <c DI_OK> = <c S_OK>: The operation completed successfully.
*
*
*****************************************************************************/
STDMETHODIMP CMap_BuildDefaultDevActionMap
(
LPDIACTIONFORMATW paf,
DWORD dwFlags,
REFGUID guidDevInst,
PDIDOBJDEFSEM rgObjSem,
DWORD dwNumAxes,
DWORD dwNumPOVs,
DWORD dwNumButtons
)
{
#define IS_OBJECT_USED( dwSem ) ( DISEM_RES_GET( dwSem ) )
#define MARK_OBJECT_AS_USED( dwSem ) ( dwSem |= DISEM_RES_SET( 1 ) )
HRESULT hres = S_OK;
BOOL fSomethingMapped = FALSE;
PDIDOBJDEFSEM pSemNextPOV;
PDIDOBJDEFSEM pSemButtons;
LPDIACTIONW pAction;
enum eMap
{
eMapDeviceSemantic,
eMapDeviceCompat,
eMapGenericSemantic,
eMapGenericCompat,
eMapEnd
} iMap;
EnterProcI(IDirectInputDeviceCallback::CMap::BuildDefaultDevActionMap,
(_ "pxGpxxx", paf, dwFlags, guidDevInst,
rgObjSem, dwNumAxes, dwNumPOVs, dwNumButtons ));
pSemNextPOV = &rgObjSem[dwNumAxes];
pSemButtons = &rgObjSem[dwNumAxes+dwNumPOVs];
/*
* Make an initial pass through to mark already mapped actions
*/
for( pAction = paf->rgoAction; pAction < &paf->rgoAction[paf->dwNumActions]; pAction++ )
{
PDIDOBJDEFSEM pSemExact;
/*
* These flags have already been validated during semantic validation,
*/
AssertF( ( pAction->dwHow & ~DIAH_VALID ) == 0 );
AssertF( ( pAction->dwHow & DIAH_ERROR ) == 0 );
AssertF( ( pAction->dwFlags & ~DIA_VALID ) == 0 );
if( ( pAction->dwFlags & DIA_APPNOMAP )
||!( pAction->dwHow & DIAH_MAPMASK )
||!IsEqualGUID( &pAction->guidInstance, guidDevInst ) )
{
continue;
}
/*
* This object has already been validated so mark it as
* in use so we don't try to reuse it.
* No errors should be detected here so use asserts not retail tests
*/
AssertF( pAction->dwObjID != 0xFFFFFFFF );
/*
* Find the object
*/
for( pSemExact = rgObjSem;
pSemExact < &rgObjSem[dwNumAxes+dwNumPOVs+dwNumButtons];
pSemExact++ )
{
if( ( ( pSemExact->dwID ^ pAction->dwObjID )
&~( DIDFT_FFACTUATOR | DIDFT_FFEFFECTTRIGGER ) ) == 0 )
{
AssertF( !IS_OBJECT_USED( pSemExact->dwSemantic ) );
AssertF( DISEM_TYPE_GET( pAction->dwSemantic )
== DISEM_TYPE_GET( pSemExact->dwSemantic ) );
MARK_OBJECT_AS_USED( pSemExact->dwSemantic );
break;
}
}
/*
* ISSUE-2001/03/29-timgill There should always be an exact action match
* May need to use tests for duplicates and unmatched controls
*/
AssertF( pSemExact < &rgObjSem[dwNumAxes+dwNumPOVs+dwNumButtons] );
}
for( iMap=0; iMap<eMapEnd; iMap++ )
{
for( pAction = paf->rgoAction; pAction < &paf->rgoAction[paf->dwNumActions]; pAction++ )
{
/*
* Do trivial tests first
*/
if( pAction->dwHow & DIAH_MAPMASK )
{
continue;
}
if( pAction->dwFlags & DIA_APPNOMAP )
{
continue;
}
switch( iMap )
{
case eMapDeviceSemantic:
case eMapGenericSemantic:
if( DISEM_GENRE_GET( pAction->dwSemantic ) == DISEM_GENRE_GET( DISEMGENRE_ANY ) )
{
continue; /* No semantic mapping requested */
}
if( ( DISEM_TYPE_GET( pAction->dwSemantic ) == DISEM_TYPE_GET( DISEM_TYPE_BUTTON ) )
&& ( DISEM_FLAGS_GET( pAction->dwSemantic ) != 0 ) )
{
continue; /* Don't touch link buttons now */
}
break;
case eMapDeviceCompat:
case eMapGenericCompat:
if( ( DISEM_GENRE_GET( pAction->dwSemantic ) != DISEM_GENRE_GET( DISEMGENRE_ANY ) )
&& ( DISEM_TYPE_GET( pAction->dwSemantic ) == DISEM_TYPE_GET( DISEM_TYPE_AXIS ) ) )
{
continue; /* No generic mapping requested or taken by default */
}
break;
}
/*
* Next test that this device suits this action (for this pass)
*/
if( iMap <= eMapDeviceCompat )
{
if( !IsEqualGUID( &pAction->guidInstance, guidDevInst ) )
{
continue;
}
}
else if( !IsEqualGUID( &pAction->guidInstance, &GUID_Null) )
{
continue;
}
else if( ( DISEM_GENRE_GET( pAction->dwSemantic ) == DISEM_GENRE_GET( DIPHYSICAL_MOUSE ) )
|| ( DISEM_GENRE_GET( pAction->dwSemantic ) == DISEM_GENRE_GET( DIPHYSICAL_KEYBOARD ) )
|| ( DISEM_GENRE_GET( pAction->dwSemantic ) == DISEM_GENRE_GET( DIPHYSICAL_VOICE ) ) )
{
continue;
}
/*
* Only actions which may be matched on this device get this far.
*/
switch( iMap )
{
case eMapDeviceSemantic:
case eMapGenericSemantic:
/*
* See if a matching control is available.
*/
switch( DISEM_TYPE_GET( pAction->dwSemantic ) )
{
case DISEM_TYPE_GET( DISEM_TYPE_AXIS ):
{
DWORD dwAxisType = DISEM_FLAGS_GET( pAction->dwSemantic );
DWORD dwSemObjType;
UINT uAxisIdx;
/*
* Set up a mask of the type of object we need to find
*/
dwSemObjType = c_SemTypeToDFType[ DISEM_TYPEANDMODE_GET( pAction->dwSemantic ) ];
if( pAction->dwFlags & DIA_FORCEFEEDBACK )
{
dwSemObjType |= DIDFT_FFACTUATOR;
}
for( uAxisIdx = 0; uAxisIdx < dwNumAxes; uAxisIdx++ )
{
if( ( dwAxisType == DISEM_FLAGS_GET( rgObjSem[uAxisIdx].dwSemantic ) )
&& ( ( dwSemObjType & rgObjSem[uAxisIdx].dwID ) == dwSemObjType )
&& ( !IS_OBJECT_USED( rgObjSem[uAxisIdx].dwSemantic ) ) )
{
pAction->dwObjID = rgObjSem[uAxisIdx].dwID;
MARK_OBJECT_AS_USED( rgObjSem[uAxisIdx].dwSemantic );
break;
}
}
if( uAxisIdx >= dwNumAxes )
{
continue; /* No matching left */
}
break;
}
case DISEM_TYPE_GET( DISEM_TYPE_POV ):
/*
* Note, no control of POV ordering
*/
if( ( pSemNextPOV < pSemButtons )
&&!( pAction->dwFlags & DIA_FORCEFEEDBACK ) )
{
pAction->dwObjID = pSemNextPOV->dwID;
MARK_OBJECT_AS_USED( pSemNextPOV->dwSemantic );
pSemNextPOV++;
}
else
{
if( pAction->dwFlags & DIA_FORCEFEEDBACK )
{
SquirtSqflPtszV(sqflDf | sqflBenign,
TEXT( "Not mapping force feedback semantic hat switch (huh?), rgoAction[%d]"),
pAction - paf->rgoAction );
}
continue; /* None left */
}
break;
case DISEM_TYPE_GET( DISEM_TYPE_BUTTON ):
{
DWORD dwButtonIdx;
dwButtonIdx = DISEM_INDEX_GET( pAction->dwSemantic );
if( dwButtonIdx >= DIAS_INDEX_SPECIAL )
{
/*
* 0xFF used to mean DIBUTTON_ANY.
* To avoid changing other special indices, still
* use 0xFF as the base number.
*/
dwButtonIdx = dwNumButtons - ( 0xFF - dwButtonIdx );
}
else
{
dwButtonIdx--;
}
if( ( dwButtonIdx >= dwNumButtons )
|| ( IS_OBJECT_USED( pSemButtons[dwButtonIdx].dwSemantic ) )
|| ( ( pAction->dwFlags & DIA_FORCEFEEDBACK )
&&!( pSemButtons[dwButtonIdx].dwID & DIDFT_FFEFFECTTRIGGER ) ) )
{
continue; /* No match, no harm */
}
else
{
pAction->dwObjID = pSemButtons[dwButtonIdx].dwID;
MARK_OBJECT_AS_USED( pSemButtons[dwButtonIdx].dwSemantic );
}
break;
}
default:
RPF( "ERROR Invalid action: rgoAction[%d].dwSemantic 0x%08x",
pAction - paf->rgoAction, pAction->dwSemantic );
pAction->dwHow = DIAH_ERROR;
hres = DIERR_INVALIDPARAM;
goto error_exit;
}
pAction->dwHow = DIAH_DEFAULT;
break;
case eMapDeviceCompat:
case eMapGenericCompat:
if( ( DISEM_TYPE_GET( pAction->dwSemantic ) == DISEM_TYPE_GET( DISEM_TYPE_BUTTON ) )
&& ( DISEM_FLAGS_GET( pAction->dwSemantic ) != 0 ) )
{
LPDIACTIONW pActionTest;
PDIDOBJDEFSEM pSemTest;
DWORD dwSemMask;
/*
* See if the axis or POV has been mapped
* Note, there may be no linked object
*/
if( ( pAction->dwSemantic & DISEM_FLAGS_MASK ) == DISEM_FLAGS_P )
{
dwSemMask = DISEM_GROUP_MASK;
}
else
{
dwSemMask = ( DISEM_FLAGS_MASK | DISEM_GROUP_MASK );
}
for( pActionTest = paf->rgoAction; pActionTest < &paf->rgoAction[paf->dwNumActions]; pActionTest++ )
{
/*
* Find the axis or POV for which this button is a fallback
* Ignore buttons as they are just other fallbacks for the same action
* Don't do fallbacks for ANY* axes or POVs.
*/
if( ( DISEM_TYPE_GET( pActionTest->dwSemantic ) != DISEM_TYPE_GET( DISEM_TYPE_BUTTON ) )
&& ( DISEM_GENRE_GET( pAction->dwSemantic ) != DISEM_GENRE_GET( DISEMGENRE_ANY ) )
&& ( ( ( pActionTest->dwSemantic ^ pAction->dwSemantic ) & dwSemMask ) == 0 ) )
{
break;
}
}
if( ( pActionTest < &paf->rgoAction[paf->dwNumActions] )
&& ( pActionTest->dwHow & DIAH_MAPMASK ) )
{
continue; /* Don't need a fallback */
}
/*
* Find a button
*/
for( pSemTest = pSemButtons; pSemTest < &pSemButtons[dwNumButtons]; pSemTest++ )
{
if( !IS_OBJECT_USED( pSemTest->dwSemantic ) )
{
if( ( pAction->dwFlags & DIA_FORCEFEEDBACK )
&&!( pSemTest->dwID & DIDFT_FFEFFECTTRIGGER ) )
{
continue;
}
pAction->dwObjID = pSemTest->dwID;
MARK_OBJECT_AS_USED( pSemTest->dwSemantic );
break;
}
}
if( pSemTest == &pSemButtons[dwNumButtons] )
{
continue; /* None left */
}
pAction->dwHow = DIAH_DEFAULT;
}
else
{
PDIDOBJDEFSEM pSemTest;
PDIDOBJDEFSEM pSemBound;
int iDirection = 1;
DWORD dwSemObjType;
/*
* Set up a mask of the type of object we need to find to
* filter out axes of the wrong mode and non-FF if needed
*/
dwSemObjType = c_SemTypeToDFType[ DISEM_TYPEANDMODE_GET( pAction->dwSemantic ) ];
if( pAction->dwFlags & DIA_FORCEFEEDBACK )
{
dwSemObjType |= DIDFT_FFACTUATOR | DIDFT_FFEFFECTTRIGGER;
}
/*
* Search the available controls for a match
*/
switch( DISEM_TYPE_GET( pAction->dwSemantic ) )
{
case DISEM_TYPE_GET( DISEM_TYPE_AXIS ):
pSemTest = rgObjSem;
pSemBound = &rgObjSem[dwNumAxes];
/*
* Filter out axes of the wrong mode and FF caps
*/
dwSemObjType &= DIDFT_FFACTUATOR | DIDFT_AXIS;
break;
case DISEM_TYPE_GET( DISEM_TYPE_POV ):
if( pAction->dwFlags & DIA_FORCEFEEDBACK )
{
SquirtSqflPtszV(sqflDf | sqflBenign,
TEXT( "Not mapping force feedback compatible hat switch (huh?), rgoAction[%d]"),
pAction - paf->rgoAction );
continue;
}
pSemTest = pSemNextPOV;
pSemBound = pSemButtons;
/*
* Don't filter POVs any more
*/
dwSemObjType = 0;
break;
case DISEM_TYPE_GET( DISEM_TYPE_BUTTON ):
/*
* Note a DIBUTTON_ANY with instance DIAS_INDEX_SPECIAL
* or greater can be mapped from the end.
*/
if( DISEM_INDEX_GET( pAction->dwSemantic ) >= DIAS_INDEX_SPECIAL )
{
/*
* For buttons selected from the end, find the last available
*/
iDirection = -1;
pSemTest = &rgObjSem[dwNumAxes + dwNumPOVs + dwNumButtons - 1];
pSemBound = pSemButtons - 1;
}
else
{
pSemTest = pSemButtons;
pSemBound = &rgObjSem[dwNumAxes + dwNumPOVs + dwNumButtons];
}
/*
* Filter triggers but just in case, do not distinguish
* between types of buttons (toggle/push).
*/
dwSemObjType &= DIDFT_FFEFFECTTRIGGER;
break;
}
while( pSemTest != pSemBound )
{
if( !IS_OBJECT_USED( pSemTest->dwSemantic )
&& ( ( dwSemObjType & pSemTest->dwID ) == dwSemObjType )
&& ( ( DISEM_FLAGS_GET( pAction->dwSemantic ) == 0 )
||( DISEM_FLAGS_GET( pAction->dwSemantic ) == DISEM_FLAGS_GET( pSemTest->dwSemantic ) ) ) )
{
pAction->dwObjID = pSemTest->dwID;
MARK_OBJECT_AS_USED( pSemTest->dwSemantic );
break;
}
pSemTest += iDirection;
}
if( pSemTest == pSemBound )
{
continue; /* None left */
}
pAction->dwHow = DIAH_DEFAULT;
}
break;
#ifdef XDEBUG
default:
AssertF(0);
#endif
}
SquirtSqflPtszV(sqflDf | sqflVerbose,
TEXT( "Match for action %d is object 0x%08x and how 0x%08x"),
pAction - paf->rgoAction, pAction->dwObjID, pAction->dwHow );
/*
* If we get this far, we have a match.
* The control object id and dwHow field should have been set
*/
AssertF( ( pAction->dwHow == DIAH_DEFAULT ) || ( pAction->dwHow == DIAH_APPREQUESTED ) );
pAction->guidInstance = *guidDevInst;
SquirtSqflPtszV(sqflDf | sqflVerbose,
TEXT("Action %d mapped to object id 0x%08x"),
pAction - paf->rgoAction, pAction->dwObjID );
fSomethingMapped = TRUE;
} /* Action loop */
} /* Match loop */
/*
* The result should always be S_OK
*/
AssertF( hres == S_OK );
/*
* If nothing was mapped, let the caller know
*/
if( !fSomethingMapped )
{
hres = DI_NOEFFECT;
}
error_exit:;
ExitOleProc();
return hres;
#undef IS_OBJECT_USED
#undef MARK_OBJECT_AS_USED
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CMap | BuildDefaultSysActionMap |
*
* Build default action map from the action format for mouse or
* keyboard devices.
*
* @parm LPDIACTIONFORMATW | paf |
*
* Actions to map.
*
* @parm DWORD | dwFlags |
*
* Flags used to indicate mapping preferences.
*
* @parm DWORD | dwPhysicalGenre |
*
* Device genre to match.
*
* @parm REFGUID | guidDevInst |
*
* Instance guid of device to match.
*
* @parm LPDIDATAFORMAT | dfDev |
*
* Internal data format of device.
*
* @parm DWORD | dwButtonZeroInst |
*
* For mice only, the instance number of the first button.
*
* @returns
*
* <c DI_OK> = <c S_OK>: The operation completed successfully.
*
*
*****************************************************************************/
STDMETHODIMP
CMap_BuildDefaultSysActionMap
(
LPDIACTIONFORMATW paf,
DWORD dwFlags,
DWORD dwPhysicalGenre,
REFGUID guidDevInst,
LPDIDATAFORMAT dfDev,
DWORD dwButtonZeroInst
)
{
HRESULT hres;
PBYTE pMatch;
UINT idxAxis;
UINT idxButton;
EnterProcI(IDirectInputDeviceCallback::CMap::BuildDefaultSysActionMap,
(_ "pxxGpu", paf, dwFlags, dwPhysicalGenre, guidDevInst, dfDev, dwButtonZeroInst ));
idxButton = 0;
if( dwPhysicalGenre == DIPHYSICAL_KEYBOARD )
{
idxAxis = dfDev->dwNumObjs;
}
else
{
idxAxis = 0;
AssertF( dwPhysicalGenre == DIPHYSICAL_MOUSE );
}
if( SUCCEEDED( hres = AllocCbPpv( dfDev->dwNumObjs, &pMatch) ) )
{
BOOL fSomethingMapped = FALSE;
enum eMap
{
eMapPrevious,
eMapDeviceSemantic,
eMapClassSemantic,
eMapEnd
} iMap;
for( iMap=0; iMap<eMapEnd; iMap++ )
{
LPDIACTIONW pAction;
for( pAction = paf->rgoAction; pAction < &paf->rgoAction[paf->dwNumActions]; pAction++ )
{
DWORD dwObject;
UINT idxObj;
dwObject = (DWORD)-1;
/*
* These flags have already been validated during semantic validation,
*/
AssertF( ( pAction->dwHow & ~DIAH_VALID ) == 0 );
AssertF( ( pAction->dwHow & DIAH_ERROR ) == 0 );
AssertF( ( pAction->dwFlags & ~DIA_VALID ) == 0 );
if( pAction->dwFlags & DIA_APPNOMAP )
{
continue;
}
if( iMap == eMapPrevious )
{
if( !( pAction->dwHow & DIAH_MAPMASK ) )
{
continue;
}
}
else
{
if( pAction->dwHow & DIAH_MAPMASK )
{
continue;
}
}
if( iMap < eMapClassSemantic )
{
if( !IsEqualGUID( &pAction->guidInstance, guidDevInst ) )
{
continue;
}
/*
* Check that the physical genre is compatible with this device
*/
if( DISEM_GENRE_GET( pAction->dwSemantic ) != DISEM_GENRE_GET( dwPhysicalGenre ) )
{
SquirtSqflPtszV(sqflDf | sqflError,
TEXT("Device specified for action does not match physical genre"));
break;
}
}
else
if( !IsEqualGUID( &pAction->guidInstance, &GUID_Null)
|| ( DISEM_GENRE_GET( pAction->dwSemantic ) != DISEM_GENRE_GET( dwPhysicalGenre ) ) )
{
continue;
}
if( iMap == eMapPrevious )
{
/*
* This match has already been validated
*/
SquirtSqflPtszV(sqflDf | sqflVerbose,
TEXT("Action %d already mapped by 0x%08x to object 0x%08x"),
pAction - paf->rgoAction, pAction->dwHow, pAction->dwObjID );
AssertF( pAction->dwObjID != 0xFFFFFFFF );
/*
* Find the object index
*/
for( idxObj = 0; idxObj < dfDev->dwNumObjs; idxObj++ )
{
if( ( dfDev->rgodf[idxObj].dwType & DIDFT_FINDMASK ) == ( pAction->dwObjID & DIDFT_FINDMASK ) )
{
break;
}
}
if( idxObj < dfDev->dwNumObjs )
{
/*
* Validation should have caught duplicates
*/
AssertF( !pMatch[idxObj] );
pMatch[idxObj] = TRUE;
/*
* Nothing else to do since we're just counting previous matches
*/
continue;
}
else
{
SquirtSqflPtszV(sqflDf | sqflError,
TEXT("Action %d previously mapped by 0x%08x to unknown object 0x%08x"),
pAction - paf->rgoAction, pAction->dwHow, pAction->dwObjID );
}
}
else
{
DWORD dwSemObjType = c_SemTypeToDFType[ DISEM_TYPEANDMODE_GET( pAction->dwSemantic ) ];
AssertF( ( iMap == eMapDeviceSemantic ) || ( iMap == eMapClassSemantic ) );
/*
* System devices have index of the semantic = object default offset
* use that to find the object index
*/
for( idxObj = 0; idxObj < dfDev->dwNumObjs; idxObj++ )
{
/*
* Test that this is an appropriate input type.
*/
if(!( dfDev->rgodf[idxObj].dwType & dwSemObjType )
|| ( dfDev->rgodf[idxObj].dwType & DIDFT_NODATA ) )
{
continue;
}
/*
* All keyboards currently use the same (default)
* data format so the index can be used directly
* to match the semantic.
*/
if( dwPhysicalGenre == DIPHYSICAL_KEYBOARD )
{
if( dfDev->rgodf[idxObj].dwOfs != DISEM_INDEX_GET( pAction->dwSemantic ) )
{
continue;
}
}
else
{
/*
* Mice are more awkward as HID mice data
* formats depend on the device so use the
* dwType instead.
*/
if( dwSemObjType & DIDFT_BUTTON )
{
/*
* A matching button is offset by the
* caller supplied button zero instance as
* the default button zero is instance 3.
*/
if( DIDFT_GETINSTANCE( dfDev->rgodf[idxObj].dwType ) - (BYTE)dwButtonZeroInst
!= DISEM_INDEX_GET( pAction->dwSemantic ) - DIMOFS_BUTTON0 )
{
continue;
}
}
else
{
/*
* All mice have axis instances: x=0, y=1, z=2
*/
AssertF( dwSemObjType & DIDFT_AXIS );
if( ( DIDFT_GETINSTANCE( dfDev->rgodf[idxObj].dwType ) << 2 )
!= DISEM_INDEX_GET( pAction->dwSemantic ) )
{
continue;
}
}
}
/*
* A semantic match has been found
*/
if( pMatch[idxObj] )
{
SquirtSqflPtszV(sqflDf | sqflError,
TEXT("Action %d maps to already mapped object 0x%08x"),
pAction - paf->rgoAction, pAction->dwObjID );
}
else
{
if(!( pAction->dwFlags & DIA_FORCEFEEDBACK )
|| ( dfDev->rgodf[idxObj].dwType & ( DIDFT_FFACTUATOR | DIDFT_FFEFFECTTRIGGER ) ) )
{
/*
* If the game needs FF, only map FF objects
*/
dwObject = dfDev->rgodf[idxObj].dwType;
}
}
break;
}
if( dwObject == (DWORD)-1 )
{
if( ( iMap == eMapClassSemantic )
&& SUCCEEDED( CMap_TestSysOffset( dwPhysicalGenre,
DISEM_INDEX_GET( pAction->dwSemantic ) ) ) )
{
/*
* Don't worry that this device is less capable than some
*/
continue;
}
}
}
/*
* If we get this far, we either have a possible match or the
* action is invalid. Since we could still find errors, look
* at matches first.
*/
if( dwObject != -1 )
{
if( idxObj < dfDev->dwNumObjs )
{
if( iMap == eMapPrevious )
{
/*
* Validation should have caught duplicates
*/
AssertF( !pMatch[idxObj] );
pMatch[idxObj] = TRUE;
continue;
}
else
{
if( pMatch[idxObj] )
{
SquirtSqflPtszV(sqflDf | sqflError,
TEXT("Object specified more than once on device"));
dwObject = (DWORD)-1;
}
}
}
else
{
hres = CMap_TestSysObject( dwPhysicalGenre, dwObject );
if( SUCCEEDED( hres ) )
{
/*
* Not an unreasonable request so just carry on
*/
continue;
}
else
{
dwObject = (DWORD)-1;
}
}
}
/*
* We have either a valid object or an error
*/
if( dwObject != (DWORD)-1 )
{
pAction->dwHow = DIAH_DEFAULT;
pAction->dwObjID = dwObject;
pAction->guidInstance = *guidDevInst;
SquirtSqflPtszV(sqflDf | sqflVerbose,
TEXT("Action %d mapped to object index 0x%08x type 0x%08x"),
pAction - paf->rgoAction, idxObj, dwObject );
pMatch[idxObj] = TRUE;
fSomethingMapped = TRUE;
}
else
{
/*
* Mark this action as invalid and quit.
*/
pAction->dwHow = DIAH_ERROR;
RPF("ERROR BuildActionMap: arg %d: rgoAction[%d] invalid", 1, pAction - paf->rgoAction );
RPF( "Semantic 0x%08x", pAction->dwSemantic );
hres = DIERR_INVALIDPARAM;
goto free_and_exit;
}
} /* Action loop */
} /* Match loop */
/*
* The result should always be a successful memory allocation (S_OK)
*/
AssertF( hres == S_OK );
/*
* If nothing was mapped, let the caller know
*/
if( !fSomethingMapped )
{
hres = DI_NOEFFECT;
}
free_and_exit:;
FreePv( pMatch );
}
ExitOleProc();
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CMap | ActionMap_IsValidMapObject |
*
* Utility function to check a DIACTIONFORMAT structure for validity.
*
* @cwrap LPDIRECTINPUTDEVICE | lpDirectInputDevice
*
* @parm LPDIACTIONFORMAT | paf |
*
* Points to a structure that describes the actions needed by the
* application.
*
* @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 structure is valid.
*
* <c DIERR_INVALIDPARAM> = <c E_INVALIDARG>: The structure is
* not valid.
*
*****************************************************************************/
HRESULT
CDIDev_ActionMap_IsValidMapObject
(
LPDIACTIONFORMATW paf
#ifdef XDEBUG
comma
LPCSTR pszProc
comma
UINT argnum
#endif
)
{
HRESULT hres = E_INVALIDARG;
/*
* Assert that the structures are the same until the final element
*/
#if defined(_WIN64)
CAssertF( ( ( cbX( DIACTIONFORMATW ) - cbX( ((LPDIACTIONFORMATW)0)->tszActionMap ) )
- ( cbX( DIACTIONFORMATA ) - cbX( ((LPDIACTIONFORMATA)0)->tszActionMap ) )
< MAX_NATURAL_ALIGNMENT ) );
#else
CAssertF( ( cbX( DIACTIONFORMATW ) - cbX( ((LPDIACTIONFORMATW)0)->tszActionMap ) )
== ( cbX( DIACTIONFORMATA ) - cbX( ((LPDIACTIONFORMATA)0)->tszActionMap ) ) );
#endif
CAssertF( FIELD_OFFSET( DIACTIONFORMATW, tszActionMap )
== FIELD_OFFSET( DIACTIONFORMATA, tszActionMap ) );
CAssertF( cbX(DIACTIONA) == cbX(DIACTIONW) );
if( FAILED(hresFullValidWriteNoScramblePvCb_(paf, MAKELONG( cbX(DIACTIONFORMATA), cbX(DIACTIONFORMATW) ), pszProc, argnum)) )
{
}
else if( paf->dwActionSize != cbX(DIACTION) )
{
D( RPF("IDirectInputDevice::%s: Invalid DIACTIONFORMAT.dwActionSize 0x%08x",
pszProc, paf->dwActionSize ); )
}
else if( paf->dwDataSize != (paf->dwNumActions * cbX( ((LPDIDEVICEOBJECTDATA)0)->dwData ) ) )
{
D( RPF("IDirectInputDevice::%s: DIACTIONFORMAT.dwDataSize 0x%08x not valid for DIACTIONFORMAT.dwNumActions 0x%08x",
pszProc, paf->dwDataSize ); )
}
else if( IsEqualGUID(&paf->guidActionMap, &GUID_Null) )
{
D( RPF("IDirectInputDevice::%s: DIACTIONFORMAT.guidActionMap is a NULL GUID", pszProc ); )
}
else if( !DISEM_VIRTUAL_GET( paf->dwGenre ) )
{
D( RPF("IDirectInputDevice::%s: Invalid (1) DIACTIONFORMAT.dwGenre 0x%08x", pszProc, paf->dwGenre ); )
}
else if( DISEM_GENRE_GET( paf->dwGenre ) > DISEM_MAX_GENRE )
{
D( RPF("IDirectInputDevice::%s: Invalid (2) DIACTIONFORMAT.dwGenre 0x%08x", pszProc, paf->dwGenre ); )
}
else if( ( paf->lAxisMin | paf->lAxisMax ) && ( paf->lAxisMin > paf->lAxisMax ) )
{
D( RPF("IDirectInputDevice::%s: Invalid DIACTIONFORMAT.lAxisMin 0x%08x for lAxisMax 0x%08x",
pszProc, paf->lAxisMin, paf->lAxisMax ); )
}
else if( !paf->dwNumActions )
{
D( RPF("IDirectInputDevice::%s: DIACTIONFORMAT.dwNumActions is zero", pszProc ); )
}
else if( paf->dwNumActions & 0xFF000000 )
{
D( RPF("IDirectInputDevice::%s: DIACTIONFORMAT.dwNumActions of 0x%08x is unreasonable", paf->dwNumActions, pszProc ); )
}
else if( !paf->rgoAction )
{
D( RPF("IDirectInputDevice::%s: DIACTIONFORMAT.rgoAction is NULL", pszProc ); )
}
else if( FAILED( hresFullValidWriteNoScramblePvCb_(paf->rgoAction,
cbX(*paf->rgoAction) * paf->dwNumActions, pszProc, argnum ) ) )
{
}
else
{
hres = S_OK;
}
/*
* Warning only tests go here. Only test if everything else was OK.
*/
#ifdef XDEBUG
if( SUCCEEDED( hres ) )
{
}
#endif
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @func DWORD | BitwiseReflect |
*
* Reflect the bottom bits of a value.
* Note, this could easily be optimized but it is only used once.
*
* @parm IN DWORD | dwValue |
*
* The value to be reflected.
*
* @parm IN int | iBottom |
*
* The number of bits to be reflected.
*
* @returns
* Returns the value dwValue with the bottom iBottom bits reflected
*
*****************************************************************************/
DWORD BitwiseReflect
(
DWORD dwValue,
int iBottom
)
{
int BitIdx;
DWORD dwTemp = dwValue;
#define BITMASK(X) (1L << (X))
for( BitIdx = 0; BitIdx < iBottom; BitIdx++ )
{
if( dwTemp & 1L )
dwValue |= BITMASK( ( iBottom - 1 ) - BitIdx );
else
dwValue &= ~BITMASK( ( iBottom - 1 ) - BitIdx );
dwTemp >>= 1;
}
return dwValue;
#undef BITMASK
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @func HRESULT | CMap_InitializeCRCTable |
*
* If needed create and initialize the global table used for CRCs.
*
* Allocate memory for the 256 DWORD array and generate a set of
* values used to calculate a Cyclic Redundancy Check.
* The algorithm used is supposedly the same as Ethernet's CRC-32.
*
* @returns
* Returns one of the following a COM error codes:
*
* <c DI_OK> = <c S_OK>: The operation completed successfully.
* <c DI_NOEFFECT> = <c S_FALSE>: The table already existed.
*
* <c E_OUTOFMEMORY>: insufficient memory available for the table.
* The GetMapCRC function does not check that the table has been
* initialized so failure of this function should not allow
* processing to proceed into any function that uses GetMapCRC.
*
*****************************************************************************/
#define CRC_TABLE_SIZE 256
#define CRCWIDTH 32
#define POLY 0x04C11DB7
HRESULT CMap_InitializeCRCTable( void )
{
HRESULT hres;
int TableIdx;
if( g_rgdwCRCTable )
{
hres = S_FALSE;
}
else
{
hres = AllocCbPpv( CRC_TABLE_SIZE * cbX( *g_rgdwCRCTable ), &g_rgdwCRCTable );
if( SUCCEEDED( hres ) )
{
/*
* Special case the first element so it gets a non-zero value
*/
g_rgdwCRCTable[0] = POLY;
for( TableIdx = 1; TableIdx < CRC_TABLE_SIZE; TableIdx++ )
{
int BitIdx;
DWORD dwR;
dwR = BitwiseReflect( TableIdx, 8 ) << ( CRCWIDTH - 8 );
for( BitIdx = 0; BitIdx < 8; BitIdx++ )
{
if( dwR & 0x80000000 )
dwR = ( dwR << 1 ) ^ POLY;
else
dwR <<= 1;
}
g_rgdwCRCTable[TableIdx] = BitwiseReflect( dwR, CRCWIDTH );
/*
* We do not want a value of zero or identical values to be
* generated.
*/
AssertF( g_rgdwCRCTable[TableIdx] );
AssertF( g_rgdwCRCTable[TableIdx] != g_rgdwCRCTable[TableIdx-1] );
}
}
}
return hres;
}
#undef CRCWIDTH
/*****************************************************************************
*
* @doc INTERNAL
*
* @func DWORD | GetMapCRC |
*
* Calculate a CRC based on the passed DIACTIONFORMAT contents.
* The algorithm used is based on "CRC-32" which is supposedly what
* Ethernet uses, however some changes have been made to suit the
* specific use.
*
* @parm IN LPDIACTIONFORMAT | lpaf |
*
* Points to a structure that describes the actions to be mapped
* for which a CRC is to be generated.
*
* @returns
*
* The 32 bit CRC as a DWORD value.
*
*****************************************************************************/
DWORD GetMapCRC
(
LPDIACTIONFORMATW paf,
REFGUID guidInst
)
{
DWORD dwCRC;
PBYTE pBuffer;
LPCDIACTIONW pAction;
/*
* It is the caller's responsibility to make sure g_rgdwCRCTable has
* been allocated and initialized.
*/
AssertF( g_rgdwCRCTable );
/*
* Initialize to dwNumActions to avoid having to CRC it
*/
dwCRC = paf->dwNumActions;
/* Assert that the action map guid and the genre can be tested in series */
CAssertF( FIELD_OFFSET( DIACTIONFORMATW, dwGenre )
== FIELD_OFFSET( DIACTIONFORMATW, guidActionMap ) + cbX( paf->guidActionMap ) );
for( pBuffer = ((PBYTE)&paf->guidActionMap) + cbX( paf->guidActionMap ) + cbX( paf->dwGenre );
pBuffer >= ((PBYTE)&paf->guidActionMap); pBuffer-- )
{
dwCRC = g_rgdwCRCTable[( LOBYTE(dwCRC) ^ *pBuffer )] ^ (dwCRC >> 8);
}
/* Assert that the device instance guid and object ID can be tested in series */
CAssertF( FIELD_OFFSET( DIACTIONW, dwObjID )
== FIELD_OFFSET( DIACTIONW, guidInstance ) + cbX( pAction->guidInstance ) );
for( pAction = paf->rgoAction; pAction < &paf->rgoAction[paf->dwNumActions]; pAction++ )
{
/*
* Make sure this action is really relevant before including it in
* the CRC. It is assumed that any change in which actions are
* included will be picked up in the resultant CRC.
*/
if( IsEqualGUID( &pAction->guidInstance, guidInst )
&& ( pAction->dwHow & DIAH_MAPMASK )
&& ( ( pAction->dwFlags & DIA_APPNOMAP ) == 0 ) )
{
/*
* Besides which actions are taken into account, the only fields
* need to be verified are those that would change a SetActionMap.
* Although flags such as DIA_FORCEFEEDBACK could alter the
* mappings they do not change a SetActionMap.
*/
for( pBuffer = ((PBYTE)&pAction->guidInstance) + cbX( pAction->guidInstance ) + cbX( pAction->dwObjID );
pBuffer >= ((PBYTE)&pAction->guidInstance); pBuffer-- )
{
dwCRC = g_rgdwCRCTable[( LOBYTE(dwCRC) ^ *pBuffer )] ^ (dwCRC >> 8);
}
}
}
return dwCRC;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | IDirectInputDevice | CDIDev_BuildActionMapCore |
*
* Worker function for BuildActionMapA and BuildActionMapW.
* This does the real work once the external entry points have done
* dialect specific validation and set up.
*
*****************************************************************************/
STDMETHODIMP CDIDev_BuildActionMapCore
(
PDD this,
LPDIACTIONFORMATW paf,
LPCWSTR lpwszUserName,
DWORD dwFlags
)
{
HRESULT hres;
EnterProcI(CDIDev_BuildActionMapCore, (_ "pWx", paf, lpwszUserName, dwFlags ));
// This application uses the mapper
AhAppRegister(this->dwVersion, 0x1);
switch( dwFlags & ( DIDBAM_PRESERVE | DIDBAM_INITIALIZE | DIDBAM_HWDEFAULTS ) )
{
case DIDBAM_DEFAULT:
case DIDBAM_PRESERVE:
case DIDBAM_INITIALIZE:
case DIDBAM_HWDEFAULTS:
hres = S_OK;
break;
default:
RPF("ERROR %s: arg %d: Must not combine "
"DIDBAM_PRESERVE, DIDBAM_INITIALIZE and DIDBAM_HWDEFAULTS", s_szProc, 3);
hres = E_INVALIDARG;
}
if( SUCCEEDED(hres)
&& SUCCEEDED(hres = hresFullValidFl(dwFlags, DIDBAM_VALID, 3))
&& SUCCEEDED(hres = CMap_ValidateActionMapSemantics( paf, dwFlags ) ) )
{
LPDIPROPSTRING pdipMapFile;
if( SUCCEEDED( hres = AllocCbPpv(cbX(*pdipMapFile), &pdipMapFile) ) )
{
HRESULT hresExactMaps = E_FAIL;
PWCHAR pwszMapFile;
DWORD dwCommsType;
if( dwFlags & DIDBAM_HWDEFAULTS )
{
hres = CMap_DeviceValidateActionMap( (PV)this, paf, DVAM_DEFAULT, &dwCommsType );
hresExactMaps = hres;
if( hres == S_OK )
{
hresExactMaps = DI_NOEFFECT;
}
}
else
{
/*
* Do a generic test and map of any exact device matches
*/
hres = CMap_DeviceValidateActionMap( (PV)this, paf, DVAM_GETEXACTMAPPINGS, &dwCommsType );
if( SUCCEEDED( hres ) )
{
/*
* Save the exact mapping result to combine with the result
* of semantic mapping.
*/
hresExactMaps = hres;
}
}
if( SUCCEEDED( hres ) )
{
pdipMapFile->diph.dwSize = cbX(DIPROPSTRING);
pdipMapFile->diph.dwHeaderSize = cbX(DIPROPHEADER);
pdipMapFile->diph.dwObj = 0;
pdipMapFile->diph.dwHow = DIPH_DEVICE;
/*
* Try to get a configured mapping.
* If there is no IHV file there may still be a user file
*/
hres = CDIDev_GetPropertyW( &this->ddW, DIPROP_MAPFILE, &pdipMapFile->diph );
pwszMapFile = SUCCEEDED( hres ) ? pdipMapFile->wsz : NULL;
if( dwCommsType )
{
/*
* Communications control device
*/
if( !pwszMapFile )
{
/*
* If there's no IHV mapping there's nothing to add.
*/
hres = DI_NOEFFECT;
}
else
{
/*
* Modify the genre over the call to the mapper so
* that we get physical genre mappings from the IHV
* file if no user mappings are available
*/
DWORD dwAppGenre = paf->dwGenre;
paf->dwGenre = DIPHYSICAL_VOICE;
hres = this->pMS->lpVtbl->GetActionMap(this->pMS, &this->guid, pwszMapFile,
(LPDIACTIONFORMATW)paf, lpwszUserName, NULL, dwFlags );
/*
* ISSUE-2001/03/29-timgill Only want the timestamp for hardcoded devices
* ->Read again for mappings
*/
if( ( dwCommsType == DI8DEVTYPEDEVICECTRL_COMMSSELECTION_HARDWIRED )
&&!( dwFlags & DIDBAM_HWDEFAULTS ) )
{
DWORD dwLowTime;
DWORD dwHighTime;
dwLowTime = paf->ftTimeStamp.dwLowDateTime;
dwHighTime = paf->ftTimeStamp.dwHighDateTime;
hres = this->pMS->lpVtbl->GetActionMap(this->pMS, &this->guid, pwszMapFile,
(LPDIACTIONFORMATW)paf, lpwszUserName, NULL, DIDBAM_HWDEFAULTS );
paf->ftTimeStamp.dwLowDateTime = dwLowTime;
paf->ftTimeStamp.dwHighDateTime = dwHighTime;
}
paf->dwGenre = dwAppGenre;
if( SUCCEEDED( hres ) )
{
if( hres == S_NOMAP )
{
/*
* Make sure we do not attempt defaults and
* the exact match return code gets back to the
* caller
*/
hres = DI_NOEFFECT;
}
}
else
{
/*
* If there was an error, there are no defaults
* so quit now.
*/
if( ( HRESULT_FACILITY( hres ) == FACILITY_ITF )
&& ( HRESULT_CODE( hres ) > 0x0600 ) )
{
AssertF( HRESULT_CODE( hres ) < 0x0680 );
RPF( "Internal GetActionMap error 0x%08x for hardwired device", hres );
hres = DIERR_MAPFILEFAIL;
}
goto FreeAndExitCDIDev_BuildActionMapCore;
}
}
}
else if( !pwszMapFile && ( dwFlags & DIDBAM_HWDEFAULTS ) )
{
/*
* Make sure we get defaults
*/
SquirtSqflPtszV(sqflDf | sqflBenign,
TEXT("Failed to GetProperty DIPROP_MAPFILE 0x%08x, default will be generated"), hres );
hres = S_NOMAP;
}
else
{
hres = this->pMS->lpVtbl->GetActionMap(this->pMS, &this->guid, pwszMapFile,
(LPDIACTIONFORMATW)paf, lpwszUserName, NULL, dwFlags);
if( ( paf->ftTimeStamp.dwHighDateTime == DIAFTS_UNUSEDDEVICEHIGH )
&& ( paf->ftTimeStamp.dwLowDateTime == DIAFTS_UNUSEDDEVICELOW )
&& SUCCEEDED( hres ) )
{
/*
* If the device has never been used, the saved
* mappings are either the IHV defaults or cooked up
* defaults. Unfortunately, DIMap will have marked
* them as DIAH_USERCONFIG. Some day DIMap should
* either return the true flags or return without
* changing the flags, until then, reset all the
* flags and then do a second request for defaults.
*/
LPDIACTIONW pAction;
for( pAction = paf->rgoAction; pAction < &paf->rgoAction[paf->dwNumActions]; pAction++ )
{
if( ( ( pAction->dwFlags & ( DIA_APPMAPPED | DIA_APPNOMAP ) ) == 0 )
&& ( pAction->dwHow & DIAH_USERCONFIG )
&& IsEqualGUID( &pAction->guidInstance, &this->guid ) )
{
pAction->dwHow = DIAH_UNMAPPED;
}
}
hres = this->pMS->lpVtbl->GetActionMap(this->pMS, &this->guid, pwszMapFile,
(LPDIACTIONFORMATW)paf, lpwszUserName, NULL, DIDBAM_HWDEFAULTS);
/*
* Make sure the timestamps are still set for unused.
*/
paf->ftTimeStamp.dwLowDateTime = DIAFTS_UNUSEDDEVICELOW;
paf->ftTimeStamp.dwHighDateTime = DIAFTS_UNUSEDDEVICEHIGH;
}
if( FAILED( hres ) )
{
if( ( HRESULT_FACILITY( hres ) == FACILITY_ITF )
&& ( HRESULT_CODE( hres ) > 0x0600 ) )
{
AssertF( HRESULT_CODE( hres ) < 0x0680 );
RPF( "Internal GetActionMap error 0x%08x for configurable device", hres );
hres = DIERR_MAPFILEFAIL;
}
}
}
}
if( SUCCEEDED( hresExactMaps ) )
{
/*
* If we took an IHV mapping, do a default mapping on top.
* This allows IHVs to only map objects that are special
* leaving other objects to be used for whatever semantics
* match.
* Some day we should have a return code that indicates which
* type of mapping DIMap produced, until then, search the
* mappings for a HWDefault.
*/
if( SUCCEEDED( hres ) && ( hres != S_NOMAP )
&& ( dwCommsType != DI8DEVTYPEDEVICECTRL_COMMSSELECTION_HARDWIRED ) )
{
LPDIACTIONW pAction;
for( pAction = paf->rgoAction; pAction < &paf->rgoAction[paf->dwNumActions]; pAction++ )
{
if( ( ( pAction->dwFlags & ( DIA_APPMAPPED | DIA_APPNOMAP ) ) == 0 )
&& ( pAction->dwHow & DIAH_HWDEFAULT )
&& IsEqualGUID( &pAction->guidInstance, &this->guid ) )
{
hres = S_NOMAP;
break;
}
}
}
if( FAILED( hres ) || ( hres == S_NOMAP ) )
{
hres = this->pdcb->lpVtbl->BuildDefaultActionMap( this->pdcb, paf, dwFlags, &this->guid );
if( SUCCEEDED( hres ) )
{
paf->ftTimeStamp.dwLowDateTime = DIAFTS_NEWDEVICELOW;
paf->ftTimeStamp.dwHighDateTime = DIAFTS_NEWDEVICEHIGH;
SquirtSqflPtszV(sqflDf | sqflVerbose, TEXT("Default action map used"));
}
else
{
SquirtSqflPtszV(sqflDf | sqflError, TEXT("Default action map failed"));
}
}
else
{
hres = CMap_DeviceValidateActionMap( (PV)this, paf, DVAM_DEFAULT, &dwCommsType );
if( SUCCEEDED( hres ) )
{
SquirtSqflPtszV(sqflDf | sqflVerbose, TEXT("Action map validated"));
}
else
{
RPF( "Initially valid action map invalidated by mapper!" );
}
}
/*
* If no semantics mapped, return the exact map result.
*/
if( hres == DI_NOEFFECT )
{
hres = hresExactMaps;
}
if( dwFlags & DIDBAM_HWDEFAULTS )
{
/*
* Timestamps are meaningless for hardware defaults
* so just make sure the values are consistent.
*/
paf->ftTimeStamp.dwLowDateTime = DIAFTS_UNUSEDDEVICELOW;
paf->ftTimeStamp.dwHighDateTime = DIAFTS_UNUSEDDEVICEHIGH;
}
else if( ( paf->ftTimeStamp.dwHighDateTime == DIAFTS_NEWDEVICEHIGH )
&& ( paf->ftTimeStamp.dwLowDateTime == DIAFTS_NEWDEVICELOW )
&& SUCCEEDED( hres ) )
{
if( FAILED( this->pMS->lpVtbl->SaveActionMap( this->pMS, &this->guid,
pwszMapFile, paf, lpwszUserName, dwFlags ) ) )
{
SquirtSqflPtszV(sqflDf | sqflBenign,
TEXT("Failed to save action map on first use 0x%08x"), hres );
paf->ftTimeStamp.dwLowDateTime = DIAFTS_UNUSEDDEVICELOW;
paf->ftTimeStamp.dwHighDateTime = DIAFTS_UNUSEDDEVICEHIGH;
/*
* Don't return an internal DIMap result, convert it to a published one
*/
if( ( HRESULT_FACILITY( hres ) == FACILITY_ITF )
&& ( HRESULT_CODE( hres ) > 0x0600 ) )
{
AssertF( HRESULT_CODE( hres ) < 0x0680 );
hres = DIERR_MAPFILEFAIL;
}
}
}
}
else
{
SquirtSqflPtszV(sqflDf | sqflError, TEXT("Invalid mappings in action array"));
}
FreeAndExitCDIDev_BuildActionMapCore:;
FreePv( pdipMapFile );
if( SUCCEEDED( hres ) )
{
paf->dwCRC = GetMapCRC( paf, &this->guid );
}
}
else
{
/*
* Note, we could try to do a default map even though we could not
* allocate space for the file name property but if allocations
* are failing we're better of quitting ASAP.
*/
SquirtSqflPtszV(sqflDf | sqflError, TEXT("Mem allocation failure") );
}
}
#if 0
{
LPDIACTIONW pAction;
RPF( "Action map leaving build" );
// RPF( "Act# Semantic Flags Object How App Data" );
RPF( "A# Semantic Device Object How" );
for( pAction = paf->rgoAction; pAction < &paf->rgoAction[paf->dwNumActions]; pAction++ )
{
RPF( "%02d %08x {%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X} %08x %08x",
pAction - paf->rgoAction,
pAction->dwSemantic,
pAction->guidInstance.Data1, pAction->guidInstance.Data2, pAction->guidInstance.Data3,
pAction->guidInstance.Data4[0], pAction->guidInstance.Data4[1],
pAction->guidInstance.Data4[2], pAction->guidInstance.Data4[3],
pAction->guidInstance.Data4[4], pAction->guidInstance.Data4[5],
pAction->guidInstance.Data4[6], pAction->guidInstance.Data4[7],
pAction->dwObjID,
pAction->dwHow,
pAction->uAppData );
// RPF( "%02d %08x %08x %08x %08x %08x",
// pAction - paf->rgoAction,
// pAction->dwSemantic,
// pAction->dwFlags,
// pAction->dwObjID,
// pAction->dwHow,
// pAction->uAppData );
}
RPF( "--" );
}
#endif
ExitOleProc();
return hres;
}
/*****************************************************************************
*
* @doc EXTERNAL
*
* @method HRESULT | IDirectInputDevice | BuildActionMap |
*
* Obtains the mapping of actions described in the <t DIACTIONFORMAT>
* to controls for this device.
* Information about user preferences and hardware manufacturer
* provided defaults is used to create the association between game
* actions and device controls.
*
* @cwrap LPDIRECTINPUTDEVICE | lpDirectInputDevice
*
* @parm LPDIACTIONFORMAT | paf |
*
* Points to a structure that describes the actions needed by the
* application.
*
* @parm LPCSTR | lpszUserName |
*
* Name of user for whom mapping is requested. This may be a NULL
* pointer in which case the current user is assumed.
*
* @parm DWORD | dwFlags |
*
* Flags used to control the mapping. Must be a valid combination
* of the <c DIDBAM_*> 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 DI_NOEFFECT> = <c S_OK>: The operation completed successfully
* but no actions were mapped.
*
* <c DIERR_INVALIDPARAM> = <c E_INVALIDARG>: A parameter is invalid.
*
*****************************************************************************/
STDMETHODIMP CDIDev_BuildActionMapW
(
PV pdidW,
LPDIACTIONFORMATW paf,
LPCWSTR lpwszUserName,
DWORD dwFlags
)
{
HRESULT hres;
EnterProcR(IDirectInputDevice8W::BuildActionMap, (_ "ppWx", pdidW, paf, lpwszUserName, dwFlags));
if( SUCCEEDED(hres = hresPvW( pdidW ) )
&& SUCCEEDED(hres = CDIDev_ActionMap_IsValidMapObject( paf D(comma s_szProc comma 1) ) ) )
{
if( paf->dwSize != cbX(DIACTIONFORMATW) )
{
D( RPF("IDirectInputDevice::%s: Invalid DIACTIONFORMATW.dwSize 0x%08x",
s_szProc, paf->dwSize ); )
hres = E_INVALIDARG;
}
else
{
LPWSTR pwszGoodUserName;
hres = GetWideUserName( NULL, lpwszUserName, &pwszGoodUserName );
if( SUCCEEDED( hres ) )
{
hres = CDIDev_BuildActionMapCore( _thisPvNm(pdidW, ddW), paf, lpwszUserName, dwFlags );
if( !lpwszUserName )
{
FreePv( pwszGoodUserName );
}
}
}
}
ExitOleProc();
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | IDirectInputDevice | BuildActionMapA |
*
* ANSI version of BuildActionMap.
*
*****************************************************************************/
STDMETHODIMP CDIDev_BuildActionMapA
(
PV pdidA,
LPDIACTIONFORMATA pafA,
LPCSTR lpszUserName,
DWORD dwFlags
)
{
HRESULT hres;
EnterProcR(IDirectInputDevice8A::BuildActionMap, (_ "ppAx", pdidA, pafA, lpszUserName, dwFlags));
if( SUCCEEDED(hres = hresPvA( pdidA ) )
&& SUCCEEDED(hres = CDIDev_ActionMap_IsValidMapObject( (LPDIACTIONFORMATW)pafA D(comma s_szProc comma 1) ) ) )
{
if( pafA->dwSize != cbX(DIACTIONFORMATA) )
{
D( RPF("IDirectInputDevice::%s: Invalid DIACTIONFORMATA.dwSize 0x%08x",
s_szProc, pafA->dwSize ); )
hres = E_INVALIDARG;
}
else
{
LPWSTR pwszGoodUserName;
hres = GetWideUserName( lpszUserName, NULL, &pwszGoodUserName );
if( SUCCEEDED( hres ) )
{
/*
* For the sake of the mapper DLLs validation set the size to
* the UNICODE version. If we ever send this to an external
* component we should do this differently.
*/
pafA->dwSize = cbX(DIACTIONFORMATW);
hres = CDIDev_BuildActionMapCore( _thisPvNm(pdidA, ddA), (LPDIACTIONFORMATW)pafA, pwszGoodUserName, dwFlags );
pafA->dwSize = cbX(DIACTIONFORMATA);
FreePv( pwszGoodUserName );
}
}
}
ExitOleProc();
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | IDirectInputDevice | CDIDev_SaveActionMap |
*
* Worker function for SetActionMapA and SetActionMapW.
* Used to save an actions map.
*
*****************************************************************************/
STDMETHODIMP CDIDev_SaveActionMap
(
PDD this,
LPDIACTIONFORMATW paf,
LPWSTR lpwszUserName,
DWORD dwFlags
)
{
HRESULT hres;
LPDIPROPSTRING pdipMapFile;
EnterProcI(CDIDev_SaveActionMap, (_ "pWAx", paf, lpwszUserName, dwFlags));
if( SUCCEEDED( hres = AllocCbPpv(cbX(*pdipMapFile), &pdipMapFile) ) )
{
DWORD dwLowTime;
DWORD dwHighTime;
// Save user's pass-in timestamps
dwLowTime = paf->ftTimeStamp.dwLowDateTime;
dwHighTime = paf->ftTimeStamp.dwHighDateTime;
pdipMapFile->diph.dwSize = cbX(DIPROPSTRING);
pdipMapFile->diph.dwHeaderSize = cbX(DIPROPHEADER);
pdipMapFile->diph.dwObj = 0;
pdipMapFile->diph.dwHow = DIPH_DEVICE;
paf->ftTimeStamp.dwLowDateTime = DIAFTS_UNUSEDDEVICELOW;
paf->ftTimeStamp.dwHighDateTime = DIAFTS_UNUSEDDEVICEHIGH;
hres = CDIDev_GetPropertyW( &this->ddW, DIPROP_MAPFILE, &pdipMapFile->diph );
hres = this->pMS->lpVtbl->SaveActionMap( this->pMS, &this->guid,
/* No map file if the GetProperty failed */
(SUCCEEDED( hres )) ? pdipMapFile->wsz : NULL,
paf, lpwszUserName, dwFlags );
// restore user's pass-in timestamps
paf->ftTimeStamp.dwLowDateTime = dwLowTime;
paf->ftTimeStamp.dwHighDateTime = dwHighTime;
FreePv( pdipMapFile );
}
ExitOleProc();
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CDIDev | ParseActionFormat |
*
* Parse the action format passed by the application and
* convert it into a format that we can use to translate
* the device data into application data.
*
* @parm IN LPDIACTIONFORMAT | lpaf |
*
* Points to a structure that describes the actions to be mapped
* to this device.
*
* @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 lpvData> parameter is not a valid pointer.
*
*
*****************************************************************************/
STDMETHODIMP
CDIDev_ParseActionFormat
(
PDD this,
LPDIACTIONFORMATW paf
)
{
PDIXLAT pdix;
PINT rgiobj;
VXDDATAFORMAT vdf;
HRESULT hres;
#ifdef DEBUG
EnterProc(CDIDev_ParseActionFormat, (_ "pp", this, paf));
#endif
/*
* Caller should've nuked the old translation table.
*/
AssertF(this->pdix == 0);
AssertF(this->rgiobj == 0);
if( paf->dwDataSize != paf->dwNumActions * cbX( ((LPDIDEVICEOBJECTDATA)0)->dwData ) )
{
SquirtSqflPtszV(sqflDf | sqflError,
TEXT("Incorrect dwDataSize (0x%08X) for dwNumActions (0x%08X)"),
paf->dwDataSize, paf->dwNumActions );
hres = E_INVALIDARG;
goto done_without_free;
}
vdf.cbData = this->df.dwDataSize;
vdf.pDfOfs = 0;
rgiobj = 0;
if( SUCCEEDED(hres = AllocCbPpv(cbCxX(this->df.dwNumObjs, DIXLAT), &pdix))
&& SUCCEEDED(hres = AllocCbPpv(cbCdw(this->df.dwDataSize), &vdf.pDfOfs))
&& SUCCEEDED(hres = AllocCbPpv(cbCdw(paf->dwDataSize), &rgiobj)) )
{
LPCDIACTIONW pAction;
DIPROPDWORD dipdw;
DIPROPRANGE diprange;
DWORD dwAxisMode = DIPROPAXISMODE_REL;
BOOL fSomethingMapped = FALSE;
BOOL fAxisModeKnown = FALSE;
/*
* Pre-init all the translation tags to -1,
* which means "not in use"
*/
memset(pdix, 0xFF, cbCxX(this->df.dwNumObjs, DIXLAT));
memset(vdf.pDfOfs, 0xFF, cbCdw(this->df.dwDataSize));
memset(rgiobj, 0xFF, cbCdw(paf->dwDataSize) );
/*
* Set up the property invariants
*/
dipdw.diph.dwSize = sizeof(DIPROPDWORD);
dipdw.diph.dwHeaderSize = sizeof(DIPROPHEADER);
dipdw.diph.dwHow = DIPH_BYID;
diprange.diph.dwSize = sizeof(DIPROPRANGE);
diprange.diph.dwHeaderSize = sizeof(DIPROPHEADER);
diprange.diph.dwHow = DIPH_BYID;
diprange.lMin = paf->lAxisMin;
diprange.lMax = paf->lAxisMax;
for( pAction = paf->rgoAction; pAction < &paf->rgoAction[paf->dwNumActions]; pAction++ )
{
if( IsEqualGUID( &pAction->guidInstance, &this->guid ) )
{
/*
* These flags have already been validated but it does not hurt to assert
*/
AssertF( ( pAction->dwHow & ~DIAH_VALID ) == 0 );
AssertF( ( pAction->dwHow & DIAH_ERROR ) == 0 );
AssertF( ( pAction->dwFlags & ~DIA_VALID ) == 0 );
if( ( pAction->dwHow & DIAH_MAPMASK )
&& ( ( pAction->dwFlags & DIA_APPNOMAP ) == 0 ) )
{
int iobjDev = -1;
PCODF podfFound;
for( podfFound = this->df.rgodf; podfFound < &this->df.rgodf[this->df.dwNumObjs]; podfFound++ )
{
iobjDev++;
/*
* Look for an exact type flags match
*/
if( podfFound->dwType == pAction->dwObjID )
{
break;
}
}
if( podfFound < &this->df.rgodf[this->df.dwNumObjs] )
{
DWORD dwAppOffset = (DWORD)(pAction - paf->rgoAction) * cbX( ((LPDIDEVICEOBJECTDATA)0)->dwData );
fSomethingMapped = TRUE;
vdf.pDfOfs[podfFound->dwOfs] = iobjDev;
rgiobj[dwAppOffset] = iobjDev;
pdix[iobjDev].dwOfs = dwAppOffset;
pdix[iobjDev].uAppData = pAction->uAppData;
if ( podfFound->dwFlags & DIDOI_POLLED ) {
this->fPolledDataFormat = TRUE;
}
dipdw.diph.dwObj = podfFound->dwType;
dipdw.dwData = 0x1; // Enable this report ID
hres = CDIDev_RealSetProperty(this, DIPROP_ENABLEREPORTID, &dipdw.diph);
if ( hres == E_NOTIMPL )
{
hres = S_OK;
}
else if( FAILED( hres ) )
{
SquirtSqflPtszV(sqflDf | sqflError,
TEXT("Could not set DIPROP_ENABLEREPORTID for object 0x%08x, error 0x%08x"),
pAction->dwObjID, hres);
/*
* Ouch! Can't carry on or the error will be lost so quit
*/
break;
}
/*
* Set the default axis parameters
*/
if( DISEM_TYPE_GET( pAction->dwSemantic ) == DISEM_TYPE_GET( DISEM_TYPE_AXIS ) )
{
if( podfFound->dwType & DIDFT_ABSAXIS )
{
if( !fAxisModeKnown )
{
fAxisModeKnown = TRUE;
dwAxisMode = DIPROPAXISMODE_ABS;
}
if( !( pAction->dwFlags & DIA_NORANGE )
&& ( diprange.lMin | diprange.lMax ) )
{
diprange.diph.dwObj = podfFound->dwType;
hres = CDIDev_RealSetProperty(this, DIPROP_RANGE, &diprange.diph);
if( FAILED( hres ) )
{
SquirtSqflPtszV(sqflDf | sqflBenign,
TEXT("failed (0x%08x) to set range on mapped axis action"),
hres );
}
/*
* Ranges cannot be set on natively relative
* axes so don't worry what the result is.
*/
hres = S_OK;
}
}
else
{
/*
* dwAxisMode is initialized to DIPROPAXISMODE_REL
* so that this code path is the same as the one
* for DIDF_ABSAXIS as far as it goes. Compilers
* are good at delaying branches to remove such
* duplication.
*/
if( !fAxisModeKnown )
{
fAxisModeKnown = TRUE;
}
}
}
}
else
{
SquirtSqflPtszV(sqflDf | sqflError,
TEXT("mapped action format contains invalid object 0x%08x"),
pAction->dwObjID );
hres = E_INVALIDARG;
goto done;
}
}
}
#ifdef XDEBUG
else
{
if( ( pAction->dwHow & ~DIAH_VALID )
|| ( pAction->dwHow & DIAH_ERROR )
|| ( pAction->dwFlags & ~DIA_VALID ) )
{
SquirtSqflPtszV(sqflDf | sqflBenign,
TEXT("action format contains invalid object 0x%08x"),
pAction->dwObjID );
RPF("rgoAction[%d].dwHow 0x%08x or rgoAction[%d].dwFlags 0x%08x is invalid",
pAction - paf->rgoAction, pAction->dwHow,
pAction - paf->rgoAction, pAction->dwFlags );
}
}
#endif
}
if( !fSomethingMapped )
{
SquirtSqflPtszV(sqflDf | sqflBenign, TEXT("No actions mapped") );
hres = DI_NOEFFECT;
goto done;
}
#ifdef DEBUG
/*
* Double-check the lookup tables just to preserve our sanity.
*/
{
UINT dwOfs;
for ( dwOfs = 0; dwOfs < paf->dwNumActions; dwOfs++ )
{
if ( rgiobj[dwOfs] >= 0 ) {
AssertF(pdix[rgiobj[dwOfs]].dwOfs == dwOfs);
} else {
AssertF(rgiobj[dwOfs] == -1);
}
}
}
#endif
vdf.pvi = this->pvi;
if ( fLimpFF(this->pvi,
SUCCEEDED(hres = Hel_SetDataFormat(&vdf))) ) {
this->pdix = pdix;
pdix = 0;
this->rgiobj = rgiobj;
rgiobj = 0;
this->dwDataSize = paf->dwDataSize;
/*
* Now that the lower level knows what it's dealing with set
* the default buffer size.
*/
dipdw.diph.dwObj = 0;
dipdw.diph.dwHow = DIPH_DEVICE;
dipdw.dwData = paf->dwBufferSize;
hres = CDIDev_RealSetProperty(this, DIPROP_BUFFERSIZE, &dipdw.diph);
if( SUCCEEDED( hres ) )
{
if( fAxisModeKnown )
{
AssertF( ( dwAxisMode == DIPROPAXISMODE_REL ) || ( dwAxisMode == DIPROPAXISMODE_ABS ) );
dipdw.dwData = dwAxisMode;
D( hres = )
CDIDev_RealSetProperty(this, DIPROP_AXISMODE, &dipdw.diph);
AssertF( SUCCEEDED( hres ) );
}
/*
* Complete success, whatever (success) SetProperty returns
* assume that DIPROP_AXISMODE will never fail from here.
*/
hres = S_OK;
}
else
{
SquirtSqflPtszV(sqflDf | sqflError,
TEXT("failed (0x%08x) to set buffer size 0x%0x8 for device"),
hres );
hres = E_INVALIDARG;
}
} else {
AssertF(FAILED(hres));
}
} else {
/* Out of memory */
}
done:;
FreePpv(&pdix);
FreePpv(&rgiobj);
FreePpv(&vdf.pDfOfs);
done_without_free:;
#ifdef DEBUG
ExitOleProc();
#endif
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | IDirectInputDevice | CDIDev_SetDataFormatFromMap |
*
* Worker function for SetActionMapA and SetActionMapW.
* Used to set a data format based on passed mapped actions.
*
*****************************************************************************/
STDMETHODIMP
CDIDev_SetDataFormatFromMap
(
PDD this,
LPDIACTIONFORMATW paf
)
{
HRESULT hres;
EnterProcI(CDIDev_SetDataFormatFromMap, (_ "p", paf));
if( !paf->dwBufferSize )
{
SquirtSqflPtszV(sqflDf | sqflVerbose,
TEXT("%S: zero DIACTIONFORMAT.dwBufferSize, may need to set yourself"),
s_szProc );
}
if( paf->dwBufferSize > DEVICE_MAXBUFFERSIZE )
{
RPF("IDirectInputDevice::%s: DIACTIONFORMAT.dwBufferSize of 0x%08x is very large",
s_szProc, paf->dwBufferSize );
}
/*
* Must protect with the critical section to prevent two people
* from changing the format simultaneously, or one person from
* changing the data format while somebody else is reading data.
*/
CDIDev_EnterCrit(this);
if( !this->fAcquired )
{
DIPROPDWORD dipdw;
/*
* Nuke the old data format stuff before proceeding.
* Include the "failed POV" array as we can't fail and continue.
*/
FreePpv(&this->pdix);
FreePpv(&this->rgiobj);
FreePpv(&this->rgdwPOV);
this->cdwPOV = 0;
D(this->GetState = 0);
this->fPolledDataFormat = FALSE;
/*
* Wipe out the report IDs
*/
dipdw.diph.dwSize = sizeof(DIPROPDWORD);
dipdw.diph.dwHeaderSize = sizeof(DIPROPHEADER);
dipdw.diph.dwObj = 0x0;
dipdw.diph.dwHow = DIPH_DEVICE;
dipdw.dwData = 0; // Nuke all knowledge of reportId's
hres = CDIDev_RealSetProperty(this, DIPROP_ENABLEREPORTID, &dipdw.diph);
if( SUCCEEDED(hres) || hres == E_NOTIMPL )
{
hres = CDIDev_ParseActionFormat(this, paf);
/*
* If other success codes are implemented, this check should
* be modified to ( SUCCEEDED( hres ) && ( hres != DI_NOEFFECT ) )
*/
AssertF( ( hres == S_OK ) || ( hres == DI_NOEFFECT ) || FAILED( hres ) );
if( hres == S_OK )
{
hres = CDIDev_OptimizeDataFormat(this);
}
}
else
{
SquirtSqflPtszV(sqflDf | sqflVerbose,
TEXT("Could not set DIPROP_ENABLEREPORTID to 0x0"));
}
}
else
{ /* Already acquired */
hres = DIERR_ACQUIRED;
}
CDIDev_LeaveCrit(this);
ExitOleProcR();
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | IDirectInputDevice | SetActionMapCore |
*
* Worker function, does all the real work for SetActionMapW and
* SetActionMapA. See SetActionMapW for details.
*
*****************************************************************************/
STDMETHODIMP CDIDev_SetActionMapCore
(
PDD this,
LPDIACTIONFORMATW paf,
LPWSTR lpwszUserName,
LPSTR lpszUserName,
DWORD dwFlags
)
{
HRESULT hres;
EnterProcI(IDirectInputDevice8::SetActionMapCore, (_ "pxWA", paf, dwFlags, lpwszUserName, lpszUserName ));
if( SUCCEEDED( hres = hresFullValidFl( dwFlags, DIDSAM_VALID, 3 ) ) )
{
if( dwFlags & DIDSAM_NOUSER )
{
if( dwFlags & ~DIDSAM_NOUSER )
{
RPF( "IDirectInputDevice8::SetActionMap: Invalid dwFlags 0x%08x, cannot use DIDSAM_NOUSER with other flags" );
hres = E_INVALIDARG;
}
else
{
hres = CMap_SetDeviceUserName( &this->guid, NULL );
}
}
else
{
DWORD dwCRC;
LPWSTR pwszGoodUserName;
hres = GetWideUserName( lpszUserName, lpwszUserName, &pwszGoodUserName );
if( SUCCEEDED( hres ) )
{
dwCRC = GetMapCRC( paf, &this->guid );
if( ( paf->dwCRC != dwCRC )
|| CMap_IsNewDeviceUserName( &this->guid, pwszGoodUserName ) )
{
/*
* Set the force save flag so we only have to test one bit later
*/
dwFlags |= DIDSAM_FORCESAVE;
}
if( dwFlags & DIDSAM_FORCESAVE )
{
hres = CMap_ValidateActionMapSemantics( paf, DIDBAM_PRESERVE );
if( SUCCEEDED( hres ) )
{
DWORD dwDummy;
hres = CMap_DeviceValidateActionMap( (PV)this, paf, DVAM_DEFAULT, &dwDummy );
if( FAILED( hres ) )
{
SquirtSqflPtszV(sqflDf | sqflError, TEXT("Action map invalid on SetActionMap"));
}
else if( ( hres == DI_WRITEPROTECT ) && ( paf->dwCRC != dwCRC ) )
{
RPF( "Refusing changed mappings for hardcoded device" );
hres = DIERR_INVALIDPARAM;
}
}
else
{
SquirtSqflPtszV(sqflDf | sqflError, TEXT("Action map invalid on SetActionMap"));
}
}
if( SUCCEEDED( hres ) )
{
if( SUCCEEDED( hres = CMap_SetDeviceUserName( &this->guid, pwszGoodUserName ) )
&& SUCCEEDED( hres = CDIDev_SetDataFormatFromMap( this, paf ) ) )
{
if( dwFlags & DIDSAM_FORCESAVE )
{
hres = CDIDev_SaveActionMap( this, paf, pwszGoodUserName, dwFlags );
if( SUCCEEDED( hres ) )
{
//We don't remap success code anywhere so
//assert it is what we expected
AssertF(hres==S_OK);
paf->dwCRC = dwCRC;
}
else
{
RPF( "Ignoring internal SaveActionMap error 0x%08x", hres );
hres = DI_SETTINGSNOTSAVED;
}
}
}
}
if( !lpwszUserName )
{
/*
* Free either the default name or the ANSI translation
*/
FreePv( pwszGoodUserName );
}
}
}
}
ExitOleProc();
return hres;
}
/*****************************************************************************
*
* @doc EXTERNAL
*
* @method HRESULT | IDirectInputDevice | SetActionMap |
*
* Set the data format for the DirectInput device from
* an action map for the passed application and user.
*
* If the action map has been changed (as determined by a CRC check)
* this latest map is saved after it has been applied.
*
* The data format must be set before the device can be
* acquired.
*
* It is necessary to set the data format only once.
*
* The data format may not be changed while the device
* is acquired.
*
* If the attempt to set the data format fails, all data
* format information is lost, and a valid data format
* must be set before the device may be acquired.
*
* @cwrap LPDIRECTINPUTDEVICE | lpDirectInputDevice
*
* @parm LPDIACTIONFORMAT | paf |
*
* Points to a structure that describes the actions needed by the
* application.
*
* @parm LPCTSTR | lptszUserName |
*
* Name of user for whom mapping is being set. This may be a NULL
* pointer in which case the current user is assumed.
*
* @parm DWORD | dwFlags |
*
* Flags used to control how the mapping should be set.
* Must be a valid combination of the <c DIDSAM_*> 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_INVALIDPARAM> = <c E_INVALIDARG>: A parameter is invalid.
*
* <c DIERR_ACQUIRED>: Cannot apply an action map while the device
* is acquired.
*
*****************************************************************************/
STDMETHODIMP CDIDev_SetActionMapW
(
PV pdidW,
LPDIACTIONFORMATW pafW,
LPCWSTR lpwszUserName,
DWORD dwFlags
)
{
HRESULT hres;
EnterProcR(IDirectInputDevice8W::SetActionMap, (_ "ppWx", pdidW, pafW, lpwszUserName, dwFlags));
if( ( SUCCEEDED( hres = hresPvW( pdidW ) ) )
&& ( SUCCEEDED( hres = CDIDev_ActionMap_IsValidMapObject( pafW D(comma s_szProc comma 1) ) ) ) )
{
if( pafW->dwSize != cbX(DIACTIONFORMATW) )
{
D( RPF("IDirectInputDevice::%s: Invalid DIACTIONFORMAT.dwSize 0x%08x",
s_szProc, pafW->dwSize ); )
hres = E_INVALIDARG;
}
else
{
hres = CDIDev_SetActionMapCore( _thisPvNm( pdidW, ddW ),
pafW, (LPWSTR)lpwszUserName, NULL, dwFlags );
}
}
ExitOleProc();
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | IDirectInputDevice | SetActionMapA |
*
* ANSI version of SetActionMap, see SetActionMapW for details.
*
*
*****************************************************************************/
STDMETHODIMP CDIDev_SetActionMapA
(
PV pdidA,
LPDIACTIONFORMATA pafA,
LPCSTR lpszUserName,
DWORD dwFlags
)
{
HRESULT hres;
EnterProcR(IDirectInputDevice8A::SetActionMap, (_ "ppAx", pdidA, pafA, lpszUserName, dwFlags));
if( ( SUCCEEDED( hres = hresPvA( pdidA ) ) )
&& ( SUCCEEDED( hres = CDIDev_ActionMap_IsValidMapObject(
(LPDIACTIONFORMATW)pafA D(comma s_szProc comma 1) ) ) ) )
{
if( pafA->dwSize != cbX(DIACTIONFORMATA) )
{
D( RPF("IDirectInputDevice::%s: Invalid DIACTIONFORMAT.dwSize 0x%08x",
s_szProc, pafA->dwSize ); )
hres = E_INVALIDARG;
}
else
{
/*
* For the sake of the mapper DLLs validation set the size to
* the UNICODE version. If we ever send this to an external
* component we should do this differently.
*/
pafA->dwSize = cbX(DIACTIONFORMATW);
/*
* Note, the ANSI user name is passed on as there may be no need
* to translate it. CDIDev_SetActionMapCore deals with this.
*/
hres = CDIDev_SetActionMapCore( _thisPvNm( pdidA, ddA ),
(LPDIACTIONFORMATW)pafA, NULL, (LPSTR)lpszUserName, dwFlags );
pafA->dwSize = cbX(DIACTIONFORMATA);
}
}
ExitOleProc();
return hres;
}
/*****************************************************************************
*
* @doc EXTERNAL
*
* @method HRESULT | IDirectInputDevice | GetImageInfo |
*
* Retrieves device image information for use in displaying a
* configuration UI for a single device.
*
* @cwrap LPDIRECTINPUTDEVICE | lpDirectInputDevice
*
* @parm LPDIDEVICEIMAGEINFOHEADER | pih |
*
* Pointer to structure into which the info is retrieved.
*
* @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>: A parameter is invalid.
*
* <c DIERR_NOTFOUND>: The device has no image information.
*
*****************************************************************************/
STDMETHODIMP CDIDev_GetImageInfoCore
(
PDD this,
LPDIDEVICEIMAGEINFOHEADERW piih
)
{
HRESULT hres;
EnterProcI(CDIDev_GetImageInfoCore, (_ "p", piih));
if( piih->dwSize != cbX( *piih ) )
{
D( RPF("IDirectInputDevice::%s: Invalid DIDEVICEIMAGEINFOHEADER.dwSize 0x%08x",
s_szProc, piih->dwSize ); )
hres = E_INVALIDARG;
}
else if( ( piih->lprgImageInfoArray )
&& ( piih->dwBufferSize < piih->dwSizeImageInfo ) )
{
D( RPF("IDirectInputDevice::%s: Invalid DIDEVICEIMAGEINFOHEADER.dwBufferSize 0x%08x",
s_szProc, piih->dwBufferSize ); )
hres = E_INVALIDARG;
}
else if( piih->dwBufferSize && !piih->lprgImageInfoArray )
{
D( RPF("IDirectInputDevice::%s: Invalid DIDEVICEIMAGEINFOHEADERW has dwBufferSize 0x%08x but NULL lprgImageInfoArray",
s_szProc, piih->dwBufferSize ); )
hres = E_INVALIDARG;
}
else
{
LPDIPROPSTRING pdipMapFile;
if( SUCCEEDED( hres = AllocCbPpv(cbX(*pdipMapFile), &pdipMapFile) ) )
{
pdipMapFile->diph.dwSize = cbX(DIPROPSTRING);
pdipMapFile->diph.dwHeaderSize = cbX(DIPROPHEADER);
pdipMapFile->diph.dwObj = 0;
pdipMapFile->diph.dwHow = DIPH_DEVICE;
/*
* Must have an IHV file for image info
*/
hres = CDIDev_GetPropertyW( &this->ddW, DIPROP_MAPFILE, &pdipMapFile->diph );
if( SUCCEEDED( hres ) )
{
/*
* ISSUE-2001/03/29-timgill workaraound code needs to be removed
* Initializing this to zero works around most of 34453
* Remove when that is fixed in DIMap.dll
*/
piih->dwBufferUsed = 0;
hres = this->pMS->lpVtbl->GetImageInfo( this->pMS, &this->guid, pdipMapFile->wsz, piih );
if( SUCCEEDED( hres ) )
{
piih->dwcButtons = this->dc3.dwButtons;
piih->dwcAxes = this->dc3.dwAxes;
piih->dwcPOVs = this->dc3.dwPOVs;
AssertF( ( piih->dwBufferSize == 0 )
|| ( piih->dwBufferSize >= piih->dwBufferUsed ) );
}
else
{
/*
* Use the same return code for all internal DIMap errors
*/
if( ( HRESULT_FACILITY( hres ) == FACILITY_ITF )
&& ( HRESULT_CODE( hres ) > 0x0600 ) )
{
AssertF( HRESULT_CODE( hres ) < 0x0680 );
RPF( "Internal GetImageInfo error 0x%08x", hres );
hres = DIERR_MAPFILEFAIL;
}
}
}
else
{
/*
* Use the same return code for all forms of not found
*/
hres = DIERR_NOTFOUND;
}
FreePv( pdipMapFile );
}
}
#ifdef DEBUG
ExitOleProc();
#endif
return hres;
}
STDMETHODIMP CDIDev_GetImageInfoW
(
PV pdidW,
LPDIDEVICEIMAGEINFOHEADERW piih
)
{
HRESULT hres;
EnterProcR(IDirectInputDevice8W::GetImageInfo, (_ "pp", pdidW, piih));
if( SUCCEEDED(hres = hresPvW( pdidW ) )
&& SUCCEEDED(hres = hresFullValidWriteNoScramblePxCb( piih, *piih, 1 ) ) )
{
ScrambleBuf( &piih->dwcViews, cbX( piih->dwcViews ) );
ScrambleBuf( &piih->dwcButtons, cbX( piih->dwcButtons ) );
ScrambleBuf( &piih->dwcAxes, cbX( piih->dwcAxes ) );
ScrambleBuf( &piih->dwBufferUsed, cbX( piih->dwBufferUsed ) );
if( piih->dwSizeImageInfo != cbX( *piih->lprgImageInfoArray ) )
{
D( RPF("IDirectInputDevice::%s: Invalid DIDEVICEIMAGEINFOHEADERW.dwSizeImageInfo 0x%08x",
s_szProc, piih->dwSizeImageInfo ); )
hres = E_INVALIDARG;
}
else if( SUCCEEDED(hres = hresFullValidWriteLargePvCb(
piih->lprgImageInfoArray, piih->dwBufferSize, 1 ) ) )
{
PDD this;
this = _thisPvNm(pdidW, ddW);
hres = CDIDev_GetImageInfoCore( this, piih );
}
}
ExitOleProc();
return hres;
}
STDMETHODIMP CDIDev_GetImageInfoA
(
PV pdidA,
LPDIDEVICEIMAGEINFOHEADERA piih
)
{
HRESULT hres;
EnterProcR(IDirectInputDevice8A::GetImageInfo, (_ "pp", pdidA, piih));
if( SUCCEEDED(hres = hresPvA( pdidA ) )
&& SUCCEEDED(hres = hresFullValidWriteNoScramblePxCb( piih, *piih, 1 ) ) )
{
ScrambleBuf( &piih->dwcViews, cbX( piih->dwcViews ) );
ScrambleBuf( &piih->dwcButtons, cbX( piih->dwcButtons ) );
ScrambleBuf( &piih->dwcAxes, cbX( piih->dwcAxes ) );
ScrambleBuf( &piih->dwBufferUsed, cbX( piih->dwBufferUsed ) );
if( piih->dwSizeImageInfo != cbX( *piih->lprgImageInfoArray ) )
{
D( RPF("IDirectInputDevice::%s: Invalid DIDEVICEIMAGEINFOHEADERA.dwSizeImageInfo 0x%08x",
s_szProc, piih->dwSizeImageInfo ); )
hres = E_INVALIDARG;
}
else if( SUCCEEDED(hres = hresFullValidWriteLargePvCb(
piih->lprgImageInfoArray, piih->dwBufferSize, 1 ) ) )
{
PDD this;
DIDEVICEIMAGEINFOHEADERW ihPrivate;
ihPrivate.dwSize = cbX( ihPrivate );
ihPrivate.dwSizeImageInfo = cbX( *ihPrivate.lprgImageInfoArray );
ihPrivate.dwBufferSize = cbX( *ihPrivate.lprgImageInfoArray )
* ( piih->dwBufferSize / cbX( *piih->lprgImageInfoArray ) );
hres = AllocCbPpv( ihPrivate.dwBufferSize, &ihPrivate.lprgImageInfoArray );
if( SUCCEEDED( hres ) )
{
this = _thisPvNm(pdidA, ddA);
hres = CDIDev_GetImageInfoCore( this, &ihPrivate );
if( SUCCEEDED( hres ) )
{
LPDIDEVICEIMAGEINFOW piiW;
LPDIDEVICEIMAGEINFOA piiA = piih->lprgImageInfoArray;
CAssertF( cbX( *piiA ) - cbX( piiA->tszImagePath ) == cbX( *piiW ) - cbX( piiW->tszImagePath ) );
CAssertF( FIELD_OFFSET( DIDEVICEIMAGEINFOA, tszImagePath ) == 0 );
CAssertF( FIELD_OFFSET( DIDEVICEIMAGEINFOW, tszImagePath ) == 0 );
CAssertF( FIELD_OFFSET( DIDEVICEIMAGEINFOW, dwFlags ) == cbX( piiW->tszImagePath ) );
if(ihPrivate.lprgImageInfoArray)
{
for( piiW = ihPrivate.lprgImageInfoArray;
(PBYTE)piiW < (PBYTE)ihPrivate.lprgImageInfoArray + ihPrivate.dwBufferUsed;
piiW++ )
{
UToA( piiA->tszImagePath, cbX( piiA->tszImagePath ), piiW->tszImagePath );
memcpy( (PV)&piiA->dwFlags, (PV)&piiW->dwFlags,
cbX( *piiA ) - cbX( piiA->tszImagePath ) );
piiA++;
}
}
piih->dwBufferUsed = cbX( *piih->lprgImageInfoArray )
* ( ihPrivate.dwBufferUsed / cbX( *ihPrivate.lprgImageInfoArray ) );
piih->dwcViews = ihPrivate.dwcViews;
piih->dwcButtons = ihPrivate.dwcButtons;
piih->dwcAxes = ihPrivate.dwcAxes;
piih->dwcPOVs = ihPrivate.dwcPOVs;
}
FreePv( ihPrivate.lprgImageInfoArray );
}
}
}
ExitOleProc();
return hres;
}
/*****************************************************************************
*
* @doc EXTERNAL
*
* @method HRESULT | IDirectInputDevice | GetDeviceState |
*
* Obtains instantaneous data from the DirectInput device.
*
* Before device data can be obtained, the data format must
* be set via <mf IDirectInputDevice::SetDataFormat>, and
* the device must be acquired via
* <mf IDirectInputDevice::Acquire>.
*
* @cwrap LPDIRECTINPUTDEVICE | lpDirectInputDevice
*
* @parm DWORD | cbData |
*
* The size of the buffer pointed to by <p lpvData>, in bytes.
*
* @parm OUT LPVOID | lpvData |
*
* Points to a structure that receives the current state
* of the device.
* The format of the data is established by a prior call
* to <mf IDirectInputDevice::SetDataFormat>.
*
* @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_PENDING>: The device does not have data yet.
* Some devices (such as USB joysticks) require a delay
* between the time the device is turned on and the time
* the device begins sending data. During this "warm-up" time,
* <mf IDirectInputDevice::GetDeviceState> will return
* <c E_PENDING>. When data becomes available, the event
* notification handle will be signalled.
*
* <c DIERR_NOTACQUIRED>: The device is not acquired.
*
* <c DIERR_INPUTLOST>: Access to the device has been
* interrupted. The application should re-acquire the
* device.
*
* <c DIERR_INVALIDPARAM> = <c E_INVALIDARG>: The
* <p lpvData> parameter is not a valid pointer or
* the <p cbData> parameter does not match the data size
* set by a previous call to <mf IDirectInputDevice::SetDataFormat>.
*
*****************************************************************************/
extern STDMETHODIMP CDIDev_Acquire(PV pdd _THAT);
STDMETHODIMP
CDIDev_GetDeviceState(PV pdd, DWORD cbDataSize, LPVOID pvData _THAT)
{
HRESULT hres;
PDD this;
EnterProcR(IDirectInputDevice8::GetDeviceState, (_ "pp", pdd, pvData));
/*
* Note that we do not validate the parameters.
* The reason is that GetDeviceState is an inner loop function,
* so it should be as fast as possible.
*/
#ifdef XDEBUG
hresPvT(pdd);
hresFullValidWritePvCb(pvData, cbDataSize, 1);
#endif
this = _thisPv(pdd);
/*
* Must protect with the critical section to prevent somebody from
* unacquiring while we're reading.
*/
CDIDev_EnterCrit(this);
/*
* Reacquire is not allowed until after Win98 SE, see OSR Bug # 89958
*/
if ( this->diHacks.fReacquire &&
!this->fAcquired && (this->fOnceAcquired || this->fOnceForcedUnacquired) )
{
if ( SUCCEEDED( CDIDev_Acquire(pdd THAT_) ) ) {
// 7/18/2000(a-JiTay): IA64: Use %p format specifier for 32/64-bit pointers.
RPF(" DirectInput: Auto acquired (0x%p)", pdd);
}
}
#ifdef WINNT
if( this->fUnacquiredWhenIconic && !IsIconic(this->hwnd) ) {
if ( SUCCEEDED( CDIDev_Acquire(pdd THAT_) ) ) {
this->fUnacquiredWhenIconic = 0;
RPF(" DirectInput: Auto acquired device (0x%p) after being iconic. ", pdd);
}
}
#endif
if ( this->fAcquired ) {
AssertF(this->pdix); /* Acquire shouldn't let you get this far */
AssertF(this->GetState);
AssertF(this->GetDeviceState);
AssertF(this->pdcb);
if ( this->dwDataSize == cbDataSize ) {
#ifndef DEBUG_STICKY
hres = this->GetState(this, pvData);
#else
PBYTE pbDbg;
TCHAR tszDbg[80];
hres = this->GetState(this, pvData);
for( pbDbg=(PBYTE)pvData; pbDbg<((PBYTE)pvData+cbDataSize); pbDbg++ )
{
if( *pbDbg )
{
wsprintf( tszDbg, TEXT("GotState @ 0x%02x, 0x%02x\r\n"), pbDbg-(PBYTE)pvData, *pbDbg );
OutputDebugString( tszDbg );
}
}
#endif /* DEBUG_STICKY */
if ( SUCCEEDED(hres) ) {
UINT idw;
AssertF(hres == S_OK);
/*
* Icky POV hack for apps that don't check if they have
* a POV before reading from it.
*/
for ( idw = 0; idw < this->cdwPOV; idw++ ) {
DWORD UNALIGNED *pdw = pvAddPvCb(pvData, this->rgdwPOV[idw]);
*pdw = JOY_POVCENTERED;
}
hres = S_OK;
} else if ( hres == DIERR_INPUTLOST ) {
RPF("%s: Input lost", s_szProc);
CDIDev_InternalUnacquire(this);
hres = DIERR_INPUTLOST;
}
} else {
RPF("ERROR %s: arg %d: invalid value", s_szProc, 1);
hres = E_INVALIDARG;
}
} else {
hres = this->hresNotAcquired;
}
if ( FAILED(hres) ) {
ScrambleBuf(pvData, cbDataSize);
}
CDIDev_LeaveCrit(this);
ExitOleProc();
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method void | IDirectInputDevice | CookDeviceData |
*
* Cook device data that was recently obtained from the
* device buffer.
*
* Right now, only the joystick device requires cooking,
* and nobody in their right mind uses buffered joystick
* data, and the joystick has only a few objects, so we
* can afford to be slow on this.
*
* @cwrap LPDIRECTINPUTDEVICE | lpDirectInputDevice
*
* @parm DWORD | cdod |
*
* Number of objects to cook.
*
* @parm LPDIDEVICEOBJECTDATA | rgdod |
*
* Array of object data to cook. The dwOfs are really
* device object indexes (relative to the device format).
* After calling the callback, we convert them into
* application data format offsets.
*
* @returns
*
* None.
*
*****************************************************************************/
void INTERNAL
CDIDev_CookDeviceData(PDD this, DWORD cdod, LPDIDEVICEOBJECTDATA rgdod)
{
EnterProc(IDirectInputDevice8::CookDeviceData,
(_ "pxp", this, cdod, rgdod));
AssertF(this->fCook);
/*
* Relative data does not need to be cooked by the callback.
*/
if( ( this->pvi->fl & VIFL_RELATIVE ) == 0 )
{
this->pdcb->lpVtbl->CookDeviceData(this->pdcb, cdod, rgdod);
}
/*
* Step through array converting to application data format offsets
* including adding the uAppData
*/
for( ; cdod; cdod--,rgdod++ )
{
rgdod->uAppData = this->pdix[rgdod->dwOfs].uAppData;
rgdod->dwOfs = this->pdix[rgdod->dwOfs].dwOfs;
}
ExitProc();
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @struct SOMEDEVICEDATA |
*
* Instance data used by <mf IDirectInputDevice::GetSomeDeviceData>.
*
* @field DWORD | celtIn |
*
* Number of elements remaining in output buffer.
*
* @field PDOD | rgdod |
*
* Output buffer for data elements, or <c NULL> if
* elements should be discarded.
*
* @field DWORD | celtOut |
*
* Number of elements actually copied (so far).
*
*****************************************************************************/
typedef struct SOMEDEVICEDATA {
DWORD celtIn;
PDOD rgdod;
DWORD celtOut;
} SOMEDEVICEDATA, *PSOMEDEVICEDATA;
/*****************************************************************************
*
* @doc INTERNAL
*
* @method PDOD | IDirectInputDevice | GetSomeDeviceData |
*
* Obtains a small amount of
* buffered data from the DirectInput device.
*
* @cwrap LPDIRECTINPUTDEVICE | lpDirectInputDevice
*
* @parm PDOD | pdod |
*
* First element to copy.
*
* @parm DWORD | celt |
*
* Maximum number of elements to copy.
*
* @parm PSOMEDEVICEDATA | psdd |
*
* Structure describing the state of the ongoing
* <mf IDirectInputDevice::GetDeviceData>.
*
* @returns
*
* Returns a pointer to the first uncopied item.
*
*****************************************************************************/
LPDIDEVICEOBJECTDATA_DX3 INTERNAL
CDIDev_GetSomeDeviceData
(
PDD this,
LPDIDEVICEOBJECTDATA_DX3 pdod,
DWORD celt,
PSOMEDEVICEDATA psdd
)
{
#ifdef XDEBUG
DWORD cCopied;
#endif
EnterProc(IDirectInputDevice8::GetSomeDeviceData,
(_ "ppxx", this, pdod, celt, psdd->celtIn));
/*
* Copy as many elements as fit, but not more than exist
* in the output buffer.
*/
if ( celt > psdd->celtIn ) {
celt = psdd->celtIn;
}
#ifdef XDEBUG
cCopied = celt;
#endif
/*
* Copy the elements (if requested) and update the state.
* Note that celt might be zero.
*/
psdd->celtOut += celt;
psdd->celtIn -= celt;
if( psdd->rgdod )
{
LPDIDEVICEOBJECTDATA pdod8;
pdod8 = psdd->rgdod;
if( this->fCook )
{
/*
* For a cooked device, leave the offset untranslated so that it
* can be used to find the appropriate calibration data.
*/
for( ; celt ; celt-- )
{
pdod8->dwOfs = pdod->dwOfs;
pdod8->dwData = pdod->dwData;
pdod8->dwTimeStamp = pdod->dwTimeStamp;
pdod8->dwSequence = pdod->dwSequence;
pdod++;
pdod8++;
}
}
else
{
for( ; celt ; celt-- )
{
pdod8->dwOfs = this->pdix[pdod->dwOfs].dwOfs;
pdod8->uAppData = this->pdix[pdod->dwOfs].uAppData;
pdod8->dwData = pdod->dwData;
pdod8->dwTimeStamp = pdod->dwTimeStamp;
pdod8->dwSequence = pdod->dwSequence;
pdod++;
pdod8++;
}
}
psdd->rgdod = pdod8;
}
else
{
pdod += celt;
}
if ( pdod == this->pvi->pEnd ) {
pdod = this->pvi->pBuffer;
}
ExitProcX(cCopied);
return pdod;
}
/*
* Keep GetDeviceData, SendDeviceData and Poll in sqflDev
*/
#undef sqfl
#define sqfl sqflDev
/*****************************************************************************
*
* @doc EXTERNAL
*
* @method HRESULT | IDirectInputDevice | GetDeviceData |
*
* Obtains buffered data from the DirectInput device.
*
* DirectInput devices are, by default, unbuffered. To
* turn on buffering, you must set the buffer size
* via <mf IDirectInputDevice::SetProperty>, setting the
* <c DIPROP_BUFFERSIZE> property to the desired size
* of the input buffer.
*
* Before device data can be obtained, the data format must
* be set via <mf IDirectInputDevice::SetDataFormat>, and
* the device must be acquired via
* <mf IDirectInputDevice::Acquire>.
*
* @cwrap LPDIRECTINPUTDEVICE | lpDirectInputDevice
*
* @parm DWORD | cbObjectData |
*
* The size of a single <t DIDEVICEOBJECTDATA> structure in bytes.
*
* @parm OUT LPDIDEVICEOBJECTDATA | rgdod |
*
* Array of <t DIDEVICEOBJECTDATA> structures to receive
* the buffered data. It must consist of
* *<p pdwInOut> elements.
*
* If this parameter is <c NULL>, then the buffered data is
* not stored anywhere, but all other side-effects take place.
*
* @parm INOUT LPDWORD | pdwInOut |
*
* On entry, contains the number of elements in the array
* pointed to by <p rgdod>. On exit, contains the number
* of elements actually obtained.
*
* @parm DWORD | fl |
*
* Flags which control the manner in which data is obtained.
* It may be zero or more of the following flags:
*
* <c DIGDD_PEEK>: Do not remove the items from the buffer.
* A subsequent <mf IDirectInputDevice::GetDeviceData> will
* read the same data. Normally, data is removed from the
* buffer after it is read.
*
;begin_internal dx4
* <c DIGDD_RESIDUAL>: Read data from the device buffer
* even if the device is not acquired. Normally, attempting
* to read device data from an unacquired device will return
* <c DIERR_NOTACQUIRED> or <c DIERR_INPUTLOST>.
;end_internal dx4
*
* @returns
*
* <c DI_OK> = <c S_OK>: All data were retrieved
* successfully. Note that the application needs to check
* the output value of *<p pdwInOut> to determine whether
* and how much data was retrieved: The value may be zero,
* indicating that the buffer was empty.
*
* <c DI_BUFFEROVERFLOW> = <c S_FALSE>: Some data
* were retrieved successfully, but some data were lost
* because the device's buffer size was not large enough.
* The application should retrieve buffered data more frequently
* or increase the device buffer size. This status code is
* returned only on the first <mf IDirectInput::GetDeviceData>
* call after the buffer has overflowed. Note that this is
* a success status code.
*
* <c DIERR_NOTACQUIRED>: The device is not acquired.
*
* <c DIERR_INPUTLOST>: Access to the device has been
* interrupted. The application should re-acquire the
* device.
*
* <c DIERR_INVALIDPARAM> = <c E_INVALIDARG>: One or more
* parameters was invalid. A common cause for this is
* neglecting to set a buffer size.
*
* <c DIERR_NOTBUFFERED>: The device is not buffered.
* Set the <c DIPROP_BUFFERSIZE> property to enable buffering.
*
* @ex
*
* The following sample reads up to ten buffered data elements,
* removing them from the device buffer as they are read.
*
* |
*
* DIDEVICEOBJECTDATA rgdod[10];
* DWORD dwItems = 10;
* hres = IDirectInputDevice_GetDeviceData(
* pdid,
* sizeof(DIDEVICEOBJECTDATA),
* rgdod,
* &dwItems,
* 0);
* if (SUCCEEDED(hres)) {
* // Buffer successfully flushed.
* // dwItems = number of elements flushed
* if (hres == DI_BUFFEROVERFLOW) {
* // Buffer had overflowed.
* }
* }
*
*
*
*
* @ex
*
* If you pass <c NULL> for the <p rgdod> and request an
* infinite number of items, this has the effect of flushing
* the buffer and returning the number of items that were
* flushed.
*
* |
*
* dwItems = INFINITE;
* hres = IDirectInputDevice_GetDeviceData(
* pdid,
* sizeof(DIDEVICEOBJECTDATA),
* NULL,
* &dwItems,
* 0);
* if (SUCCEEDED(hres)) {
* // Buffer successfully flushed.
* // dwItems = number of elements flushed
* if (hres == DI_BUFFEROVERFLOW) {
* // Buffer had overflowed.
* }
* }
*
* @ex
*
* If you pass <c NULL> for the <p rgdod>, request an
* infinite number of items, and ask that the data not be
* removed from the device buffer, this has the effect of
* querying for the number of elements in the device buffer.
*
* |
*
* dwItems = INFINITE;
* hres = IDirectInputDevice_GetDeviceData(
* pdid,
* sizeof(DIDEVICEOBJECTDATA),
* NULL,
* &dwItems,
* DIGDD_PEEK);
* if (SUCCEEDED(hres)) {
* // dwItems = number of elements in buffer
* if (hres == DI_BUFFEROVERFLOW) {
* // Buffer overflow occurred; not all data
* // were successfully captured.
* }
* }
*
* @ex
*
* If you pass <c NULL> for the <p rgdod> and request zero
* items, this has the effect of querying whether buffer
* overflow has occurred.
*
* |
*
* dwItems = 0;
* hres = IDirectInputDevice_GetDeviceData(
* pdid,
* sizeof(DIDEVICEOBJECTDATA),
* NULL,
* &dwItems,
* 0);
* if (hres == DI_BUFFEROVERFLOW) {
* // Buffer overflow occurred
* }
*
*
*//**************************************************************************
*
* When reading this code, the following pictures will come in handy.
*
*
* Buffer not wrapped.
*
* pBuffer pEnd
* | |
* v v
* +----+----+----+----+----+----+----+----+----+----+----+
* | | | | | | | | | | | |
* | | | |data|data|data|data|data| | | |
* | | | | | | | | | | | |
* +----+----+----+----+----+----+----+----+----+----+----+
* ^ ^
* | |
* pTail pHead
*
*
* Buffer wrapped.
*
* pBuffer pEnd
* | |
* v v
* +----+----+----+----+----+----+----+----+----+----+----+
* | | | | | | | | | | | |
* |data|data| | | | | | |data|data|data|
* | | | | | | | | | | | |
* +----+----+----+----+----+----+----+----+----+----+----+
* ^ ^
* | |
* pHead pTail
*
*
* Boundary wrap case.
*
*
* pBuffer pEnd
* | |
* v v
* +----+----+----+----+----+----+----+----+----+----+----+
* | | | | | | | | | | | |
* | | | | | | |data|data|data|data|data|
* | | | | | | | | | | | |
* +----+----+----+----+----+----+----+----+----+----+----+
* ^ ^
* | |
* pHead pTail
*
*
* Note! At no point is pTail == pEnd or pHead == pEnd.
*
*****************************************************************************/
STDMETHODIMP
CDIDev_GetDeviceData(PV pdd, DWORD cbdod, PDOD rgdod,
LPDWORD pdwInOut, DWORD fl _THAT)
{
HRESULT hres;
PDD this;
SOMEDEVICEDATA sdd;
EnterProcR(IDirectInputDevice8::GetDeviceData,
(_ "pxpxx", pdd, cbdod, rgdod,
IsBadReadPtr(pdwInOut, cbX(DWORD)) ? 0 : *pdwInOut, fl));
/*
* Note that we do not validate the parameters.
* The reason is that GetDeviceData is an inner loop function,
* so it should be as fast as possible.
*
* Note also that it is legal to get device data after the device
* has been unacquired. This lets you "turn on the faucet" for
* a short period of time, and then parse the data out later.
*/
this = _thisPv(pdd);
#ifdef XDEBUG
hresPvT(pdd);
if ( IsBadWritePtr(pdwInOut, cbX(*pdwInOut)) ) {
RPF("ERROR %s: arg %d: invalid value; crash soon", s_szProc, 3);
}
#endif
if( cbdod == cbX(DOD) )
{
#ifdef XDEBUG
/*
* Only check the buffer if the size is correct otherwise
* we can smash the stack of the caller when we've already
* detected the error.
*/
if ( rgdod ) {
hresFullValidWritePvCb(rgdod, *pdwInOut * cbdod, 2);
}
#endif
/*
* Must protect with the critical section to prevent somebody from
* acquiring/unacquiring or changing the data format or calling
* another GetDeviceData while we're reading. (We must be serialized.)
*/
CDIDev_EnterCrit(this);
AssertF(CDIDev_IsConsistent(this));
if ( SUCCEEDED(hres = hresFullValidFl(fl, DIGDD_VALID, 4)) ) {
if ( this->celtBuf ) {
/*
* Don't try to read more than there possibly could be.
* This avoids overflow conditions in case celtIn is
* some absurdly huge number.
*/
sdd.celtIn = *pdwInOut;
sdd.celtOut = 0;
if ( sdd.celtIn > this->celtBuf ) {
sdd.celtIn = this->celtBuf;
}
sdd.rgdod = rgdod;
/*
* For this version of DirectInput, we do not allow
* callbacks to implement their own GetDeviceData.
*/
if ( this->pvi ) {
/*
* Reacquire is not allowed until after Win98 SE, see OSR Bug # 89958
*/
if ( this->diHacks.fReacquire &&
!this->fAcquired && (this->fOnceAcquired || this->fOnceForcedUnacquired) )
{
if ( SUCCEEDED( CDIDev_Acquire(pdd THAT_) ) ) {
// 7/18/2000(a-JiTay): IA64: Use %p format specifier for 32/64-bit pointers.
RPF(" DirectInput: Auto acquired device (0x%p)", pdd);
}
}
#ifdef WINNT
if( this->fUnacquiredWhenIconic && !IsIconic(this->hwnd) ) {
if ( SUCCEEDED( CDIDev_Acquire(pdd THAT_) ) ) {
this->fUnacquiredWhenIconic = 0;
RPF(" DirectInput: Auto acquired device (0x%p) after being iconic. ", pdd);
}
}
#endif
if ( (this->fAcquired && (this->pvi->fl & VIFL_ACQUIRED)) ||
(fl & DIGDD_RESIDUAL) ) {
/*
* The device object data from the driver is always a
* DX3 (<DX8) structure
*/
LPDIDEVICEOBJECTDATA_DX3 pdod, pdodHead;
DWORD celt;
/*
* Snapshot the value of pdodHead, because it can
* change asynchronously. The other fields won't
* change unless we ask for them to be changed.
*/
pdodHead = this->pvi->pHead;
/*
* Throughout, pdod points to the first unprocessed
* element.
*/
pdod = this->pvi->pTail;
/*
* If we are wrapped, handle the initial run.
*/
if ( pdodHead < this->pvi->pTail ) {
celt = (DWORD)(this->pvi->pEnd - this->pvi->pTail);
AssertF(celt);
pdod = CDIDev_GetSomeDeviceData( this, pdod, celt, &sdd );
}
/*
* Now handle the glob from pdod to pdodHead.
* Remember, pvi->pdodHead may have changed
* behind our back; use the cached value to
* ensure consistency. (If we miss data,
* it'll show up later.)
*/
AssertF(fLimpFF(sdd.celtIn, pdodHead >= pdod));
celt = (DWORD)(pdodHead - pdod);
if ( celt ) {
pdod = CDIDev_GetSomeDeviceData( this, pdod, celt, &sdd );
}
*pdwInOut = sdd.celtOut;
if ( !(fl & DIGDD_PEEK) ) {
this->pvi->pTail = pdod;
}
if ( rgdod && sdd.celtOut && this->fCook ) {
CDIDev_CookDeviceData(this, sdd.celtOut, rgdod );
}
CAssertF(S_OK == 0);
CAssertF(DI_BUFFEROVERFLOW == 1);
hres = (HRESULT)(UINT_PTR)pvExchangePpvPv(&this->pvi->fOverflow, 0);
#ifdef DEBUG_STICKY
if( hres == 1 )
{
OutputDebugString( TEXT( "Device buffer overflowed\r\n" ) );
}
if( sdd.celtOut )
{
PDOD pdoddbg;
TCHAR tszDbg[80];
wsprintf( tszDbg, TEXT("GotData %d elements: "), sdd.celtOut );
OutputDebugString( tszDbg );
for( pdoddbg=rgdod; pdoddbg<&rgdod[sdd.celtOut]; pdoddbg++ )
{
wsprintf( tszDbg, TEXT("0x%02x:x0x%08x "), pdoddbg->dwOfs, pdoddbg->dwData );
OutputDebugString( tszDbg );
}
OutputDebugString( TEXT("\r\n") );
}
#endif /* DEBUG_STICKY */
} else if (this->fAcquired && !(this->pvi->fl & VIFL_ACQUIRED)) {
RPF("ERROR %s - %s", s_szProc, "input lost");
hres = DIERR_INPUTLOST;
CDIDev_InternalUnacquire(this);
} else {
RPF("ERROR %s: %s", s_szProc,
this->hresNotAcquired == DIERR_NOTACQUIRED
? "Not acquired" : "Input lost");
hres = this->hresNotAcquired;
}
} else { /* Don't support device-side GetData yet */
hres = E_NOTIMPL;
}
} else { /* Device is not buffered */
#ifdef XDEBUG
if ( !this->fNotifiedNotBuffered ) {
this->fNotifiedNotBuffered = 1;
RPF("ERROR %s: arg %d: device is not buffered", s_szProc, 0);
}
#endif
hres = DIERR_NOTBUFFERED;
}
}
}
else
{
if( cbdod == cbX(DIDEVICEOBJECTDATA_DX3) )
{
RPF("ERROR %s: arg %d: old size, invalid for DX8", s_szProc, 1);
}
else
{
RPF("ERROR %s: arg %d: invalid value", s_szProc, 1);
}
hres = E_INVALIDARG;
}
CDIDev_LeaveCrit(this);
return hres;
}
/*****************************************************************************
*
* @doc EXTERNAL
*
* @method HRESULT | IDirectInputDevice8 | Poll |
*
* Retrieves data from polled objects on a DirectInput device.
* If the device does not require polling, then calling this
* method has no effect. If a device that requires polling
* is not polled periodically, no new data will be received
* from the device.
*
* Before a device data can be polled, the data format must
* be set via <mf IDirectInputDevice::SetDataFormat>, and
* the device must be acquired via
* <mf IDirectInputDevice::Acquire>.
*
* @cwrap LPDIRECTINPUTDEVICE | lpDirectInputDevice
*
* @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 DI_NOEFFECT> = <c S_FALSE>: The device does not require
* polling.
*
* <c DIERR_INPUTLOST>: Access to the device has been
* interrupted. The application should re-acquire the
* device.
*
* <c DIERR_NOTACQUIRED>: The device is not acquired.
*
*****************************************************************************/
STDMETHODIMP
CDIDev_Poll(PV pdd _THAT)
{
HRESULT hres;
PDD this;
EnterProcR(IDirectInputDevice8::Poll, (_ "p", pdd));
/*
* Note that we do not validate the parameters.
* The reason is that Poll is an inner loop function,
* so it should be as fast as possible.
*/
#ifdef XDEBUG
hresPvT(pdd);
#endif
this = _thisPv(pdd);
/*
* Fast out: If the device doesn't require polling,
* then don't bother with the critical section or other validation.
*/
if ( this->fPolledDataFormat ) {
/*
* Must protect with the critical section to prevent somebody from
* unacquiring while we're polling.
*/
CDIDev_EnterCrit(this);
if ( this->fAcquired ) {
hres = this->pdcb->lpVtbl->Poll(this->pdcb);
} else {
hres = this->hresNotAcquired;
}
CDIDev_LeaveCrit(this);
} else {
if ( this->fAcquired ) {
hres = S_FALSE;
} else {
hres = this->hresNotAcquired;
}
}
/*
* Failing polls are really annoying so don't use ExitOleProc
*/
if( FAILED( hres ) )
{
SquirtSqflPtszV(sqfl | sqflVerbose, TEXT("IDirectInputDevice::Poll failed 0x%08x"), hres );
}
ExitProc();
return hres;
}
/*****************************************************************************
*
* @doc EXTERNAL
*
* @method HRESULT | IDirectInputDevice8 | SendDeviceData |
*
* Sends data to the device.
*
* Before device data can be sent to a device,
* the device must be acquired via
* <mf IDirectInputDevice::Acquire>.
*
* Note that no guarantees
* are made on the order in which the individual data
* elements are sent. However, data sent by
* successive calls to
* <mf IDirectInputDevice8::SendDeviceData>
* will not be interleaved.
* Furthermore, if multiple pieces of
* data are sent to the same object, it is unspecified
* which actual piece of data is sent.
*
* Consider, for example, a device which can be sent
* data in packets, each packet describing two pieces
* of information, call them A and B. Suppose the
* application attempts to send three data elements,
* "B = 2", "A = 1", and "B = 0".
*
* The actual device will be sent a single packet.
* The "A" field of the packet will contain the value 1,
* and the "B" field of the packet will be either 2 or 0.
*
* If the application wishes the data to be sent to the
* device exactly as specified, then three calls to
* <mf IDirectInputDevice8::SendDeviceData> should be
* performed, each call sending one data element.
*
* In response to the first call,
* the device will be sent a packet where the "A" field
* is blank and the "B" field contains the value 2.
*
* In response to the second call,
* the device will be sent a packet where the "A" field
* contains the value 1, and the "B" field is blank.
*
* Finally, in response to the third call,
* the device will be sent a packet where the "A" field
* is blank and the "B" field contains the value 0.
*
*
*
* @cwrap LPDIRECTINPUTDEVICE | lpDirectInputDevice
*
* @parm DWORD | cbObjectData |
*
* The size of a single <t DIDEVICEOBJECTDATA> structure in bytes.
*
* @parm IN LPCDIDEVICEOBJECTDATA | rgdod |
*
* Array of <t DIDEVICEOBJECTDATA> structures containing
* the data to send to the device. It must consist of
* *<p pdwInOut> elements.
*
* <y Note>: The <e DIDEVICEOBJECTDATA.dwOfs> field of
* the <t DIDEVICEOBJECTDATA> structure must contain the
* device object identifier (as obtained from the
* <e DIDEVICEOBJECTINSTANCE.dwType> field of the
* <t DIDEVICEOBJECTINSTANCE> sturcture) for the device
* object at which the data is directed.
*
* Furthermore, the <e DIDEVICEOBJECTDATA.dwTimeStamp>
* <e DIDEVICEOBJECTDATA.dwSequence> and
* <e DIDEVICEOBJECTDATA.uAppData> fields are
* reserved for future use and must be zero.
*
* @parm INOUT LPDWORD | pdwInOut |
*
* On entry, contains the number of elements in the array
* pointed to by <p rgdod>. On exit, contains the number
* of elements actually sent to the device.
*
* @parm DWORD | fl |
*
* Flags which control the manner in which data is sent.
* It may consist of zero or more of the following flags:
*
* <c DISDD_CONTINUE>: If this flag is set, then
* the device data sent will be overlaid upon the previously
* sent device data. Otherwise, the device data sent
* will start from scratch.
*
* For example, suppose a device supports two button outputs,
* call them A and B.
* If an application first calls
* <mf IDirectInputDevice8::SendDeviceData> passing
* "button A pressed", then
* a packet of the form "A pressed, B not pressed" will be
* sent to the device.
* If an application then calls
* <mf IDirectInputDevice8::SendDeviceData> passing
* "button B pressed" and the <c DISDD_CONTINUE> flag, then
* a packet of the form "A pressed, B pressed" will be
* sent to the device.
* However, if the application had not passed the
* <c DISDD_CONTINUE> flag, then the packet sent to the device
* would have been "A not pressed, B pressed".
*
*
* @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_INPUTLOST>: Access to the device has been
* interrupted. The application should re-acquire the
* device.
*
* <c DIERR_NOTACQUIRED>: The device is not acquired.
*
*****************************************************************************/
STDMETHODIMP
CDIDev_SendDeviceData(PV pdd, DWORD cbdod, LPCDIDEVICEOBJECTDATA rgdod,
LPDWORD pdwInOut, DWORD fl _THAT)
{
HRESULT hres;
PDD this;
EnterProcR(IDirectInputDevice8::SendDeviceData,
(_ "pxpxx", pdd, cbdod, rgdod,
IsBadReadPtr(pdwInOut, cbX(DWORD)) ? 0 : *pdwInOut, fl));
/*
* Note that parameter validation is limited as SendDeviceData is
* intended to be an inner loop function. In practice SendDeviceData is
* rarely used so speed is not that important.
*/
#ifdef XDEBUG
hresPvT(pdd);
if ( IsBadWritePtr(pdwInOut, cbX(*pdwInOut)) ) {
RPF("ERROR %s: arg %d: invalid value; crash soon", s_szProc, 3);
}
hresFullValidReadPvCb(rgdod, cbX(*pdwInOut) * cbdod, 2);
#endif
this = _thisPv(pdd);
/*
* Must protect with the critical section to prevent somebody from
* unacquiring while we're sending data.
*/
CDIDev_EnterCrit(this);
if ( SUCCEEDED(hres = hresFullValidFl(fl, DISDD_VALID, 4)) ) {
if( cbdod == cbX(DOD) )
{
#ifdef XDEBUG
UINT iodDbg;
LPCDIDEVICEOBJECTDATA pcdod;
for ( iodDbg = 0, pcdod=rgdod; iodDbg < *pdwInOut; iodDbg++ ) {
if ( pcdod->dwTimeStamp ) {
RPF("%s: ERROR: dwTimeStamp must be zero", s_szProc);
}
if ( pcdod->dwSequence ) {
RPF("%s: ERROR: dwSequence must be zero", s_szProc);
}
if( pcdod->uAppData ){
RPF("%s: ERROR: uAppData must be zero", s_szProc);
}
pcdod++;
}
#endif
if ( this->fAcquired ) {
UINT iod;
LPDIDEVICEOBJECTDATA pdodCopy;
hres = AllocCbPpv( cbCxX( *pdwInOut, *pdodCopy ), &pdodCopy );
if( SUCCEEDED( hres ) )
{
LPDIDEVICEOBJECTDATA pdod;
memcpy( pdodCopy, rgdod, cbCxX( *pdwInOut, *pdodCopy ) );
for( iod=0, pdod=pdodCopy; iod < *pdwInOut; iod++ )
{
int iobj = CDIDev_OffsetToIobj(this, pdod->dwOfs);
pdod->dwOfs = this->df.rgodf[iobj].dwType;
pdod++;
}
hres = this->pdcb->lpVtbl->SendDeviceData(this->pdcb, cbdod,
pdodCopy, pdwInOut, fl );
FreePv( pdodCopy );
}
} else {
hres = this->hresNotAcquired;
}
} else {
RPF("ERROR %s: arg %d: invalid value", s_szProc, 1);
}
}
CDIDev_LeaveCrit(this);
ExitOleProc();
return hres;
}
#undef sqfl
#define sqfl sqflDf
/*****************************************************************************
*
* @doc INTERNAL
*
* @func BOOL | CDIDev_CheckId |
*
* Verify that the item has the appropriate type.
*
* @parm DWORD | dwId |
*
* ID to locate.
*
* @parm UINT | fl |
*
* Bitmask of flags for things to validate.
*
* The <c DEVCO_TYPEMASK> fields describe what type
* of object we should be locating.
*
* The <c DEVCO_ATTRMASK> fields describe the attribute
* bits that are required.
*
*****************************************************************************/
BOOL INLINE
CDIDev_CheckId(DWORD dwId, DWORD fl)
{
CAssertF(DIDFT_ATTRMASK == DEVCO_ATTRMASK);
return(dwId & fl & DEVCO_TYPEMASK) &&
fHasAllBitsFlFl(dwId, fl & DIDFT_ATTRMASK);
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method int | CDIDev | IdToIobj |
*
* Locate an item which matches the specified ID.
*
* @cwrap PDD | this
*
* @parm DWORD | dwId |
*
* ID to locate.
*
* @returns
*
* Returns the index of the object found, or -1 on error.
*
*****************************************************************************/
int INTERNAL
CDIDev_IdToIobj(PDD this, DWORD dwId)
{
int iobj;
/* Someday: Perf: Should have xlat table */
for ( iobj = this->df.dwNumObjs; --iobj >= 0; ) {
PODF podf = &this->df.rgodf[iobj];
if ( DIDFT_FINDMATCH(podf->dwType, dwId) ) {
goto done;
}
}
iobj = -1;
done:;
return iobj;
}
#if 0
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CDIDev | IdToId |
*
* Convert a single <t DWORD> from an ID to an ID.
*
* This is clearly a very simple operation.
*
* It's all validation.
*
* @cwrap PDD | this
*
* @parm LPDWORD | pdw |
*
* Single item to convert.
*
* @parm UINT | fl |
*
* Bitmask of flags that govern the conversion.
* The function should look only at
* <c DEVCO_AXIS> or <c DEVCO_BUTTON>.
*
*****************************************************************************/
HRESULT INTERNAL
CDIDev_IdToId(PDD this, LPDWORD pdw, UINT fl)
{
HRESULT hres;
int iobj;
iobj = CDIDev_FindId(this, *pdw, fl);
if ( iobj >= 0 ) {
*pdw = this->df.rgodf[iobj].dwType;
hres = S_OK;
} else {
hres = E_INVALIDARG;
}
return hres;
}
#endif
/*****************************************************************************
*
* @doc INTERNAL
*
* @method int | CDIDev | OffsetToIobj |
*
* Convert a single <t DWORD> from an offset to an object index.
*
* @cwrap PDD | this
*
* @parm DWORD | dwOfs |
*
* Offset to convert.
*
*****************************************************************************/
int INTERNAL
CDIDev_OffsetToIobj(PDD this, DWORD dwOfs)
{
int iobj;
AssertF(this->pdix);
AssertF(this->rgiobj);
if ( dwOfs < this->dwDataSize ) {
iobj = this->rgiobj[dwOfs];
if ( iobj >= 0 ) {
AssertF(this->pdix[iobj].dwOfs == dwOfs);
} else {
AssertF(iobj == -1);
}
} else {
iobj = -1;
}
return iobj;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method int | CDIDev | IobjToId |
*
* Convert an object index to an ID.
*
* @cwrap PDD | this
*
* @parm int | iobj |
*
* Single item to convert.
*
*****************************************************************************/
DWORD INLINE
CDIDev_IobjToId(PDD this, int iobj)
{
AssertF((DWORD)iobj < this->df.dwNumObjs);
return this->df.rgodf[iobj].dwType;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method int | CDIDev | IobjToOffset |
*
* Convert an object index to an offset.
*
* @cwrap PDD | this
*
* @parm int | iobj |
*
* Single item to convert.
*
*****************************************************************************/
DWORD INLINE
CDIDev_IobjToOffset(PDD this, int iobj)
{
AssertF((DWORD)iobj < this->df.dwNumObjs);
AssertF(this->pdix);
return this->pdix[iobj].dwOfs;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CDIDev | ConvertObjects |
*
* Convert between the ways of talking about device gizmos.
*
* Since this is used only by the force feedback subsystem,
* we also barf if the device found does not support
* force feedback.
*
* @cwrap PDD | this
*
* @parm UINT | cdw |
*
* Number of elements to convert (in-place).
*
* @parm LPDWORD | rgdw |
*
* Array of elements to convert.
*
* @parm UINT | fl |
*
* Flags that describe how to do the conversion.
*
* <c DEVCO_AXIS> or <c DEVCO_BUTTON> indicate whether
* the item being converted is an axis or button.
*
* <c DEVCO_FROM*> specifies what the existing value is.
*
* <c DEVCO_TO*> specifies what the new values should be.
*
*****************************************************************************/
STDMETHODIMP
CDIDev_ConvertObjects(PDD this, UINT cdw, LPDWORD rgdw, UINT fl)
{
HRESULT hres;
/*
* Don't let somebody change the data format while we're
* looking at it.
*/
CDIDev_EnterCrit(this);
AssertF((fl & ~DEVCO_VALID) == 0);
if ( fLimpFF(fl & (DEVCO_FROMOFFSET | DEVCO_TOOFFSET),
this->pdix && this->rgiobj) ) {
UINT idw;
for ( idw = 0; idw < cdw; idw++ ) {
/*
* Convert from its source to an object index,
* validate the object index, then convert to
* the target.
*/
int iobj;
switch ( fl & DEVCO_FROMMASK ) {
default:
AssertF(0); /* Huh? */
case DEVCO_FROMID:
iobj = CDIDev_IdToIobj(this, rgdw[idw]);
break;
case DEVCO_FROMOFFSET:
iobj = CDIDev_OffsetToIobj(this, rgdw[idw]);
break;
}
if ( iobj < 0 ) {
hres = E_INVALIDARG; /* Invalid object */
goto done;
}
AssertF((DWORD)iobj < this->df.dwNumObjs);
if ( !CDIDev_CheckId(this->df.rgodf[iobj].dwType, fl) ) {
hres = E_INVALIDARG; /* Bad attributes */
goto done;
}
switch ( fl & DEVCO_TOMASK ) {
default:
AssertF(0); /* Huh? */
case DEVCO_TOID:
rgdw[idw] = CDIDev_IobjToId(this, iobj);
break;
case DEVCO_TOOFFSET:
rgdw[idw] = CDIDev_IobjToOffset(this, iobj);
break;
}
}
hres = S_OK;
done:;
} else {
RPF("ERROR: Must have a data format to use offsets");
hres = E_INVALIDARG;
}
CDIDev_LeaveCrit(this);
return hres;
}
Reference in New Issue View Git Blame Copy Permalink