You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2646 lines
94 KiB
2646 lines
94 KiB
/***************************************************************************
|
|
*
|
|
* Copyright (C) 1996 - 2000 Microsoft Corporation. All Rights Reserved.
|
|
*
|
|
* File: dinputi.h
|
|
* Content: DirectInput internal include file
|
|
*@@BEGIN_MSINTERNAL
|
|
* History:
|
|
* Date By Reason
|
|
* ==== == ======
|
|
* 1996.05.07 raymondc Lost a bet
|
|
*
|
|
*@@END_MSINTERNAL
|
|
*
|
|
***************************************************************************/
|
|
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/***************************************************************************
|
|
*
|
|
* Debug / RDebug / Retail
|
|
*
|
|
* If either DEBUG or RDEBUG, set XDEBUG.
|
|
*
|
|
* Retail defines nothing.
|
|
*
|
|
***************************************************************************/
|
|
|
|
#if defined(DEBUG) || defined(RDEBUG)
|
|
#define XDEBUG
|
|
#endif
|
|
|
|
/***************************************************************************
|
|
*
|
|
* Turning off stuff...
|
|
*
|
|
* Turn off these things, because they confuse the bilingualism macros.
|
|
* Instead, we call then IMumbleT.
|
|
*
|
|
***************************************************************************/
|
|
|
|
#undef IDirectInput
|
|
#undef IDirectInput2
|
|
#undef IDirectInput7
|
|
#undef IDirectInputDevice
|
|
#undef IDirectInputDevice2
|
|
#undef IDirectInputDevice7
|
|
/*
|
|
* And <mmsystem.h> defines JOY_POVCENTERED incorrectly...
|
|
*/
|
|
#undef JOY_POVCENTERED
|
|
#define JOY_POVCENTERED 0xFFFFFFFF
|
|
|
|
/*
|
|
* And older versions of windows.h don't have this definition.
|
|
*/
|
|
#ifndef HasOverlappedIoCompleted
|
|
#define HasOverlappedIoCompleted(lpOverlapped) \
|
|
((lpOverlapped)->Internal != STATUS_PENDING)
|
|
#endif
|
|
|
|
/***************************************************************************
|
|
*
|
|
* Abbreviations....
|
|
*
|
|
* Give shorter names to things we talk about frequently.
|
|
*
|
|
***************************************************************************/
|
|
|
|
typedef LPDIRECTINPUT PDI , *PPDI ;
|
|
typedef LPDIRECTINPUTA PDIA, *PPDIA;
|
|
typedef LPDIRECTINPUTW PDIW, *PPDIW;
|
|
|
|
typedef LPDIRECTINPUTDEVICE PDID , *PPDID ;
|
|
typedef LPDIRECTINPUTDEVICEA PDIDA, *PPDIDA;
|
|
typedef LPDIRECTINPUTDEVICEW PDIDW, *PPDIDW;
|
|
|
|
typedef LPDIRECTINPUTEFFECT PDIE , *PPDIE ;
|
|
|
|
typedef DIOBJECTDATAFORMAT ODF, *PODF;
|
|
typedef const ODF *PCODF;
|
|
|
|
typedef LPUNKNOWN PUNK;
|
|
typedef LPVOID PV, *PPV;
|
|
typedef CONST VOID *PCV;
|
|
typedef REFIID RIID;
|
|
typedef CONST GUID *PCGUID;
|
|
|
|
/***************************************************************************
|
|
*
|
|
* GetProcAddress'd KERNEL32 and USER32 functions.
|
|
*
|
|
***************************************************************************/
|
|
typedef DWORD (WINAPI *OPENVXDHANDLE)(HANDLE);
|
|
typedef BOOL (WINAPI *CANCELIO)(HANDLE);
|
|
typedef DWORD (WINAPI *MSGWAITFORMULTIPLEOBJECTSEX)
|
|
(DWORD, LPHANDLE, DWORD, DWORD, DWORD);
|
|
|
|
typedef BOOL (WINAPI *TRYENTERCRITICALSECTION)(LPCRITICAL_SECTION);
|
|
|
|
extern OPENVXDHANDLE _OpenVxDHandle;
|
|
extern CANCELIO _CancelIO;
|
|
extern MSGWAITFORMULTIPLEOBJECTSEX _MsgWaitForMultipleObjectsEx;
|
|
#ifdef XDEBUG
|
|
extern TRYENTERCRITICALSECTION _TryEnterCritSec;
|
|
BOOL WINAPI FakeTryEnterCriticalSection(LPCRITICAL_SECTION lpCrit_sec);
|
|
#endif
|
|
|
|
DWORD WINAPI
|
|
FakeMsgWaitForMultipleObjectsEx(DWORD, LPHANDLE, DWORD, DWORD, DWORD);
|
|
|
|
BOOL WINAPI FakeCancelIO(HANDLE h);
|
|
|
|
|
|
/***************************************************************************
|
|
*
|
|
* Our global variables - see dinput.c for documentation
|
|
*
|
|
***************************************************************************/
|
|
|
|
extern HINSTANCE g_hinst;
|
|
#ifndef WINNT
|
|
extern HANDLE g_hVxD;
|
|
#endif
|
|
extern DWORD g_flEmulation;
|
|
extern LPDWORD g_pdwSequence;
|
|
|
|
#ifdef USE_SLOW_LL_HOOKS
|
|
extern HHOOK g_hhkLLHookCheck;
|
|
#define g_fUseLLHooks ((BOOL)(UINT_PTR)g_hhkLLHookCheck)
|
|
#endif
|
|
|
|
extern HANDLE g_hmtxGlobal;
|
|
extern HANDLE g_hfm;
|
|
extern struct SHAREDOBJECTPAGE *g_psop;
|
|
extern UINT g_wmJoyChanged;
|
|
extern HANDLE g_hmtxJoy;
|
|
extern HINSTANCE g_hinstRPCRT4;
|
|
extern HINSTANCE g_hinstSetupapi;
|
|
extern LONG g_lWheelGranularity;
|
|
extern BOOL fWinnt; //whether we are running in Winnt
|
|
|
|
extern BOOL g_fRawInput;
|
|
#ifdef USE_WM_INPUT
|
|
extern HWND g_hwndThread;
|
|
extern HANDLE g_hEventAcquire;
|
|
extern HANDLE g_hEventThread;
|
|
extern HANDLE g_hEventHid;
|
|
#endif
|
|
|
|
#if (DIRECTINPUT_VERSION > 0x061A)
|
|
typedef struct _DIAPPHACKS
|
|
{
|
|
BOOL fReacquire;
|
|
BOOL fNoSubClass;
|
|
BOOL fNativeAxisOnly;
|
|
BOOL fNoPollUnacquire;
|
|
BOOL fSucceedAcquire;
|
|
int nMaxDeviceNameLength;
|
|
DWORD dwDevType;
|
|
} DIAPPHACKS, *LPDIAPPHACKS;
|
|
#endif
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Baggage
|
|
*
|
|
* Stuff I carry everywhere.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
#define INTERNAL NTAPI /* Called only within a translation unit */
|
|
#define EXTERNAL NTAPI /* Called from other translation units */
|
|
#define INLINE static __inline
|
|
|
|
#define BEGIN_CONST_DATA data_seg(".text", "CODE")
|
|
#define END_CONST_DATA data_seg(".data", "DATA")
|
|
|
|
/*
|
|
* Arithmetic on pointers.
|
|
*/
|
|
#define pvSubPvCb(pv, cb) ((PV)((PBYTE)pv - (cb)))
|
|
#define pvAddPvCb(pv, cb) ((PV)((PBYTE)pv + (cb)))
|
|
#define cbSubPvPv(p1, p2) ((PBYTE)(p1) - (PBYTE)(p2))
|
|
|
|
/*
|
|
* Convert an object (X) to a count of bytes (cb).
|
|
*/
|
|
#define cbX(X) sizeof(X)
|
|
|
|
/*
|
|
* Convert an array name (A) to a generic count (c).
|
|
*/
|
|
#define cA(a) (cbX(a)/cbX(a[0]))
|
|
|
|
/*
|
|
* Convert a count of X's (cx) into a count of bytes
|
|
* and vice versa.
|
|
*/
|
|
#define cbCxX(cx, X) ((cx) * cbX(X))
|
|
#define cxCbX(cb, X) ((cb) / cbX(X))
|
|
|
|
/*
|
|
* Convert a count of chars (cch), tchars (ctch), wchars (cwch),
|
|
* or dwords (cdw) into a count of bytes, and vice versa.
|
|
*/
|
|
#define cbCch(cch) cbCxX( cch, CHAR)
|
|
#define cbCwch(cwch) cbCxX(cwch, WCHAR)
|
|
#define cbCtch(ctch) cbCxX(ctch, TCHAR)
|
|
#define cbCdw(cdw) cbCxX( cdw, DWORD)
|
|
|
|
#define cchCb(cb) cxCbX(cb, CHAR)
|
|
#define cwchCb(cb) cxCbX(cb, WCHAR)
|
|
#define ctchCb(cb) cxCbX(cb, TCHAR)
|
|
#define cdwCb(cb) cxCbX(cb, DWORD)
|
|
|
|
/*
|
|
* Zero an arbitrary buffer. It is a common error to get the second
|
|
* and third parameters to memset backwards.
|
|
*/
|
|
#define ZeroBuf(pv, cb) memset(pv, 0, cb)
|
|
|
|
/*
|
|
* Zero an arbitrary object.
|
|
*/
|
|
#define ZeroX(x) ZeroBuf(&(x), cbX(x))
|
|
|
|
/*
|
|
* land -- Logical and. Evaluate the first. If the first is zero,
|
|
* then return zero. Otherwise, return the second.
|
|
*/
|
|
|
|
#define fLandFF(f1, f2) ((f1) ? (f2) : 0)
|
|
|
|
/*
|
|
* lor -- Logical or. Evaluate the first. If the first is nonzero,
|
|
* return it. Otherwise, return the second.
|
|
*
|
|
* Unfortunately, due to the nature of the C language, this can
|
|
* be implemented only with a GNU extension. In the non-GNU case,
|
|
* we return 1 if the first is nonzero.
|
|
*/
|
|
|
|
#if defined(__GNUC__)
|
|
#define fLorFF(f1, f2) ((f1) ?: (f2))
|
|
#else
|
|
#define fLorFF(f1, f2) ((f1) ? 1 : (f2))
|
|
#endif
|
|
|
|
/*
|
|
* limp - logical implication. True unless the first is nonzero and
|
|
* the second is zero.
|
|
*/
|
|
#define fLimpFF(f1, f2) (!(f1) || (f2))
|
|
|
|
/*
|
|
* leqv - logical equivalence. True if both are zero or both are nonzero.
|
|
*/
|
|
#define fLeqvFF(f1, f2) (!(f1) == !(f2))
|
|
|
|
/*
|
|
* fInOrder - checks that i1 <= i2 < i3.
|
|
*/
|
|
#define fInOrder(i1, i2, i3) ((unsigned)((i2)-(i1)) < (unsigned)((i3)-(i1)))
|
|
|
|
/*
|
|
* fHasAllBitsFlFl - checks that all bits in fl2 are set in fl1.
|
|
*/
|
|
BOOL INLINE
|
|
fHasAllBitsFlFl(DWORD fl1, DWORD fl2)
|
|
{
|
|
return (fl1 & fl2) == fl2;
|
|
}
|
|
|
|
/*
|
|
* fEqualMask - checks that all masked bits are equal
|
|
*/
|
|
BOOL INLINE
|
|
fEqualMaskFlFl(DWORD flMask, DWORD fl1, DWORD fl2)
|
|
{
|
|
return ((fl1 ^ fl2) & flMask) == 0;
|
|
}
|
|
|
|
/*
|
|
* Words to keep preprocessor happy.
|
|
*/
|
|
#define comma ,
|
|
#define empty
|
|
|
|
/*
|
|
* Atomically exchange one value for another.
|
|
*/
|
|
#if defined(_M_IA64) || defined(_M_AMD64)
|
|
#define InterlockedExchange64 _InterlockedExchange64
|
|
#ifndef RC_INVOKED
|
|
#pragma intrinsic(_InterlockedExchange64)
|
|
#endif /*RC_INVOKED*/
|
|
#define pvExchangePpvPv(ppv, pv) \
|
|
InterlockedExchange((ppv), (pv))
|
|
#define pvExchangePpvPv64(ppv, pv) \
|
|
InterlockedExchange64((PLONGLONG)(ppv), (LONGLONG)(pv))
|
|
#else /*_M_IA64*/
|
|
#define pvExchangePpvPv(ppv, pv) \
|
|
(PV)InterlockedExchange((PLONG)(ppv), (LONG)(pv))
|
|
#define pvExchangePpvPv64(ppv, pv) \
|
|
(PV)InterlockedExchange((PLONG)(ppv), (LONG)(pv))
|
|
#endif /*_M_IA64*/
|
|
|
|
/*
|
|
* Creating HRESULTs from a USHORT or from a LASTERROR.
|
|
*/
|
|
#define hresUs(us) MAKE_HRESULT(SEVERITY_SUCCESS, 0, (USHORT)(us))
|
|
#define hresLe(le) MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, (USHORT)(le))
|
|
/*
|
|
* or a registry function return code
|
|
*/
|
|
HRESULT INLINE
|
|
hresReg( LONG lRc )
|
|
{
|
|
return( (lRc) ? MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, (USHORT)(lRc))
|
|
: S_OK );
|
|
}
|
|
|
|
/***************************************************************************
|
|
*
|
|
* Debugging macros needed by inline functions
|
|
*
|
|
* The build of debugging goo is in debug.h
|
|
*
|
|
***************************************************************************/
|
|
|
|
int EXTERNAL AssertPtszPtszLn(LPCTSTR ptszExpr, LPCTSTR ptszFile, int iLine);
|
|
|
|
#ifdef DEBUG
|
|
|
|
#define AssertFPtsz(c, ptsz) \
|
|
((c) ? 0 : AssertPtszPtszLn(ptsz, TEXT(__FILE__), __LINE__))
|
|
#define ValidateF(c, arg) \
|
|
((c) ? 0 : (RPF arg, ValidationException(), 0))
|
|
#define ConfirmF(c) \
|
|
((c) ? 0 : AssertPtszPtszLn(TEXT(#c), TEXT(__FILE__), __LINE__))
|
|
|
|
#else /* !DEBUG */
|
|
|
|
#define AssertFPtsz(c, ptsz)
|
|
#define ValidateF(c, arg)
|
|
#define ConfirmF(c) (c)
|
|
|
|
#endif
|
|
|
|
/*
|
|
* CAssertF - compile-time assertion.
|
|
*/
|
|
#define CAssertF(c) switch(0) case c: case 0:
|
|
|
|
#define AssertF(c) AssertFPtsz(c, TEXT(#c))
|
|
|
|
/***************************************************************************
|
|
*
|
|
* Validation Code....
|
|
*
|
|
* "If it crashes in retail, it must crash in debug."
|
|
*
|
|
* What we don't want is an app that works fine under debug, but crashes
|
|
* under retail.
|
|
*
|
|
* So if we find an invalid parameter in debug that would not have been
|
|
* detected by retail, let it pass through after a warning. That way,
|
|
* the invalid parameter continues onward through the system and creates
|
|
* as much (or more) havoc in debug as it would under retail.
|
|
*
|
|
* There used to be _fFastValidXxx functions, but the decision was made
|
|
* to do full validation always, except in inner-loop methods.
|
|
*
|
|
* The hresFullValidXxx functions return HRESULTs instead of BOOLs.
|
|
*
|
|
* Values for Xxx:
|
|
*
|
|
* Hwnd - hwnd = window handle
|
|
* Pdw - pdw = pointer to a dword
|
|
* PdwOut - pdw = pointer to a dword that will be set initially to 0
|
|
* Pfn - pfn = function pointer
|
|
* riid - riid = pointer to IID
|
|
* guid - pguid = pointer to GUID
|
|
* Esc - pesc = pointer to DIEFFESCAPE
|
|
*
|
|
* ReadPx - p -> structure for reading, X = structure name
|
|
* WritePx - p -> structure for writing, X = structure name
|
|
*
|
|
* ReadPxCb - p -> structure for reading, X = structure name
|
|
* first field of structure is dwSize which must be
|
|
* equal to cbX(X).
|
|
*
|
|
* WritePxCb - p -> structure for writing, X = structure name
|
|
* first field of structure is dwSize which must be
|
|
* equal to cbX(X).
|
|
*
|
|
* WritePxCb2 - p -> structure for writing, X = structure name
|
|
* first field of structure is dwSize which must be
|
|
* equal to cbX(X) or cbX(X2).
|
|
*
|
|
* ReadPvCb - p -> buffer, cb = size of buffer
|
|
* WritePvCb - p -> buffer, cb = size of buffer
|
|
*
|
|
* Pobj - p -> internal interface
|
|
*
|
|
* fl - fl = incoming flags, flV = valid flags
|
|
*
|
|
***************************************************************************/
|
|
|
|
#ifndef XDEBUG
|
|
|
|
/*
|
|
* Wrappers that throw away the szProc and iarg info.
|
|
*/
|
|
|
|
#define hresFullValidHwnd_(hwnd, z, i) \
|
|
_hresFullValidHwnd_(hwnd) \
|
|
|
|
#define hresFullValidPcbOut_(pdw, cb, z, i) \
|
|
_hresFullValidPcbOut_(pdw, cb) \
|
|
|
|
#define hresFullValidReadPxCb_(pv, cb, pszProc, iarg) \
|
|
_hresFullValidReadPxCb_(pv, cb) \
|
|
|
|
#define hresFullValidReadPvCb_(pv, cb, pszProc, iarg) \
|
|
_hresFullValidReadPvCb_(pv, cb) \
|
|
|
|
#define hresFullValidWritePxCb_(pv, cb, pszProc, iarg) \
|
|
_hresFullValidWritePxCb_(pv, cb) \
|
|
|
|
#define hresFullValidWriteNoScramblePxCb_(pv, cb, pszProc, iarg)\
|
|
_hresFullValidWriteNoScramblePxCb_(pv, cb) \
|
|
|
|
#define hresFullValidWritePvCb_(pv, cb, pszProc, iarg) \
|
|
_hresFullValidWritePvCb_(pv, cb) \
|
|
|
|
#define hresFullValidFl_(fl, flV, pszProc, iarg) \
|
|
_hresFullValidFl_(fl, flV) \
|
|
|
|
#define hresFullValidPfn_(pfn, pszProc, iarg) \
|
|
_hresFullValidPfn_(pfn) \
|
|
|
|
#define hresFullValidPitf_(punk, pszProc, iarg) \
|
|
_hresFullValidPitf_(punk) \
|
|
|
|
#define hresFullValidReadStrA_(psz, cch, pszProc, iarg) \
|
|
_hresFullValidReadStrA_(psz, cch) \
|
|
|
|
#define hresFullValidReadStrW_(pwsz, cwch, pszProc, iarg) \
|
|
_hresFullValidReadStrW_(pwsz, cwch) \
|
|
|
|
#define hresFullValidHwnd0_(hwnd, pszProc, iarg) \
|
|
_hresFullValidHwnd0_(hwnd) \
|
|
|
|
#define hresFullValidPitf0_(punk, pszProc, iarg) \
|
|
_hresFullValidPitf0_(punk) \
|
|
|
|
#define hresFullValidPesc_(pesc, pszProc, iarg) \
|
|
_hresFullValidPesc_(pesc) \
|
|
|
|
#endif
|
|
|
|
/*
|
|
* The actual functions.
|
|
*/
|
|
|
|
STDMETHODIMP hresFullValidHwnd_(HWND hwnd, LPCSTR pszProc, int iarg);
|
|
STDMETHODIMP hresFullValidPcbOut_(PV pdw, UINT cb, LPCSTR pszProc, int iarg);
|
|
STDMETHODIMP hresFullValidReadPxCb_(PCV pv, UINT cb, LPCSTR pszProc, int iarg);
|
|
STDMETHODIMP hresFullValidReadPvCb_(PCV pv, UINT cb, LPCSTR pszProc, int iarg);
|
|
STDMETHODIMP hresFullValidWritePxCb_(PV pv, UINT cb, LPCSTR pszProc, int iarg);
|
|
STDMETHODIMP hresFullValidWritePvCb_(PV pv, UINT cb, LPCSTR pszProc, int iarg);
|
|
STDMETHODIMP hresFullValidFl_(DWORD fl, DWORD flV, LPCSTR pszProc, int iarg);
|
|
STDMETHODIMP hresFullValidPfn_(FARPROC pfn, LPCSTR pszProc, int iarg);
|
|
STDMETHODIMP hresFullValidPitf_(PUNK punk, LPCSTR pszProc, int iarg);
|
|
STDMETHODIMP hresFullValidReadStrA_(LPCSTR psz, UINT cch,
|
|
LPCSTR s_szProc, int iarg);
|
|
STDMETHODIMP hresFullValidReadStrW_(LPCWSTR pwsz, UINT cwch,
|
|
LPCSTR pszProc, int iarg);
|
|
STDMETHODIMP hresFullValidPesc_(LPDIEFFESCAPE pesc, LPCSTR pszProc, int iarg);
|
|
|
|
#ifdef XDEBUG
|
|
|
|
STDMETHODIMP
|
|
hresFullValidWriteNoScramblePxCb_(PV pv, UINT cb, LPCSTR s_szProc, int iarg);
|
|
|
|
#define hresFullValidWriteNoScramblePvCb_(pv, cb, pszProc, iarg) \
|
|
hresFullValidWritePvCb_(pv, cb, pszProc, MAKELONG(iarg, 1)) \
|
|
|
|
#else
|
|
|
|
/*
|
|
* Retail doesn't scramble.
|
|
*/
|
|
#define _hresFullValidWriteNoScramblePxCb_ \
|
|
_hresFullValidWritePxCb_ \
|
|
|
|
#define hresFullValidWriteNoScramblePvCb_ \
|
|
hresFullValidWritePvCb_ \
|
|
|
|
#endif
|
|
|
|
HRESULT INLINE
|
|
hresFullValidHwnd0_(HWND hwnd, LPCSTR pszProc, int iarg)
|
|
{
|
|
HRESULT hres;
|
|
if(hwnd)
|
|
{
|
|
hres = hresFullValidHwnd_(hwnd, pszProc, iarg);
|
|
} else
|
|
{
|
|
hres = S_OK;
|
|
}
|
|
return hres;
|
|
}
|
|
|
|
HRESULT INLINE
|
|
hresFullValidPitf0_(PUNK punk, LPCSTR pszProc, int iarg)
|
|
{
|
|
HRESULT hres;
|
|
if(punk)
|
|
{
|
|
hres = hresFullValidPitf_(punk, pszProc, iarg);
|
|
} else
|
|
{
|
|
hres = S_OK;
|
|
}
|
|
return hres;
|
|
}
|
|
|
|
/*
|
|
* Wrappers for derived types.
|
|
*/
|
|
|
|
#define hresFullValidRiid_(riid, s_szProc, iarg) \
|
|
hresFullValidReadPvCb_(riid, cbX(IID), s_szProc, iarg) \
|
|
|
|
/*
|
|
* Wrapers that add the szProc and iarg info.
|
|
*/
|
|
|
|
#define hresFullValidHwnd(hwnd, iarg) \
|
|
hresFullValidHwnd_(hwnd, s_szProc, iarg) \
|
|
|
|
#define hresFullValidPcbOut(pdw, cb, i) \
|
|
hresFullValidPcbOut_(pdw, cb, s_szProc, i) \
|
|
|
|
#define hresFullValidReadPdw_(pdw, z, i) \
|
|
hresFullValidReadPvCb_(pdw, cbX(DWORD), z, i) \
|
|
|
|
#define hresFullValidRiid(riid, iarg) \
|
|
hresFullValidRiid_(riid, s_szProc, iarg) \
|
|
|
|
#define hresFullValidGuid(pguid, iarg) \
|
|
hresFullValidReadPvCb_(pguid, cbX(GUID), s_szProc, iarg) \
|
|
|
|
#define hresFullValidReadPxCb(pv, X, iarg) \
|
|
hresFullValidReadPxCb_(pv, cbX(X), s_szProc, iarg) \
|
|
|
|
#define hresFullValidReadPxCb2(pv, X, X2, iarg) \
|
|
hresFullValidReadPxCb_(pv, MAKELONG(cbX(X), cbX(X2)), \
|
|
s_szProc, iarg) \
|
|
|
|
#define hresFullValidReadPvCb(pv, cb, iarg) \
|
|
hresFullValidReadPvCb_(pv, cb, s_szProc, iarg) \
|
|
|
|
#define hresFullValidReadPx(pv, X, iarg) \
|
|
hresFullValidReadPvCb_(pv, cbX(X), s_szProc, iarg) \
|
|
|
|
#define hresFullValidWritePxCb(pv, X, iarg) \
|
|
hresFullValidWritePxCb_(pv, cbX(X), s_szProc, iarg) \
|
|
|
|
#define hresFullValidWritePxCb2(pv, X, X2, iarg) \
|
|
hresFullValidWritePxCb_(pv, MAKELONG(cbX(X), cbX(X2)), \
|
|
s_szProc, iarg) \
|
|
|
|
#define hresFullValidWriteNoScramblePxCb(pv, X, iarg) \
|
|
hresFullValidWriteNoScramblePxCb_(pv, cbX(X), s_szProc, iarg)\
|
|
|
|
#define hresFullValidWriteNoScramblePxCb2(pv, X, X2, iarg) \
|
|
hresFullValidWriteNoScramblePxCb_(pv, MAKELONG(cbX(X), cbX(X2)),\
|
|
s_szProc, iarg)\
|
|
|
|
#define hresFullValidWritePvCb(pv, cb, iarg) \
|
|
hresFullValidWritePvCb_(pv, cb, s_szProc, iarg) \
|
|
|
|
#define hresFullValidWriteNoScramblePvCb(pv, cb, iarg) \
|
|
hresFullValidWriteNoScramblePvCb_(pv, cb, s_szProc, iarg) \
|
|
|
|
#define hresFullValidWritePx(pv, X, iarg) \
|
|
hresFullValidWritePvCb_(pv, cbX(X), s_szProc, iarg) \
|
|
|
|
#define hresFullValidReadPdw(pdw, iarg) \
|
|
hresFullValidReadPdw_(pdw, s_szProc, iarg) \
|
|
|
|
#define hresFullValidWritePguid(pguid, iarg) \
|
|
hresFullValidWritePx(pguid, GUID, iarg) \
|
|
|
|
#define hresFullValidFl(fl, flV, iarg) \
|
|
hresFullValidFl_(fl, flV, s_szProc, iarg) \
|
|
|
|
#define hresFullValidPfn(pfn, iarg) \
|
|
hresFullValidPfn_((FARPROC)(pfn), s_szProc, iarg) \
|
|
|
|
#define hresFullValidPitf(pitf, iarg) \
|
|
hresFullValidPitf_((PUNK)(pitf), s_szProc, iarg) \
|
|
|
|
#define hresFullValidReadStrA(psz, cch, iarg) \
|
|
hresFullValidReadStrA_(psz, cch, s_szProc, iarg) \
|
|
|
|
#define hresFullValidReadStrW(pwsz, cwch, iarg) \
|
|
hresFullValidReadStrW_(pwsz, cwch, s_szProc, iarg) \
|
|
|
|
#define hresFullValidHwnd0(hwnd, iarg) \
|
|
hresFullValidHwnd0_(hwnd, s_szProc, iarg) \
|
|
|
|
#define hresFullValidPitf0(pitf, iarg) \
|
|
hresFullValidPitf0_((PUNK)(pitf), s_szProc, iarg) \
|
|
|
|
#define hresFullValidPesc(pesc, iarg) \
|
|
hresFullValidPesc_(pesc, s_szProc, iarg) \
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func void | ValidationException |
|
|
*
|
|
* Raises a parameter validation exception in XDEBUG.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
#define ecValidation (ERROR_SEVERITY_ERROR | hresLe(ERROR_INVALID_PARAMETER))
|
|
|
|
#ifdef XDEBUG
|
|
#define ValidationException() RaiseException(ecValidation, 0, 0, 0)
|
|
#else
|
|
#define ValidationException()
|
|
#endif
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Bilingualism
|
|
*
|
|
* Special macros that help writing ANSI and UNICODE versions of
|
|
* the same underlying interface.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
/*
|
|
* _THAT is something you tack onto the end of a "bilingual" interface.
|
|
* In debug, it expands to the magic third argument which represents
|
|
* the vtbl the object should have. In retail, it expands to nothing.
|
|
*/
|
|
#ifdef XDEBUG
|
|
#define _THAT , PV vtblExpected
|
|
#define THAT_ , vtblExpected
|
|
#else
|
|
#define _THAT
|
|
#define THAT_
|
|
#endif
|
|
|
|
|
|
/*
|
|
* CSET_STUBS creates stubs for ANSI and UNICODE versions of the
|
|
* same procedure that is not character set-sensitive.
|
|
*
|
|
* mf - method function name
|
|
* arg1 - argument list in prototype form
|
|
* arg2 - argument list for calling (with _riid appended).
|
|
*
|
|
* It is assumed that the caller has already defined the symbols
|
|
* ThisClass and ThisInterface[AWT]. If a "2" interface is involved,
|
|
* then also define ThisInterface2.
|
|
*
|
|
* This macro should be used only in DEBUG. In retail, the common
|
|
* procedure handles both character sets directly.
|
|
*/
|
|
#ifdef XDEBUG
|
|
|
|
#define CSET_STUBS(mf, arg1, arg2) \
|
|
CSET_STUB(TFORM, mf, arg1, arg2) \
|
|
CSET_STUB(SFORM, mf, arg1, arg2) \
|
|
|
|
#define CSET_STUB(FORM, mf, arg1, arg2) \
|
|
_CSET_STUB(FORM, mf, arg1, arg2, ThisClass, ThisInterface) \
|
|
|
|
#define _CSET_STUB(FORM, mf, arg1, arg2, cls, itf) \
|
|
__CSET_STUB(FORM, mf, arg1, arg2, cls, itf) \
|
|
|
|
#define __CSET_STUB(FORM, mf, arg1, arg2, cls, itf) \
|
|
STDMETHODIMP \
|
|
FORM(cls##_##mf) arg1 \
|
|
{ \
|
|
PV vtblExpected = Class_Vtbl(ThisClass, FORM(ThisInterfaceT)); \
|
|
return cls##_##mf arg2; \
|
|
} \
|
|
|
|
#define CSET_STUBS2(mf, arg1, arg2) \
|
|
CSET_STUB2(TFORM, mf, arg1, arg2) \
|
|
CSET_STUB2(SFORM, mf, arg1, arg2) \
|
|
|
|
#define CSET_STUB2(FORM, mf, arg1, arg2) \
|
|
_CSET_STUB2(FORM, mf, arg1, arg2, ThisClass, ThisInterface2) \
|
|
|
|
#define _CSET_STUB2(FORM, mf, arg1, arg2, cls, itf) \
|
|
__CSET_STUB2(FORM, mf, arg1, arg2, cls, itf) \
|
|
|
|
#define __CSET_STUB2(FORM, mf, arg1, arg2, cls, itf) \
|
|
STDMETHODIMP \
|
|
FORM(cls##_##mf##2) arg1 \
|
|
{ \
|
|
PV vtblExpected = Class_Vtbl(ThisClass, FORM(ThisInterface2T)); \
|
|
return cls##_##mf arg2; \
|
|
} \
|
|
|
|
#endif
|
|
|
|
/*
|
|
* TFORM(x) expands to x##A if ANSI or x##W if UNICODE.
|
|
* This T-izes a symbol, in the sense of TCHAR or PTSTR.
|
|
*
|
|
* SFORM(x) expands to x##W if ANSI or x##A if UNICODE.
|
|
* This anti-T-izes a symbol.
|
|
*/
|
|
|
|
#ifdef UNICODE
|
|
#define _TFORM(x) x##W
|
|
#define _SFORM(x) x##A
|
|
#else
|
|
#define _TFORM(x) x##A
|
|
#define _SFORM(x) x##W
|
|
#endif
|
|
|
|
#define TFORM(x) _TFORM(x)
|
|
#define SFORM(x) _SFORM(x)
|
|
|
|
#ifdef UNICODE
|
|
typedef CHAR SCHAR;
|
|
#else
|
|
typedef WCHAR SCHAR;
|
|
#endif
|
|
|
|
typedef SCHAR * LPSSTR;
|
|
typedef const SCHAR * LPCSSTR;
|
|
|
|
/*
|
|
* SToT(dst, cchDst, src) - convert S to T
|
|
* TToS(dst, cchDst, src) - convert T to S
|
|
*
|
|
* Remember, "T" means "ANSI if ANSI, or UNICODE if UNICODE",
|
|
* and "S" is the anti-T.
|
|
*
|
|
* So SToT converts to the preferred character set, and TToS converts
|
|
* to the alternate character set.
|
|
*
|
|
*/
|
|
|
|
#define AToU(dst, cchDst, src) \
|
|
MultiByteToWideChar(CP_ACP, 0, src, -1, dst, cchDst)
|
|
#define UToA(dst, cchDst, src) \
|
|
WideCharToMultiByte(CP_ACP, 0, src, -1, dst, cchDst, 0, 0)
|
|
|
|
#ifdef UNICODE
|
|
#define SToT AToU
|
|
#define TToS UToA
|
|
#define AToT AToU
|
|
#define TToU(dst, cchDst, src) lstrcpyn(dst, src, cchDst)
|
|
#define UToT(dst, cchDst, src) lstrcpyn(dst, src, cchDst)
|
|
#else
|
|
#define SToT UToA
|
|
#define TToS AToU
|
|
#define AToT(dst, cchDst, src) lstrcpyn(dst, src, cchDst)
|
|
#define TToU AToU
|
|
#define UToT UToA
|
|
#endif
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Unicode wrappers for Win95
|
|
*
|
|
*****************************************************************************/
|
|
|
|
|
|
#ifndef UNICODE
|
|
|
|
#define LoadStringW _LoadStringW
|
|
int EXTERNAL LoadStringW(HINSTANCE hinst, UINT ids, LPWSTR pwsz, int cwch);
|
|
|
|
#define RegDeleteKeyW _RegDeleteKeyW
|
|
LONG EXTERNAL RegDeleteKeyW(HKEY hk, LPCWSTR pwsz);
|
|
|
|
#endif
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Registry access functions
|
|
*
|
|
*****************************************************************************/
|
|
//our own version of KEY_ALL_ACCESS, that does not use WRITE_DAC and WRITE_OWNER (see Whistler bug 318865)
|
|
#define DI_DAC_OWNER (WRITE_DAC | WRITE_OWNER)
|
|
#define DI_KEY_ALL_ACCESS (KEY_ALL_ACCESS & ~DI_DAC_OWNER)
|
|
|
|
LONG EXTERNAL
|
|
RegQueryString(HKEY hk, LPCTSTR ptszValue, LPTSTR ptszBuf, DWORD ctchBuf);
|
|
|
|
LONG EXTERNAL RegQueryStringValueW(HKEY hk, LPCTSTR ptszValue,
|
|
LPWSTR pwszBuf, LPDWORD pcbBuf);
|
|
|
|
LONG EXTERNAL RegSetStringValueW(HKEY hk, LPCTSTR ptszValue, LPCWSTR pwszBuf);
|
|
|
|
DWORD EXTERNAL RegQueryDIDword(LPCTSTR ptszPath, LPCTSTR ptszValue, DWORD dwDefault);
|
|
|
|
STDMETHODIMP
|
|
hresMumbleKeyEx(HKEY hk, LPCTSTR ptszKey, REGSAM sam, DWORD dwOptions, PHKEY phk);
|
|
|
|
STDMETHODIMP
|
|
hresRegCopyValues( HKEY hkSrc, HKEY hkDest );
|
|
|
|
STDMETHODIMP
|
|
hresRegCopyKey( HKEY hkSrcRoot, PTCHAR szSrcName, PTCHAR szClass, HKEY hkDestRoot, PTCHAR szDestName, HKEY *phkSub );
|
|
|
|
STDMETHODIMP
|
|
hresRegCopyKeys( HKEY hkSrc, HKEY hkRoot, PDWORD OPTIONAL pMaxNameLen );
|
|
|
|
STDMETHODIMP
|
|
hresRegCopyBranch( HKEY hkSrc, HKEY hkDest );
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Common Object Managers for the Component Object Model
|
|
*
|
|
* OLE wrapper macros and structures. For more information, see
|
|
* the beginning of common.c
|
|
*
|
|
*****************************************************************************/
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Pre-vtbl structures
|
|
*
|
|
* Careful! If you change these structures, you must also adjust
|
|
* common.c accordingly.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
typedef struct PREVTBL
|
|
{ /* Shared vtbl prefix */
|
|
RIID riid; /* Type of this object */
|
|
LONG lib; /* offset from start of object */
|
|
} PREVTBL, *PPREVTBL;
|
|
|
|
typedef struct PREVTBLP
|
|
{ /* Prefix for primary vtbl */
|
|
#ifdef DEBUG
|
|
LPCTSTR tszClass; /* Class name (for squirties) */
|
|
#endif
|
|
PPV rgvtbl; /* Array of standard vtbls */
|
|
UINT cbvtbl; /* Size of vtbl array in bytes */
|
|
STDMETHOD(QIHelper)(PV pv, RIID riid, PPV ppvOut); /* QI helper */
|
|
STDMETHOD_(void,AppFinalizeProc)(PV pv);/* App finalization procedure */
|
|
STDMETHOD_(void,FinalizeProc)(PV pv);/* Finalization procedure */
|
|
PREVTBL prevtbl; /* lib must be zero */
|
|
} PREVTBLP, *PPREVTBLP;
|
|
|
|
/*
|
|
* A fuller implementation is in common.c. Out here, we need only
|
|
* concern ourselves with getting to the primary interface.
|
|
*/
|
|
|
|
#define _thisPv(pitf) \
|
|
pvSubPvCb(pitf, (*(PPREVTBL*)(pitf))[-1].lib)
|
|
|
|
#define _thisPvNm(pitf, nm) \
|
|
pvSubPvCb(pitf, FIELD_OFFSET(ThisClass, nm)) \
|
|
|
|
#ifndef XDEBUG
|
|
|
|
#define hresPvVtbl_(pv, vtbl, pszProc) \
|
|
_hresPvVtbl_(pv, vtbl) \
|
|
|
|
#define hresPvVtbl2_(pv, vtbl, vtbl2, pszProc) \
|
|
_hresPvVtbl2_(pv, vtbl, vtbl2) \
|
|
|
|
#endif
|
|
|
|
HRESULT EXTERNAL
|
|
hresPvVtbl_(PV pv, PV vtbl, LPCSTR pszProc);
|
|
|
|
HRESULT EXTERNAL
|
|
hresPvVtbl2_(PV pv, PV vtbl, PV vtbl2, LPCSTR pszProc);
|
|
|
|
#define hresPvVtbl(pv, vtbl) \
|
|
hresPvVtbl_(pv, vtbl, s_szProc) \
|
|
|
|
#define hresPvVtbl2(pv, vtbl, vtbl2) \
|
|
hresPvVtbl2_(pv, vtbl, vtbl2, s_szProc) \
|
|
|
|
#define hresPvI(pv, I) \
|
|
hresPvVtbl(pv, Class_Vtbl(ThisClass, I)) \
|
|
|
|
#define hresPv2I(pv, I, I2) \
|
|
hresPvVtbl2(pv, Class_Vtbl(ThisClass, I), Class_Vtbl(ThisClass, I2)) \
|
|
|
|
#define hresPv(pv) \
|
|
hresPvI(pv, ThisInterface) \
|
|
|
|
#define hresPvA(pv) \
|
|
hresPvI(pv, ThisInterfaceA) \
|
|
|
|
#define hresPvW(pv) \
|
|
hresPvI(pv, ThisInterfaceW) \
|
|
|
|
#define hresPv2A(pv) \
|
|
hresPv2I(pv, ThisInterfaceA, ThisInterface2A) \
|
|
|
|
#define hresPv2W(pv) \
|
|
hresPv2I(pv, ThisInterfaceW, ThisInterface2W) \
|
|
|
|
#ifdef XDEBUG
|
|
|
|
#define hresPvT(pv) \
|
|
hresPvVtbl(pv, vtblExpected) \
|
|
|
|
#else
|
|
|
|
#define hresPvT(pv) \
|
|
hresPv(pv) \
|
|
|
|
#endif
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Declaring interfaces
|
|
*
|
|
* The extra level of indirection on _Primary_Interface et al
|
|
* allow the interface name to be a macro which expands to the
|
|
* *real* name of the interface.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
#define __Class_Vtbl(C, I) &c_##I##_##C##VI.vtbl
|
|
#define _Class_Vtbl(C, I) __Class_Vtbl(C, I)
|
|
#define Class_Vtbl(C, I) _Class_Vtbl(C, I)
|
|
|
|
#define Num_Interfaces(C) cA(c_rgpv##C##Vtbl)
|
|
|
|
#ifdef DEBUG
|
|
|
|
#define Simple_Interface(C) Primary_Interface(C, IUnknown); \
|
|
Default_QueryInterface(C) \
|
|
Default_AddRef(C) \
|
|
Default_Release(C)
|
|
#define Simple_Vtbl(C) Class_Vtbl(C)
|
|
#define Simple_Interface_Begin(C) Primary_Interface_Begin(C, IUnknown)
|
|
#define Simple_Interface_End(C) Primary_Interface_End(C, IUnknown)
|
|
|
|
#else
|
|
|
|
#define Simple_Interface(C) Primary_Interface(C, IUnknown)
|
|
#define Simple_Vtbl(C) Class_Vtbl(C)
|
|
#define Simple_Interface_Begin(C) \
|
|
struct S_##C##Vtbl c_##I##_##C##VI = { { \
|
|
c_rgpv##C##Vtbl, \
|
|
cbX(c_rgpv##C##Vtbl), \
|
|
C##_QIHelper, \
|
|
C##_AppFinalize, \
|
|
C##_Finalize, \
|
|
{ &IID_##IUnknown, 0 }, \
|
|
}, { \
|
|
Common##_QueryInterface, \
|
|
Common##_AddRef, \
|
|
Common##_Release, \
|
|
|
|
#define Simple_Interface_End(C) \
|
|
} }; \
|
|
|
|
#endif
|
|
|
|
#define _Primary_Interface(C, I) \
|
|
extern struct S_##C##Vtbl { \
|
|
PREVTBLP prevtbl; \
|
|
I##Vtbl vtbl; \
|
|
} c_##I##_##C##VI \
|
|
|
|
#define Primary_Interface(C, I) \
|
|
_Primary_Interface(C, I) \
|
|
|
|
#ifdef DEBUG
|
|
#define _Primary_Interface_Begin(C, I) \
|
|
struct S_##C##Vtbl c_##I##_##C##VI = { { \
|
|
TEXT(#C), \
|
|
c_rgpv##C##Vtbl, \
|
|
cbX(c_rgpv##C##Vtbl), \
|
|
C##_QIHelper, \
|
|
C##_AppFinalize, \
|
|
C##_Finalize, \
|
|
{ &IID_##I, 0, }, \
|
|
}, { \
|
|
C##_QueryInterface, \
|
|
C##_AddRef, \
|
|
C##_Release, \
|
|
|
|
#else
|
|
#define _Primary_Interface_Begin(C, I) \
|
|
struct S_##C##Vtbl c_##I##_##C##VI = { { \
|
|
c_rgpv##C##Vtbl, \
|
|
cbX(c_rgpv##C##Vtbl), \
|
|
C##_QIHelper, \
|
|
C##_AppFinalize, \
|
|
C##_Finalize, \
|
|
{ &IID_##I, 0, }, \
|
|
}, { \
|
|
C##_QueryInterface, \
|
|
C##_AddRef, \
|
|
C##_Release, \
|
|
|
|
#endif
|
|
|
|
#define Primary_Interface_Begin(C, I) \
|
|
_Primary_Interface_Begin(C, I) \
|
|
|
|
#define Primary_Interface_End(C, I) \
|
|
} }; \
|
|
|
|
#define _Secondary_Interface(C, I) \
|
|
extern struct S_##I##_##C##Vtbl { \
|
|
PREVTBL prevtbl; \
|
|
I##Vtbl vtbl; \
|
|
} c_##I##_##C##VI \
|
|
|
|
#define Secondary_Interface(C, I) \
|
|
_Secondary_Interface(C, I) \
|
|
|
|
/*
|
|
* Secret backdoor for the "private" IUnknown in common.c
|
|
*/
|
|
#define _Secondary_Interface_Begin(C, I, ofs, Pfx) \
|
|
struct S_##I##_##C##Vtbl c_##I##_##C##VI = { { \
|
|
&IID_##I, \
|
|
ofs, \
|
|
}, { \
|
|
Pfx##QueryInterface, \
|
|
Pfx##AddRef, \
|
|
Pfx##Release, \
|
|
|
|
#define Secondary_Interface_Begin(C, I, nm) \
|
|
_Secondary_Interface_Begin(C, I, FIELD_OFFSET(C, nm), Common_) \
|
|
|
|
#define _Secondary_Interface_End(C, I) \
|
|
} }; \
|
|
|
|
#define Secondary_Interface_End(C, I, nm) \
|
|
_Secondary_Interface_End(C, I) \
|
|
|
|
#define Interface_Template_Begin(C) \
|
|
PV c_rgpv##C##Vtbl[] = { \
|
|
|
|
#define Primary_Interface_Template(C, I) \
|
|
Class_Vtbl(C, I), \
|
|
|
|
#define Secondary_Interface_Template(C, I) \
|
|
Class_Vtbl(C, I), \
|
|
|
|
#define Interface_Template_End(C) \
|
|
}; \
|
|
|
|
|
|
STDMETHODIMP Common_QueryInterface(PV, RIID, PPV);
|
|
STDMETHODIMP_(ULONG) Common_AddRef(PV pv);
|
|
STDMETHODIMP_(ULONG) Common_Release(PV pv);
|
|
|
|
STDMETHODIMP_(void) Common_Hold(PV pv);
|
|
STDMETHODIMP_(void) Common_Unhold(PV pv);
|
|
|
|
STDMETHODIMP Common_QIHelper(PV, RIID, PPV);
|
|
void EXTERNAL Common_Finalize(PV);
|
|
|
|
#define Common_AppFinalize Common_Finalize
|
|
|
|
#ifndef XDEBUG
|
|
|
|
#define _Common_New_(cb, punkOuter, vtbl, pvpObj, z) \
|
|
__Common_New_(cb, punkOuter, vtbl, pvpObj) \
|
|
|
|
#define _Common_NewRiid_(cb, vtbl, punkOuter, riid, pvpObj, z) \
|
|
__Common_NewRiid_(cb, vtbl, punkOuter, riid, pvpObj) \
|
|
|
|
#endif
|
|
|
|
STDMETHODIMP
|
|
_Common_New_(ULONG cb, PUNK punkOuter, PV vtbl, PPV ppvObj, LPCSTR s_szProc);
|
|
|
|
STDMETHODIMP
|
|
_Common_NewRiid_(ULONG cb, PV vtbl, PUNK punkOuter, RIID riid, PPV pvpObj,
|
|
LPCSTR s_szProc);
|
|
|
|
#define Common_NewCb(cb, C, punkOuter, ppvObj) \
|
|
_Common_New_(cb, punkOuter, Class_Vtbl(C, ThisInterface), ppvObj, s_szProc)
|
|
|
|
#define Common_New(C, punkOuter, ppvObj) \
|
|
Common_NewCb(cbX(C), C, punkOuter, ppvObj) \
|
|
|
|
#define Common_NewCbRiid(cb, C, punkOuter, riid, ppvObj) \
|
|
_Common_NewRiid_(cb, Class_Vtbl(C, ThisInterface), punkOuter, riid, ppvObj, s_szProc)
|
|
|
|
#define Common_NewRiid(C, punkOuter, riid, ppvObj) \
|
|
_Common_NewRiid_(cbX(C), Class_Vtbl(C, ThisInterface), punkOuter, riid, ppvObj, s_szProc)
|
|
|
|
#ifdef DEBUG
|
|
PV EXTERNAL Common_IsType(PV pv);
|
|
#else
|
|
#define Common_IsType
|
|
#endif
|
|
#define Assert_CommonType Common_IsType
|
|
|
|
STDMETHODIMP Forward_QueryInterface(PV pv, RIID riid, PPV ppvObj);
|
|
STDMETHODIMP_(ULONG) Forward_AddRef(PV pv);
|
|
STDMETHODIMP_(ULONG) Forward_Release(PV pv);
|
|
|
|
void EXTERNAL Invoke_Release(PV pv);
|
|
|
|
#define Common_DumpObjects()
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* OLE wrappers
|
|
*
|
|
* These basically do the same as IUnknown_Mumble, except that they
|
|
* avoid side-effects in evaluation by being inline functions.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
HRESULT INLINE
|
|
OLE_QueryInterface(PV pv, RIID riid, PPV ppvObj)
|
|
{
|
|
PUNK punk = pv;
|
|
return punk->lpVtbl->QueryInterface(punk, riid, ppvObj);
|
|
}
|
|
|
|
ULONG INLINE
|
|
OLE_AddRef(PV pv)
|
|
{
|
|
PUNK punk = pv;
|
|
return punk->lpVtbl->AddRef(punk);
|
|
}
|
|
|
|
ULONG INLINE
|
|
OLE_Release(PV pv)
|
|
{
|
|
PUNK punk = pv;
|
|
return punk->lpVtbl->Release(punk);
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Macros that forward to the common handlers after squirting.
|
|
* Use these only in DEBUG.
|
|
*
|
|
* It is assumed that sqfl has been #define'd to the appropriate sqfl.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
#ifdef DEBUG
|
|
|
|
#define Default_QueryInterface(Class) \
|
|
STDMETHODIMP \
|
|
Class##_QueryInterface(PV pv, RIID riid, PPV ppvObj) \
|
|
{ \
|
|
SquirtSqflPtszV(sqfl, TEXT(#Class) TEXT("_QueryInterface()")); \
|
|
return Common_QueryInterface(pv, riid, ppvObj); \
|
|
} \
|
|
|
|
// 7/21/2000(a-JiTay): IA64: Use %p format specifier for 32/64-bit pointers.
|
|
#define Default_AddRef(Class) \
|
|
STDMETHODIMP_(ULONG) \
|
|
Class##_AddRef(PV pv) \
|
|
{ \
|
|
ULONG ulRc = Common_AddRef(pv); \
|
|
SquirtSqflPtszV(sqfl, TEXT(#Class) \
|
|
TEXT("_AddRef(%p) -> %d"), pv, ulRc); \
|
|
return ulRc; \
|
|
} \
|
|
|
|
// 7/21/2000(a-JiTay): IA64: Use %p format specifier for 32/64-bit pointers.
|
|
#define Default_Release(Class) \
|
|
STDMETHODIMP_(ULONG) \
|
|
Class##_Release(PV pv) \
|
|
{ \
|
|
ULONG ulRc = Common_Release(pv); \
|
|
SquirtSqflPtszV(sqfl, TEXT(#Class) \
|
|
TEXT("_Release(%p) -> %d"), pv, ulRc); \
|
|
return ulRc; \
|
|
} \
|
|
|
|
#endif
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Paranoid callbacks
|
|
*
|
|
* Callback() performs a callback. The callback must accept exactly
|
|
* two parameters, both pointers. (All our callbacks are like this.)
|
|
* And it must return a BOOL.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
typedef BOOL (FAR PASCAL * DICALLBACKPROC)(LPVOID, LPVOID);
|
|
|
|
#ifdef XDEBUG
|
|
BOOL EXTERNAL Callback(DICALLBACKPROC, PVOID, PVOID);
|
|
#else
|
|
#define Callback(pec, pv1, pv2) pec(pv1, pv2)
|
|
#endif
|
|
|
|
#if 0
|
|
/*****************************************************************************
|
|
*
|
|
* Groveling into a CONTEXT structure.
|
|
*
|
|
* This is used to check that a callback procedure is properly
|
|
* prototyped. We save the stack register before calling the
|
|
* procedure and compare it with the stack register on the way back.
|
|
* If they are different, explode!
|
|
*
|
|
* ctxEsp is the name of the stack pointer register.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
typedef struct STACKINFO
|
|
{
|
|
CONTEXT ctxPre; /* Thread context before call */
|
|
CONTEXT ctxPost; /* Thread context after call */
|
|
} STACKINFO, *PSTACKINFO;
|
|
|
|
#ifdef XDEBUG
|
|
|
|
#if defined(_X86_)
|
|
#define ctxEsp Esp
|
|
|
|
#elif defined(_ALPHA_)
|
|
#define ctxEsp IntSp
|
|
|
|
#elif defined(_MIPS_)
|
|
#define ctxEsp IntSp
|
|
|
|
#elif defined(_PPC_)
|
|
#define ctxEsp Gpr1
|
|
|
|
#else
|
|
#pragma message("I don't know what the stack register is called on this platform")
|
|
#endif
|
|
|
|
#endif
|
|
|
|
#ifdef ctxEsp
|
|
|
|
#define DECLARE_STACKINFO() \
|
|
STACKINFO si \
|
|
|
|
#define PRE_CALLBACK() \
|
|
si.ctxPre.ContextFlags = CONTEXT_CONTROL; \
|
|
GetThreadContext(GetCurrentThread(), &si.ctxPre) \
|
|
|
|
#define POST_CALLBACK() \
|
|
si.ctxPost.ContextFlags = CONTEXT_CONTROL; \
|
|
if (GetThreadContext(GetCurrentThread(), &si.ctxPost) && \
|
|
si.ctxPre.ctxEsp != si.ctxPost.ctxEsp) { \
|
|
RPF("DINPUT: Incorrectly prototyped callback! Crash soon!"); \
|
|
ValidationException(); \
|
|
} \
|
|
|
|
#else
|
|
|
|
#define DECLARE_STACKINFO()
|
|
#define PRE_CALLBACK()
|
|
#define POST_CALLBACK()
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Alternative message cracker macros
|
|
*
|
|
* Basically the same as HANDLE_MSG, except that it stashes the
|
|
* answer into hres.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
#define HRES_MSG(this, msg, fn) \
|
|
case msg: hres = HANDLE_##msg(this, wParam, lParam, fn); break
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Registry keys and value names
|
|
*
|
|
*****************************************************************************/
|
|
|
|
#define REGSTR_PATH_DINPUT TEXT("Software\\Microsoft\\DirectInput")
|
|
#define REGSTR_PATH_LASTAPP REGSTR_PATH_DINPUT TEXT("\\MostRecentApplication\\")
|
|
#define REGSTR_PATH_DITYPEPROP REGSTR_PATH_PRIVATEPROPERTIES TEXT("\\DirectInput")
|
|
#define REGSTR_KEY_APPHACK TEXT("Compatibility")
|
|
#define REGSTR_KEY_TEST TEXT("Test")
|
|
#define REGSTR_KEY_KEYBTYPE REGSTR_KEY_TEST TEXT("\\KeyboardType")
|
|
#define REGSTR_VAL_EMULATION TEXT("Emulation")
|
|
#define REGSTR_VAL_GAMEPADDELAY TEXT("GamepadDelay")
|
|
#define REGSTR_VAL_JOYNFFCONFIG TEXT("Joystick%dFFConfiguration")
|
|
#define REGSTR_VAL_JOYGAMEPORTEMULATOR TEXT("OEMEmulator")
|
|
#define REGSTR_VAL_CPLCLSID TEXT("ConfigCLSID")
|
|
#define REGSTR_KEY_JOYPREDEFN TEXT("predef%d")
|
|
#define REGSTR_VAL_JOYOEMCALLOUT TEXT("OEMCallout")
|
|
#define REGSTR_VAL_JOYOEMHARDWAREID TEXT("OEMHardwareID")
|
|
#define REGSTR_VAL_FLAGS1 TEXT("Flags1")
|
|
#define REGSTR_VAL_FLAGS2 TEXT("Flags2")
|
|
/*****************************************************************************
|
|
*
|
|
* Registered window messages
|
|
*
|
|
*****************************************************************************/
|
|
|
|
#define MSGSTR_JOYCHANGED TEXT("MSJSTICK_VJOYD_MSGSTR")
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* mem.c - Memory management
|
|
*
|
|
* Be extremely careful with FreePv, because it doesn't work if
|
|
* the pointer is null.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
#define NEED_REALLOC
|
|
|
|
STDMETHODIMP EXTERNAL ReallocCbPpv(UINT cb, PV ppvObj);
|
|
STDMETHODIMP EXTERNAL AllocCbPpv(UINT cb, PV ppvObj);
|
|
|
|
#ifdef NEED_REALLOC
|
|
#define FreePpv(ppv) (void)ReallocCbPpv(0, ppv)
|
|
#else
|
|
void EXTERNAL FreePpv(PV ppv);
|
|
#define FreePpv(ppv) FreePpv(ppv)
|
|
#endif
|
|
#define FreePv(pv) LocalFree((HLOCAL)(pv))
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* diutil.c - Misc utilities
|
|
*
|
|
*****************************************************************************/
|
|
|
|
extern GUID GUID_Null;
|
|
|
|
#define ctchGuid (1 + 8 + 1 + 4 + 1 + 4 + 1 + 4 + 1 + 12 + 1 + 1)
|
|
|
|
BOOL EXTERNAL ParseGUID(LPGUID pGUID, LPCTSTR ptsz);
|
|
BOOL EXTERNAL ParseVIDPID(PUSHORT puVID, PUSHORT puPID , LPCWSTR ptsz);
|
|
|
|
#define ctchNamePrefix 12 /* 12 = strlen("DirectInput.") */
|
|
#define ctchNameGuid (ctchNamePrefix + ctchGuid)
|
|
void EXTERNAL NameFromGUID(LPTSTR ptszBuf, PCGUID pGUID);
|
|
|
|
typedef STDMETHOD(CREATEDCB)(PUNK, REFGUID, RIID, PPV);
|
|
|
|
typedef struct DIOBJECTSTATICDATA
|
|
{
|
|
union
|
|
{
|
|
PCGUID rguidInstance; /* If a static device */
|
|
UINT uiButtons; /* If a HID mouse */
|
|
};
|
|
DWORD dwDevType;
|
|
union
|
|
{
|
|
CREATEDCB CreateDcb; /* If a static device */
|
|
UINT uiAxes; /* If a HID mouse */
|
|
};
|
|
} DIOBJECTSTATICDATA, *PDIOBJECTSTATICDATA, **PPDIOBJECTSTATICDATA;
|
|
|
|
HRESULT EXTERNAL hresRunControlPanel(LPCTSTR ptszCpl);
|
|
|
|
void EXTERNAL DeviceInfoWToA(LPDIDEVICEINSTANCEA pdiA,
|
|
LPCDIDEVICEINSTANCEW pdiW);
|
|
|
|
void EXTERNAL ObjectInfoWToA(LPDIDEVICEOBJECTINSTANCEA pdoiA,
|
|
LPCDIDEVICEOBJECTINSTANCEW pdoiW);
|
|
|
|
#ifdef IDirectInputDevice2Vtbl
|
|
void EXTERNAL EffectInfoWToA(LPDIEFFECTINFOA pdeiA,
|
|
LPCDIEFFECTINFOW pdeiW);
|
|
|
|
#endif
|
|
|
|
#ifndef XDEBUG
|
|
|
|
#define hresFindInstanceGUID_(pGUID, pcdcb, z, i) \
|
|
_hresFindInstanceGUID_(pGUID, pcdcb) \
|
|
|
|
#define hresValidInstanceVer_(hinst, dwVer, z) \
|
|
_hresValidInstanceVer_(hinst, dwVer) \
|
|
|
|
#endif
|
|
|
|
HRESULT EXTERNAL hresFindInstanceGUID_(PCGUID pGUID, CREATEDCB *pcdcb,
|
|
LPCSTR s_szProc, int iarg);
|
|
|
|
HRESULT EXTERNAL
|
|
hresValidInstanceVer_(HINSTANCE hinst, DWORD dwVersion, LPCSTR s_szProc);
|
|
|
|
#define hresFindInstanceGUID(pGuid, pcdcb, iarg) \
|
|
hresFindInstanceGUID_(pGuid, pcdcb, s_szProc, iarg) \
|
|
|
|
#define hresValidInstanceVer(hinst, dwVer) \
|
|
hresValidInstanceVer_(hinst, dwVer, s_szProc) \
|
|
|
|
HRESULT EXTERNAL DupEventHandle(HANDLE h, LPHANDLE phOut);
|
|
DWORD EXTERNAL GetWindowPid(HWND hwnd);
|
|
|
|
PV EXTERNAL pvFindResource(HINSTANCE hinst, DWORD id, LPCTSTR rt);
|
|
|
|
void EXTERNAL GetNthString(LPWSTR pwsz, UINT ids, UINT ui);
|
|
|
|
#define GetNthButtonString(pwsz, ui) \
|
|
GetNthString(pwsz, IDS_BUTTONTEMPLATE, ui)
|
|
|
|
#define GetNthAxisString(pwsz, ui) \
|
|
GetNthString(pwsz, IDS_AXISTEMPLATE, ui)
|
|
|
|
#define GetNthPOVString(pwsz, ui) \
|
|
GetNthString(pwsz, IDS_POVTEMPLATE, ui)
|
|
|
|
HRESULT EXTERNAL hresDupPtszPptsz(LPCTSTR ptszSrc, LPTSTR *pptszDst);
|
|
|
|
BOOL EXTERNAL fInitializeCriticalSection(LPCRITICAL_SECTION pCritSec);
|
|
|
|
void EXTERNAL DiCharUpperW(LPWSTR pwsz);
|
|
|
|
#define WIN_UNKNOWN_OS 0
|
|
#define WIN95_OS 1
|
|
#define WIN98_OS 2
|
|
#define WINME_OS 3
|
|
#define WINNT_OS 4
|
|
#define WINWH_OS 5
|
|
|
|
DWORD INTERNAL DIGetOSVersion();
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* dilist.c
|
|
*
|
|
*****************************************************************************/
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @struct GPA |
|
|
*
|
|
* Growable pointer array.
|
|
*
|
|
* @field PPV | rgpv |
|
|
*
|
|
* The base of the array of pointers.
|
|
*
|
|
* @field int | cpv |
|
|
*
|
|
* The number of pointers in use in the array.
|
|
*
|
|
* @field int | cpvAlloc |
|
|
*
|
|
* The number of pointers allocated in the array.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
typedef struct GPA
|
|
{
|
|
|
|
PPV rgpv;
|
|
int cpv;
|
|
int cpvAlloc;
|
|
|
|
} GPA, *HGPA;
|
|
|
|
void EXTERNAL GPA_Init(HGPA hgpa);
|
|
void EXTERNAL GPA_Term(HGPA hgpa);
|
|
|
|
STDMETHODIMP GPA_Append(HGPA hgpa, PV pv);
|
|
BOOL EXTERNAL GPA_FindPtr(HGPA hgpa, PV pv);
|
|
STDMETHODIMP GPA_DeletePtr(HGPA hgpa, PV pv);
|
|
STDMETHODIMP GPA_Clone(HGPA hgpaDst, HGPA hgpaSrc);
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func void | GPA_InitFromZero |
|
|
*
|
|
* Initialize a GPA structure that is already zero-initialized.
|
|
*
|
|
* @parm HGPA | hgpa |
|
|
*
|
|
* Handle to pointer array.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
/*
|
|
* Nothing needs to be done; zero-init is just fine.
|
|
*
|
|
* Note: didev.c also has a global GPA, and it assumes that zero-init
|
|
* is just fine.
|
|
*/
|
|
#define GPA_InitFromZero(hgpa)
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* dioledup.c
|
|
*
|
|
*****************************************************************************/
|
|
|
|
STDMETHODIMP
|
|
DICoCreateInstance(LPTSTR ptszClsid, LPUNKNOWN punkOuter,
|
|
RIID riid, PPV ppvOut, HINSTANCE *phinst);
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* diexcl.c - Exclusive access management
|
|
*
|
|
* We also keep GUID uniqueness goo up here, because it is
|
|
* diexcl.c that manages shared memory.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
STDMETHODIMP Excl_Acquire(PCGUID pguid, HWND hwnd, DWORD discl);
|
|
void EXTERNAL Excl_Unacquire(PCGUID pguid, HWND hwnd, DWORD discl);
|
|
STDMETHODIMP Excl_Init(void);
|
|
|
|
LONG EXTERNAL Excl_UniqueGuidInteger(void);
|
|
DWORD EXTERNAL Excl_GetConfigChangedTime();
|
|
void EXTERNAL Excl_SetConfigChangedTime(DWORD tm);
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @struct GLOBALJOYSTATE |
|
|
*
|
|
* Structure that records global joystick state information.
|
|
*
|
|
* @field DWORD | dwTag |
|
|
*
|
|
* Counter used to keep track of how many times each joystick's
|
|
* force feedback driver has been reset. This is used to make
|
|
* sure that nobody messes with a joystick that he doesn't own.
|
|
*
|
|
* Each time the joystick is reset, the corresponding counter
|
|
* is incremented. Before we do anything to a device, we check
|
|
* if the reset counter matches the value stored in the
|
|
* object. If not, then it means that the device has been
|
|
* reset in the meantime and no longer belongs to the caller.
|
|
*
|
|
* @field DWORD | dwCplGain |
|
|
*
|
|
* Control panel (global) gain setting for the joystick.
|
|
*
|
|
* @field DWORD | dwDevGain |
|
|
*
|
|
* Most recent device (local) gain applied to the joystick.
|
|
*
|
|
* This is cached so that when the global gain changes,
|
|
* we know what physical gain to apply as a result.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
typedef struct GLOBALJOYSTATE
|
|
{
|
|
DWORD dwTag;
|
|
DWORD dwCplGain;
|
|
DWORD dwDevGain;
|
|
} GLOBALJOYSTATE, *PGLOBALJOYSTATE;
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @struct SHAREDOBJECTHEADER |
|
|
*
|
|
* A simple header comes in front of the array of objects.
|
|
*
|
|
* WARNING! This structure may not change between DEBUG and
|
|
* RETAIL. Otherwise, you have problems if one DirectInput
|
|
* app is using DEBUG and another is using RETAIL.
|
|
*
|
|
* The global <c g_gsop> variable points to one of these things,
|
|
* suitably cast.
|
|
*
|
|
* @field int | cso |
|
|
*
|
|
* Number of <t SHAREDOBJECT>s currently in use. The array
|
|
* is kept packed for simplicity.
|
|
*
|
|
* @field DWORD | dwSequence |
|
|
*
|
|
* Global sequence number used during data collection.
|
|
* (Not used if we have a VxD to manage a "really global"
|
|
* sequence number.)
|
|
*
|
|
* @field int | cguid |
|
|
*
|
|
* Unique integer for GUID generation.
|
|
*
|
|
* @field DWORD | rgdwJoy[cMaxJoy] |
|
|
*
|
|
* Counter used to keep track of how many times each joystick's
|
|
* force feedback driver has been reset. This is used to make
|
|
* sure that nobody messes with a joystick that they don't own.
|
|
*
|
|
* Each time the joystick is reset, the corresponding counter
|
|
* is incremented. Before we do anything to a device, we check
|
|
* if the reset counter matches the value stored in the
|
|
* object. If not, then it means that the device has been
|
|
* reset in the meantime and no longer belongs to the caller.
|
|
*
|
|
* Note! We support up to 16 joysticks. Hope that'll be enough
|
|
* for a while.
|
|
*
|
|
* @field GLOBALJOYSTATE | rggjs[cMaxJoy] |
|
|
*
|
|
* Global settings for each joystick.
|
|
*
|
|
* @field DWORD | tmConfigChanged
|
|
*
|
|
* The tick count of last config changed.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
#define cJoyMax 16 /* Up to 16 joysticks */
|
|
typedef struct SHAREDOBJECTHEADER
|
|
{
|
|
int cso;
|
|
DWORD dwSequence;
|
|
int cguid;
|
|
GLOBALJOYSTATE rggjs[cJoyMax];
|
|
DWORD tmConfigChanged;
|
|
} SHAREDOBJECTHEADER, *PSHAREDOBJECTHEADER;
|
|
|
|
#define g_psoh ((PSHAREDOBJECTHEADER)g_psop)
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @topic The Worker Thread |
|
|
*
|
|
* Some emulation behaviors (low-level hooks, HID) require
|
|
* a worker thread to do the data collection. We multiplex
|
|
* all such work onto a single worker thread (known as
|
|
* simple "the" worker thread).
|
|
*
|
|
* The thread is spun up when the first client needs it
|
|
* and is taken down when the last client has been released.
|
|
*
|
|
* To prevent race conditions from crashing us, we addref
|
|
* our DLL when the thread exists and have the thread
|
|
* perform a FreeLibrary as its final act.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
#if defined(USE_SLOW_LL_HOOKS) || defined(HID_SUPPORT)
|
|
#define WORKER_THREAD
|
|
#endif
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* diem.c - Emulation
|
|
*
|
|
*****************************************************************************/
|
|
|
|
HRESULT EXTERNAL CEm_AcquireInstance(PVXDINSTANCE *ppvi);
|
|
HRESULT EXTERNAL CEm_UnacquireInstance(PVXDINSTANCE *ppvi);
|
|
HRESULT EXTERNAL CEm_SetBufferSize(PVXDDWORDDATA pvdd);
|
|
HRESULT EXTERNAL CEm_DestroyInstance(PVXDINSTANCE *ppvi);
|
|
|
|
HRESULT EXTERNAL CEm_SetDataFormat(PVXDDATAFORMAT pvdf);
|
|
|
|
HRESULT EXTERNAL CEm_Mouse_CreateInstance(PVXDDEVICEFORMAT pdevf,
|
|
PVXDINSTANCE *ppviOut);
|
|
|
|
HRESULT EXTERNAL CEm_Mouse_InitButtons(PVXDDWORDDATA pvdd);
|
|
|
|
HRESULT EXTERNAL CEm_Kbd_CreateInstance(PVXDDEVICEFORMAT pdevf,
|
|
PVXDINSTANCE *ppviOut);
|
|
|
|
HRESULT EXTERNAL CEm_Kbd_InitKeys(PVXDDWORDDATA pvdd);
|
|
|
|
HRESULT EXTERNAL CEm_Joy_CreateInstance(PVXDDEVICEFORMAT pdevf,
|
|
PVXDINSTANCE *ppviOut);
|
|
|
|
HRESULT EXTERNAL CEm_Joy_Ping(PVXDINSTANCE *ppvi);
|
|
|
|
HRESULT EXTERNAL CEm_HID_CreateInstance(PVXDDEVICEFORMAT pdevf,
|
|
PVXDINSTANCE *ppviOut);
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* diemm.c - Mouse Emulation
|
|
*
|
|
*****************************************************************************/
|
|
|
|
void EXTERNAL CEm_Mouse_AddState(LPDIMOUSESTATE_INT pms, DWORD tm);
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* dinput.c - Basic DLL stuff
|
|
*
|
|
*****************************************************************************/
|
|
|
|
void EXTERNAL DllEnterCrit_(LPCTSTR lptszFile, UINT line);
|
|
void EXTERNAL DllLeaveCrit_(LPCTSTR lptszFile, UINT line);
|
|
|
|
#ifdef DEBUG
|
|
BOOL EXTERNAL DllInCrit(void);
|
|
#define DllEnterCrit() DllEnterCrit_(TEXT(__FILE__), __LINE__)
|
|
#define DllLeaveCrit() DllLeaveCrit_(TEXT(__FILE__), __LINE__)
|
|
#else
|
|
#define DllEnterCrit() DllEnterCrit_(NULL, 0x0)
|
|
#define DllLeaveCrit() DllLeaveCrit_(NULL, 0x0)
|
|
#endif
|
|
|
|
void EXTERNAL DllAddRef(void);
|
|
void EXTERNAL DllRelease(void);
|
|
|
|
void EXTERNAL DllLoadLibrary(void);
|
|
void EXTERNAL DllFreeLibrary(void);
|
|
|
|
#ifdef DEBUG
|
|
|
|
extern UINT g_thidCrit;
|
|
|
|
#define InCrit() (g_thidCrit == GetCurrentThreadId())
|
|
|
|
#endif
|
|
|
|
/*
|
|
* Describes the CLSIDs we provide to OLE.
|
|
*/
|
|
|
|
typedef STDMETHOD(CREATEFUNC)(PUNK punkOuter, RIID riid, PPV ppvOut);
|
|
|
|
typedef struct CLSIDMAP
|
|
{
|
|
REFCLSID rclsid; /* The clsid */
|
|
CREATEFUNC pfnCreate; /* How to create it */
|
|
UINT ids; /* String that describes it */
|
|
} CLSIDMAP, *PCLSIDMAP;
|
|
|
|
#ifdef DEBUG
|
|
#define DEMONSTRATION_FFDRIVER
|
|
#define cclsidmap 3 /* DirectInput, DirectInputDevice, DIEffectDiver */
|
|
#else
|
|
#define cclsidmap 2 /* CLSID_DirectInput, CLSID_DirectInputDevice */
|
|
#endif
|
|
|
|
extern CLSIDMAP c_rgclsidmap[cclsidmap];
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* dicf.c - IClassFactory implementation
|
|
*
|
|
*****************************************************************************/
|
|
|
|
STDMETHODIMP CDIFactory_New(CREATEFUNC pfnCreate, RIID riid, PPV ppvObj);
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* didenum.c - IDirectInput device enumeration
|
|
*
|
|
*****************************************************************************/
|
|
|
|
typedef struct CDIDEnum CDIDEnum;
|
|
|
|
extern GUID rgGUID_Joystick[cJoyMax];
|
|
|
|
#define GUID_Joystick (rgGUID_Joystick[0])
|
|
|
|
void EXTERNAL CDIDEnum_Release(CDIDEnum *pde);
|
|
STDMETHODIMP CDIDEnum_Next(CDIDEnum *pde, LPDIDEVICEINSTANCEW pddiW);
|
|
STDMETHODIMP
|
|
CDIDEnum_New(PDIW pdiW, DWORD dwDevType, DWORD edfl, DWORD dwVer, CDIDEnum **);
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* diobj.c - IDirectInput implementation
|
|
*
|
|
*****************************************************************************/
|
|
|
|
HRESULT EXTERNAL CDIObj_TestDeviceFlags(PDIDW pdidW, DWORD diedfl);
|
|
HRESULT EXTERNAL CDIObj_FindDeviceInternal(LPCTSTR ptszName, LPGUID pguidOut);
|
|
|
|
STDMETHODIMP CDIObj_New(PUNK punkOuter, RIID riid, PPV ppvOut);
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* diaddhw.c - AddNewHardware
|
|
*
|
|
*****************************************************************************/
|
|
|
|
HRESULT EXTERNAL AddNewHardware(HWND hwnd, REFGUID rguid);
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* dijoycfg.c - IDirectInputJoyConfig implementation
|
|
*
|
|
*****************************************************************************/
|
|
|
|
STDMETHODIMP CJoyCfg_New(PUNK punkOuter, RIID riid, PPV ppvOut);
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INLINE
|
|
*
|
|
* @method BOOL | IsWriteSam |
|
|
*
|
|
* Nonzero if the registry security access mask will
|
|
* obtain (or attempt to obtain) write access.
|
|
*
|
|
* @parm REGSAM | regsam |
|
|
*
|
|
* Registry security access mask.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
BOOL INLINE
|
|
IsWriteSam(REGSAM sam)
|
|
{
|
|
return sam & (KEY_SET_VALUE | KEY_CREATE_SUB_KEY | MAXIMUM_ALLOWED);
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* dijoyreg.c - Joystick registry services
|
|
*
|
|
*****************************************************************************/
|
|
extern LPCWSTR c_rghwIdPredef[];
|
|
|
|
STDMETHODIMP JoyReg_OpenTypeKey(LPCWSTR pwszType, DWORD sam, DWORD dwOptions, PHKEY phk);
|
|
STDMETHODIMP JoyReg_OpenFFKey(HKEY hkType, REGSAM sam, PHKEY phk);
|
|
|
|
STDMETHODIMP
|
|
JoyReg_OpenConfigKey(UINT idJoy, DWORD sam, PJOYCAPS pcaps, DWORD dwOptions, PHKEY phk);
|
|
|
|
STDMETHODIMP JoyReg_OpenPropKey(LPCWSTR pwszType, DWORD sam, DWORD dwOptions, PHKEY phk);
|
|
|
|
STDMETHODIMP JoyReg_GetTypeInfo(LPCWSTR pwszType,
|
|
LPDIJOYTYPEINFO pjti, DWORD fl);
|
|
STDMETHODIMP JoyReg_SetTypeInfo(HKEY hkTypesW, LPCWSTR pwszType,
|
|
LPCDIJOYTYPEINFO pjti, DWORD fl);
|
|
|
|
STDMETHODIMP JoyReg_GetConfig(UINT idJoy, PJOYCAPS pcaps,
|
|
LPDIJOYCONFIG pcfg, DWORD fl);
|
|
STDMETHODIMP JoyReg_SetConfig(UINT idJoy, LPJOYREGHWCONFIG phwc,
|
|
LPCDIJOYCONFIG pcfg, DWORD fl);
|
|
|
|
STDMETHODIMP JoyReg_GetUserValues(LPDIJOYUSERVALUES pjuv, DWORD fl);
|
|
STDMETHODIMP JoyReg_SetUserValues(LPCDIJOYUSERVALUES pjuv, DWORD fl);
|
|
|
|
|
|
STDMETHODIMP
|
|
JoyReg_GetSetConfigValue(HKEY hk, LPCTSTR ptszNValue, UINT idJoy,
|
|
DWORD reg, PV pvBuf, DWORD cb, BOOL fSet);
|
|
|
|
#define GSCV_GET 0
|
|
#define GSCV_SET 1
|
|
|
|
#define JoyReg_GetConfigValue(hk, ptsz, id, reg, pv, cb) \
|
|
JoyReg_GetSetConfigValue(hk, ptsz, id, reg, pv, cb, GSCV_GET)
|
|
|
|
#define JoyReg_SetConfigValue(hk, ptsz, id, reg, pv, cb) \
|
|
JoyReg_GetSetConfigValue(hk, ptsz, id, reg, (PV)(pv), cb, GSCV_SET)
|
|
|
|
|
|
STDMETHODIMP
|
|
JoyReg_GetValue(HKEY hk, LPCTSTR ptszValue, DWORD reg, PV pvBuf, DWORD cb);
|
|
|
|
STDMETHODIMP
|
|
JoyReg_IsWdmGameport(HKEY hk);
|
|
|
|
#if 0
|
|
STDMETHODIMP
|
|
JoyReg_IsWdmGameportFromDeviceInstance( LPTSTR ptszDeviceInst );
|
|
#endif
|
|
|
|
STDMETHODIMP
|
|
JoyReg_SetValue(HKEY hk, LPCTSTR ptszValue, DWORD reg, PCV pvBuf, DWORD cb);
|
|
|
|
LPSTR EXTERNAL
|
|
JoyReg_JoyIdToDeviceInterface_95(UINT idJoy, PVXDINITPARMS pvip, LPSTR ptszBuf);
|
|
|
|
HRESULT EXTERNAL
|
|
JoyReg_GetPredefTypeInfo(LPCWSTR pwszType, LPDIJOYTYPEINFO pjti, DWORD fl);
|
|
|
|
HRESULT EXTERNAL
|
|
hResIdJoypInstanceGUID_95( UINT idJoy, LPGUID lpguid);
|
|
|
|
HRESULT EXTERNAL
|
|
hResIdJoypInstanceGUID_WDM( UINT idJoy, LPGUID lpguid);
|
|
|
|
#if 0
|
|
HRESULT EXTERNAL JoyReg_GetIDByOemName( LPTSTR szOemName, PUINT pId );
|
|
#endif
|
|
/*****************************************************************************
|
|
*
|
|
* didev.c - IDirectInputDevice implementation
|
|
*
|
|
*****************************************************************************/
|
|
|
|
STDMETHODIMP CDIDev_New(PUNK punkOuter, RIID riid, PPV ppvObj);
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* CDIDev_Enter/LeaveCrit are secret backdoors to allow emulation
|
|
* and effects
|
|
* to take the device critical section when updating buffers.
|
|
*
|
|
* CDIDev_InCrit is used for assertion checking.
|
|
*
|
|
* CDIDev_IsExclAcquired is used by effects to make sure the parent
|
|
* is acquired for exclusive before attempting to download.
|
|
*
|
|
* CDIDev_SyncShepHandle is used to get the joystick "tag" which
|
|
* is used by dieshep.c to determine who owns the joystick.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
void EXTERNAL CDIDev_EnterCrit_(struct CDIDev *this, LPCTSTR lptszFile, UINT line);
|
|
void EXTERNAL CDIDev_LeaveCrit_(struct CDIDev *this, LPCTSTR lptszFile, UINT line);
|
|
|
|
#ifdef DEBUG
|
|
BOOL INTERNAL CDIDev_InCrit(struct CDIDev *this);
|
|
#define CDIDev_EnterCrit(cdidev) CDIDev_EnterCrit_(cdidev, TEXT(__FILE__), __LINE__)
|
|
#define CDIDev_LeaveCrit(cdidev) CDIDev_LeaveCrit_(cdidev, TEXT(__FILE__), __LINE__)
|
|
#else
|
|
#define CDIDev_EnterCrit(cdidev) CDIDev_EnterCrit_(cdidev, NULL, 0x0);
|
|
#define CDIDev_LeaveCrit(cdidev) CDIDev_LeaveCrit_(cdidev, NULL, 0x0);
|
|
#endif
|
|
|
|
#ifndef XDEBUG
|
|
|
|
#define CDIDev_IsExclAcquired_(pdd, z) \
|
|
_CDiDev_IsExclAcquired_(pdd) \
|
|
|
|
#endif
|
|
|
|
STDMETHODIMP CDIDev_IsExclAcquired_(struct CDIDev *this, LPCSTR s_szProc);
|
|
|
|
#define CDIDev_IsExclAcquired(pdd) \
|
|
CDIDev_IsExclAcquired_(pdd, s_szProc) \
|
|
|
|
|
|
STDMETHODIMP CDIDev_SyncShepHandle(struct CDIDev *this, PSHEPHANDLE psh);
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* CDIDev_SetNotifyEvent is used by the emulation code to
|
|
* notify the application when the state of the device changes.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
void EXTERNAL CDIDev_SetNotifyEvent(struct CDIDev *this);
|
|
void EXTERNAL CDIDev_SetForcedUnacquiredFlag(struct CDIDev *this);
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* CDIDev_NotifyCreate/DestroyEvent is used by CDIEff to
|
|
* let the parent know when a child effect comes or goes.
|
|
*
|
|
* CDIDev_FindEffectGUID is used by CDIEff to convert an
|
|
* effect GUID into an effect cookie dword.
|
|
*
|
|
* CDIDev_ConvertObjects converts item identifiers in various ways.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
HRESULT EXTERNAL
|
|
CDIDev_NotifyCreateEffect(struct CDIDev *this, struct CDIEff *pdeff);
|
|
HRESULT EXTERNAL
|
|
CDIDev_NotifyDestroyEffect(struct CDIDev *this, struct CDIEff *pdeff);
|
|
|
|
#ifdef IDirectInputDevice2Vtbl
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @struct EFFECTMAPINFO |
|
|
*
|
|
* Information about an effect, much like a
|
|
* <t DIEFFECTINFO>, but containing the
|
|
* effect ID, too.
|
|
*
|
|
* @field DWORD | dwId |
|
|
*
|
|
* The effect ID. This comes first so we can copy
|
|
* an <t EFFECTMAPINFO> into a <t DIEFFECTINFO>
|
|
* all at one go.
|
|
*
|
|
* @field GUID | guid |
|
|
*
|
|
* The effect GUID.
|
|
*
|
|
* @field DWORD | dwEffType |
|
|
*
|
|
* The effect type and flags.
|
|
*
|
|
* @field WCHAR | wszName[MAX_PATH] |
|
|
*
|
|
* The name for the effect.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
typedef struct EFFECTMAPINFO
|
|
{
|
|
DIEFFECTATTRIBUTES attr;
|
|
GUID guid;
|
|
WCHAR wszName[MAX_PATH];
|
|
} EFFECTMAPINFO, *PEFFECTMAPINFO;
|
|
typedef const EFFECTMAPINFO *PCEFFECTMAPINFO;
|
|
|
|
#ifndef XDEBUG
|
|
|
|
#define CDIDev_FindEffectGUID_(this, rguid, pemi, z, i) \
|
|
_CDIDev_FindEffectGUID_(this, rguid, pemi) \
|
|
|
|
#endif
|
|
|
|
#define CDIDev_FindEffectGUID(this, rguid, pemi, iarg) \
|
|
CDIDev_FindEffectGUID_(this, rguid, pemi, s_szProc, iarg) \
|
|
|
|
|
|
STDMETHODIMP
|
|
CDIDev_FindEffectGUID_(struct CDIDev *this, REFGUID rguid,
|
|
PEFFECTMAPINFO pemi, LPCSTR s_szProc, int iarg);
|
|
|
|
STDMETHODIMP
|
|
CDIDev_ConvertObjects(struct CDIDev *this, UINT cdw, LPDWORD rgdw, UINT fl);
|
|
|
|
/*
|
|
* Note that the bonus DEVCO flags live inside the DIDFT_INSTANCEMASK.
|
|
*/
|
|
#define DEVCO_AXIS DIDFT_AXIS
|
|
#define DEVCO_BUTTON DIDFT_BUTTON
|
|
#define DEVCO_TYPEMASK DIDFT_TYPEMASK
|
|
|
|
#define DEVCO_FFACTUATOR DIDFT_FFACTUATOR
|
|
#define DEVCO_FFEFFECTTRIGGER DIDFT_FFEFFECTTRIGGER
|
|
#define DEVCO_ATTRMASK DIDFT_ATTRMASK
|
|
|
|
#define DEVCO_FROMID 0x00000100
|
|
#define DEVCO_FROMOFFSET 0x00000200
|
|
#define DEVCO_FROMMASK 0x00000300
|
|
#define DEVCO_TOID 0x00001000
|
|
#define DEVCO_TOOFFSET 0x00002000
|
|
#define DEVCO_TOMASK 0x00003000
|
|
|
|
|
|
#if ((DEVCO_FROMMASK | DEVCO_TOMASK) & DIDFT_INSTANCEMASK) != \
|
|
(DEVCO_FROMMASK | DEVCO_TOMASK)
|
|
#error DEVCO_FROMMASK and DEVCI_TOMASK should not escape DIDFT_INSTANCEMASK.
|
|
#endif
|
|
|
|
#define DEVCO_VALID (DEVCO_TYPEMASK | \
|
|
DEVCO_ATTRMASK | \
|
|
DEVCO_FROMMASK | \
|
|
DEVCO_TOMASK)
|
|
|
|
#endif
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* dieffv.c - IDirectInputEffectDriver for VJoyD joysticks
|
|
*
|
|
*****************************************************************************/
|
|
|
|
STDMETHODIMP CEffVxd_New(PUNK punkOuter, RIID riid, PPV ppvOut);
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* dieshep.c - IDirectInputEffectShepherd
|
|
*
|
|
*****************************************************************************/
|
|
|
|
STDMETHODIMP CEShep_New(HKEY hk, PUNK punkOuter, RIID riid, PPV ppvOut);
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* digendef.c - Default IDirectInputDeviceCallback
|
|
*
|
|
*****************************************************************************/
|
|
|
|
/*
|
|
* We can't call it a DCB because winbase.h already has one for
|
|
* comm goo.
|
|
*/
|
|
|
|
typedef IDirectInputDeviceCallback DICB, *PDICB;
|
|
|
|
STDMETHODIMP
|
|
CDefDcb_Acquire(PDICB pdcb);
|
|
|
|
STDMETHODIMP
|
|
CDefDcb_Unacquire(PDICB pdcb);
|
|
|
|
STDMETHODIMP
|
|
CDefDcb_GetProperty(PDICB pdcb, LPCDIPROPINFO ppropi, LPDIPROPHEADER pdiph);
|
|
|
|
STDMETHODIMP
|
|
CDefDcb_SetProperty(PDICB pdcb, LPCDIPROPINFO ppropi, LPCDIPROPHEADER pdiph);
|
|
|
|
STDMETHODIMP
|
|
CDefDcb_SetEventNotification(PDICB pdcb, HANDLE h);
|
|
|
|
STDMETHODIMP
|
|
CDefDcb_SetCooperativeLevel(PDICB pdcb, HWND hwnd, DWORD dwFlags);
|
|
|
|
STDMETHODIMP
|
|
CDefDcb_CookDeviceData(PDICB pdcb, UINT cdod, LPDIDEVICEOBJECTDATA rgdod);
|
|
|
|
STDMETHODIMP
|
|
CDefDcb_CreateEffect(PDICB pdcb, LPDIRECTINPUTEFFECTSHEPHERD *ppes);
|
|
|
|
STDMETHODIMP
|
|
CDefDcb_GetFFConfigKey(PDICB pdcb, DWORD sam, PHKEY phk);
|
|
|
|
STDMETHODIMP
|
|
CDefDcb_SendDeviceData(PDICB pdcb, LPCDIDEVICEOBJECTDATA rgdod,
|
|
LPDWORD pdwInOut, DWORD fl);
|
|
|
|
STDMETHODIMP
|
|
CDefDcb_Poll(IDirectInputDeviceCallback *pdcb);
|
|
|
|
STDMETHODIMP
|
|
CDefDcb_GetVersions(IDirectInputDeviceCallback *pdcb, LPDIDRIVERVERSIONS pvers);
|
|
|
|
STDMETHODIMP
|
|
CDefDcb_MapUsage(IDirectInputDeviceCallback *pdcb, DWORD dwUsage, PINT piOut);
|
|
|
|
STDMETHODIMP_(DWORD)
|
|
CDefDcb_GetUsage(IDirectInputDeviceCallback *pdcb, int iobj);
|
|
|
|
STDMETHODIMP
|
|
CDefDcb_SetDIData(PDICB pdcb, DWORD dwVer, LPVOID lpdihacks);
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* digenx.c - IDirectInputDeviceCallback that does nothing
|
|
*
|
|
*****************************************************************************/
|
|
|
|
extern IDirectInputDeviceCallback c_dcbNil;
|
|
|
|
#define c_pdcbNil &c_dcbNil
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* digenm.c - IDirectInputDeviceCallback for mouse
|
|
*
|
|
*****************************************************************************/
|
|
|
|
STDMETHODIMP CMouse_New(PUNK punkOuter, REFGUID rguid, RIID riid, PPV ppvOut);
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* digenk.c - IDirectInputDeviceCallback for keyboard
|
|
*
|
|
*****************************************************************************/
|
|
|
|
STDMETHODIMP CKbd_New(PUNK punkOuter, REFGUID rguid, RIID riid, PPV ppvOut);
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* digenj.c - IDirectInputDeviceCallback for joystick
|
|
*
|
|
*****************************************************************************/
|
|
|
|
STDMETHODIMP CJoy_New(PUNK punkOuter, REFGUID rguid, RIID riid, PPV ppvOut);
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func UINT | ibJoyPosAxisFromPosAxis |
|
|
*
|
|
* Returns the offset of the <p iAxis>'th joystick axis
|
|
* in the <t JOYPOS> structure.
|
|
*
|
|
* @parm UINT | uiAxis |
|
|
*
|
|
* The index of the requested axis. X, Y, Z, R, U and V are
|
|
* respctively zero through five.
|
|
*
|
|
* @returns
|
|
*
|
|
* The offset relative to the structure.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
#define _ibJoyPosAxisFromPosAxis(uiAxis) \
|
|
(FIELD_OFFSET(JOYPOS, dwX) + cbX(DWORD) * (uiAxis))
|
|
|
|
UINT INLINE
|
|
ibJoyPosAxisFromPosAxis(UINT uiPosAxis)
|
|
{
|
|
#define CheckAxis(x) \
|
|
CAssertF(_ibJoyPosAxisFromPosAxis(iJoyPosAxis##x) \
|
|
== FIELD_OFFSET(JOYPOS, dw##x)) \
|
|
|
|
CheckAxis(X);
|
|
CheckAxis(Y);
|
|
CheckAxis(Z);
|
|
CheckAxis(R);
|
|
CheckAxis(U);
|
|
CheckAxis(V);
|
|
|
|
#undef CheckAxis
|
|
|
|
return _ibJoyPosAxisFromPosAxis(uiPosAxis);
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* dieffj.c - Dummy IDirectInputEffectDriver for joystick
|
|
*
|
|
*****************************************************************************/
|
|
|
|
STDMETHODIMP CJoyEff_New(PUNK punkOuter, RIID riid, PPV ppvOut);
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* dihid.c - IDirectInputDeviceCallback for generic HID devices
|
|
*
|
|
*****************************************************************************/
|
|
STDMETHODIMP CHid_New(PUNK punkOuter, REFGUID rguid, RIID riid, PPV ppvOut);
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* dieff.c - IDirectInputEffect implementation
|
|
*
|
|
*****************************************************************************/
|
|
|
|
STDMETHODIMP
|
|
CDIEff_New(struct CDIDev *pdev, LPDIRECTINPUTEFFECTSHEPHERD pes,
|
|
PUNK punkOuter, RIID riid, PPV ppvObj);
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* dihidusg.c - HID usage converters
|
|
*
|
|
*****************************************************************************/
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @struct HIDUSAGEMAP |
|
|
*
|
|
* This structure maps HID usages to GUIDs
|
|
* or legacy joystick axes.
|
|
*
|
|
* @field DWORD | dwUsage |
|
|
*
|
|
* Packed usage via <f DIMAKEUSAGEDWORD>.
|
|
*
|
|
* @field UINT | uiPosAxis |
|
|
*
|
|
* <t JOYPOS> axis number, where 0 = X, 1 = Y, ..., 5 = V.
|
|
*
|
|
* @field PCGUID | pguid |
|
|
*
|
|
* Corresponding <t GUID>.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
typedef struct HIDUSAGEMAP
|
|
{
|
|
|
|
DWORD dwUsage;
|
|
UINT uiPosAxis;
|
|
PCGUID pguid;
|
|
|
|
} HIDUSAGEMAP, *PHIDUSAGEMAP;
|
|
|
|
PHIDUSAGEMAP EXTERNAL UsageToUsageMap(DWORD dwUsage);
|
|
|
|
DWORD EXTERNAL GuidToUsage(PCGUID pguid);
|
|
|
|
UINT EXTERNAL
|
|
GetHIDString(DWORD Usage, DWORD UsagePage, LPWSTR pwszBuf, UINT cwch);
|
|
|
|
void EXTERNAL InsertCollectionNumber(UINT icoll, LPWSTR pwszBuf);
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* disubcls.c - Subclassing
|
|
*
|
|
*****************************************************************************/
|
|
|
|
typedef LRESULT
|
|
(CALLBACK *SUBCLASSPROC)(HWND hwnd, UINT wm, WPARAM wp,
|
|
LPARAM lp, UINT_PTR uId, ULONG_PTR dwRef);
|
|
|
|
BOOL EXTERNAL
|
|
SetWindowSubclass(HWND hwnd, SUBCLASSPROC pfnSubclass, UINT_PTR uId, ULONG_PTR dwRef);
|
|
|
|
BOOL EXTERNAL
|
|
GetWindowSubclass(HWND hwnd, SUBCLASSPROC pfnSubclass, UINT_PTR uId, ULONG_PTR *pdwRef);
|
|
|
|
BOOL EXTERNAL
|
|
RemoveWindowSubclass(HWND hwnd, SUBCLASSPROC pfnSubclass, UINT_PTR uId);
|
|
|
|
LRESULT EXTERNAL
|
|
DefSubclassProc(HWND hwnd, UINT wm, WPARAM wp, LPARAM lp);
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* dical.c - Axis ramps and calibration
|
|
*
|
|
* Structure names begin with "Joy" for historical reasons.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
#if defined(_X86_)
|
|
|
|
LONG EXTERNAL CCal_MulDiv(LONG lA, LONG lB, LONG lC);
|
|
|
|
#else
|
|
|
|
#define CCal_MulDiv MulDiv
|
|
|
|
#endif
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @struct JOYRAMP |
|
|
*
|
|
* Parameters for a "ramp". A ramp looks like this:
|
|
*
|
|
* r !
|
|
* e dy - *---
|
|
* t ! /
|
|
* u ! /
|
|
* r ! /
|
|
* n y ---*
|
|
* e !
|
|
* d +--!---!---
|
|
* x dx
|
|
*
|
|
* physical position
|
|
*
|
|
*
|
|
* y, dy = baseline and height
|
|
*
|
|
* x, dx = initiation level and width
|
|
*
|
|
* The mapping is
|
|
*
|
|
*
|
|
* (-infty, x ] -> y
|
|
* (x, x+dx ) -> (y, y+dy)
|
|
* [x+dx, infty) -> y+dy
|
|
*
|
|
* It is very important that the middle range not be taken
|
|
* if dx = 0.
|
|
*
|
|
* @field int | x |
|
|
*
|
|
* Horizontal value below which we return the baseline.
|
|
*
|
|
* @field DWORD | dx |
|
|
*
|
|
* Width of the ramp. Beyond this point, we return the
|
|
* full height.
|
|
*
|
|
* @field int | y |
|
|
*
|
|
* Baseline.
|
|
*
|
|
* @field int | dy |
|
|
*
|
|
* Total height.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
typedef struct JOYRAMP
|
|
{
|
|
|
|
int x;
|
|
int y;
|
|
DWORD dx;
|
|
int dy;
|
|
|
|
} JOYRAMP, *PJOYRAMP;
|
|
|
|
typedef const JOYRAMP *PCJOYRAMP;
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @struct JOYRANGECONVERT |
|
|
*
|
|
* Parameters for range conversion.
|
|
*
|
|
* The conversion curve is in five sections.
|
|
*
|
|
*
|
|
*
|
|
* !
|
|
* lmax- *----
|
|
* r ! /
|
|
* e ! /
|
|
* t ! /
|
|
* u lc- *------*
|
|
* r ! /
|
|
* n ! /
|
|
* e ! /
|
|
* d lmin-------*
|
|
* !
|
|
* +-!----!---!------!----!----!--
|
|
* pmin smin dmin dmax smax pmax
|
|
*
|
|
* !
|
|
* pc
|
|
*
|
|
*
|
|
* physical position
|
|
*
|
|
*
|
|
* lmin/lmax = logical min/max - This is the smallest/largest
|
|
* position the app will ever see.
|
|
*
|
|
* lc = logical center
|
|
*
|
|
* pmin/pmax = physical min/max - This is the position determined by
|
|
* calibration to be the value which the hardware reports
|
|
* when the device is physically at its bottom/upper limit. Note
|
|
* that the hardware might report values outside this range.
|
|
*
|
|
* pc = physical center - This is the nominal neutral location for
|
|
* the axis
|
|
*
|
|
* dmin/dmax = dead zone min/max - This is the zone around which
|
|
* the center is artificially expanded.
|
|
*
|
|
* smin/smax = saturation min/max - This is the level at which
|
|
* we treat the axis as being at its most extreme position.
|
|
*
|
|
* @field BOOL | fRaw |
|
|
*
|
|
* Is the axis in raw mode? If so, then no cooking is performed.
|
|
*
|
|
* @field JOYRAMP | rmpLow |
|
|
*
|
|
* The ramp for below-center.
|
|
*
|
|
* @field JOYRAMP | rmpHigh |
|
|
*
|
|
* The ramp for above-center.
|
|
*
|
|
* @field DWORD | dwPmin |
|
|
*
|
|
* Physical minimum.
|
|
*
|
|
* @field DWORD | dwPmax |
|
|
*
|
|
* Physical maximum.
|
|
*
|
|
* @field LONG | lMin |
|
|
*
|
|
* Logical minimum.
|
|
*
|
|
* @field LONG | lCenter |
|
|
*
|
|
* Logical center.
|
|
*
|
|
* @field LONG | lMax |
|
|
*
|
|
* Logical maximum.
|
|
*
|
|
* @field DWORD | dwPc |
|
|
*
|
|
* Physical center.
|
|
*
|
|
* @field DWORD | dwDz |
|
|
*
|
|
* Dead zone (in ten thousandths, 10000 = 100%).
|
|
*
|
|
* @field DWORD | dwSat |
|
|
*
|
|
* Saturation level (in ten thousands, 10000 = 100%).
|
|
*
|
|
* @field BOOL | fPolledPOV |
|
|
*
|
|
* Whether the axis is a polled POV. Usable only when the axis is a POV.
|
|
*
|
|
* @field LONG | lMinPOV[5] |
|
|
*
|
|
* Mininum ranges of POV directions. Usable only when the axis is a POV.
|
|
*
|
|
* @field LONG | lMaxPOV[5] |
|
|
*
|
|
* Maxinum ranges of POV directions. Usable only when the axis is a POV.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
/*
|
|
* Number of range divisions. We work in ten thousandths.
|
|
*/
|
|
#define RANGEDIVISIONS 10000
|
|
|
|
typedef struct JOYRANGECONVERT
|
|
{
|
|
BOOL fRaw;
|
|
|
|
JOYRAMP rmpLow;
|
|
JOYRAMP rmpHigh;
|
|
|
|
DWORD dwPmin;
|
|
DWORD dwPmax;
|
|
DWORD dwPc;
|
|
LONG lMin;
|
|
LONG lMax;
|
|
LONG lC;
|
|
DWORD dwDz;
|
|
DWORD dwSat;
|
|
#ifdef WINNT
|
|
BOOL fFakeRaw;
|
|
BOOL fPolledPOV;
|
|
LONG lMinPOV[5];
|
|
LONG lMaxPOV[5];
|
|
#endif
|
|
|
|
} JOYRANGECONVERT, *PJOYRANGECONVERT;
|
|
|
|
typedef const JOYRANGECONVERT *PCJOYRANGECONVERT;
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* dical.c functions
|
|
*
|
|
*****************************************************************************/
|
|
|
|
void EXTERNAL CCal_CookRange(PJOYRANGECONVERT this, LONG UNALIGNED *pl);
|
|
void EXTERNAL CCal_RecalcRange(PJOYRANGECONVERT this);
|
|
|
|
STDMETHODIMP
|
|
CCal_GetProperty(PJOYRANGECONVERT this, REFGUID rguid, LPDIPROPHEADER pdiph, DWORD dwVersion);
|
|
|
|
STDMETHODIMP
|
|
CCal_SetProperty(PJOYRANGECONVERT this, LPCDIPROPINFO ppropi,
|
|
LPCDIPROPHEADER pdiph, HKEY hkType, DWORD dwVersion);
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func LONG | CCal_Midpoint |
|
|
*
|
|
* Return the midpoint of two values. Note, however, that
|
|
* we round <y upward> instead of downward. This is important,
|
|
* because many people set the ranges to something like
|
|
* 0 .. 0xFFFF, and we want the midpoint to be 0x8000.
|
|
*
|
|
* Care must be taken that the intermediate sum does not overflow.
|
|
*
|
|
* @parm LONG | lMin |
|
|
*
|
|
* Lower limit.
|
|
*
|
|
* @parm LONG | lMax |
|
|
*
|
|
* Upper limit.
|
|
*
|
|
* @returns
|
|
*
|
|
* The midpoint.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
LONG INLINE
|
|
CCal_Midpoint(LONG lMin, LONG lMax)
|
|
{
|
|
/*
|
|
* Can't do "lMax + lMin" because that might overflow.
|
|
*/
|
|
AssertF(lMax >= lMin);
|
|
return lMin + (UINT)(lMax - lMin + 1) / 2;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* dijoytyp.c
|
|
*
|
|
*****************************************************************************/
|
|
|
|
STDMETHODIMP CType_OpenIdSubkey(HKEY, DWORD, REGSAM, PHKEY);
|
|
void EXTERNAL CType_RegGetObjectInfo(HKEY hkType, DWORD dwId,
|
|
LPDIDEVICEOBJECTINSTANCEW pdidoiW);
|
|
void EXTERNAL CType_RegGetTypeInfo(HKEY hkType, LPDIOBJECTDATAFORMAT podf, BOOL bHid);
|
|
void EXTERNAL CType_MakeGameCtrlName(PWCHAR wszOutput, DWORD dwDevType,
|
|
DWORD dwAxes, DWORD dwButtons, DWORD dwPOVs );
|
|
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* diaphack.c
|
|
*
|
|
*****************************************************************************/
|
|
|
|
HRESULT EXTERNAL AhAppRegister(DWORD dwVer);
|
|
BOOL EXTERNAL AhGetAppHacks(LPDIAPPHACKS);
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* diraw.c
|
|
*
|
|
*****************************************************************************/
|
|
#ifdef USE_WM_INPUT
|
|
#define DIRAW_NONEXCL 0
|
|
#define DIRAW_EXCL 1
|
|
#define DIRAW_NOHOTKEYS 2
|
|
|
|
HRESULT CDIRaw_RegisterRawInputDevice( UINT uirim, DWORD dwOrd, HWND hwnd);
|
|
HRESULT CDIRaw_UnregisterRawInputDevice( UINT uirim, HWND hwnd );
|
|
BOOL CDIRaw_OnInput(MSG *pmsg);
|
|
HRESULT INTERNAL CDIRaw_Mouse_InitButtons();
|
|
int EXTERNAL DIRaw_GetKeyboardType(int nTypeFlag);
|
|
#endif
|
|
|
|
#ifdef __cplusplus
|
|
};
|
|
#endif
|