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

5641 lines
171 KiB
C
Raw Permalink Blame History

/*****************************************************************************
*
* DIDev.c
*
* Copyright (c) 1996 Microsoft Corporation. All Rights Reserved.
*
* Abstract:
*
* The standard implementation of IDirectInputDevice.
*
* This is the device-independent part. the device-dependent
* part is handled by the IDirectInputDeviceCallback.
*
* And the IDirectInputEffect support lives in didevef.c.
*
* Contents:
*
* CDIDev_CreateInstance
*
*****************************************************************************/
#include "dinputpr.h"
#define INCLUDED_BY_DIDEV
#include "didev.h"
/*****************************************************************************
*
* Declare the interfaces we will be providing.
*
*****************************************************************************/
Interface_Template_Begin(CDIDev)
Primary_Interface_Template(CDIDev, TFORM(ThisInterfaceT))
Secondary_Interface_Template(CDIDev, SFORM(ThisInterfaceT))
Interface_Template_End(CDIDev)
/*****************************************************************************
*
* @doc INTERNAL
*
* @global PDD * | g_rgpddForeground |
*
* A list of all devices which have obtained foreground
* acquisition. Items on the list have been
* held (not AddRef'd).
*
* @global UINT | g_cpddForeground |
*
* The number of entries in <p g_rgpddForeground>. When foreground
* activation is lost, all objects in the array are unacquired.
*
*
* @global UINT | g_cpddForegroundMax |
*
* The size of the <p g_rgpddForeground> array, including dummy
* spaces that are not yet in use.
*
*****************************************************************************/
/*
* ISSUE-2001/03/29-timgill We assume that all-zeros is a valid initialization.
*/
GPA g_gpaExcl;
#define g_hgpaExcl (&g_gpaExcl)
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | IDirectInputDevice | NotAcquired |
*
* Check that the device is not acquired.
*
* @cwrap LPDIRECTINPUTDEVICE | lpDirectInputDevice
*
* @returns
*
* Returns
* <c S_OK> if all is well, or <c DIERR_ACQUIRED> if
* the device is acquired.
*
*****************************************************************************/
#ifndef XDEBUG
#define IDirectInputDevice_NotAcquired_(pdd, z) \
_IDirectInputDevice_NotAcquired_(pdd) \
#endif
HRESULT INLINE
IDirectInputDevice_NotAcquired_(PDD this, LPCSTR s_szProc)
{
HRESULT hres;
if(!this->fAcquired)
{
hres = S_OK;
} else
{
RPF("ERROR %s: May not be called while device is acquired", s_szProc);
hres = DIERR_ACQUIRED;
}
return hres;
}
#define IDirectInputDevice_NotAcquired(pdd) \
IDirectInputDevice_NotAcquired_(pdd, s_szProc) \
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CDIDev | IsExclAcquired |
*
* Check that the device is acquired exclusively.
*
* The device critical section must already be held.
*
* @cwrap PDD | this
*
* @returns
*
* <c S_OK> if the device is exclusively acquired.
*
* <c DIERR_INPUTLOST> if acquisition has been lost.
*
* <c DIERR_NOTEXCLUSIVEACQUIRED> the device is acquired,
* but not exclusively, or if the device is not acquired
* at all.
*
*****************************************************************************/
STDMETHODIMP
CDIDev_IsExclAcquired_(PDD this, LPCSTR s_szProc)
{
HRESULT hres;
AssertF(CDIDev_InCrit(this));
if(this->discl & DISCL_EXCLUSIVE)
{
if(this->fAcquired)
{
hres = S_OK;
} else
{
hres = this->hresNotAcquired;
if(hres == DIERR_NOTACQUIRED)
{
hres = DIERR_NOTEXCLUSIVEACQUIRED;
}
}
} else
{
hres = DIERR_NOTEXCLUSIVEACQUIRED;
}
if(s_szProc && hres == DIERR_NOTEXCLUSIVEACQUIRED)
{
RPF("ERROR %s: Device is not acquired in exclusive mode", s_szProc);
}
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method void | IDirectInputDevice | EnterCrit |
*
* Enter the object critical section.
*
* @cwrap LPDIRECTINPUTDEVICE | lpDirectInputDevice
*
*****************************************************************************/
void EXTERNAL
CDIDev_EnterCrit_(struct CDIDev *this, LPCTSTR lptszFile, UINT line)
{
#ifdef XDEBUG
if( ! _TryEnterCritSec(&this->crst) )
{
SquirtSqflPtszV(sqflCrit, TEXT("Device CritSec blocked @%s,%d"), lptszFile, line);
EnterCriticalSection(&this->crst);
}
SquirtSqflPtszV(sqflCrit, TEXT("Device CritSec Entered @%s,%d"), lptszFile, line);
#else
EnterCriticalSection(&this->crst);
#endif
this->thidCrit = GetCurrentThreadId();
InterlockedIncrement(&this->cCrit);
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method void | IDirectInputDevice | LeaveCrit |
*
* Leave the object critical section.
*
* @cwrap LPDIRECTINPUTDEVICE | lpDirectInputDevice
*
*****************************************************************************/
void EXTERNAL
CDIDev_LeaveCrit_(struct CDIDev *this, LPCTSTR lptszFile, UINT line)
{
#ifdef XDEBUG
AssertF(this->cCrit);
AssertF(this->thidCrit == GetCurrentThreadId());
SquirtSqflPtszV(sqflCrit | sqflVerbose, TEXT("Device CritSec Leaving @%s,%d"), lptszFile, line);
#endif
if(InterlockedDecrement(&this->cCrit) == 0)
{
this->thidCrit = 0;
}
LeaveCriticalSection(&this->crst);
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method void | IDirectInputDevice | SetNotifyEvent |
*
* Set the event associated with the device, if any.
*
* @cwrap LPDIRECTINPUTDEVICE | lpDirectInputDevice
*
*****************************************************************************/
void EXTERNAL
CDIDev_SetNotifyEvent(PDD this)
{
if(this->hNotify)
{
SetEvent(this->hNotify);
}
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method void | IDirectInputDevice | SetForcedUnacquiredFlag |
*
* When forced unacquired happens, set the fOnceForcedUnacquired flag.
*
*****************************************************************************/
void EXTERNAL
CDIDev_SetForcedUnacquiredFlag(PDD this)
{
/*
* This is an internal interface, so we can skimp on validation.
*/
this->fOnceForcedUnacquired = 1;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method BOOL | CDIDev | InCrit |
*
* Nonzero if we are in the critical section.
*
*****************************************************************************/
#ifdef DEBUG
BOOL INTERNAL
CDIDev_InCrit(PDD this)
{
return this->cCrit && this->thidCrit == GetCurrentThreadId();
}
#endif
#ifdef DEBUG
/*****************************************************************************
*
* @doc INTERNAL
*
* @method BOOL | IDirectInputDevice | IsConsistent |
*
* Check that various state variables are consistent.
*
* @cwrap LPDIRECTINPUTDEVICE | lpDirectInputDevice
*
*****************************************************************************/
#define VerifyF(f,m) if( !(f) ) { fRc = 0; RPF( m ); }
BOOL INTERNAL
CDIDev_IsConsistent(PDD this)
{
BOOL fRc = 1;
/*
* If acquired, then we must have a translation table, a state manager,
* and a device callback.
*/
if(this->fAcquired)
{
VerifyF( this->pdix, "Acquired device has no translation table" )
VerifyF( this->GetState, "Acquired device has no state manager" )
VerifyF( this->pdcb != c_pdcbNil, "Acquired device has no device callback" )
}
/*
* If buffering, then must have a device callback.
*/
if(this->celtBuf)
{
VerifyF( this->pdcb != c_pdcbNil, "Buffered device has no device callback" )
}
/*
* If managing an instance, then make sure buffer variables are
* consistent.
*/
if(this->pvi)
{
if(this->celtBuf)
{
VerifyF( this->pvi->pBuffer, "Null internal data buffer" )
VerifyF( this->pvi->pEnd, "Null internal end of buffer pointer" )
VerifyF( this->pvi->pHead, "Null internal head of buffer pointer" )
VerifyF( this->pvi->pTail, "Null internal tail of buffer pointer" )
VerifyF( this->pvi->pBuffer < this->pvi->pEnd, "Internal buffer pointers invalid" )
VerifyF(fInOrder((DWORD)(UINT_PTR)this->pvi->pBuffer,
(DWORD)(UINT_PTR)this->pvi->pHead,
(DWORD)(UINT_PTR)this->pvi->pEnd), "Head of internal buffer pointer invalid" )
VerifyF(fInOrder((DWORD)(UINT_PTR)this->pvi->pBuffer,
(DWORD)(UINT_PTR)this->pvi->pTail,
(DWORD)(UINT_PTR)this->pvi->pEnd), "Tail of internal buffer pointer invalid" )
} else
{
VerifyF( ( this->pvi->pBuffer == 0
&&this->pvi->pEnd == 0
&&this->pvi->pHead == 0
&&this->pvi->pTail == 0), "Inactive internal buffer has non-zero pointers" )
}
}
/*
* The cooperative levels must match the cached window handle.
*/
VerifyF(fLimpFF(this->discl & (DISCL_FOREGROUND | DISCL_EXCLUSIVE),
this->hwnd), "Cooperative level does not match window" );
return fRc;
}
#undef VerifyF
#endif
/*****************************************************************************
*
* @doc EXTERNAL
*
* @method HRESULT | IDirectInputDevice | QueryInterface |
*
* Gives a client access to other interfaces on an object.
*
* @cwrap LPDIRECTINPUTDEVICE | lpDirectInputDevice
*
* @parm IN REFIID | riid |
*
* The requested interface's IID.
*
* @parm OUT LPVOID * | ppvObj |
*
* Receives a pointer to the obtained interface.
*
* @returns
*
* Returns a COM error code.
*
* @xref OLE documentation for <mf IUnknown::QueryInterface>.
*
*****************************************************************************
*
* @doc EXTERNAL
*
* @method HRESULT | IDirectInputDevice | AddRef |
*
* Increments the reference count for the interface.
*
* @cwrap LPDIRECTINPUTDEVICE | lpDirectInputDevice
*
* @returns
*
* Returns the object reference count.
*
* @xref OLE documentation for <mf IUnknown::AddRef>.
*
*****************************************************************************
*
* @doc EXTERNAL
*
* @method HRESULT | IDirectInputDevice | Release |
*
* Decrements the reference count for the interface.
* If the reference count on the object falls to zero,
* the object is freed from memory.
*
* @cwrap LPDIRECTINPUTDEVICE | lpDirectInputDevice
*
* @returns
*
* Returns the object reference count.
*
* @xref OLE documentation for <mf IUnknown::Release>.
*
*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CDIDev | QIHelper |
*
* We don't have any dynamic interfaces and simply forward
* to <f Common_QIHelper>.
*
* @parm IN REFIID | riid |
*
* The requested interface's IID.
*
* @parm OUT LPVOID * | ppvObj |
*
* Receives a pointer to the obtained interface.
*
*****************************************************************************/
#ifdef DEBUG
Default_QueryInterface(CDIDev)
Default_AddRef(CDIDev)
Default_Release(CDIDev)
#else
#define CDIDev_QueryInterface Common_QueryInterface
#define CDIDev_AddRef Common_AddRef
#define CDIDev_Release Common_Release
#endif
#define CDIDev_QIHelper Common_QIHelper
/*****************************************************************************
*
* @doc INTERNAL
*
* @func HRESULT | CDIDev_Reset |
*
* Releases all the resources of a generic device that
* are associated with a particular device instance.
*
* This method is called in preparation for reinitialization.
*
* It is the responsibility of the caller to have taken
* any necessary critical sections.
*
*
* @parm PV | pvObj |
*
* Object being reset. Note that it may not have been
* completely initialized, so everything should be done
* carefully.
*
*****************************************************************************/
STDMETHODIMP
CDIDev_Reset(PDD this)
{
HRESULT hres;
if(!this->fAcquired)
{
/*
* Note! that we must release the driver before releasing
* the callback, because the callback will unload the
* driver DLL.
*
* We cannot allow people to reset the device
* while there are still effects outstanding,
* because that would cause us to throw away the
* callback while the effects are still using
* the effect driver!
*/
if(this->gpaEff.cpv == 0)
{
Invoke_Release(&this->pes);
Invoke_Release(&this->pdcb);
this->pdcb = c_pdcbNil;
FreePpv(&this->pdix);
FreePpv(&this->rgiobj);
FreePpv(&this->pvBuffer);
FreePpv(&this->pvLastBuffer);
FreePpv(&this->rgdwAxesOfs);
FreePpv(&this->rgemi);
FreePpv(&this->rgdwPOV);
AssertF(!this->fAcquired);
AssertF(!this->fAcquiredInstance);
if(this->hNotify)
{
CloseHandle(this->hNotify);
}
ZeroBuf(&this->hwnd, FIELD_OFFSET(DD, celtBufMax) -
FIELD_OFFSET(DD, hwnd));
ZeroX(this->guid);
this->celtBufMax = DEVICE_MAXBUFFERSIZE;
this->GetDeviceState = CDIDev_GetAbsDeviceState;
this->hresNotAcquired = DIERR_NOTACQUIRED;
this->fCook = 0;
AssertF(this->hNotify == 0);
AssertF(this->cemi == 0);
AssertF(this->didcFF == 0);
this->dwGain = 10000; /* Default to full gain */
this->dwAutoCenter = DIPROPAUTOCENTER_ON; /* Default to centered */
GPA_InitFromZero(&this->gpaEff);
hres = S_OK;
} else
{
RPF("IDirectInputDevice::Initialize: Device still has effects");
hres = DIERR_HASEFFECTS;
}
} else
{
RPF("IDirectInputDevice::Initialize: Device is busy");
hres = DIERR_ACQUIRED;
}
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @func void | CDIDev_AppFinalize |
*
* The application has performed its final release.
*
* If the device is acquired, then unacquire it.
*
* Release the holds on all the created effects that
* we have been hanging onto for enumeration purposes.
*
* @parm PV | pvObj |
*
* Object being released. Note that it may not have been
* completely initialized, so everything should be done
* carefully.
*
*****************************************************************************/
void INTERNAL
CDIDev_AppFinalize(PV pvObj)
{
PDD this = pvObj;
if(this->fAcquired)
{
RPF("IDirectInputDevice::Release: Forgot to call Unacquire()");
CDIDev_InternalUnacquire(pvObj);
/*
* If our refcount is wrong, we may have just freed ourselves.
* PREFIX picks this up (mb:34651) however there is no point in
* adding checks in case we have bugs in refcounting as that has to
* be bug free.
*/
}
if(this->fCritInited)
{
/*
* Stop all the effects, if they are playing.
*
* Then unhold them (because we're done).
*
* ISSUE-2001/03/29-timgill Need to totally remove all effects created by a destroyed device
* We also need to neuter them so they don't
* do anything any more. Otherwise, an app might
* destroy the parent device and then try to mess with
* an effect created by that device after the device
* is gone.
*
* Note that we cannot call the effect while inside our
* private little critical section, because the effect
* may need to do crazy things to stop itself.
*
* (It will almost certainly call back up into the device
* to remove itself from the list of created effects.)
*/
UINT ipdie;
PPDIE rgpdie;
UINT cpdie;
CDIDev_EnterCrit(this);
rgpdie = (PV)this->gpaEff.rgpv;
cpdie = this->gpaEff.cpv;
GPA_Init(&this->gpaEff);
CDIDev_LeaveCrit(this);
for(ipdie = 0; ipdie < cpdie; ipdie++)
{
AssertF(rgpdie[ipdie]);
// 7/19/2000(a-JiTay): IA64: Use %p format specifier for 32/64-bit pointers.
SquirtSqflPtszV(sqfl | sqflError,
TEXT("Device %p forgot to destroy effect %p"),
this, rgpdie[ipdie]);
IDirectInputEffect_Stop(rgpdie[ipdie]);
Common_Unhold(rgpdie[ipdie]);
}
FreePpv(&rgpdie);
}
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @func void | CDIDev_Finalize |
*
* Releases the resources of a generic device.
*
* @parm PV | pvObj |
*
* Object being released. Note that it may not have been
* completely initialized, so everything should be done
* carefully.
*
*****************************************************************************/
void INTERNAL
CDIDev_Finalize(PV pvObj)
{
HRESULT hres;
PDD this = pvObj;
#ifdef XDEBUG
if(this->cCrit)
{
RPF("IDirectInputDevice::Release: Another thread is using the object; crash soon!");
}
#endif
AssertF(!this->fAcquired);
Invoke_Release(&this->pMS);
/*
* Note that we cannot take the critical section because it
* might not exist. (We might've died during initialization.)
* Fortunately, we finalize only after every possible client
* (both internal and external) has done its final Release(),
* so it's impossible for any other method to get called at
* this point.
*/
hres = CDIDev_Reset(this);
AssertF(SUCCEEDED(hres));
if(this->fCritInited)
{
DeleteCriticalSection(&this->crst);
}
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method void | CDIDev | GetVersions |
*
* Obtain version information from the device.
*
* First try to get it from the effect driver. If
* that doesn't work, then get it from the VxD.
* And if that doesn't work, then tough.
*
* @parm IN OUT LPDIDRIVERVERSIONS | pvers |
*
* Receives version information.
*
*****************************************************************************/
void INLINE
CDIDev_GetVersions(PDD this, LPDIDRIVERVERSIONS pvers)
{
HRESULT hres;
/*
* Pre-fill with zeros in case nobody implements GetVersions.
*/
pvers->dwSize = cbX(*pvers);
pvers->dwFirmwareRevision = 0;
pvers->dwHardwareRevision = 0;
pvers->dwFFDriverVersion = 0;
hres = CDIDev_CreateEffectDriver(this);
/*
* Prefix raises a warning (mb:34561) that this->pes could be NULL
* however CDIDev_CreateEffectDriver only succeeds if it is not.
*/
if(SUCCEEDED(hres) &&
SUCCEEDED(hres = this->pes->lpVtbl->
GetVersions(this->pes, pvers)))
{
} else
{
hres = this->pdcb->lpVtbl->GetVersions(this->pdcb, pvers);
}
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | IDirectInputDevice | GetCapabilitiesHelper |
*
* Obtains information about the device.
*
* @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 DIERR_INVALIDPARAM> = <c E_INVALIDARG>: The
* <p lpDirectInputDevice> or
* <p lpdc> parameter is invalid.
*
*****************************************************************************/
STDMETHODIMP
CDIDev_GetCapabilitiesHelper(PV pdd)
{
HRESULT hres;
PDD this = _thisPv(pdd);
LPDIDEVCAPS pdc = (PV)&this->dc3;
pdc->dwSize = cbX(this->dc3);
hres = this->pdcb->lpVtbl->GetCapabilities(this->pdcb, pdc);
if(SUCCEEDED(hres))
{
/*
* We'll handle the DIDC_EMULATED and
* DIDC_POLLEDDATAFORMAT bits to save the callback
* some trouble.
*/
AssertF(this->pvi);
if(this->pvi->fl & VIFL_EMULATED)
{
pdc->dwFlags |= DIDC_EMULATED;
}
if(this->fPolledDataFormat)
{
pdc->dwFlags |= DIDC_POLLEDDATAFORMAT;
}
/*
* Add in the force feedback flags, too.
*/
pdc->dwFlags |= this->didcFF;
hres = S_OK;
}
return hres;
}
/*****************************************************************************
*
* @doc EXTERNAL
*
* @method HRESULT | IDirectInputDevice | GetCapabilities |
*
* Obtains information about the device.
*
* @cwrap LPDIRECTINPUTDEVICE | lpDirectInputDevice
*
* @parm IN OUT LPDIDEVCAPS | lpdc |
*
* Points to a <t DIDEVCAPS> structure that is filled in
* by the function. The <e DIDEVCAPS.dwSize>
* field "must" be filled in
* by the application before calling this method.
* See the documentation of the <t DIDEVCAPS> structure
* for additional information.
*
* @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 lpDirectInputDevice> or
* <p lpdc> parameter is invalid.
*
*****************************************************************************/
STDMETHODIMP
CDIDev_GetCapabilities(PV pdd, LPDIDEVCAPS pdc _THAT)
{
HRESULT hres;
EnterProcR(IDirectInputDevice8::GetCapabilities, (_ "pp", pdd, pdc));
if(SUCCEEDED(hres = hresPvT(pdd)) &&
SUCCEEDED(hres = hresFullValidWritePxCb2(pdc,
DIDEVCAPS_DX5,
DIDEVCAPS_DX3, 1)))
{
PDD this = _thisPv(pdd);
CDIDev_EnterCrit(this);
/*
* For the convenience of the callback, zero out all the fields,
* save for the dwSize.
*/
ZeroBuf(pvAddPvCb(pdc, cbX(DWORD)), pdc->dwSize - cbX(DWORD));
hres = this->pdcb->lpVtbl->GetCapabilities(this->pdcb, pdc);
if(SUCCEEDED(hres))
{
/*
* We'll handle the DIDC_EMULATED and
* DIDC_POLLEDDATAFORMAT bits to save the callback
* some trouble.
*/
AssertF(this->pvi);
if(this->pvi->fl & VIFL_EMULATED)
{
pdc->dwFlags |= DIDC_EMULATED;
}
if(this->fPolledDataFormat)
{
pdc->dwFlags |= DIDC_POLLEDDATAFORMAT;
}
/*
* Add in the force feedback flags, too.
*/
pdc->dwFlags |= this->didcFF;
/*
* If the caller wants force feedback parameters, then
* set them, too.
*/
if(pdc->dwSize >= cbX(DIDEVCAPS_DX5))
{
DIDRIVERVERSIONS vers;
pdc->dwFFSamplePeriod = this->ffattr.dwFFSamplePeriod;
pdc->dwFFMinTimeResolution = this->ffattr.dwFFMinTimeResolution;
CDIDev_GetVersions(this, &vers);
pdc->dwFirmwareRevision = vers.dwFirmwareRevision;
pdc->dwHardwareRevision = vers.dwHardwareRevision;
pdc->dwFFDriverVersion = vers.dwFFDriverVersion;
}
hres = S_OK;
}
CDIDev_LeaveCrit(this);
ScrambleBit(&pdc->dwDevType, DIDEVTYPE_RANDOM);
ScrambleBit(&pdc->dwFlags, DIDC_RANDOM);
}
ExitOleProcR();
return hres;
}
#ifdef XDEBUG
CSET_STUBS(GetCapabilities, (PV pdd, LPDIDEVCAPS pdc), (pdd, pdc THAT_))
#else
#define CDIDev_GetCapabilitiesA CDIDev_GetCapabilities
#define CDIDev_GetCapabilitiesW CDIDev_GetCapabilities
#endif
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CDIDev | GetDataFormat |
*
* Get the data format for the device if we don't have it already.
*
* @parm PDD | this |
*
* Device object.
*
* @returns
*
* COM return code.
*
*****************************************************************************/
STDMETHODIMP
CDIDev_GetDataFormat(PDD this)
{
HRESULT hres;
LPDIDATAFORMAT pdf;
/*
* If the DIDATAFORMAT structure changes, you also need to invent
* a new DCB message (DIDM_GETDATAFORMAT2), and then do
* the right thing when faced with a mix of old and new.
*/
hres = this->pdcb->lpVtbl->GetDataFormat(this->pdcb, &pdf);
/*
* Note! We don't support external drivers in this release,
* so it's okay to treat these are Assert's and not try to recover.
*/
if(SUCCEEDED(hres))
{
AssertF(pdf->dwSize == sizeof(this->df));
this->df = *pdf;
AssertF(!IsBadReadPtr(pdf->rgodf, cbCxX(pdf->dwNumObjs, ODF)));
/*
* Prepare the axis goo in case the app sets relative mode.
*/
if(SUCCEEDED(hres = ReallocCbPpv(pdf->dwDataSize,
&this->pvLastBuffer)) &&
SUCCEEDED(hres = ReallocCbPpv(cbCdw(pdf->dwNumObjs),
&this->rgdwAxesOfs)))
{
UINT iobj;
this->cAxes = 0;
for(iobj = 0; iobj < pdf->dwNumObjs; iobj++)
{
AssertF(pdf->rgodf[iobj].dwOfs < pdf->dwDataSize);
if(pdf->rgodf[iobj].dwType & DIDFT_AXIS)
{
this->rgdwAxesOfs[this->cAxes++] = pdf->rgodf[iobj].dwOfs;
}
}
}
}
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CDIDev | GetPolled |
*
* Determine whether the device is polled.
*
* @parm PDD | this |
*
* Device object.
*
* @returns
*
* COM result code.
*
*****************************************************************************/
STDMETHODIMP
CDIDev_GetPolled(PDD this)
{
HRESULT hres;
DIDEVCAPS_DX3 dc;
/*
* We intentionally use a DIDEVCAPS_DX3 because going for
* a full DIDEVCAPS_DX5 requires us to load the force
* feedback driver which is pointless for our current
* goal.
*/
ZeroX(dc);
dc.dwSize = cbX(dc);
hres = this->pdcb->lpVtbl->GetCapabilities(this->pdcb, (PV)&dc);
if(SUCCEEDED(hres))
{
if(dc.dwFlags & DIDC_POLLEDDEVICE)
{
this->hresPolled = DI_POLLEDDEVICE;
} else
{
this->hresPolled = S_OK;
}
}
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CDIDev | GetObjectInfoHelper |
*
* Set up all the information we can deduce ourselves and
* have the callback finish.
*
* @cwrap LPDIRECTINPUTDEVICE | lpDirectInputDevice
*
* @parm LPCDIPROPINFO | ppropi |
*
* Object descriptor.
*
* @parm LPDIDEVICEOBJECTINSTANCEW | pdoiW |
*
* Structure to receive result.
*
*****************************************************************************/
STDMETHODIMP
CDIDev_GetObjectInfoHelper(PDD this, LPCDIPROPINFO ppropi,
LPDIDEVICEOBJECTINSTANCEW pdoiW)
{
HRESULT hres;
AssertF(IsValidSizeDIDEVICEOBJECTINSTANCEW(pdoiW->dwSize));
pdoiW->guidType = *this->df.rgodf[ppropi->iobj].pguid;
/*
* Always report the internal data format offset here.
* This is the way DX3 and DX5 worked until DX7 changed the behavior to
* report the user data format value if there was one. That was very
* confusing so revert it for DX8.
*/
pdoiW->dwOfs = this->df.rgodf[ppropi->iobj].dwOfs;
pdoiW->dwType = this->df.rgodf[ppropi->iobj].dwType;
pdoiW->dwFlags = this->df.rgodf[ppropi->iobj].dwFlags;
ScrambleBit(&pdoiW->dwFlags, DIDOI_RANDOM);
/*
* Wipe out everything starting at tszName.
*/
ZeroBuf(&pdoiW->tszName,
pdoiW->dwSize - FIELD_OFFSET(DIDEVICEOBJECTINSTANCEW, tszName));
hres = this->pdcb->lpVtbl->GetObjectInfo(this->pdcb, ppropi, pdoiW);
return hres;
}
/*****************************************************************************
*
* @doc EXTERNAL
*
* @method HRESULT | IDirectInputDevice | EnumObjects |
*
* Enumerate the input sources (buttons, axes)
* available on a device.
*
* @cwrap LPDIRECTINPUTDEVICE | lpDirectInputDevice
*
* @parm IN LPDIENUMDEVICEOBJECTSCALLBACK | lpCallback |
*
* Callback function.
*
* @parm IN LPVOID | pvRef |
*
* Reference data (context) for callback.
*
* @parm IN DWORD | fl |
*
* Flags specifying the type(s) of objects to be enumerated.
* See the section "DirectInput Data Format Types" for a
* list of flags that can be passed.
*
* Furthermore, the enumeration can be restricted to objects
* from a single HID link collection by using the
* <f DIDFT_ENUMCOLLECTION> macro.
*
* @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.
* Note that if the callback stops the enumeration prematurely,
* the enumeration is considered to have succeeded.
*
* <c DIERR_INVALIDPARAM> = <c E_INVALIDARG>: The
* <p fl> parameter contains invalid flags, or the callback
* procedure returned an invalid status code.
*
* @cb BOOL CALLBACK | DIEnumDeviceObjectsProc |
*
* An application-defined callback function that receives
* DirectInputDevice objects as a result of a call to the
* <om IDirectInputDevice::EnumObjects> method.
*
* @parm IN LPCDIDEVICEOBJECTINSTANCE | lpddoi |
*
* A <t DIDEVICEOBJECTINSTANCE> structure which describes
* the object being enumerated.
*
* @parm IN OUT LPVOID | pvRef |
* Specifies the application-defined value given in the
* <mf IDirectInputDevice::EnumObjects> function.
*
* @returns
*
* Returns <c DIENUM_CONTINUE> to continue the enumeration
* or <c DIENUM_STOP> to stop the enumeration.
*
* @ex
*
* To enumerate all axis objects:
*
* |
*
* // C++
* HRESULT hr = pDevice->EnumObjects(EnumProc, RefData, DIDFT_AXIS);
*
* // C
* hr = IDirectInputDevice_EnumObjects(pDevice, EnumProc, RefData,
* DIDFT_AXIS);
*
* @ex
*
* To enumerate all objects in the third HID link collection:
*
* |
*
* // C++
* HRESULT hr = pDevice->EnumObjects(EnumProc, RefData,
* DIDFT_ENUMCOLLECTION(3));
*
* // C
* hr = IDirectInputDevice_EnumObjects(pDevice, EnumProc, RefData,
* DIDFT_ENUMCOLLECTION(3));
*
*****************************************************************************/
STDMETHODIMP
CDIDev_EnumObjectsW
(PV pddW, LPDIENUMDEVICEOBJECTSCALLBACKW pec, LPVOID pvRef, DWORD fl)
{
HRESULT hres;
EnterProcR(IDirectInputDevice8::EnumObjectsW, (_ "ppx", pddW, pec, fl));
if(SUCCEEDED(hres = hresPvW(pddW)) &&
SUCCEEDED(hres = hresFullValidPfn(pec, 1)) &&
SUCCEEDED(hres = hresFullValidFl(fl, DIDFT_ENUMVALID, 3)))
{
PDD this = _thisPvNm(pddW, ddW);
DWORD flExclude;
WORD wCollection;
/*
* We snapshot the object information underneath the critical
* section so we don't blow up if another thread Reset()s
* the device in the middle of an enumeration. The DIDATAFORMAT
* contains pointers to the dcb, so we need to AddRef the
* dcb as well.
*/
AssertF(!CDIDev_InCrit(this));
CDIDev_EnterCrit(this);
if(this->pdcb != c_pdcbNil)
{
DIPROPINFO propi;
DIDATAFORMAT df;
IDirectInputDeviceCallback *pdcb;
pdcb = this->pdcb;
OLE_AddRef(pdcb);
df = this->df;
CDIDev_LeaveCrit(this);
AssertF(!CDIDev_InCrit(this));
flExclude = 0;
/* Exclude alises if necessary */
if( !(fl & DIDFT_ALIAS) )
{
flExclude |= DIDFT_ALIAS;
} else
{
fl &= ~DIDFT_ALIAS;
}
/* Exclude Vendor Defined fields */
if( !(fl & DIDFT_VENDORDEFINED) )
{
flExclude |= DIDFT_VENDORDEFINED;
} else
{
fl &= ~DIDFT_VENDORDEFINED;
}
if(fl == DIDFT_ALL)
{
fl = DIDFT_ALLOBJS;
}
/*
* Pull out the link collection we are enumerating.
* Note: Backwards compatibility hack. We can't
* use link collection 0 to mean "no parent" because
* 0 means "don't care". So instead, we use 0xFFFF
* to mean "no parent". This means that we need to
* interchange 0 and 0xFFFF before entering the main
* loop.
*/
wCollection = DIDFT_GETCOLLECTION(fl);
switch(wCollection)
{
case 0:
wCollection = 0xFFFF;
break;
case DIDFT_GETCOLLECTION(DIDFT_NOCOLLECTION):
wCollection = 0;
break;
}
propi.pguid = 0;
for(propi.iobj = 0; propi.iobj < df.dwNumObjs; propi.iobj++)
{
propi.dwDevType = df.rgodf[propi.iobj].dwType;
if((propi.dwDevType & fl & DIDFT_TYPEMASK) &&
fHasAllBitsFlFl(propi.dwDevType, fl & DIDFT_ATTRMASK) &&
!(propi.dwDevType & flExclude))
{
DIDEVICEOBJECTINSTANCEW doiW;
doiW.dwSize = cbX(doiW);
hres = CDIDev_GetObjectInfoHelper(this, &propi, &doiW);
if(SUCCEEDED(hres) &&
fLimpFF(wCollection != 0xFFFF,
doiW.wCollectionNumber == wCollection))
{
BOOL fRc = Callback(pec, &doiW, pvRef);
switch(fRc)
{
case DIENUM_STOP: goto enumdoneok;
case DIENUM_CONTINUE: break;
default:
RPF("IDirectInputDevice::EnumObjects: Invalid return value from enumeration callback");
ValidationException();
break;
}
} else
{
if( hres == DIERR_OBJECTNOTFOUND ) {
// This can only happen on Keyboard.
continue;
} else {
goto enumdonefail;
}
}
}
}
enumdoneok:;
hres = S_OK;
enumdonefail:;
OLE_Release(pdcb);
} else
{
CDIDev_LeaveCrit(this);
RPF("ERROR: IDirectInputDevice: Not initialized");
hres = DIERR_NOTINITIALIZED;
}
}
ExitOleProcR();
return hres;
}
#define CDIDev_EnumObjects2W CDIDev_EnumObjectsW
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | IDirectInputDeviceA | EnumObjectsCallbackA |
*
* Custom callback that wraps
* <mf IDirectInputDeviceW::EnumObjects> which
* translates the UNICODE string to ANSI.
*
* @parm IN LPCDIENUMDEVICEOBJECTINSTANCE | pdoiW |
*
* Structure to be translated to ANSI.
*
* @parm IN LPVOID | pvRef |
*
* Pointer to <t struct ENUMDEVICEOBJECTINFO> which describes
* the original callback.
*
* @returns
*
* Returns whatever the original callback returned.
*
*****************************************************************************/
typedef struct ENUMOBJECTSINFO
{
LPDIENUMDEVICEOBJECTSCALLBACKA pecA;
PV pvRef;
} ENUMOBJECTSINFO, *PENUMOBJECTSINFO;
BOOL CALLBACK
CDIDev_EnumObjectsCallbackA(LPCDIDEVICEOBJECTINSTANCEW pdoiW, PV pvRef)
{
PENUMOBJECTSINFO peoi = pvRef;
BOOL fRc;
DIDEVICEOBJECTINSTANCEA doiA;
EnterProc(CDIDev_EnumObjectsCallbackA,
(_ "GxxWp", &pdoiW->guidType,
pdoiW->dwOfs,
pdoiW->dwType,
pdoiW->tszName, pvRef));
doiA.dwSize = cbX(doiA);
ObjectInfoWToA(&doiA, pdoiW);
fRc = peoi->pecA(&doiA, peoi->pvRef);
ExitProcX(fRc);
return fRc;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | IDirectInputDeviceA | EnumObjects |
*
* Enumerate the input sources (buttons, axes)
* available on a device, in ANSI.
* See <mf IDirectInputDevice::EnumObjects> for more information.
*
* @cwrap LPDIRECTINPUTDEVICE | lpDirectInputDevice
*
* @parm IN LPDIENUMDEVICEOBJECTSCALLBACK | lpCallback |
*
* Same as <mf IDirectInputDeviceW::EnumObjects>, except in ANSI.
*
* @parm IN LPVOID | pvRef |
*
* Same as <mf IDirectInputDeviceW::EnumObjects>.
*
* @parm IN DWORD | fl |
*
* Same as <mf IDirectInputDeviceW::EnumObjects>.
*
*****************************************************************************/
STDMETHODIMP
CDIDev_EnumObjectsA
(PV pddA, LPDIENUMDEVICEOBJECTSCALLBACKA pec, LPVOID pvRef, DWORD fl)
{
HRESULT hres;
EnterProcR(IDirectInputDevice8A::EnumDevices,
(_ "pppx", pddA, pec, pvRef, fl));
/*
* EnumObjectsW will validate the rest.
*/
if(SUCCEEDED(hres = hresPvA(pddA)) &&
SUCCEEDED(hres = hresFullValidPfn(pec, 1)))
{
ENUMOBJECTSINFO eoi = { pec, pvRef};
PDD this = _thisPvNm(pddA, ddA);
hres = CDIDev_EnumObjectsW(&this->ddW, CDIDev_EnumObjectsCallbackA,
&eoi, fl);
}
ExitOleProcR();
return hres;
}
#define CDIDev_EnumObjects2A CDIDev_EnumObjectsA
/*****************************************************************************
*
* @doc EXTERNAL
*
* @method HRESULT | IDirectInputDevice | SetEventNotification |
*
* Specify the event that should be set when the device
* state changes, or turns off such notifications.
*
* A device state change is defined as any of the following:
*
* - A change in the position of an axis.
*
* - A change in the state (pressed or released) of a button.
*
* - A change in the direction of a POV control.
*
* - Loss of acquisition.
*
* "It is an error" to call <f CloseHandle> on the event
* while it has been selected into an <i IDirectInputDevice>
* object. You must call
* <mf IDirectInputDevice::SetEventNotification> with the
* <p hEvent> parameter set to NULL before closing the
* event handle.
*
* The event notification handle cannot be changed while the
* device is acquired.
*
* If the function is successful, then the application can
* use the event handle in the same manner as any other
* Win32 event handle. Examples of usage are shown below.
* For additional information on using Win32 wait functions,
* see the Win32 SDK and related documentation.
*
* @cwrap LPDIRECTINPUTDEVICE | lpDirectInputDevice
*
* @parm IN HANDLE | hEvent |
*
* Specifies the event handle which will be set when the
* device state changes. It "must" be an event
* handle. DirectInput will <f SetEvent> the handle when
* the state of the device changes.
*
* The application should create the handle via the
* <f CreateEvent> function. If the event is created as
* an automatic-reset event, then the operating system will
* automatically reset the event once a wait has been
* satisfied. If the event is created as a manual-reset
* event, then it is the application's responsibility to
* call <f ResetEvent> to reset it. DirectInput will not
* call <f ResetEvent> for event notification handles.
*
* If the <p hEvent> is zero, then notification is disabled.
*
* @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_HANDLEEXISTS>: The <i IDirectInputDevice> object
* already has an event notification handle
* associated with it. DirectInput supports only one event
* notification handle per <i IDirectInputDevice> object.
*
* <c DIERR_ACQUIRED>: The <i IDirectInputDevice> object
* has been acquired. You must <mf IDirectInputDevice::Unacquire>
* the device before you can change the notification state.
*
* <c E_INVALIDARG>: The thing isn't an event handle.
*
* @ex
*
* To check if the handle is currently set without blocking:
*
* |
*
* dwResult = WaitForSingleObject(hEvent, 0);
* if (dwResult == WAIT_OBJECT_0) {
* // Event is set. If the event was created as
* // automatic-reset, then it has also been reset.
* }
*
* @ex
*
* The following example illustrates blocking
* indefinitely until the event is set. Note that this
* behavior is <y strongly> discouraged because the thread
* will not respond to the system until the wait is
* satisfied. (In particular, the thread will not respond
* to Windows messages.)
*
* |
*
* dwResult = WaitForSingleObject(hEvent, INFINITE);
* if (dwResult == WAIT_OBJECT_0) {
* // Event has been set. If the event was created as
* // automatic-reset, then it has also been reset.
* }
*
* @ex
*
* The following example illustrates a typical message loop
* for a message-based application that uses two events.
*
* |
*
* HANDLE ah[2] = { hEvent1, hEvent2 };
*
* while (TRUE) {
*
* dwResult = MsgWaitForMultipleObjects(2, ah, FALSE,
* INFINITE, QS_ALLINPUT);
* switch (dwResult) {
* case WAIT_OBJECT_0:
* // Event 1 has been set. If the event was created as
* // automatic-reset, then it has also been reset.
* ProcessInputEvent1();
* break;
*
* case WAIT_OBJECT_0 + 1:
* // Event 2 has been set. If the event was created as
* // automatic-reset, then it has also been reset.
* ProcessInputEvent2();
* break;
*
* case WAIT_OBJECT_0 + 2:
* // A Windows message has arrived. Process messages
* // until there aren't any more.
* while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
* if (msg.message == WM_QUIT) {
* goto exitapp;
* }
* TranslateMessage(&msg);
* DispatchMessage(&msg);
* }
* break;
*
* default:
* // Unexpected error.
* Panic();
* break;
* }
* }
*
* @ex
*
* The following example illustrates a typical application loop
* for a non-message-based application that uses two events.
*
* |
*
* HANDLE ah[2] = { hEvent1, hEvent2 };
* DWORD dwWait = 0;
*
* while (TRUE) {
*
* dwResult = MsgWaitForMultipleObjects(2, ah, FALSE,
* dwWait, QS_ALLINPUT);
* dwWait = 0;
*
* switch (dwResult) {
* case WAIT_OBJECT_0:
* // Event 1 has been set. If the event was created as
* // automatic-reset, then it has also been reset.
* ProcessInputEvent1();
* break;
*
* case WAIT_OBJECT_0 + 1:
* // Event 2 has been set. If the event was created as
* // automatic-reset, then it has also been reset.
* ProcessInputEvent2();
* break;
*
* case WAIT_OBJECT_0 + 2:
* // A Windows message has arrived. Process messages
* // until there aren't any more.
* while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
* if (msg.message == WM_QUIT) {
* goto exitapp;
* }
* TranslateMessage(&msg);
* DispatchMessage(&msg);
* }
* break;
*
* default:
* // No input or messages waiting.
* // Do a frame of the game.
* // If the game is idle, then tell the next wait
* // to wait indefinitely for input or a message.
* if (!DoGame()) {
* dwWait = INFINITE;
* }
* // Poll for data in case the device is not
* // interrupt-driven.
* IDirectInputDevice8_Poll(pdev);
* break;
* }
* }
*
*
*****************************************************************************/
STDMETHODIMP
CDIDev_SetEventNotification(PV pdd, HANDLE h _THAT)
{
HRESULT hres;
EnterProcR(IDirectInputDevice8::SetEventNotification, (_ "px", pdd, h));
if(SUCCEEDED(hres = hresPvT(pdd)))
{
PDD this = _thisPv(pdd);
/*
* Must protect with the critical section to prevent somebody from
* acquiring or setting a new event handle while we're changing it.
*/
CDIDev_EnterCrit(this);
if(!this->fAcquired)
{
/*
* Don't operate on the original handle because
* the app might decide to do something *interesting* to it
* on another thread.
*/
hres = DupEventHandle(h, &h);
if(SUCCEEDED(hres))
{
/*
* Resetting the event serves two purposes.
*
* 1. It performs parameter validation for us, and
* 2. The event must be reset while the device is
* not acquired.
*/
if(fLimpFF(h, ResetEvent(h)))
{
if(!this->hNotify || !h)
{
hres = this->pdcb->lpVtbl->
SetEventNotification(this->pdcb, h);
/*
* All dcb's use default handling for now so
* assert the callback returns S_FALSE
* so we are reminded to change this if need be.
* An uninitialized device would fail but don't
* break if we hit one of those, just assert that
* we won't accidentally call a HEL on it.
*/
AssertF( ( hres == S_FALSE )
|| ( ( hres == DIERR_NOTINITIALIZED ) && !this->pvi ) );
if(this->pvi)
{
VXDDWORDDATA vhd;
vhd.pvi = this->pvi;
vhd.dw = (DWORD)(UINT_PTR)h;
hres = Hel_SetNotifyHandle(&vhd);
AssertF(SUCCEEDED(hres)); /* Should never fail */
h = (HANDLE)(UINT_PTR)pvExchangePpvPv64(&this->hNotify, (UINT_PTR)h);
hres = this->hresPolled;
}
else
{
/*
* ISSUE-2001/03/29-timgill Is this actually an error case?
* Can this ever validly occur?
* if yes, don't we need any of the above?
*/
RPF( "Device internal data missing on SetEventNotification" );
}
} else
{
hres = DIERR_HANDLEEXISTS;
}
} else
{
RPF( "Handle not for Event in SetEventNotification" );
hres = E_HANDLE;
}
/*
* Close the old handle if we swapped one out
* or our duplicate if something went wrong
*/
if(h != 0)
{
CloseHandle(h);
}
}
} else
{
hres = DIERR_ACQUIRED;
}
CDIDev_LeaveCrit(this);
}
ExitOleProc();
return hres;
}
#ifdef XDEBUG
CSET_STUBS(SetEventNotification, (PV pdd, HANDLE h), (pdd, h THAT_))
#else
#define CDIDev_SetEventNotificationA CDIDev_SetEventNotification
#define CDIDev_SetEventNotificationW CDIDev_SetEventNotification
#endif
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | IDirectInputDevice | hresMapHow |
*
* Map the <p dwObj> and <p dwHow> fields into an object index.
*
* @parm DWORD | dwObj |
*
* Object identifier.
*
* @parm DWORD | dwHow |
*
* How <p dwObj> should be interpreted.
*
* @parm OUT LPDIPROPINFO | ppropi |
*
* Receives object index and <p dwDevType>.
*
*****************************************************************************/
#ifndef XDEBUG
#define CDIDev_hresMapHow_(this, dwObj, dwHow, ppropi, z) \
_CDIDev_hresMapHow_(this, dwObj, dwHow, ppropi) \
#endif
STDMETHODIMP
CDIDev_hresMapHow_(PDD this, DWORD dwObj, DWORD dwHow,
LPDIPROPINFO ppropi, LPCSTR s_szProc)
{
HRESULT hres;
if(this->pdcb != c_pdcbNil)
{
int iobj = 0;
switch(dwHow)
{
case DIPH_DEVICE:
if(dwObj == 0)
{
ppropi->iobj = 0xFFFFFFFF;
ppropi->dwDevType = 0;
hres = S_OK;
} else
{
RPF("%s: dwObj must be zero if DIPH_DEVICE", s_szProc);
hres = E_INVALIDARG;
}
break;
case DIPH_BYOFFSET:
if(this->pdix && this->rgiobj)
{
if(dwObj < this->dwDataSize)
{
iobj = this->rgiobj[dwObj];
if(iobj >= 0)
{
AssertF(this->pdix[iobj].dwOfs == dwObj);
ppropi->iobj = iobj;
ppropi->dwDevType = this->df.rgodf[iobj].dwType;
hres = S_OK;
goto done;
} else
{
AssertF(iobj == -1);
}
}
SquirtSqflPtszV(sqfl | sqflBenign,
TEXT("%S: Invalid offset in dwObj. You may use DIPH_BYID to enum it."), s_szProc);
//RPF("%s: Invalid offset in dwObj", s_szProc);
} else
{
RPF("%s: Must have a data format to use if DIPH_BYOFFSET", s_szProc);
}
hres = DIERR_OBJECTNOTFOUND;
goto done;
case DIPH_BYID:
for(iobj = this->df.dwNumObjs; --iobj >= 0; )
{
if(DIDFT_FINDMATCH(this->df.rgodf[iobj].dwType, dwObj))
{
ppropi->iobj = iobj;
ppropi->dwDevType = this->df.rgodf[iobj].dwType;
hres = S_OK;
goto done;
}
}
RPF("%s: Invalid ID in dwObj", s_szProc);
hres = DIERR_OBJECTNOTFOUND;
break;
case DIPH_BYUSAGE:
hres = IDirectInputDeviceCallback_MapUsage(this->pdcb,
dwObj, &ppropi->iobj);
if(SUCCEEDED(hres))
{
ppropi->dwDevType = this->df.rgodf[ppropi->iobj].dwType;
}
break;
default:
RPF("%s: Invalid dwHow", s_szProc);
hres = E_INVALIDARG;
break;
}
done:;
} else
{
RPF("ERROR: IDirectInputDevice: Not initialized");
hres = DIERR_NOTINITIALIZED;
}
return hres;
}
#define CDIDev_hresMapHow(this, dwObj, dwHow, pdwOut) \
CDIDev_hresMapHow_(this, dwObj, dwHow, pdwOut, s_szProc) \
/*****************************************************************************
*
* @doc EXTERNAL
*
* @method HRESULT | IDirectInputDevice | GetObjectInfo |
*
* Obtains information about an object.
*
* @cwrap LPDIRECTINPUTDEVICE | lpDirectInputDevice
*
* @parm OUT LPDIDEVICEOBJECTINSTANCE | pdidoi |
*
* Receives information about the object.
* The caller "must" initialize the <e DIDEVICEOBJECTINSTANCE.dwSize>
* field before calling this method.
*
* @parm DWORD | dwObj |
*
* Identifies the object for which the property is to be
* accessed. The meaning of this value depends on the
* value of the <p dwHow> parameter.
* See the documentation of the <t DIPROPHEADER>
* structure for additional information.
*
* @parm DWORD | dwHow |
*
* Identifies how <p dwObj> is to be interpreted.
* It must be one of the <c DIPH_*> values.
* See the documentation of the <t DIPROPHEADER>
* structure for additional information.
*
* @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>: One or more
* parameters was invalid.
*
* <c DIERR_OBJECTNOTFOUND>: The specified object does not
* exist.
*
*****************************************************************************/
STDMETHODIMP
CDIDev_GetObjectInfoW(PV pddW, LPDIDEVICEOBJECTINSTANCEW pdoiW,
DWORD dwObj, DWORD dwHow)
{
HRESULT hres;
EnterProcR(IDirectInputDevice8::GetObjectInfo,
(_ "ppxx", pddW, pdoiW, dwObj, dwHow));
if(SUCCEEDED(hres = hresPvW(pddW)) &&
SUCCEEDED(hres = hresFullValidWritePxCb2(pdoiW,
DIDEVICEOBJECTINSTANCE_DX5W,
DIDEVICEOBJECTINSTANCE_DX3W, 1)))
{
PDD this = _thisPvNm(pddW, ddW);
DIPROPINFO propi;
/*
* Must protect with the critical section to prevent
* another thread from Reset()ing behind our back.
*/
CDIDev_EnterCrit(this);
propi.pguid = 0;
/*
* Prefix picks up that ppropi->iobj is uninitialized (mb:34557) in
* the case of a BY_USAGE dwHow. However, the value is only an
* output for MapUsage which will always either set it or fail so
* there is no error.
*/
hres = CDIDev_hresMapHow(this, dwObj, dwHow, &propi);
if(SUCCEEDED(hres))
{
if(dwHow != DIPH_DEVICE)
{
hres = CDIDev_GetObjectInfoHelper(this, &propi, pdoiW);
} else
{
RPF("%s: Invalid dwHow", s_szProc);
hres = E_INVALIDARG;
}
}
if(FAILED(hres))
{
ScrambleBuf(&pdoiW->guidType,
pdoiW->dwSize -
FIELD_OFFSET(DIDEVICEOBJECTINSTANCEW, guidType));
}
CDIDev_LeaveCrit(this);
}
ExitBenignOleProcR();
return hres;
}
#define CDIDev_GetObjectInfo2W CDIDev_GetObjectInfoW
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | IDirectInputDeviceA | GetObjectInfo |
*
* ANSI version of same.
*
* @cwrap LPDIRECTINPUTDEVICE | lpDirectInputDevice
*
* @parm OUT LPDIDEVICEOBJECTINSTANCEA | pdoiA |
*
* Receives information about the device's identity.
*
* @parm DWORD | dwObj |
*
* Identifies the object for which the property is to be
* accessed.
*
* @parm DWORD | dwHow |
*
* Identifies how <p dwObj> is to be interpreted.
*
* @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>: One or more
* parameters was invalid.
*
*****************************************************************************/
STDMETHODIMP
CDIDev_GetObjectInfoA(PV pddA, LPDIDEVICEOBJECTINSTANCEA pdoiA,
DWORD dwObj, DWORD dwHow)
{
HRESULT hres;
EnterProcR(IDirectInputDevice8::GetObjectInfo,
(_ "ppxx", pddA, pdoiA, dwObj, dwHow));
if(SUCCEEDED(hres = hresPvA(pddA)) &&
SUCCEEDED(hres = hresFullValidWritePxCb2(pdoiA,
DIDEVICEOBJECTINSTANCE_DX5A,
DIDEVICEOBJECTINSTANCE_DX3A, 1)))
{
PDD this = _thisPvNm(pddA, ddA);
DIDEVICEOBJECTINSTANCEW doiW;
doiW.dwSize = cbX(DIDEVICEOBJECTINSTANCEW);
hres = CDIDev_GetObjectInfoW(&this->ddW, &doiW, dwObj, dwHow);
if(SUCCEEDED(hres))
{
ObjectInfoWToA(pdoiA, &doiW);
hres = S_OK;
}
}
ExitBenignOleProcR();
return hres;
}
#define CDIDev_GetObjectInfo2A CDIDev_GetObjectInfoA
/*****************************************************************************
*
* @doc EXTERNAL
*
* @method HRESULT | IDirectInputDevice | GetDeviceInfo |
*
* Obtains information about the device's identity.
*
* @cwrap LPDIRECTINPUTDEVICE | lpDirectInputDevice
*
* @parm OUT LPDIDEVICEINSTANCE | pdidi |
*
* Receives information about the device's identity.
* The caller "must" initialize the <e DIDEVICEINSTANCE.dwSize>
* field before calling this method.
*
* If <e DIDEVICEINSTANCE.dwSize> is equal to the size of
* the <t DIDEVICEINSTANCE_DX3> structure, then a
* DirectX 3.0-compatible structure is returned instead of
* a DirectX 5.0 structure.
*
* @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>: One or more
* parameters was invalid.
*
*****************************************************************************/
STDMETHODIMP
CDIDev_GetDeviceInfoW(PV pddW, LPDIDEVICEINSTANCEW pdidiW)
{
HRESULT hres;
EnterProcR(IDirectInputDevice8::GetDeviceInfo, (_ "pp", pddW, pdidiW));
if(SUCCEEDED(hres = hresPvW(pddW)) &&
SUCCEEDED(hres = hresFullValidWritePxCb2(pdidiW,
DIDEVICEINSTANCE_DX5W,
DIDEVICEINSTANCE_DX3W, 1)))
{
PDD this = _thisPvNm(pddW, ddW);
/*
* Must protect with the critical section to prevent
* another thread from Reset()ing behind our back.
*/
CDIDev_EnterCrit(this);
pdidiW->guidInstance = this->guid;
pdidiW->guidProduct = this->guid;
/*
* Don't overwrite the dwSize, guidInstance, or guidProduct.
* Start at the dwDevType.
*/
ZeroBuf(&pdidiW->dwDevType,
pdidiW->dwSize - FIELD_OFFSET(DIDEVICEINSTANCEW, dwDevType));
hres = this->pdcb->lpVtbl->GetDeviceInfo(this->pdcb, pdidiW);
if(FAILED(hres))
{
ScrambleBuf(&pdidiW->guidInstance,
cbX(DIDEVICEINSTANCEW) -
FIELD_OFFSET(DIDEVICEINSTANCEW, guidInstance));
}
CDIDev_LeaveCrit(this);
}
ExitOleProcR();
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @func void | DeviceInfoWToA |
*
* Convert a <t DIDEVICEINSTANCEW> to a <t DIDEVICEINSTANCE_DX3A>
* <t DIDEVICEINSTANCE_DX5A> or a <t DIDEVICEINSTANCE_DX8A>.
*
* @parm LPDIDIDEVICEINSTANCEA | pdiA |
*
* Destination.
*
* @parm LPCDIDIDEVICEINSTANCEW | pdiW |
*
* Source.
*
*****************************************************************************/
void EXTERNAL
DeviceInfoWToA(LPDIDEVICEINSTANCEA pdiA, LPCDIDEVICEINSTANCEW pdiW)
{
EnterProc(DeviceInfoWToA, (_ "pp", pdiA, pdiW));
AssertF(pdiW->dwSize == sizeof(DIDEVICEINSTANCEW));
AssertF(IsValidSizeDIDEVICEINSTANCEA(pdiA->dwSize));
pdiA->guidInstance = pdiW->guidInstance;
pdiA->guidProduct = pdiW->guidProduct;
pdiA->dwDevType = pdiW->dwDevType;
UToA(pdiA->tszInstanceName, cA(pdiA->tszInstanceName), pdiW->tszInstanceName);
UToA(pdiA->tszProductName, cA(pdiA->tszProductName), pdiW->tszProductName);
if(pdiA->dwSize >= cbX(DIDEVICEINSTANCE_DX5A))
{
pdiA->guidFFDriver = pdiW->guidFFDriver;
pdiA->wUsage = pdiW->wUsage;
pdiA->wUsagePage = pdiW->wUsagePage;
}
ExitProc();
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @func void | Device8WTo8A |
*
* Convert a <t LPDIRECTINPUTDEVICE8W> to a <t LPDIRECTINPUTDEVICE8A>.
*
* @parm LPDIRECTINPUTDEVICE8A * | ppdid8A |
*
* Destination.
*
* @parm LPDIRECTINPUTDEVICE8W | pdid8W |
*
* Source.
*
*****************************************************************************/
void EXTERNAL
Device8WTo8A(LPDIRECTINPUTDEVICE8A *ppdid8A, LPDIRECTINPUTDEVICE8W pdid8W)
{
PDD this;
EnterProc(Device8WTo8A, (_ "pp", ppdid8A, pdid8W));
this = _thisPvNm(pdid8W, ddW);
*ppdid8A = (ThisInterfaceA*)&this->ddA;
ExitProc();
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | IDirectInputDeviceA | GetDeviceInfo |
*
* ANSI version of same.
*
* @cwrap LPDIRECTINPUTDEVICE | lpDirectInputDevice
*
* @parm OUT LPDIDEVICEINSTANCEA | pdidiA |
*
* Receives information about the device's identity.
*
* @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>: One or more
* parameters was invalid.
*
*****************************************************************************/
STDMETHODIMP
CDIDev_GetDeviceInfoA(PV pddA, LPDIDEVICEINSTANCEA pdidiA)
{
HRESULT hres;
EnterProcR(IDirectInputDevice8::GetDeviceInfo, (_ "pp", pddA, pdidiA));
if(SUCCEEDED(hres = hresPvA(pddA)) &&
SUCCEEDED(hres = hresFullValidWritePxCb2(pdidiA,
DIDEVICEINSTANCE_DX5A,
DIDEVICEINSTANCE_DX3A, 1)))
{
PDD this = _thisPvNm(pddA, ddA);
DIDEVICEINSTANCEW diW;
diW.dwSize = cbX(DIDEVICEINSTANCEW);
hres = CDIDev_GetDeviceInfoW(&this->ddW, &diW);
if(SUCCEEDED(hres))
{
DeviceInfoWToA(pdidiA, &diW);
hres = S_OK;
}
}
ExitOleProcR();
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method void | CDIDev | UnhookCwp |
*
* Remove the CallWndProc handler.
*
* See <mf CDIDev::InstallCwp> for details.
*
*****************************************************************************/
HWND g_hwndExclusive;
HHOOK g_hhkCwp;
void INTERNAL
CDIDev_UnhookCwp(void)
{
DllEnterCrit();
if(g_hhkCwp)
{
UnhookWindowsHookEx(g_hhkCwp);
g_hhkCwp = 0;
g_hwndExclusive = 0;
}
DllLeaveCrit();
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CDIDev | AddForegroundDevice |
*
* Add ourselves to the list of devices that need to be
* unacquired when the window loses foreground activation.
*
* @parm PDD | this |
*
* Device to be added.
*
* @devnote
*
* Note that we do not need to AddRef the device, because
* <f CDIDev_Finalize> will unacquire the device for us
* automatically, so we will never be freed while still
* acquired.
*
* (Note that if we did choose to AddRef, it must be done
* outside the DLL critical
* section, in order to preserve the semaphore hierarchy.)
*
*****************************************************************************/
STDMETHODIMP
CDIDev_AddForegroundDevice(PDD this)
{
HRESULT hres;
DllEnterCrit();
hres = GPA_Append(g_hgpaExcl, this);
Common_Hold(this);
DllLeaveCrit();
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method void | CDIDev | DelForegroundDevice |
*
* Remove ourselves from the list, if we're there.
* It is not an error if we aren't on the list, because
* in the case of forced unacquire, the list is blanked
* out in order to avoid race conditions where somebody
* tries to acquire a device immediately upon receiving
* foreground activation, before we get a chance to
* unacquire all the old guys completely.
*
* @parm PDD | this |
*
* Device to be removed.
*
* @devnote
*
* Note that the Unhold must be done outside the DLL critical
* section, in order to preserve the semaphore hierarchy.
*
* Theoretically, the unhold will never drop the reference count
* to zero (because the latest it could be called is during
* the AppFinalize, where there is stll the outstanding refcount
* from the external ref that hasn't been released yet).
*
* But it's better to play it safe and always release the
* object outside.
*
*****************************************************************************/
void INTERNAL
CDIDev_DelForegroundDevice(PDD this)
{
HRESULT hres;
DllEnterCrit();
hres = GPA_DeletePtr(g_hgpaExcl, this);
if(hres == hresUs(0))
{ /* If the last one went away */
GPA_Term(g_hgpaExcl); /* Free the tracking memory */
CDIDev_UnhookCwp(); /* Then unhook ourselves */
}
DllLeaveCrit();
if(SUCCEEDED(hres))
{
Common_Unhold(this);
}
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @func LRESULT | CDIDev_CallWndProc |
*
* Thread-specific CallWndProc handler.
*
* Note that we need only one of these, since only the foreground
* window will require a hook.
*
* @parm int | nCode |
*
* Notification code.
*
* @parm WPARAM | wp |
*
* "Specifies whether the message is sent by the current process."
* We don't care.
*
* @parm LPARAM | lp |
*
* Points to a <t CWPSTRUCT> which describes the message.
*
* @returns
*
* Always chains to the next hook.
*
*****************************************************************************/
LRESULT CALLBACK
CDIDev_CallWndProc(int nCode, WPARAM wp, LPARAM lp)
{
LRESULT rc;
LPCWPSTRUCT pcwp = (LPCWPSTRUCT)lp;
#ifdef WINNT
static BOOL fKillFocus = FALSE;
static BOOL fIconic = FALSE;
fIconic = FALSE;
/*
* This part of code is to fix Windows bug 430051.
* The logic is: if WM_KILLFOCUS is followed by WM_SIZE(minimized),
* then the app is minimized from full screen mode.
* This combination should only happen to full screen mode game using DDraw.
*/
if(pcwp->message == WM_KILLFOCUS)
{
fKillFocus = TRUE;
} else if(pcwp->message == WM_SETFOCUS)
{
fKillFocus = FALSE;
} else if (pcwp->message == WM_SIZE)
{
if(pcwp->wParam == SIZE_MINIMIZED){
if( fKillFocus ) {
fIconic = TRUE;
fKillFocus = FALSE;
}else{
fKillFocus = FALSE;
}
} else {
fKillFocus = FALSE;
}
}
#endif
rc = CallNextHookEx(g_hhkCwp, nCode, wp, lp);
if( nCode == HC_ACTION && (pcwp->message == WM_ACTIVATE
#ifdef WINNT
|| fIconic
#endif
)
)
{
PDD *rgpdid;
UINT ipdid, cpdid;
#ifdef WINNT
fIconic = FALSE;
#endif
/*
* We cannot mess with items while inside the DLL critical section,
* because that would violate our semaphore hierarchy.
*
* Instead, we stash the active item list and replace it with
* an empty list. Then, outside the DLL critical section, we
* calmly operate on each item.
*/
DllEnterCrit();
rgpdid = (PV)g_hgpaExcl->rgpv;
cpdid = g_hgpaExcl->cpv;
GPA_Init(g_hgpaExcl);
/*
* Some sanity checking here.
*/
for(ipdid = 0; ipdid < cpdid; ipdid++)
{
AssertF(rgpdid[ipdid]);
}
DllLeaveCrit();
/*
* Note that InternalUnacquire will set the notification
* event so the app knows that input was lost.
*/
for(ipdid = 0; ipdid < cpdid; ipdid++)
{
AssertF(rgpdid[ipdid]);
// 7/19/2000(a-JiTay): IA64: Use %p format specifier for 32/64-bit pointers.
SquirtSqflPtszV(sqfl,
TEXT("Forcing unacquire of %p due to focus loss"),
rgpdid[ipdid]);
CDIDev_InternalUnacquire(rgpdid[ipdid]);
/*
* Prefix notices (mb:34651) that the above could release the
* interface, causing the following to party on garbage but this
* should be OK as long as we don't have a refcounting bug.
*/
Common_Unhold(rgpdid[ipdid]);
}
FreePpv(&rgpdid);
CDIDev_UnhookCwp();
}
return rc;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CDIDev | CanAcquire |
*
* Determine whether the device may be acquired exclusively.
*
* If exclusive access is not requested, then the function
* succeeds vacuously.
*
* If exclusive access is requested, then the window must
* be the foreground window and must belong to the current
* process.
*
*****************************************************************************/
STDMETHODIMP
CDIDev_CanAcquire(PDD this)
{
HRESULT hres;
AssertF(CDIDev_IsConsistent(this));
if(this->discl & DISCL_FOREGROUND)
{
HWND hwndForeground = GetForegroundWindow();
AssertF(this->hwnd);
/*
* Note that we don't have to do an IsWindow() on this->hwnd,
* because GetForegroundWindow() will always return a valid
* window or NULL. Since we already tested this->hwnd != 0
* above, the only way the equality can occur is if the window
* handle is indeed valid.
*/
if(this->hwnd == hwndForeground && !IsIconic(this->hwnd))
{
/*
* Need to make sure that the window "still" belongs to
* this process, in case the window handle got recycled.
*/
DWORD idProcess;
GetWindowThreadProcessId(this->hwnd, &idProcess);
if(idProcess == GetCurrentProcessId())
{
hres = S_OK;
} else
{
/*
* Put a permanently invalid handle here so that we
* won't accidentally take a new window that happens
* to get a recycled handle value.
*/
this->hwnd = INVALID_HANDLE_VALUE;
RPF("Error: Window destroyed while associated with a device");
hres = E_INVALIDARG;
}
} else
{
hres = DIERR_OTHERAPPHASPRIO;
}
} else
{ /* No window; vacuous success */
hres = S_OK;
}
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CDIDev | InstallCwp |
*
* Install the CallWndProc handler.
*
* There is a bit of subtlety in the way this works.
* Since only foreground windows may acquire exclusive access,
* we need only one hook (for there is but one foreground
* window in the system).
*
* _NT_: Does NT handle this correctly in the face of
* multiple window stations?
*
* The tricky part is that input loss occurs asynchronously.
* So a device that registers a <f CallWindowProc> hook doesn't
* find out that the input has been lost until the app next
* calls <f Unacquire>.
*
* So the way this is done is via a collection of global
* variables (which must be accessed atomically).
*
* <p g_hhkCwp> is the hook handle itself. It is zero when
* no hook is installed.
*
* Note that we install the windows hook while inside both the
* object critical section and the DLL critical section.
* You might think we'd risk deadlocking with the hook procedure,
* in case the window asynchronously deactivates while we're
* installing the hook. But your worries are unfounded:
* If the window is on the current thread, then window messages
* won't be dispatched because we never call <f GetMessage> or
* go into a modal loop. And if the window is on another thread,
* then that other thread will simply have to wait until we're done.
*
*****************************************************************************/
STDMETHODIMP
CDIDev_InstallCwp(PDD this)
{
HRESULT hres;
if(this->discl & DISCL_FOREGROUND)
{
AssertF(this->hwnd);
hres = CDIDev_CanAcquire(this);
if(SUCCEEDED(hres))
{
hres = CDIDev_AddForegroundDevice(this);
if(SUCCEEDED(hres))
{
DllEnterCrit();
if(!g_hhkCwp)
{ /* We're the first one */
g_hwndExclusive = this->hwnd;
g_hhkCwp = SetWindowsHookEx(WH_CALLWNDPROC,
CDIDev_CallWndProc, g_hinst,
GetWindowThreadProcessId(this->hwnd, 0));
} else
{
AssertF(g_hwndExclusive == this->hwnd);
}
DllLeaveCrit();
/*
* There is a race condition up above, where the foreground
* window can change between the call to CanAcquire() and
* the call to SetWindowsHookEx(). Close the window by
* checking a second time after the hook is installed.
*
* If we leave the window open, it's possible that we will
* perform a physical acquire while the wrong window has
* foreground activation. Then, of course, we are never told
* that *our* window lost activation, and the physical device
* remains acquired forever.
*/
hres = CDIDev_CanAcquire(this);
if(SUCCEEDED(hres))
{
} else
{
SquirtSqflPtszV(sqflError,
TEXT("Window no longer foreground; ")
TEXT("punting acquire"));
CDIDev_InternalUnacquire(this);
}
}
} else
{
hres = DIERR_OTHERAPPHASPRIO;
}
} else
{ /* No window; vacuous success */
hres = S_OK;
}
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | IDirectInputDevice | RealUnacquire |
*
* Release access to the device, even if the device was only
* partially acquired.
*
* @cwrap LPDIRECTINPUTDEVICE | lpDirectInputDevice
*
* @returns
*
* None.
*
*****************************************************************************/
STDMETHODIMP
CDIDev_RealUnacquire(PDD this)
{
HRESULT hres;
hres = this->pdcb->lpVtbl->Unacquire(this->pdcb);
if(hres == S_FALSE)
{
if(this->fAcquiredInstance)
{
this->fAcquiredInstance = 0;
hres = Hel_UnacquireInstance(this->pvi);
AssertF(SUCCEEDED(hres));
} else
{
hres = S_OK;
}
}
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CDIDev | FFAcquire |
*
* The device has been successfully acquired. Do any
* necessary force feedback related acquisition goo.
*
* @cwrap PDD | pdd
*
*****************************************************************************/
STDMETHODIMP
CDIDev_FFAcquire(PDD this)
{
HRESULT hres;
AssertF(CDIDev_InCrit(this));
if(this->pes && (this->discl & DISCL_EXCLUSIVE))
{
if(SUCCEEDED(hres = this->pes->lpVtbl->SendForceFeedbackCommand(
this->pes, &this->sh,
DISFFC_FORCERESET)))
{
CDIDev_RefreshGain(this);
/*
* If the center spring is to be disabled,
* then disable the center spring.
*/
if(!this->dwAutoCenter)
{
this->pes->lpVtbl->SendForceFeedbackCommand(
this->pes, &this->sh,
DISFFC_STOPALL);
}
hres = S_OK;
}
} else
{
hres = S_OK;
}
return hres;
}
/*****************************************************************************
*
* @doc EXTERNAL
*
* @method HRESULT | IDirectInputDevice | Acquire |
*
* Obtains access to the device.
*
* Device acquisition does not reference-count. If a device is
* acquired twice then unacquired once, the device is unacquired.
*
* Before the device can be acquired, a data format must
* first be set via the <mf IDirectInputDevice::SetDataFormat>
* method.
*
* @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 S_FALSE>: The device has already been acquired. Note
* that this value is a success code.
*
* <c DIERR_OTHERAPPHASPRIO>: Access to the device was not granted.
* The most common cause of this is attempting to acquire a
* device with the <c DISCL_FOREGROUND> cooperative level when
* the associated window is not foreground.
*
* This error code is also returned if an attempt to
* acquire a device in exclusive mode fails because the device
* is already acquired in exclusive mode by somebody else.
*
* <c DIERR_INVALIDPARAM> = <c E_INVALIDARG>: The device
* does not have a selected data format.
*/
/*
* The point at which we take the exclusive semaphore is important.
* We should do it after preliminary validation of foreground
* permission, so that we don't accidentally lock out somebody
* else who legitimately has permission.
*
*****************************************************************************/
STDMETHODIMP
CDIDev_Acquire(PV pdd _THAT)
{
HRESULT hres;
EnterProcR(IDirectInputDevice8::Acquire, (_ "p", pdd));
if(SUCCEEDED(hres = hresPvT(pdd)))
{
PDD this = _thisPv(pdd);
/*
* Must protect with the critical section to prevent somebody from
* acquiring or changing the data format while we're acquiring.
*/
CDIDev_EnterCrit(this);
/*
* The app explicitly messed with acquisition. Any problems
* retrieving data are now the apps' fault.
*/
this->hresNotAcquired = DIERR_NOTACQUIRED;
//We now need a pvi even in where the device doesn't use VxDs
if(this->pdix && this->pvi)
{
if(this->pvi->fl & VIFL_ACQUIRED)
{
hres = S_FALSE;
} else if(SUCCEEDED(hres = CDIDev_CanAcquire(this)))
{
hres = Excl_Acquire(&this->guid, this->hwnd, this->discl);
if(SUCCEEDED(hres))
{
if(SUCCEEDED(hres = CDIDev_FFAcquire(this)))
{
hres = this->pdcb->lpVtbl->Acquire(this->pdcb);
if(SUCCEEDED(hres))
{
if(hres == S_FALSE)
{
hres = Hel_AcquireInstance(this->pvi);
if(SUCCEEDED(hres))
{
this->fAcquiredInstance = 1;
/*
* If relative mode, need to prime the
* pvLastBuffer with the current state.
*/
if(this->pvi->fl & VIFL_RELATIVE)
{
hres = this->pdcb->lpVtbl->GetDeviceState(
this->pdcb, this->pvLastBuffer);
if(FAILED(hres))
{
goto unacquire;
}
}
} else
{
goto unacquire;
}
}
/*
* Note that InstallCwp must be the last thing
* we do, because it will add us to the foreground
* list, and none of our error exit paths remove us.
*/
hres = CDIDev_InstallCwp(this);
if(SUCCEEDED(hres))
{
this->fAcquired = 1;
this->fOnceAcquired = 1;
/*
* From now on, if we lose acquisition,
* it's not the app's fault.
*/
this->hresNotAcquired = DIERR_INPUTLOST;
hres = S_OK;
} else
{
goto unacquire;
}
} else
{
unacquire:;
CDIDev_RealUnacquire(this);
}
}
}
}
} else
{
hres = E_INVALIDARG;
}
CDIDev_LeaveCrit(this);
}
ExitOleProcR();
return hres;
}
#ifdef XDEBUG
CSET_STUBS(Acquire, (PV pdd), (pdd THAT_))
#else
#define CDIDev_AcquireA CDIDev_Acquire
#define CDIDev_AcquireW CDIDev_Acquire
#endif
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | IDirectInputDevice | InternalUnacquire |
*
* This does the real work of unacquiring. The internal
* version bypasses the "the app requested this" flag,
* so when the app goes to request something, it gets
* <c DIERR_INPUTLOST> instead of <c DIERR_NOTACQUIRED>.
*
* If the application error code is <c DIERR_INPUTLOST>, then
* we will also signal the associated event so that it knows
* that the state changed.
*
* @cwrap LPDIRECTINPUTDEVICE | lpDirectInputDevice
*
*****************************************************************************/
STDMETHODIMP
CDIDev_InternalUnacquire(PDD this)
{
HRESULT hres;
EnterProcR(IDirectInputDevice8::InternalUnacquire, (_ "p", this));
/*
* Must protect with the critical section to prevent confusing other
* methods which change their behavior depending on whether the device
* is acquired.
*/
CDIDev_EnterCrit(this);
if(this->fAcquired)
{
AssertF(this->pdcb != c_pdcbNil);
this->fAcquired = 0;
Excl_Unacquire(&this->guid, this->hwnd, this->discl);
if(this->discl & DISCL_FOREGROUND)
{
AssertF(this->hwnd);
CDIDev_DelForegroundDevice(this);
#ifdef WINNT
if( IsIconic(this->hwnd) ) {
this->fUnacquiredWhenIconic = 1;
}
#endif
/*
* Prefix notices (mb:34651) that the above could release the
* interface, causing the following to party on garbage but only
* if we have a refcounting bug so "By design".
*/
}
/*
* ISSUE-2001/03/29-timgill multithreading means we cannot rely on Excl_Unaquire() return values
* We cannot trust the return value (if we made one)
* of Excl_Unacquire, because another instance may have
* snuck in and acquired the device after we Excl_Unacquire'd
* it and started doing force feedback on it.
*
* We need to fix this with the joystick mutex.
*/
if(this->pes && (this->discl & DISCL_EXCLUSIVE))
{
this->pes->lpVtbl->SendForceFeedbackCommand(
this->pes, &this->sh, DISFFC_RESET);
this->sh.dwTag = 0;
}
hres = CDIDev_RealUnacquire(this);
if(this->hresNotAcquired == DIERR_INPUTLOST)
{
CDIDev_SetNotifyEvent(this);
}
} else
{
hres = S_FALSE;
}
CDIDev_LeaveCrit(this);
ExitOleProcR();
return hres;
}
/*****************************************************************************
*
* @doc EXTERNAL
*
* @method HRESULT | IDirectInputDevice | Unacquire |
*
* Release access to the device.
*
* @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 S_FALSE>: The object is not currently acquired.
* This may have been caused by a prior loss of input.
* Note that this is a success code.
*
*****************************************************************************/
STDMETHODIMP
CDIDev_Unacquire(PV pdd _THAT)
{
HRESULT hres;
EnterProcR(IDirectInputDevice8::Unacquire, (_ "p", pdd));
if(SUCCEEDED(hres = hresPvT(pdd)))
{
PDD this = _thisPv(pdd);
/*
* The app explicitly messed with acquisition. Any problems
* retrieving data are now the apps' fault.
*/
this->hresNotAcquired = DIERR_NOTACQUIRED;
hres = CDIDev_InternalUnacquire(this);
}
ExitOleProcR();
return hres;
}
#ifdef XDEBUG
CSET_STUBS(Unacquire, (PV pdd), (pdd THAT_))
#else
#define CDIDev_UnacquireA CDIDev_Unacquire
#define CDIDev_UnacquireW CDIDev_Unacquire
#endif
/*****************************************************************************
*
* @doc INTERNAL
*
* @method PDIPROPVALIDINFO | IDirectInputDevice | ppviFind |
*
* Locate the DIPROPVALIDINFO structure that describes
* the predefined property.
*
* @parm const GUID * | pguid |
*
* Property guid, or predefined property.
*
* @returns
*
* Pointer to a const <t DIPROPVALIDINFO> that describes
* what is and is not valid for this property.
*
* Returns 0 if the property is not one of the predefined
* properties.
*
*****************************************************************************/
#pragma BEGIN_CONST_DATA
typedef struct DIPROPVALIDINFO
{
PCGUID pguid; /* Property name */
DWORD dwSize; /* expected size */
DWORD fl; /* flags */
} DIPROPVALIDINFO, *PDIPROPVALIDINFO;
/*
* Note that the flags are negative in sense.
* This makes validation easier.
*/
#define DIPVIFL_NOTDEVICE 0x00000001 /* Cannot be device */
#define DIPVIFL_NOTOBJECT 0x00000002 /* Cannot be object */
#define DIPVIFL_READONLY 0x00000004 /* Cannot be set */
#define DIPVIFL_NOTPRIVATE 0x00000008 /* Cannot handle private pvi */
#define DIPVIFL_NOTACQUIRED 0x00000010 /* Cannot modify while acquired */
DIPROPVALIDINFO c_rgpvi[] = {
{
DIPROP_BUFFERSIZE,
cbX(DIPROPDWORD),
DIPVIFL_NOTOBJECT | DIPVIFL_NOTPRIVATE | DIPVIFL_NOTACQUIRED,
},
{
DIPROP_AXISMODE,
cbX(DIPROPDWORD),
DIPVIFL_NOTOBJECT | DIPVIFL_NOTPRIVATE | DIPVIFL_NOTACQUIRED,
},
{
DIPROP_GRANULARITY,
cbX(DIPROPDWORD),
DIPVIFL_NOTDEVICE | DIPVIFL_READONLY | DIPVIFL_NOTACQUIRED,
},
{
DIPROP_RANGE,
cbX(DIPROPRANGE),
DIPVIFL_NOTDEVICE | DIPVIFL_NOTACQUIRED,
},
/*
* Note that you can set the dead zone on the entire device.
* This is the same as applying it to each axis individually.
*/
{
DIPROP_DEADZONE,
cbX(DIPROPDWORD),
DIPVIFL_NOTACQUIRED,
},
/*
* Note that you can set the saturation on the entire device.
* This is the same as applying it to each axis individually.
*/
{
DIPROP_SATURATION,
cbX(DIPROPDWORD),
DIPVIFL_NOTACQUIRED,
},
/*
* Note that you can change the gain either while acquired
* or not. Your choice.
*/
{
DIPROP_FFGAIN,
cbX(DIPROPDWORD),
DIPVIFL_NOTOBJECT,
},
/*
* Note that the FF load is meaningful only when acquired,
* so we'd better not complain if they access it while acquired!
*/
{
DIPROP_FFLOAD,
cbX(DIPROPDWORD),
DIPVIFL_NOTOBJECT | DIPVIFL_READONLY,
},
{
DIPROP_AUTOCENTER,
cbX(DIPROPDWORD),
DIPVIFL_NOTOBJECT | DIPVIFL_NOTACQUIRED,
},
{
DIPROP_CALIBRATIONMODE,
cbX(DIPROPDWORD),
DIPVIFL_NOTOBJECT | DIPVIFL_NOTACQUIRED,
},
{
DIPROP_CALIBRATION,
cbX(DIPROPCAL),
DIPVIFL_NOTDEVICE | DIPVIFL_NOTACQUIRED,
},
{
DIPROP_GUIDANDPATH,
cbX(DIPROPGUIDANDPATH),
DIPVIFL_NOTOBJECT | DIPVIFL_READONLY,
},
{
DIPROP_INSTANCENAME,
cbX(DIPROPSTRING),
DIPVIFL_NOTOBJECT,
},
{
DIPROP_PRODUCTNAME,
cbX(DIPROPSTRING),
DIPVIFL_NOTOBJECT,
},
{
DIPROP_MAXBUFFERSIZE,
cbX(DIPROPDWORD),
DIPVIFL_NOTOBJECT | DIPVIFL_NOTPRIVATE | DIPVIFL_NOTACQUIRED,
},
{
DIPROP_JOYSTICKID,
cbX(DIPROPDWORD),
DIPVIFL_NOTOBJECT | DIPVIFL_NOTACQUIRED,
},
{
DIPROP_GETPORTDISPLAYNAME,
cbX(DIPROPSTRING),
DIPVIFL_NOTOBJECT | DIPVIFL_READONLY,
},
/*
* Note that you can change the report ID while acquired
* or not. Your choice.
*/
{
DIPROP_ENABLEREPORTID,
cbX(DIPROPDWORD),
0x0,
},
#if 0
{
DIPROP_SPECIFICCALIBRATION,
cbX(DIPROPCAL),
DIPVIFL_NOTDEVICE | DIPVIFL_NOTACQUIRED,
},
#endif
{
DIPROP_PHYSICALRANGE,
cbX(DIPROPRANGE),
DIPVIFL_NOTDEVICE | DIPVIFL_NOTACQUIRED,
},
{
DIPROP_LOGICALRANGE,
cbX(DIPROPRANGE),
DIPVIFL_NOTDEVICE | DIPVIFL_NOTACQUIRED,
},
{
DIPROP_KEYNAME,
cbX(DIPROPSTRING),
DIPVIFL_NOTDEVICE | DIPVIFL_NOTACQUIRED,
},
{
DIPROP_SCANCODE,
cbX(DIPROPDWORD),
DIPVIFL_NOTDEVICE | DIPVIFL_NOTACQUIRED,
},
{
DIPROP_APPDATA,
cbX(DIPROPPOINTER),
DIPVIFL_NOTDEVICE | DIPVIFL_NOTACQUIRED,
},
{
DIPROP_CPOINTS,
cbX(DIPROPCPOINTS),
DIPVIFL_NOTDEVICE | DIPVIFL_NOTACQUIRED,
},
{
DIPROP_VIDPID,
cbX(DIPROPDWORD),
DIPVIFL_NOTOBJECT | DIPVIFL_READONLY,
},
{
DIPROP_USERNAME,
cbX(DIPROPSTRING),
DIPVIFL_NOTOBJECT | DIPVIFL_READONLY,
},
{
DIPROP_TYPENAME,
cbX(DIPROPSTRING),
DIPVIFL_NOTOBJECT | DIPVIFL_READONLY,
},
{
DIPROP_MAPFILE,
cbX(DIPROPSTRING),
DIPVIFL_NOTOBJECT | DIPVIFL_READONLY,
},
};
#pragma END_CONST_DATA
STDMETHODIMP_(PDIPROPVALIDINFO)
CDIDev_ppviFind(PCGUID pguid)
{
PDIPROPVALIDINFO ppvi;
UINT ipvi;
for(ipvi = 0, ppvi = c_rgpvi; ipvi < cA(c_rgpvi); ipvi++, ppvi++)
{
if(ppvi->pguid == pguid)
{
goto found;
}
}
ppvi = 0;
found:
return ppvi;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | IDirectInputDevice | hresValidProp |
*
* Check that the property structure makes sense.
* Returns the object index for further processing.
*
* @parm const GUID * | pguid |
*
* Property guid, or predefined property.
*
* @parm LPCDIPROPHEADER | pdiph |
*
* Propery header structure.
*
* @parm BOOL | fWrite |
*
* Whether property should be validate for writing.
*
* @parm OUT LPDIPROPINFO | ppropi |
*
* Receives object index.
*
*****************************************************************************/
typedef BOOL (WINAPI *PFNBAD)(PCV pv, UINT cb);
STDMETHODIMP
CDIDev_hresValidProp(PDD this, const GUID *pguid, LPCDIPROPHEADER pdiph,
BOOL fWrite, LPDIPROPINFO ppropi)
{
HRESULT hres;
PFNBAD pfnBad;
EnterProcR(IDirectInputDevice8::Get/SetProperty,
(_ "pxpx", this, pguid, pdiph, fWrite));
AssertF(CDIDev_InCrit(this));
if(fWrite)
{
pfnBad = (PFNBAD)IsBadWritePtr;
} else
{
pfnBad = (PFNBAD)IsBadReadPtr;
}
if(!pfnBad(pdiph, cbX(DIPROPHEADER)) &&
pdiph->dwHeaderSize == cbX(DIPROPHEADER) &&
pdiph->dwSize % 4 == 0 &&
pdiph->dwSize >= pdiph->dwHeaderSize &&
!pfnBad(pdiph, pdiph->dwSize))
{
/*
* Now convert the item descriptor into an index.
*/
hres = CDIDev_hresMapHow(this, pdiph->dwObj, pdiph->dwHow, ppropi);
if(SUCCEEDED(hres))
{
/*
* Now validate the property id or guid.
*/
if(HIWORD((UINT_PTR)pguid) == 0)
{
PDIPROPVALIDINFO ppvi;
ppvi = CDIDev_ppviFind(pguid);
/*
* Note that if we don't find the GUID in our list,
* we fail it straight away. This prevents ISVs
* from trying to create properties in the Microsoft
* Reserved range.
*/
if(ppvi)
{
if( ppvi->pguid == DIPROP_CALIBRATION ) {
if( pdiph->dwSize == ppvi->dwSize ||
pdiph->dwSize == cbX(DIPROPCALPOV) )
{
hres = S_OK;
} else {
RPF("%s: Arg 2: Invalid dwSize for property", s_szProc);
hres = E_INVALIDARG;
}
} else if( pdiph->dwSize == ppvi->dwSize )
{
if( pguid == DIPROP_KEYNAME || pguid == DIPROP_SCANCODE ) {
// Fix Manbug 28888.
// DIPROP_KEYNAME and DIPROP_SCANCODE are not a property for device.
if( pdiph->dwHow == DIPH_DEVICE ) {
hres = E_INVALIDARG;
}
}
else
{
if(fWrite)
{
ScrambleBuf((PV)(pdiph+1), pdiph->dwSize - cbX(DIPROPHEADER) );
}
hres = S_OK;
}
} else
{
RPF("%s: Arg 2: Invalid dwSize for property", s_szProc);
hres = E_INVALIDARG;
}
} else
{
RPF("%s: Arg 1: Unknown property", s_szProc);
hres = E_NOTIMPL;
}
} else
{
hres = hresFullValidGuid(pguid, 1);
}
}
} else
{
RPF("%s: Arg 2: Invalid pointer", s_szProc);
hres = E_INVALIDARG;
}
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CDIDev | hresValidDefProp |
*
* Determine whether the property is something we can handle
* in the default property handler.
*
* @parm IN LPCDIPROPINFO | ppropi |
*
* Information describing the property being retrieved.
*
* @parm DWORD | dwFlags |
*
* Flags for forbidden things.
* <c DIPVIFL_READONLY> if being validated for writing.
*
* @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>: Passes validation.
*
* <c E_NOTIMPL>: Not something we handle.
*
*
*****************************************************************************/
HRESULT INTERNAL
CDIDev_hresValidDefProp(PDD this, LPCDIPROPINFO ppropi, DWORD dwFlags)
{
HRESULT hres;
PDIPROPVALIDINFO ppvi;
EnterProc(CDIDev_hresValidDefProp,
(_ "pGxx", this, ppropi->pguid, ppropi->dwDevType, dwFlags));
/*
* Note that it's okay if the device is acquired. We want to
* allow GetProperty to succeed on an acquired device.
*/
AssertF(CDIDev_InCrit(this));
ppvi = CDIDev_ppviFind(ppropi->pguid);
if(ppvi)
{
if(ppropi->iobj == 0xFFFFFFFF)
{
dwFlags |= DIPVIFL_NOTDEVICE; /* Fail if devices forbidden */
} else
{
dwFlags |= DIPVIFL_NOTOBJECT; /* Fail if objects forbidden */
}
if(this->pvi == 0)
{
dwFlags |= DIPVIFL_NOTPRIVATE; /* Fail if privates forbidden */
}
/*
* If attempting to modify property and we are acquired,
* then also set the "but not while acquired" filter.
*/
if((dwFlags & DIPVIFL_READONLY) && this->fAcquired)
{
dwFlags |= DIPVIFL_NOTACQUIRED; /* Fail if r/o while acq'd */
}
if((ppvi->fl & dwFlags) == 0)
{
hres = S_OK; /* Seems reasonable */
} else
{
if(ppvi->fl & dwFlags & DIPVIFL_READONLY)
{
RPF("SetProperty: Property is read-only");
hres = DIERR_READONLY;
} else if(ppvi->fl & dwFlags & DIPVIFL_NOTACQUIRED)
{
RPF("SetProperty: Cannot change property while acquired");
hres = DIERR_ACQUIRED;
} else
{
RPF("Get/SetProperty: Property does not exist for that object");
hres = E_NOTIMPL; /* Cannot do that */
}
}
} else
{
RPF("Get/SetProperty: Property does not exist");
hres = E_NOTIMPL; /* Definitely way out */
}
ExitOleProc();
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CDIDev | DefGetProperty |
*
* Default implementation of <mf IDirectInputDevice::GetProperty>
* to handle properties which the device decides not to implement.
*
* @parm IN LPCDIPROPINFO | ppropi |
*
* Information describing the property being retrieved.
*
* @parm OUT LPDIPROPHEADER | pdiph |
*
* Where to put the property value.
*
* @returns
*
* Returns a COM error code. The following error codes are
* intended to be illustrative and not necessarily comprehensive.
*
* <c DI_OK> = <c S_OK>: The operation completed successfully.
*
* <c DIERR_INVALIDPARAM> = <c E_INVALIDARG>: The
* <p pdiph> parameter is not a valid pointer.
*
*
*****************************************************************************/
STDMETHODIMP
CDIDev_DefGetProperty(PDD this, LPCDIPROPINFO ppropi, LPDIPROPHEADER pdiph)
{
HRESULT hres;
EnterProc(CDIDev_DefGetProperty,
(_ "pGx", this, ppropi->pguid, ppropi->dwDevType));
AssertF(CDIDev_InCrit(this));
hres = CDIDev_hresValidDefProp(this, ppropi, 0);
if(SUCCEEDED(hres))
{
LPDIPROPDWORD pdipdw = (PV)pdiph;
LPDIPROPRANGE pdiprg = (PV)pdiph;
LPDIPROPPOINTER pdipptr = (PV)pdiph;
LPDIPROPSTRING pdipwsz = (PV)pdiph;
switch((DWORD)(UINT_PTR)ppropi->pguid)
{
case (DWORD)(UINT_PTR)DIPROP_BUFFERSIZE:
AssertF(this->pvi); /* Validation should've caught this */
pdipdw->dwData = this->celtBuf;
hres = S_OK;
break;
case (DWORD)(UINT_PTR)DIPROP_AXISMODE:
AssertF(this->pvi); /* Validation should've caught this */
if(this->pvi->fl & VIFL_RELATIVE)
{
pdipdw->dwData = DIPROPAXISMODE_REL;
} else
{
pdipdw->dwData = DIPROPAXISMODE_ABS;
}
hres = S_OK;
break;
case (DWORD)(UINT_PTR)DIPROP_GRANULARITY:
if(DIDFT_GETTYPE(ppropi->dwDevType) & DIDFT_AXIS)
{
/* Default axis granularity is 1 */
pdipdw->dwData = 1;
hres = S_OK;
} else
{
/*
* Buttons don't have granularity.
* POVs must be handled by device driver.
*/
RPF("GetProperty: Object doesn't have a granularity");
hres = E_NOTIMPL;
}
break;
case (DWORD)(UINT_PTR)DIPROP_RANGE:
if(DIDFT_GETTYPE(ppropi->dwDevType) & DIDFT_RELAXIS)
{
/* Default rel-axis range is infinite */
pdiprg->lMin = DIPROPRANGE_NOMIN;
pdiprg->lMax = DIPROPRANGE_NOMAX;
hres = S_OK;
} else
{
/*
* Device driver must handle abs axis range.
* Buttons and POVs don't have range.
*/
RPF("GetProperty: Object doesn't have a range");
hres = E_NOTIMPL;
}
break;
case (DWORD)(UINT_PTR)DIPROP_MAXBUFFERSIZE:
pdipdw->dwData = this->celtBufMax;
hres = S_OK;
break;
case (DWORD)(UINT_PTR)DIPROP_APPDATA:
if( ( this->df.rgodf[ppropi->iobj].dwType & DIDFT_CONTROLOBJS )
&&!( this->df.rgodf[ppropi->iobj].dwType & DIDFT_NODATA ) )
{
if( this->pdix )
{
if( this->pdix[ppropi->iobj].dwOfs != 0xFFFFFFFF )
{
pdipptr->uData = this->pdix[ppropi->iobj].uAppData;
}
else
{
hres = DIERR_OBJECTNOTFOUND;
}
}
else
{
RPF("GetProperty: Need data format/semantic map applied to have app data");
hres = DIERR_NOTINITIALIZED;
}
}
else
{
RPF("SetProperty: app data only valid for input controls");
hres = E_NOTIMPL;
}
break;
case (DWORD)(UINT_PTR)DIPROP_USERNAME:
hres = CMap_GetDeviceUserName( &this->guid, pdipwsz->wsz );
break;
case (DWORD)(UINT_PTR)DIPROP_FFGAIN:
pdipdw->dwData = this->dwGain;
hres = S_OK;
break;
case (DWORD)(UINT_PTR)DIPROP_FFLOAD:
hres = CDIDev_GetLoad(this, &pdipdw->dwData);
break;
case (DWORD)(UINT_PTR)DIPROP_AUTOCENTER:
if(this->didcFF & DIDC_FORCEFEEDBACK)
{
pdipdw->dwData = this->dwAutoCenter;
hres = S_OK;
} else
{
hres = E_NOTIMPL;
}
break;
default:
/*
* The user is asking for some property that simply
* makes no sense here. E.g., asking for the dead
* zone on a keyboard.
*/
SquirtSqflPtszV(sqfl | sqflBenign,
TEXT("GetProperty: Property 0x%08x not supported on device"),
(DWORD)(UINT_PTR)ppropi->pguid );
hres = E_NOTIMPL;
break;
}
}
ExitOleProc();
return hres;
}
/*****************************************************************************
*
* @doc EXTERNAL
*
* @method HRESULT | IDirectInputDevice | GetProperty |
*
* Obtain information about a device or object in a device.
*
* @cwrap LPDIRECTINPUTDEVICE | lpDirectInputDevice
*
* @parm IN REFGUID | rguidProp |
*
* The identity of the property to be obtained. This can be
* one of the predefined <c DIPROP_*> values, or it may
* be a private GUID.
*
* @parm IN LPDIPROPHEADER | pdiph |
*
* Points to the <t DIPROPHEADER> portion of a structure
* which dependson the property.
*
* @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 pdiph> parameter is not a valid pointer, or the
* <p dwHow> field is invalid, or the <p dwObj> field
* is not zero when <p dwHow> is set to <c DIPH_DEVICE>.
*
* <c DIERR_OBJECTNOTFOUND>: The specified object does not
* exist.
*
* <c DIERR_UNSUPPORTED> = <c E_NOTIMPL>: The property
* is not supported by the device or object.
*
* @ex
*
* The following "C" code fragment illustrates how to obtain
* the value of the <c DIPROP_BUFFERSIZE> property.
*
* |
*
* DIPROPDWORD dipdw;
* HRESULT hres;
* dipdw.diph.dwSize = sizeof(DIPROPDWORD);
* dipdw.diph.dwHeaderSize = sizeof(DIPROPHEADER);
* dipdw.diph.dwObj = 0; // device property
* hres = IDirectInputDevice_GetProperty(pdid, DIPROP_BUFFERSIZE, &dipdw.diph);
* if (SUCCEEDED(hres)) {
* // dipdw.dwData contains the value of the property
* }
*
*****************************************************************************/
STDMETHODIMP
CDIDev_GetProperty(PV pdd, REFGUID rguid, LPDIPROPHEADER pdiph _THAT)
{
HRESULT hres;
EnterProcR(IDirectInputDevice8::GetProperty, (_ "pxp", pdd, rguid, pdiph));
if(SUCCEEDED(hres = hresPvT(pdd)))
{
PDD this = _thisPv(pdd);
DIPROPINFO propi;
/*
* Must protect with the critical section to prevent somebody
* acquiring or changing the property we are reading. We need
* to do this before validating, to prevent an acquisition.
*/
CDIDev_EnterCrit(this);
propi.pguid = rguid;
if(SUCCEEDED(hres = CDIDev_hresValidProp(this, rguid, pdiph,
1, &propi)))
{
/*
* Prefix picks up that ppropi->iobj is uninitialized (mb:34682)
* in the case of a BY_USAGE dwHow. However, the value is only
* an output for MapUsage which will always either set it or
* fail so there is no error.
*/
hres = this->pdcb->lpVtbl->GetProperty(this->pdcb, &propi, pdiph);
if(hres == E_NOTIMPL)
{
hres = CDIDev_DefGetProperty(this, &propi, pdiph);
}
}
CDIDev_LeaveCrit(this);
}
ExitBenignOleProcR();
return hres;
}
#ifdef XDEBUG
CSET_STUBS(GetProperty, (PV pdm, REFGUID rguid, LPDIPROPHEADER pdiph),
(pdm, rguid, pdiph THAT_))
#endif
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CDIDev | SetAxisMode |
*
* Default handler for clients trying to set the axis mode.
* If the device doesn't handle axis modes natively, then
* we'll fake it ourselves.
*
* @parm DWORD | dwMode |
*
* Desired new mode.
*
* @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.
*
*****************************************************************************/
STDMETHODIMP
CDIDev_SetAxisMode(PDD this, DWORD dwMode)
{
HRESULT hres;
EnterProcR(IDirectInputDevice8::SetProperty(AXISMODE),
(_ "px", this, dwMode));
AssertF(this->pvi); /* Validation should've caught this */
hres = hresFullValidFl(dwMode, DIPROPAXISMODE_VALID, 2);
if(SUCCEEDED(hres))
{
if(dwMode & DIPROPAXISMODE_REL)
{
this->GetDeviceState = CDIDev_GetRelDeviceState;
this->pvi->fl |= VIFL_RELATIVE;
} else
{
this->GetDeviceState = CDIDev_GetAbsDeviceState;
this->pvi->fl &= ~VIFL_RELATIVE;
}
if(this->cAxes)
{
hres = S_OK;
} else
{
hres = DI_PROPNOEFFECT;
}
}
ExitOleProc();
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CDIDev | SetAutoCenter |
*
* Default handler for clients trying to set the
* auto-center property.
*
* If the device doesn't have control over the
* auto-center spring, then we fail.
*
* @parm DWORD | dwMode |
*
* Desired new mode.
*
* @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.
*
*****************************************************************************/
STDMETHODIMP
CDIDev_SetAutoCenter(PDD this, DWORD dwMode)
{
HRESULT hres;
EnterProcR(IDirectInputDevice8::SetProperty(AUTOCENTER),
(_ "px", this, dwMode));
hres = hresFullValidFl(dwMode, DIPROPAUTOCENTER_VALID, 2);
if(SUCCEEDED(hres))
{
if(this->didcFF & DIDC_FORCEFEEDBACK)
{
/*
* We need to create the effect driver if disabling
* autocenter so that CDIDev_FFAcquire will set the feedback
* mode properly.
*/
if(fLimpFF(dwMode == DIPROPAUTOCENTER_OFF,
SUCCEEDED(hres = CDIDev_CreateEffectDriver(this))))
{
this->dwAutoCenter = dwMode;
hres = S_OK;
}
} else
{
hres = E_NOTIMPL;
}
}
ExitOleProc();
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CDIDev | SetGlobalAxisProp |
*
* Default implementation of <mf IDirectInputDevice::SetProperty>
* to handle properties which can be applied globally to all
* absolute axes.
*
* @parm IN LPDIPROPINFO | ppropi |
*
* Information describing the property being set.
* We edit it to avoid reallocating memory all the time.
*
* @parm IN LPCDIPROPHEADER | pdiph |
*
* The property itself.
*
* @returns
*
* We consider the property-set a success if all candidates
* succeeded. <c E_NOTIMPL> counts as success, on the assumption
* that the property is not meaningful on the candidate.
*
*****************************************************************************/
STDMETHODIMP
CDIDev_SetGlobalAxisProp(PDD this, LPDIPROPINFO ppropi, LPCDIPROPHEADER pdiph)
{
HRESULT hres;
for(ppropi->iobj = 0; ppropi->iobj < this->df.dwNumObjs; ppropi->iobj++)
{
DWORD dwType = this->df.rgodf[ppropi->iobj].dwType;
if(dwType & DIDFT_ABSAXIS)
{
ppropi->dwDevType = this->df.rgodf[ppropi->iobj].dwType;
hres = this->pdcb->lpVtbl->SetProperty(this->pdcb, ppropi, pdiph);
if(FAILED(hres) && hres != E_NOTIMPL)
{
goto done;
}
}
}
hres = S_OK;
done:;
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CDIDev | DefSetProperty |
*
* Default implementation of <mf IDirectInputDevice::SetProperty>
* to handle properties which the device decides not to implement.
*
* @parm IN LPDIPROPINFO | ppropi |
*
* Information describing the property being set.
* We edit it to avoid reallocating memory all the time.
*
* @parm OUT LPCDIPROPHEADER | pdiph |
*
* Where to put the property value.
*
* @returns
*
* Returns a COM error code. The following error codes are
* intended to be illustrative and not necessarily comprehensive.
*
* <c DI_OK> = <c S_OK>: The operation completed successfully.
*
* <c DI_POLLEDDEVICE>: The device is polled, so the result
* might not be meaningful. (This return code is used when
* you attempt to set the buffer size property.)
*
* <c DIERR_INVALIDPARAM> = <c E_INVALIDARG>: The
* <p pdiph> parameter is not a valid pointer.
*
*
*****************************************************************************/
STDMETHODIMP
CDIDev_DefSetProperty(PDD this, LPDIPROPINFO ppropi, LPCDIPROPHEADER pdiph)
{
HRESULT hres;
EnterProc(CDIDev_DefSetProperty,
(_ "pGx", this, ppropi->pguid, ppropi->dwDevType));
AssertF(CDIDev_InCrit(this));
/*
* Note: The indentation here is historical; I left it this way
* to keep the diff size down.
*/
hres = CDIDev_hresValidDefProp(this, ppropi, DIPVIFL_READONLY);
if(SUCCEEDED(hres))
{
LPDIPROPDWORD pdipdw = (PV)pdiph;
LPDIPROPRANGE pdiprg = (PV)pdiph;
LPDIPROPPOINTER pdipptr = (PV)pdiph;
VXDDWORDDATA vdd;
switch((DWORD)(UINT_PTR)ppropi->pguid)
{
case (DWORD)(UINT_PTR)DIPROP_BUFFERSIZE:
AssertF(this->pvi); /* Validation should've caught this */
vdd.pvi = this->pvi;
if( pdipdw->dwData > this->celtBufMax )
{
RPF( "DIPROP_BUFFERSIZE: requested size %d is larger than maximum %d, using %d",
pdipdw->dwData, this->celtBufMax, this->celtBufMax );
vdd.dw = this->celtBufMax;
}
else
{
vdd.dw = pdipdw->dwData;
}
hres = Hel_SetBufferSize(&vdd);
#ifdef DEBUG_STICKY
{
TCHAR tszDbg[80];
wsprintf( tszDbg, TEXT("SetBufferSize(0x%08x) returned 0x%08x\r\n"), vdd.dw, hres );
OutputDebugString( tszDbg );
}
#endif /* DEBUG_STICKY */
if(SUCCEEDED(hres))
{
this->celtBuf = pdipdw->dwData;
hres = this->hresPolled;
}
break;
case (DWORD)(UINT_PTR)DIPROP_AXISMODE:
hres = CDIDev_SetAxisMode(this, pdipdw->dwData);
break;
/*
* We will handle these global properties
* if the callback doesn't want to.
*/
case (DWORD)(UINT_PTR)DIPROP_RANGE:
case (DWORD)(UINT_PTR)DIPROP_DEADZONE:
case (DWORD)(UINT_PTR)DIPROP_SATURATION:
case (DWORD)(UINT_PTR)DIPROP_CALIBRATIONMODE:
case (DWORD)(UINT_PTR)DIPROP_CALIBRATION:
if(ppropi->dwDevType == 0)
{ /* For device */
hres = CDIDev_SetGlobalAxisProp(this, ppropi, pdiph);
} else
{
goto _default;
}
break;
case (DWORD)(UINT_PTR)DIPROP_MAXBUFFERSIZE:
this->celtBufMax = pdipdw->dwData;
hres = S_OK;
break;
case (DWORD)(UINT_PTR)DIPROP_APPDATA:
if( ( this->df.rgodf[ppropi->iobj].dwType & DIDFT_CONTROLOBJS )
&&!( this->df.rgodf[ppropi->iobj].dwType & DIDFT_NODATA ) )
{
if( this->pdix )
{
if( this->pdix[ppropi->iobj].dwOfs != 0xFFFFFFFF )
{
this->pdix[ppropi->iobj].uAppData = pdipptr->uData;
}
else
{
hres = DIERR_OBJECTNOTFOUND;
}
}
else
{
RPF("SetProperty: Need data format/semantic map applied to change app data");
hres = DIERR_NOTINITIALIZED;
}
}
else
{
RPF("SetProperty: app data only valid for input controls");
hres = E_NOTIMPL;
}
break;
case (DWORD)(UINT_PTR)DIPROP_FFGAIN:
if(ISVALIDGAIN(pdipdw->dwData))
{
this->dwGain = pdipdw->dwData;
CDIDev_RefreshGain(this);
hres = S_OK;
} else
{
RPF("ERROR: SetProperty(DIPROP_FFGAIN): Gain out of range");
hres = E_INVALIDARG;
}
break;
case (DWORD)(UINT_PTR)DIPROP_AUTOCENTER:
hres = CDIDev_SetAutoCenter(this, pdipdw->dwData);
break;
_default:;
default:
/*
* The validation filter already failed invalid properties.
* So what's left is that the property is valid but cannot
* be set, because it doesn't exist on the device (e.g.,
* dead zone) or because it is read-only.
*/
SquirtSqflPtszV(sqfl | sqflBenign,
TEXT("SetProperty: Property 0x%08x not supported on device"),
(DWORD)(UINT_PTR)ppropi->pguid );
hres = E_NOTIMPL;
break;
}
}
ExitOleProc();
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | IDirectInputDevice | RealSetProperty |
*
* The function that does the real work.
*
* <mf IDirectInputDevice::SetDataFormat> will internally
* set the axis mode property, so it needs this backdoor
* entry point.
*
* @cwrap LPDIRECTINPUTDEVICE | lpDirectInputDevice
*
* @parm IN REFGUID | rguidProp |
*
* The identity of the property to be set.
*
* @parm IN LPDIPROPHEADER | pdiph |
*
* Points to the <t DIPROPHEADER> portion of a structure
* which depends on the property.
*
*****************************************************************************/
STDMETHODIMP
CDIDev_RealSetProperty(PDD this, REFGUID rguid, LPCDIPROPHEADER pdiph)
{
HRESULT hres;
DIPROPINFO propi;
EnterProcR(IDirectInputDevice8::SetProperty, (_ "pxp", this, rguid, pdiph));
/*
* Must protect with the critical section to prevent somebody
* acquiring or changing the property we are reading. We need
* to do this before validating, to prevent an acquisition.
*/
CDIDev_EnterCrit(this);
propi.pguid = rguid;
if(SUCCEEDED(hres = CDIDev_hresValidProp(this, rguid, pdiph,
0, &propi)))
{
hres = this->pdcb->lpVtbl->SetProperty(this->pdcb, &propi, pdiph);
if(hres == E_NOTIMPL)
{
hres = CDIDev_DefSetProperty(this, &propi, pdiph);
}
}
CDIDev_LeaveCrit(this);
ExitOleProc();
return hres;
}
/*****************************************************************************
*
* @doc EXTERNAL
*
* @method HRESULT | IDirectInputDevice | SetProperty |
*
* Set information about a device or object in a device.
*
* @cwrap LPDIRECTINPUTDEVICE | lpDirectInputDevice
*
* @parm IN REFGUID | rguidProp |
*
* The identity of the property to be set. This can be
* one of the predefined <c DIPROP_*> values, or it may
* be a pointer to a private GUID.
*
* @parm IN LPDIPROPHEADER | pdiph |
*
* Points to the <t DIPROPHEADER> portion of a structure
* which depends on the property.
*
* @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_PROPNOEFFECT> <c S_FALSE>: The operation completed
* successfully but
* had no effect. For example, changing the axis mode
* on a device with no axes will return this value.
*
* <c DIERR_INVALIDPARAM> = <c E_INVALIDARG>: The
* <p pdiph> parameter is not a valid pointer, or the
* <p dwHow> field is invalid, or the <p dwObj> field
* is not zero when <p dwHow> is set to <c DIPH_DEVICE>.
*
* <c DIERR_OBJECTNOTFOUND>: The specified object does not
* exist.
*
* <c DIERR_UNSUPPORTED> = <c E_NOTIMPL>: The property
* is not supported by the device or object.
*
*****************************************************************************/
STDMETHODIMP
CDIDev_SetProperty(PV pdd, REFGUID rguid, LPCDIPROPHEADER pdiph _THAT)
{
HRESULT hres;
EnterProcR(IDirectInputDevice8::SetProperty, (_ "pxp", pdd, rguid, pdiph));
if(SUCCEEDED(hres = hresPvT(pdd)))
{
PDD this = _thisPv(pdd);
hres = CDIDev_RealSetProperty(this, rguid, pdiph);
}
ExitOleProcR();
return hres;
}
#ifdef XDEBUG
CSET_STUBS(SetProperty, (PV pdm, REFGUID rguid, LPCDIPROPHEADER pdiph),
(pdm, rguid, pdiph THAT_))
#else
#define CDIDev_SetPropertyA CDIDev_SetProperty
#define CDIDev_SetPropertyW CDIDev_SetProperty
#endif
/*****************************************************************************
*
* @doc EXTERNAL
*
* @method HRESULT | IDirectInputDevice | SetCooperativeLevel |
*
* Establish the cooperativity level for the instance of
* the device.
*
* The cooperativity level determines how the instance of
* the device interacts with other instances of the device
* and the rest of the system.
*
* Note that if the system mouse is acquired in exclusive
* mode, then the mouse cursor will be removed from the screen
* until the device is unacquired.
*
* @cwrap LPDIRECTINPUTDEVICE | lpDirectInputDevice
*
* @parm HWND | hwnd |
*
* The window associated with the device.
* The window must be a top-level window.
*
* It is an error to destroy the window while it is still
* active in a DirectInput device.
*
* @parm DWORD | dwFlags |
*
* Flags which describe the cooperativity level associated
* with the device.
*
* It consists of <c DISCL_*> flags, documented separately.
*
* @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 hwnd> parameter is not a valid pointer.
*
*****************************************************************************/
HRESULT INLINE
CDIDev_SetCooperativeLevel_IsValidFl(DWORD dwFlags)
{
HRESULT hres;
RD(static char s_szProc[] = "IDirectInputDevice::SetCooperativeLevel");
if(!(dwFlags & ~DISCL_VALID))
{
if((dwFlags & DISCL_EXCLMASK) == DISCL_EXCLUSIVE ||
(dwFlags & DISCL_EXCLMASK) == DISCL_NONEXCLUSIVE)
{
if((dwFlags & DISCL_GROUNDMASK) == DISCL_FOREGROUND ||
(dwFlags & DISCL_GROUNDMASK) == DISCL_BACKGROUND)
{
hres = S_OK;
} else
{
RPF("ERROR %s: arg %d: Must set exactly one of "
"DISCL_FOREGROUND or DISCL_BACKGROUND", s_szProc, 2);
hres = E_INVALIDARG;
}
} else
{
RPF("ERROR %s: arg %d: Must set exactly one of "
"DISCL_EXCLUSIVE or DISCL_NONEXCLUSIVE", s_szProc, 2);
hres = E_INVALIDARG;
}
} else
{
RPF("ERROR %s: arg %d: invalid flags", s_szProc, 2);
hres = E_INVALIDARG;
}
return hres;
}
HRESULT INLINE
CDIDev_SetCooperativeLevel_IsValidHwnd(HWND hwnd, DWORD dwFlags)
{
HRESULT hres;
RD(static char s_szProc[] = "IDirectInputDevice::SetCooperativeLevel");
/*
* If a window handle is passed, it must be valid.
*
* The window must be a top-level window to be activated.
*
* The window must belong to the calling process so we can
* hook it.
*/
if(hwnd)
{
hres = hresFullValidHwnd(hwnd, 1);
if(SUCCEEDED(hres))
{
if(!(GetWindowLong(hwnd, GWL_STYLE) & WS_CHILD))
{
if(GetWindowPid(hwnd) == GetCurrentProcessId())
{
} else
{
RPF("ERROR %s: window must belong to current process",
s_szProc);
hres = E_HANDLE;
}
} else
{
RPF("ERROR %s: window may not be a child window", s_szProc);
hres = E_HANDLE;
goto done;
}
} else
{
goto done;
}
}
/*
* Foreground mode or exclusive mode both require a window handle.
*/
if(dwFlags & (DISCL_FOREGROUND | DISCL_EXCLUSIVE))
{
if(hwnd)
{
} else
{
RPF("ERROR %s: window handle required "
"if DISCL_EXCLUSIVE or DISCL_FOREGROUND", s_szProc);
hres = E_HANDLE;
goto done;
}
}
hres = S_OK;
done:;
return hres;
}
STDMETHODIMP
CDIDev_SetCooperativeLevel(PV pdd, HWND hwnd, DWORD dwFlags _THAT)
{
HRESULT hres;
EnterProcR(IDirectInputDevice8::SetCooperativeLevel,
(_ "pxx", pdd, hwnd, dwFlags));
if(SUCCEEDED(hres = hresPvT(pdd)))
{
PDD this = _thisPv(pdd);
/*
* Must protect with the critical section to prevent somebody
* acquiring or Reset()ing behind our back.
*/
CDIDev_EnterCrit(this);
if(SUCCEEDED(hres = IDirectInputDevice_NotAcquired(this)) &&
SUCCEEDED(hres = CDIDev_SetCooperativeLevel_IsValidFl(dwFlags)) &&
SUCCEEDED(hres = CDIDev_SetCooperativeLevel_IsValidHwnd(hwnd, dwFlags)))
{
AssertF(CDIDev_IsConsistent(this));
if( SUCCEEDED( hres ) )
{
hres = this->pdcb->lpVtbl->SetCooperativeLevel(
this->pdcb, hwnd, dwFlags);
if(SUCCEEDED(hres))
{
this->discl = dwFlags;
this->hwnd = hwnd;
if(this->pvi)
{
this->pvi->hwnd = hwnd;
}
}
}
else
{
AssertF( hres == E_INVALIDARG );
RPF("ERROR %s: arg %d: invalid flags", s_szProc, 2);
}
AssertF(CDIDev_IsConsistent(this));
}
CDIDev_LeaveCrit(this);
}
ExitOleProcR();
return hres;
}
#ifdef XDEBUG
CSET_STUBS(SetCooperativeLevel, (PV pdm, HWND hwnd, DWORD fl),
(pdm, hwnd, fl THAT_))
#else
#define CDIDev_SetCooperativeLevelA CDIDev_SetCooperativeLevel
#define CDIDev_SetCooperativeLevelW CDIDev_SetCooperativeLevel
#endif
/*****************************************************************************
*
* @doc EXTERNAL
*
* @method HRESULT | IDirectInputDevice | RunControlPanel |
*
* Run the DirectInput control panel for the device.
*
* @cwrap LPDIRECTINPUTDEVICE | lpDirectInputDevice
*
* @parm IN HWND | hwndOwner |
*
* Identifies the window handle that will be used as the
* parent window for subsequent UI. NULL is a valid parameter,
* indicating that there is no parent window.
*
* @parm DWORD | dwFlags |
*
* No flags are currently defined. This parameter "must" be
* zero.
*
* @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 device is attached.
*
* @devnote
*
* The <p dwFlags> is eventually going to allow
* <c DIRCP_MODAL> to request a modal control panel.
*
*****************************************************************************/
STDMETHODIMP
CDIDev_RunControlPanel(PV pdd, HWND hwndOwner, DWORD fl _THAT)
{
HRESULT hres;
EnterProcR(IDirectInputDevice8::RunControlPanel,
(_ "pxx", pdd, hwndOwner, fl));
if(SUCCEEDED(hres = hresPvT(pdd)) &&
SUCCEEDED(hres = hresFullValidHwnd0(hwndOwner, 1)) &&
SUCCEEDED(hres = hresFullValidFl(fl, DIRCP_VALID, 2)))
{
PDD this = _thisPv(pdd);
IDirectInputDeviceCallback *pdcb;
/*
* Must protect with the critical section to prevent somebody
* Reset()ing behind our back. However, we cannot hold the
* critical section during the control panel callback, because
* that will yield.
*
* So we copy/addref the pdcb inside the critical section,
* then run the control panel outside the critical section,
* then release the pdcb when we're finally done.
*/
CDIDev_EnterCrit(this);
pdcb = this->pdcb;
OLE_AddRef(pdcb);
CDIDev_LeaveCrit(this);
hres = pdcb->lpVtbl->RunControlPanel(pdcb, hwndOwner, fl);
OLE_Release(pdcb);
}
ExitOleProc();
return hres;
}
#ifdef XDEBUG
CSET_STUBS(RunControlPanel, (PV pdd, HWND hwndOwner, DWORD fl),
(pdd, hwndOwner, fl THAT_))
#else
#define CDIDev_RunControlPanelA CDIDev_RunControlPanel
#define CDIDev_RunControlPanelW CDIDev_RunControlPanel
#endif
/*****************************************************************************
*
* @doc EXTERNAL
*
* @method HRESULT | IDirectInputDevice | Initialize |
*
* Initialize a DirectInputDevice object.
*
* Note that if this method fails, the underlying object should
* be considered to be an an indeterminate state and needs to
* be reinitialized before it can be subsequently used.
*
* The <mf IDirectInput::CreateDevice> method automatically
* initializes the device after creating it. Applications
* normally do not need to call this function.
*
* @cwrap LPDIRECTINPUTDEVICE | lpDirectInputDevice
*
* @parm IN HINSTANCE | hinst |
*
* Instance handle of the application or DLL that is creating
* the DirectInput object.
*
* See the section titled "Initialization and Versions"
* for more information.
*
* @parm DWORD | dwVersion |
*
* Version number of the dinput.h header file that was used.
*
* See the section titled "Initialization and Versions"
* for more information.
*
* @parm IN REFGUID | rguid |
*
* Identifies the instance of the device for which the interface
* should be associated.
* The <mf IDirectInput::EnumDevices> method
* can be used to determine which instance GUIDs are supported by
* the system.
*
* @returns
* Returns a COM error code. The following error codes are
* intended to be illustrative and not necessarily comprehensive.
*
* <c DI_OK> = <c S_OK>: The operation completed successfully.
*
* <c S_FALSE>: The device had already been initialized with
* the instance GUID passed in <p lpGUID>.
*
* <c DIERR_ACQUIRED>: The device cannot be initialized while
* it is acquired.
*
* <c DIERR_DEVICENOTREG>: The instance GUID does not exist
* on the current machine.
*
* <c DIERR_HASEFFECTS>:
* The device cannot be reinitialized because there are
* still effects attached to it.
*
*****************************************************************************/
STDMETHODIMP
CDIDev_Initialize(PV pdd, HINSTANCE hinst, DWORD dwVersion, REFGUID rguid _THAT)
{
HRESULT hres;
EnterProcR(IDirectInputDevice8::Initialize,
(_ "pxxG", pdd, hinst, dwVersion, rguid));
if(SUCCEEDED(hres = hresPvT(pdd)) &&
SUCCEEDED(hres = hresFullValidGuid(rguid, 1)))
{
PDD this = _thisPv(pdd);
CREATEDCB CreateDcb;
IDirectInputDeviceCallback *pdcb;
/*
* Must take the critical section to avoid Reset()ing
* the device (or generally speaking, modifying the
* internal state variables) while somebody else is
* messing with it.
*/
CDIDev_EnterCrit(this);
if(SUCCEEDED(hres = hresValidInstanceVer(hinst, dwVersion)) &&
SUCCEEDED(hres = hresFindInstanceGUID(rguid, &CreateDcb, 1)) &&
SUCCEEDED(hres = CDIDev_Reset(this)))
{
hres = CreateDcb(0, rguid, &IID_IDirectInputDeviceCallback,
(PPV)&pdcb);
if(SUCCEEDED(hres))
{
this->pdcb = pdcb;
AssertF(this->pvi == 0);
if(SUCCEEDED(hres = CDIDev_GetDataFormat(this)) &&
SUCCEEDED(hres = CDIDev_GetPolled(this)) &&
SUCCEEDED(hres = this->pdcb->lpVtbl->GetInstance(
this->pdcb, &this->pvi)) &&
SUCCEEDED(hres = CMapShep_New(NULL, &IID_IDirectInputMapShepherd, &this->pMS)) &&
SUCCEEDED(hres = CMap_InitializeCRCTable()) &&
SUCCEEDED(hres = CDIDev_GetCapabilitiesHelper(this)) )
{
this->dwVersion = dwVersion;
/*
* Take a copy of the global app hacks here rather than
* using the globals everywhere to make it easier to get
* rid of the globals some fine day.
*/
this->diHacks = g_AppHacks;
this->pdcb->lpVtbl->SetDIData(this->pdcb, dwVersion, &this->diHacks);
this->guid = *rguid;
if(this->pvi && (this->pvi->fl & VIFL_EMULATED))
{
this->pvi->pdd = this;
}
hres = this->pdcb->lpVtbl->CookDeviceData(this->pdcb, 0, 0 );
if(SUCCEEDED(hres))
{
this->fCook = 1;
}
CDIDev_InitFF(this);
hres = S_OK;
} else
{
RPF("Device driver didn't provide a data format");
}
} else
{
#ifdef NOISY
RPF("Cannot create device");
#endif
}
}
CDIDev_LeaveCrit(this);
}
ExitOleProc();
return hres;
}
#ifdef XDEBUG
CSET_STUBS(Initialize,
(PV pdd, HINSTANCE hinst, DWORD dwVersion, REFGUID rguid),
(pdd, hinst, dwVersion, rguid THAT_))
#else
#define CDIDev_InitializeA CDIDev_Initialize
#define CDIDev_InitializeW CDIDev_Initialize
#endif
/*****************************************************************************
*
* @doc INTERNAL
*
* @method void | IDirectInputDevice | Init |
*
* Initialize the internal parts of the DirectInputDevice object.
*
*****************************************************************************/
void INLINE
CDIDev_Init(PDD this)
{
/*
* The critical section must be the very first thing we do,
* because only Finalize checks for its existence.
*
* (We might be finalized without being initialized if the user
* passed a bogus interface to CDIDev_New.)
*/
this->fCritInited = fInitializeCriticalSection(&this->crst);
if( this->fCritInited )
{
this->celtBufMax = DEVICE_MAXBUFFERSIZE; /* Default maximum buffer size */
this->pdcb = c_pdcbNil;
GPA_InitFromZero(&this->gpaEff);
}
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | IDirectInputDevice | New |
*
* Create a new DirectInputDevice object, uninitialized.
*
* @parm IN PUNK | punkOuter |
*
* Controlling unknown for aggregation.
*
* @parm IN RIID | riid |
*
* Desired interface to new object.
*
* @parm OUT PPV | ppvObj |
*
* Output pointer for new object.
*
*****************************************************************************/
STDMETHODIMP
CDIDev_New(PUNK punkOuter, RIID riid, PPV ppvObj)
{
HRESULT hres;
EnterProcR(IDirectInputDevice8::<constructor>, (_ "Gp", riid, punkOuter));
if (SUCCEEDED(hres = hresFullValidPcbOut(ppvObj, cbX(*ppvObj), 3)))
{
hres = Excl_Init();
if(SUCCEEDED(hres))
{
LPVOID pvTry = NULL;
hres = Common_NewRiid(CDIDev, punkOuter, riid, &pvTry);
if(SUCCEEDED(hres))
{
PDD this = _thisPv(pvTry);
CDIDev_Init(this);
if( this->fCritInited )
{
*ppvObj = pvTry;
}
else
{
Common_Unhold(this);
*ppvObj = NULL;
hres = E_OUTOFMEMORY;
}
}
}
}
ExitOleProcPpvR(ppvObj);
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method HRESULT | CDIDev | CDIDev_ModifyEffectParams |
*
* Modifies parameters of DIEFFECT structure to fit the current FF device
*
* @cwrap LPDIRECTINPUTDEVICE | lpDirectInputDevice
*
*
* @parm IN OUT LPDIEFFECT | peff |
*
* Pointer to the effect structure
*
* @parm IN GUID | effGUID |
*
* GUID for the effect
*
* @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_UNSUPPORTED>: The effect can't be supported by the current device
* (e.g. the number of FF axes on the device is 0)
*
* <c DIERR_INVALIDPARAM>: Can't create the effect even with the modified parameters
*
*****************************************************************************/
HRESULT CDIDev_ModifyEffectParams
(
PV pdd,
LPDIEFFECT peff,
GUID effGUID
)
{
HRESULT hres = S_OK;
HRESULT hresCreate = S_OK;
LPDIRECTINPUTEFFECT pdeff;
PDD this = _thisPv(pdd);
EnterProcR(CDIDev_ModifyEffectParams, (_ "p", pdd));
/*
* To make sure that effects we enumerate will actually get
* created on the device, try creating the effect.
*
* PREFIX warns (Win:171786) that pdeff is uninitialized when
* CDIDev_CreateEffect tests that the pointer to it is writable.
*/
#ifdef XDEBUG
hresCreate = CDIDev_CreateEffect(this, &effGUID, peff, &pdeff, NULL, ((LPUNKNOWN)this)->lpVtbl);
#else
hresCreate = CDIDev_CreateEffect(this, &effGUID, peff, &pdeff, NULL);
#endif
if(SUCCEEDED(hresCreate))
{
Invoke_Release(&pdeff);
}
else
{
if (hresCreate == DIERR_INVALIDPARAM)
{
//two things can give DIERR_INVALIDPARAM:
//invalid axes and invalid trigger button
//check the axes first, then the trigger buttons
//try to eliminate all DIERR_INVALIDPARAMS
LPDIOBJECTDATAFORMAT lpObjDat = this->df.rgodf;
DWORD dwNum = this->df.dwNumObjs;
DWORD nCount;
LPDWORD lpAxes;
LPDWORD lpThisAxis;
LPDWORD lpEffAxis;
DWORD nAxes = 0;
DWORD dwTrigger = DIJOFS_BUTTON(0);
BOOL bTriggerCorrect = FALSE;
AllocCbPpv(sizeof(DWORD)*dwNum, &lpAxes);
lpThisAxis = lpAxes;
for (nCount = 0; nCount < dwNum; nCount ++)
{
AssertF(lpObjDat != NULL);
//check the axes
if ((lpObjDat->dwType & (DIDFT_AXIS | DIDFT_FFACTUATOR) & DIDFT_TYPEMASK) &&
(fHasAllBitsFlFl(lpObjDat->dwType, (DIDFT_AXIS | DIDFT_FFACTUATOR) & DIDFT_ATTRMASK)))
{
*lpAxes = lpObjDat->dwOfs;
nAxes++;
lpAxes++;
}
else
{
//check the trigger button, if there's one
if ((peff->dwTriggerButton != DIEB_NOTRIGGER) &&
(lpObjDat->dwType & DIDFT_FFEFFECTTRIGGER & DIDFT_TYPEMASK) &&
(fHasAllBitsFlFl(lpObjDat->dwType, DIDFT_FFEFFECTTRIGGER & DIDFT_ATTRMASK)))
{
if (lpObjDat->dwOfs == peff->dwTriggerButton)
{
//the trigger is valid
bTriggerCorrect = TRUE;
}
else
{
//remember the trigger offset for the future
dwTrigger = lpObjDat->dwOfs;
}
}
}
lpObjDat++;
}
//first, chack if there are any FF axes
if (nAxes == 0)
{
//return an error if no FF axes on device
hres = DIERR_UNSUPPORTED;
}
else
{
//trigger buttons are checked for validity before axes,
//so set the trigger button, if needed,
//because if it is invalid, this is what caused the error
if ((peff->dwTriggerButton != DIEB_NOTRIGGER) && (bTriggerCorrect == FALSE))
{
peff->dwTriggerButton = dwTrigger;
// and try creating again
#ifdef XDEBUG
hresCreate = CDIDev_CreateEffect(this, &effGUID, peff, &pdeff, NULL, ((LPUNKNOWN)this)->lpVtbl);
#else
hresCreate = CDIDev_CreateEffect(this, &effGUID, peff, &pdeff, NULL);
#endif
if(SUCCEEDED(hresCreate))
{
Invoke_Release(&pdeff);
}
}
if (hresCreate == DIERR_INVALIDPARAM)
{
HRESULT hresInfo = S_OK;
EFFECTMAPINFO emi;
//this time, set the axes
if (peff->cAxes > nAxes)
{
//change the number of axes
peff->cAxes = nAxes;
//change the flags
if ((nAxes < 3) && (peff->dwFlags & DIEFF_SPHERICAL))
{
peff->dwFlags &= ~DIEFF_SPHERICAL;
peff->dwFlags |= DIEFF_POLAR;
}
else
{
if ((nAxes < 2) && (peff->dwFlags & DIEFF_POLAR))
{
peff->dwFlags &= ~DIEFF_POLAR;
peff->dwFlags |= DIEFF_CARTESIAN;
}
}
}
//check if size of type-specific param structures is not bigger then number of axes,
//since this can also give us invalid params in type-specific .
//need to do this only for conditions
if (SUCCEEDED(hresInfo = CDIDev_FindEffectGUID(this, &effGUID, &emi, 2)))
{
//do the conditions
if (emi.attr.dwEffType & DIEFT_CONDITION)
{
if (peff->cbTypeSpecificParams/(sizeof(DICONDITION)) > peff->cAxes)
{
peff->cbTypeSpecificParams = peff->cAxes*(sizeof(DICONDITION));
}
}
//don't need to do anything for custom forces,
//since DInput doesn't check number of channels against number of axes anyway
}
//write over the axes
lpEffAxis = peff->rgdwAxes;
for (nCount = 0; nCount < nAxes, nCount < peff->cAxes; nCount ++)
{
*(lpEffAxis) = *(lpThisAxis);
lpThisAxis ++;
lpEffAxis++;
}
// and try creating again
#ifdef XDEBUG
hresCreate = CDIDev_CreateEffect(this, &effGUID, peff, &pdeff, NULL, ((LPUNKNOWN)this)->lpVtbl);
#else
hresCreate = CDIDev_CreateEffect(this, &effGUID, peff, &pdeff, NULL);
#endif
if(SUCCEEDED(hresCreate))
{
Invoke_Release(&pdeff);
}
}
}
//free the axes array
FreePpv(&lpAxes);
}
}
if ((SUCCEEDED(hres)) && (hresCreate == DIERR_INVALIDPARAM))
{
hres = hresCreate;
}
ExitOleProc();
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @method BOOL | CDIDev | CDIDev_IsStandardEffect |
*
* Checks if the effect GUID belongs to a standard DI effect
*
* @parm IN GUID | effGUID |
*
* GUID for the effect
*
* @returns BOOL
*
* TRUE if it is a standard DI effect;
* FALSE otherwise.
*
*
*****************************************************************************/
BOOL CDIDev_IsStandardEffect
(GUID effGUID)
{
BOOL bStandard = TRUE;
//check all the standard DX7 GUIDs
if ((IsEqualGUID(&effGUID, &GUID_Sine)) ||
(IsEqualGUID(&effGUID, &GUID_Triangle)) ||
(IsEqualGUID(&effGUID, &GUID_ConstantForce)) ||
(IsEqualGUID(&effGUID, &GUID_RampForce)) ||
(IsEqualGUID(&effGUID, &GUID_Square)) ||
(IsEqualGUID(&effGUID, &GUID_SawtoothUp)) ||
(IsEqualGUID(&effGUID, &GUID_SawtoothDown)) ||
(IsEqualGUID(&effGUID, &GUID_Spring)) ||
(IsEqualGUID(&effGUID, &GUID_Damper)) ||
(IsEqualGUID(&effGUID, &GUID_Inertia)) ||
(IsEqualGUID(&effGUID, &GUID_Friction)) ||
(IsEqualGUID(&effGUID, &GUID_CustomForce)))
{
bStandard = TRUE;
}
else
{
bStandard = FALSE;
}
return bStandard;
}
/*****************************************************************************
*
* @doc EXTERNAL
*
* @method HRESULT | IDirectInputDevice | EnumEffectsInFile |
*
* Enumerates DIEFFECT struct(s) and effect GUID from file.
* An application can use this in order to create pre-authored
* force effects.
*
* @cwrap LPDIRECTINPUTDEVICE | lpDirectInputDevice
*
* @parm LPCSTR | lpszFileName |
*
* Name of the RIFF file that contains collection of effects.
*
* @parm IN OUT LPENUMEFFECTSCALLBACK | pec |
*
* The callback function.
*
* @parm IN OUT LPVOID | pvRef |
* Specifies the application-defined value given in the
* <mf IDirectInputDevice::EnumObjects> function.
*
* @parm IN DWORD | dwFlags |
*
* Flags which control the enumeration.
*
* It consists of <c DIFEF_*> flags, documented separately.
*
* @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 lpDirectInputDevice> or
* <p lpdc> parameter is invalid.
*
* @cb BOOL CALLBACK | DIEnumEffectsCallback |
*
* An application-defined callback function that receives
* effect GUID, DIEFFECT and repeat count as a result of a call to the
* <om IDirectInputDevice::EnumEffectsInFile> method.
*
* @parm OUT LPCDIFILEEFFECT | lpDiFileEf |
*
* Pointer to a DIFILEEFFECT structure.
*
*
* @parm IN OUT LPVOID | pvRef |
* Specifies the application-defined value given in the
* <mf IDirectInputDevice::EnumObjects> function.
*
* @returns
*
* Returns <c DIENUM_CONTINUE> to continue the enumeration
* or <c DIENUM_STOP> to stop the enumeration.
*
*****************************************************************************/
HRESULT CDIDev_EnumEffectsInFileA
(
PV pddA,
LPCSTR lpszFileName,
LPDIENUMEFFECTSINFILECALLBACK pec,
LPVOID pvRef,
DWORD dwFlags
)
{
HRESULT hres = E_FAIL;
EnterProcR(IDirectInputDevice8::EnumEffectsInFile, (_ "s", lpszFileName));
/* Validate incoming parameters */
if(SUCCEEDED(hres = hresPvA(pddA)) &&
SUCCEEDED(hres = hresFullValidReadStrA(lpszFileName, MAX_JOYSTRING,1)) &&
SUCCEEDED(hres = hresFullValidPfn(pec, 2)) &&
SUCCEEDED(hres = hresFullValidFl(dwFlags, DIFEF_ENUMVALID, 3)) )
{
PDD this = _thisPvNm(pddA, ddA);
HMMIO hmmio;
MMCKINFO mmck;
DWORD dwEffectSz;
hres = RIFF_Open(lpszFileName, MMIO_READ | MMIO_ALLOCBUF , &hmmio, &mmck, &dwEffectSz);
if(SUCCEEDED(hres))
{
HRESULT hresRead;
DIEFFECT effect;
DIFILEEFFECT DiFileEf;
DIENVELOPE diEnvelope;
DWORD rgdwAxes[DIEFFECT_MAXAXES];
LONG rglDirection[DIEFFECT_MAXAXES];
effect.rgdwAxes = rgdwAxes;
effect.rglDirection = rglDirection;
effect.lpEnvelope = &diEnvelope;
DiFileEf.dwSize = cbX(DiFileEf);
DiFileEf.lpDiEffect = &effect;
while ((SUCCEEDED(hres)) && (SUCCEEDED(hresRead = RIFF_ReadEffect(hmmio, &DiFileEf))))
{
BOOL fRc = DIENUM_CONTINUE;
BOOL bInclude = TRUE;
HRESULT hresModify = DI_OK;
//modify if needed
if (dwFlags & DIFEF_MODIFYIFNEEDED)
{
hresModify = CDIDev_ModifyEffectParams(this, &effect, DiFileEf.GuidEffect);
}
//if necessary, check whether effect is standard
if (!(dwFlags & DIFEF_INCLUDENONSTANDARD))
{
bInclude = CDIDev_IsStandardEffect(DiFileEf.GuidEffect);
}
//call back only if all the conditions posed by the flags are satisfied
if ((SUCCEEDED(hresModify)) && (bInclude == TRUE))
{
fRc = Callback(pec, &DiFileEf, pvRef);
}
//free type-specific only if allocated
if(effect.cbTypeSpecificParams > 0)
{
FreePv(effect.lpvTypeSpecificParams);
effect.cbTypeSpecificParams = 0x0;
}
if(fRc == DIENUM_STOP)
{
break;
} else if(fRc == DIENUM_CONTINUE)
{
continue;
} else
{
RPF("IDirectInputDevice::EnumEffectsInFile: Invalid return value from enumeration callback");
ValidationException();
break;
}
}
RIFF_Close(hmmio, 0);
//if hresRead failed because couldn't descend into the chunk, it means the end of file,
//so everything is OK;
//else return this error
if (SUCCEEDED(hres))
{
if (hresRead == hresLe(ERROR_SECTOR_NOT_FOUND))
{
hres = S_OK;
}
else
{
hres = hresRead;
}
}
}
}
ExitOleProc();
return hres;
}
HRESULT CDIDev_EnumEffectsInFileW
(
PV pddW,
LPCWSTR lpszFileName,
LPDIENUMEFFECTSINFILECALLBACK pec,
LPVOID pvRef,
DWORD dwFlags
)
{
HRESULT hres = E_FAIL;
EnterProcR(IDirectInputDevice8::EnumEffectsInFileW, (_ "s", lpszFileName));
/* Validate incoming parameters */
if(SUCCEEDED(hres = hresPvW(pddW)) &&
SUCCEEDED(hres = hresFullValidReadStrW(lpszFileName, MAX_JOYSTRING,1)) &&
SUCCEEDED(hres = hresFullValidPfn(pec, 2)) &&
SUCCEEDED(hres = hresFullValidFl(dwFlags, DIFEF_ENUMVALID, 3)) )
{
CHAR szFileName[MAX_PATH];
PDD this = _thisPvNm(pddW, ddW);
UToA(szFileName, MAX_PATH, lpszFileName);
hres = CDIDev_EnumEffectsInFileA(&this->ddA, szFileName, pec, pvRef, dwFlags);
}
return hres;
}
/*****************************************************************************
*
* @doc EXTERNAL
*
* @method HRESULT | IDirectInputDevice | WriteEffectToFile |
*
* Writes DIEFFECT struct(s) and effect GUID to a file.
* An application can use this in order to create pre-authored
* force effects.
*
* @cwrap LPDIRECTINPUTDEVICE | lpDirectInputDevice
*
* @parm LPCSTR | lpszFileName |
*
* Name of the RIFF file that contains collection of effects.
*
* @parm IN DWORD | dwEntries |
*
* Number of <t DIFILEEFFECT> structures in the array.
*
* @parm IN LPCDIFILEEFFECT | rgDiFileEft |
*
* Array of <t DIFILEEFFECT> structure.
*
*
* @parm IN DWORD | dwFlags |
*
* Flags which control how the effect should be written.
*
* It consists of <c DIFEF_*> flags, documented separately.
*
* @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 lpDirectInputDevice> or
* <p lpdc> parameter is invalid.
*
*****************************************************************************/
HRESULT CDIDev_WriteEffectToFileA
(
PV pddA,
LPCSTR lpszFileName,
DWORD dwEntries,
LPDIFILEEFFECT rgDiFileEffect,
DWORD dwFlags
)
{
HRESULT hres = E_NOTIMPL;
EnterProcR(IDirectInputDevice8::WriteEffectToFileA, (_ "s", lpszFileName));
/* Validate incoming parameters */
if(SUCCEEDED(hres = hresPvA(pddA)) &&
SUCCEEDED(hres = hresFullValidReadStrA(lpszFileName, MAX_JOYSTRING,1))&&
SUCCEEDED(hres = hresFullValidFl(dwFlags, DIFEF_ENUMVALID, 3)) &&
SUCCEEDED(hres = (IsBadReadPtr(rgDiFileEffect, cbX(*rgDiFileEffect))) ? E_POINTER : S_OK))
{
PDD this = _thisPvNm(pddA, ddA);
HMMIO hmmio;
MMCKINFO mmck;
DWORD dwEffectSz;
hres = RIFF_Open(lpszFileName, MMIO_CREATE | MMIO_WRITE | MMIO_ALLOCBUF , &hmmio, &mmck, &dwEffectSz);
if(SUCCEEDED(hres))
{
UINT nCount;
LPDIFILEEFFECT lpDiFileEf = rgDiFileEffect;
//write out the effects
for(nCount = 0; nCount < dwEntries; nCount++)
{
BOOL bInclude = TRUE;
hres = (IsBadReadPtr(lpDiFileEf, cbX(*lpDiFileEf))) ? E_POINTER : S_OK;
if (FAILED(hres))
{
break;
}
//if necessary, check whether the effect is standard
if (!(dwFlags & DIFEF_INCLUDENONSTANDARD))
{
bInclude = CDIDev_IsStandardEffect(lpDiFileEf->GuidEffect);
}
if ((SUCCEEDED(hres)) && (bInclude == TRUE))
{
hres = RIFF_WriteEffect(hmmio, lpDiFileEf);
}
if(FAILED(hres))
{
break;
}
lpDiFileEf++;
}
RIFF_Close(hmmio, 0);
}
}
ExitOleProc();
return hres;
}
HRESULT CDIDev_WriteEffectToFileW
(
PV pddW,
LPCWSTR lpszFileName,
DWORD dwEntries,
LPDIFILEEFFECT lpDiFileEffect,
DWORD dwFlags
)
{
HRESULT hres = E_FAIL;
EnterProcR(IDirectInputDevice8::WriteEffectToFile, (_ "s", lpszFileName));
/* Validate incoming parameters */
if(SUCCEEDED(hres = hresPvW(pddW)) &&
SUCCEEDED(hres = hresFullValidReadStrW(lpszFileName, MAX_JOYSTRING,1)))
{
CHAR szFileName[MAX_PATH];
PDD this = _thisPvNm(pddW, ddW);
UToA(szFileName, MAX_PATH, lpszFileName);
hres = CDIDev_WriteEffectToFileA(&this->ddA, szFileName, dwEntries, lpDiFileEffect, dwFlags);
}
return hres;
}
/*****************************************************************************
*
* The long-awaited vtbls and templates
*
*****************************************************************************/
#pragma BEGIN_CONST_DATA
#define CDIDev_Signature 0x20564544 /* "DEV " */
Primary_Interface_Begin(CDIDev, TFORM(ThisInterfaceT))
TFORM(CDIDev_GetCapabilities),
TFORM(CDIDev_EnumObjects),
TFORM(CDIDev_GetProperty),
TFORM(CDIDev_SetProperty),
TFORM(CDIDev_Acquire),
TFORM(CDIDev_Unacquire),
TFORM(CDIDev_GetDeviceState),
TFORM(CDIDev_GetDeviceData),
TFORM(CDIDev_SetDataFormat),
TFORM(CDIDev_SetEventNotification),
TFORM(CDIDev_SetCooperativeLevel),
TFORM(CDIDev_GetObjectInfo),
TFORM(CDIDev_GetDeviceInfo),
TFORM(CDIDev_RunControlPanel),
TFORM(CDIDev_Initialize),
TFORM(CDIDev_CreateEffect),
TFORM(CDIDev_EnumEffects),
TFORM(CDIDev_GetEffectInfo),
TFORM(CDIDev_GetForceFeedbackState),
TFORM(CDIDev_SendForceFeedbackCommand),
TFORM(CDIDev_EnumCreatedEffectObjects),
TFORM(CDIDev_Escape),
TFORM(CDIDev_Poll),
TFORM(CDIDev_SendDeviceData),
TFORM(CDIDev_EnumEffectsInFile),
TFORM(CDIDev_WriteEffectToFile),
TFORM(CDIDev_BuildActionMap),
TFORM(CDIDev_SetActionMap),
TFORM(CDIDev_GetImageInfo),
Primary_Interface_End(CDIDev, TFORM(ThisInterfaceT))
Secondary_Interface_Begin(CDIDev, SFORM(ThisInterfaceT), SFORM(dd))
SFORM(CDIDev_GetCapabilities),
SFORM(CDIDev_EnumObjects),
SFORM(CDIDev_GetProperty),
SFORM(CDIDev_SetProperty),
SFORM(CDIDev_Acquire),
SFORM(CDIDev_Unacquire),
SFORM(CDIDev_GetDeviceState),
SFORM(CDIDev_GetDeviceData),
SFORM(CDIDev_SetDataFormat),
SFORM(CDIDev_SetEventNotification),
SFORM(CDIDev_SetCooperativeLevel),
SFORM(CDIDev_GetObjectInfo),
SFORM(CDIDev_GetDeviceInfo),
SFORM(CDIDev_RunControlPanel),
SFORM(CDIDev_Initialize),
SFORM(CDIDev_CreateEffect),
SFORM(CDIDev_EnumEffects),
SFORM(CDIDev_GetEffectInfo),
SFORM(CDIDev_GetForceFeedbackState),
SFORM(CDIDev_SendForceFeedbackCommand),
SFORM(CDIDev_EnumCreatedEffectObjects),
TFORM(CDIDev_Escape),
SFORM(CDIDev_Poll),
SFORM(CDIDev_SendDeviceData),
SFORM(CDIDev_EnumEffectsInFile),
SFORM(CDIDev_WriteEffectToFile),
SFORM(CDIDev_BuildActionMap),
SFORM(CDIDev_SetActionMap),
SFORM(CDIDev_GetImageInfo),
Secondary_Interface_End(CDIDev, SFORM(ThisInterfaceT), SFORM(dd))
Reference in New Issue View Git Blame Copy Permalink