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.
1127 lines
33 KiB
1127 lines
33 KiB
//+-------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
//
|
|
// Copyright (C) Microsoft Corporation, 1998 - 1999
|
|
//
|
|
// File: dinputdeviceobj.cpp
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
// dDrawColorControlObj.cpp : Implementation of CDirectApp and DLL registration.
|
|
// DHF_DS entire file
|
|
|
|
#include "stdafx.h"
|
|
#include "Direct.h"
|
|
#include "dms.h"
|
|
#include "dienumDeviceObjectsObj.h"
|
|
#include "dIEnumEffectsObj.h"
|
|
#include "dInputdeviceObj.h"
|
|
#include "dInputEffectObj.h"
|
|
#include "didevInstObj.h"
|
|
#include "didevObjInstObj.h"
|
|
|
|
|
|
//TODO move to typlib enum
|
|
#define dfDIKeyboard 1
|
|
#define dfDIMouse 2
|
|
#define dfDIJoystick 3
|
|
#define dfDIJoystick2 4
|
|
#define dfDIMouse2 5
|
|
|
|
extern HRESULT FixUpCoverEffect(GUID g, DIEFFECT_CDESC *cover,DIEFFECT *realEffect);
|
|
extern HRESULT FixUpRealEffect(GUID g,DIEFFECT *realEffect,DIEFFECT_CDESC *cover);
|
|
|
|
|
|
extern HRESULT DINPUTBSTRtoGUID(LPGUID pGuid,BSTR str);
|
|
extern BSTR DINPUTGUIDtoBSTR(LPGUID pg);
|
|
extern HRESULT FillRealActionFormat(DIACTIONFORMATW *real, DIACTIONFORMAT_CDESC *cover, SAFEARRAY **actionArray,long ActionCount );
|
|
#define SAFE_DELETE(p) { if(p) { delete (p); p=NULL; } }
|
|
|
|
HRESULT C_dxj_DirectInputDevice8Object::init()
|
|
{
|
|
nFormat=0;
|
|
return S_OK;
|
|
}
|
|
HRESULT C_dxj_DirectInputDevice8Object::cleanup()
|
|
{
|
|
return S_OK;
|
|
}
|
|
|
|
CONSTRUCTOR(_dxj_DirectInputDevice8, {init();});
|
|
DESTRUCTOR(_dxj_DirectInputDevice8, {cleanup();});
|
|
|
|
//NOTE get set for Device object
|
|
// must use QI to get at other objects.
|
|
GETSET_OBJECT(_dxj_DirectInputDevice8);
|
|
|
|
|
|
STDMETHODIMP C_dxj_DirectInputDevice8Object::getDeviceObjectsEnum(
|
|
/* [in] */ long flags,
|
|
/* [retval][out] */ I_dxj_DIEnumDeviceObjects **ppret)
|
|
{
|
|
HRESULT hr;
|
|
hr=C_dxj_DIEnumDeviceObjectsObject::create(m__dxj_DirectInputDevice8,flags,ppret);
|
|
return hr;
|
|
}
|
|
|
|
|
|
STDMETHODIMP C_dxj_DirectInputDevice8Object::acquire(){
|
|
return m__dxj_DirectInputDevice8->Acquire();
|
|
}
|
|
|
|
|
|
STDMETHODIMP C_dxj_DirectInputDevice8Object::getCapabilities(DIDEVCAPS_CDESC *caps)
|
|
{
|
|
//DIDevCaps same in VB/Java as in C
|
|
caps->lSize=sizeof(DIDEVCAPS);
|
|
HRESULT hr=m__dxj_DirectInputDevice8->GetCapabilities((DIDEVCAPS*)caps);
|
|
return hr;
|
|
}
|
|
|
|
//VB cant return sucess codes so we will return an error code
|
|
#define VB_DI_BUFFEROVERFLOW 0x80040260
|
|
|
|
|
|
STDMETHODIMP C_dxj_DirectInputDevice8Object::getDeviceData(
|
|
/* [in] */ SAFEARRAY __RPC_FAR * __RPC_FAR *deviceObjectDataArray,
|
|
/* [in] */ long flags,
|
|
long *ret)
|
|
|
|
{
|
|
HRESULT hr;
|
|
|
|
if ((*deviceObjectDataArray)->cDims!=1) return E_INVALIDARG;
|
|
if ((*deviceObjectDataArray)->cbElements!=sizeof(DIDEVICEOBJECTDATA)) return E_INVALIDARG;
|
|
|
|
DWORD dwC= (*deviceObjectDataArray)->rgsabound[0].cElements;
|
|
|
|
if (dwC==0) return E_INVALIDARG;
|
|
|
|
LPDIDEVICEOBJECTDATA pobjData=(LPDIDEVICEOBJECTDATA)((SAFEARRAY*)*deviceObjectDataArray)->pvData;
|
|
hr=m__dxj_DirectInputDevice8->GetDeviceData(sizeof(DIDEVICEOBJECTDATA), pobjData, (DWORD*)&dwC,flags);
|
|
|
|
*ret=dwC;
|
|
|
|
if (hr==DI_BUFFEROVERFLOW) hr= VB_DI_BUFFEROVERFLOW;
|
|
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
STDMETHODIMP C_dxj_DirectInputDevice8Object::getDeviceInfo(
|
|
/* [out] */ I_dxj_DirectInputDeviceInstance8 __RPC_FAR **info)
|
|
{
|
|
HRESULT hr;
|
|
|
|
|
|
DIDEVICEINSTANCEW inst;
|
|
ZeroMemory(&inst,sizeof(DIDEVICEINSTANCEW));
|
|
inst.dwSize=sizeof(DIDEVICEINSTANCEW);
|
|
|
|
hr=m__dxj_DirectInputDevice8->GetDeviceInfo(&inst);
|
|
if FAILED(hr) return hr;
|
|
|
|
hr=C_dxj_DIDeviceInstance8Object::create(&inst,info);
|
|
return hr;
|
|
|
|
|
|
}
|
|
|
|
STDMETHODIMP C_dxj_DirectInputDevice8Object::getDeviceStateKeyboard(
|
|
/* [out] */ DIKEYBOARDSTATE_CDESC __RPC_FAR *state)
|
|
{
|
|
HRESULT hr;
|
|
|
|
if ((nFormat!= dfDIKeyboard) && (nFormat!=-1)) return DIERR_NOTINITIALIZED ;
|
|
|
|
hr=m__dxj_DirectInputDevice8->GetDeviceState(256,(void*)state->key);
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
|
|
STDMETHODIMP C_dxj_DirectInputDevice8Object::getDeviceStateMouse(
|
|
/* [out] */ DIMOUSESTATE_CDESC __RPC_FAR *state)
|
|
{
|
|
HRESULT hr;
|
|
|
|
if ((nFormat!= dfDIMouse) && (nFormat!=-1)) return DIERR_NOTINITIALIZED;
|
|
|
|
hr=m__dxj_DirectInputDevice8->GetDeviceState(sizeof(DIMOUSESTATE),(void*)state);
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
STDMETHODIMP C_dxj_DirectInputDevice8Object::getDeviceStateMouse2(
|
|
/* [out] */ DIMOUSESTATE2_CDESC __RPC_FAR *state)
|
|
{
|
|
HRESULT hr;
|
|
|
|
if ((nFormat!= dfDIMouse2) && (nFormat!=-1)) return DIERR_NOTINITIALIZED;
|
|
|
|
hr=m__dxj_DirectInputDevice8->GetDeviceState(sizeof(DIMOUSESTATE2),(void*)state);
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP C_dxj_DirectInputDevice8Object::getDeviceStateJoystick(
|
|
/* [out] */ DIJOYSTATE_CDESC __RPC_FAR *state)
|
|
{
|
|
HRESULT hr;
|
|
|
|
//note Joystick1 or Joystick2 are valid formats since
|
|
//one is a superset of the other
|
|
if ((nFormat!= dfDIJoystick)&&(nFormat!= dfDIJoystick2) && (nFormat!=-1)) return DIERR_NOTINITIALIZED;
|
|
hr=m__dxj_DirectInputDevice8->GetDeviceState(sizeof(DIJOYSTATE),(void*)state);
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP C_dxj_DirectInputDevice8Object::getDeviceStateJoystick2(
|
|
/* [out] */ DIJOYSTATE2_CDESC __RPC_FAR *state)
|
|
{
|
|
HRESULT hr;
|
|
|
|
//only for format2
|
|
if ((nFormat!= dfDIJoystick2) && (nFormat!=-1)) return DIERR_NOTINITIALIZED;
|
|
hr=m__dxj_DirectInputDevice8->GetDeviceState(sizeof(DIJOYSTATE2),(void*)state);
|
|
return hr;
|
|
}
|
|
|
|
|
|
STDMETHODIMP C_dxj_DirectInputDevice8Object::getDeviceState(
|
|
/* [in] */ long cb,
|
|
/* [in] */ void *pFormat)
|
|
|
|
{
|
|
HRESULT hr;
|
|
__try {
|
|
hr=m__dxj_DirectInputDevice8->GetDeviceState((DWORD) cb,(void*)pFormat);
|
|
}
|
|
__except(1,1){
|
|
hr=E_INVALIDARG;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP C_dxj_DirectInputDevice8Object::getObjectInfo(
|
|
/* [in] */ long obj,
|
|
/* [in] */ long how,
|
|
I_dxj_DirectInputDeviceObjectInstance **ret)
|
|
{
|
|
|
|
|
|
DIDEVICEOBJECTINSTANCEW inst;
|
|
ZeroMemory(&inst,sizeof(DIDEVICEOBJECTINSTANCEW));
|
|
inst.dwSize=sizeof(DIDEVICEOBJECTINSTANCEW);
|
|
|
|
HRESULT hr;
|
|
hr=m__dxj_DirectInputDevice8->GetObjectInfo(&inst,(DWORD) obj,(DWORD)how);
|
|
if FAILED(hr) return hr;
|
|
|
|
hr=C_dxj_DIDeviceObjectInstanceObject::create(&inst,ret);
|
|
|
|
return hr;
|
|
|
|
/* DEAD
|
|
|
|
//TODO - consider what is going on here carefully
|
|
if (instCover->strGuidType) SysFreeString(instCover->strGuidType);
|
|
if (instCover->strName) SysFreeString(instCover->strName);
|
|
|
|
|
|
|
|
//TODO - consider localization
|
|
if (inst.tszName){
|
|
instCover->strName=T2BSTR(inst.tszName);
|
|
}
|
|
|
|
instCover->strGuidType=DINPUTGUIDtoBSTR(&inst.guidType);
|
|
instCover->lOfs=inst.dwOfs;
|
|
instCover->lType=inst.dwType;
|
|
instCover->lFlags=inst.dwFlags;
|
|
|
|
instCover->lFFMaxForce=inst.dwFFMaxForce;
|
|
instCover->lFFForceResolution=inst.dwFFForceResolution;
|
|
instCover->nCollectionNumber=inst.wCollectionNumber;
|
|
instCover->nDesignatorIndex=inst.wDesignatorIndex;
|
|
instCover->nUsagePage=inst.wUsagePage;
|
|
instCover->nUsage=inst.wUsage;
|
|
instCover->lDimension=inst.dwDimension;
|
|
instCover->nExponent=inst.wExponent;
|
|
instCover->nReserved=inst.wReserved;
|
|
|
|
return hr;
|
|
*/
|
|
}
|
|
|
|
|
|
|
|
|
|
STDMETHODIMP C_dxj_DirectInputDevice8Object::runControlPanel(
|
|
#ifdef _WIN64
|
|
/* [in] */ HWND hwnd)
|
|
#else
|
|
/* [in] */ long hwnd)
|
|
#endif
|
|
{
|
|
HRESULT hr;
|
|
hr=m__dxj_DirectInputDevice8->RunControlPanel((HWND) hwnd,(DWORD)0);
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP C_dxj_DirectInputDevice8Object::setCooperativeLevel(
|
|
#ifdef _WIN64
|
|
/* [in] */ HWND hwnd,
|
|
#else
|
|
/* [in] */ long hwnd,
|
|
#endif
|
|
/* [in] */ long flags)
|
|
{
|
|
HRESULT hr;
|
|
hr=m__dxj_DirectInputDevice8->SetCooperativeLevel((HWND) hwnd,(DWORD)flags);
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP C_dxj_DirectInputDevice8Object::poll()
|
|
{
|
|
HRESULT hr;
|
|
hr=m__dxj_DirectInputDevice8->Poll();
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
STDMETHODIMP C_dxj_DirectInputDevice8Object::setCommonDataFormat(
|
|
/* [in] */ long format)
|
|
{
|
|
//variant so that when structs can be packed in VARIANTS we can take care of it
|
|
HRESULT hr;
|
|
|
|
//· c_dfDIKeyboard
|
|
//· c_dfDIMouse
|
|
//· c_dfDIJoystick
|
|
//· c_dfDIJoystick2
|
|
nFormat=format;
|
|
|
|
switch(format){
|
|
case dfDIKeyboard:
|
|
hr=m__dxj_DirectInputDevice8->SetDataFormat(&c_dfDIKeyboard);
|
|
break;
|
|
case dfDIMouse:
|
|
hr=m__dxj_DirectInputDevice8->SetDataFormat(&c_dfDIMouse);
|
|
break;
|
|
case dfDIJoystick:
|
|
hr=m__dxj_DirectInputDevice8->SetDataFormat(&c_dfDIJoystick);
|
|
break;
|
|
case dfDIJoystick2:
|
|
hr=m__dxj_DirectInputDevice8->SetDataFormat(&c_dfDIJoystick2);
|
|
break;
|
|
case dfDIMouse2:
|
|
hr=m__dxj_DirectInputDevice8->SetDataFormat(&c_dfDIMouse2);
|
|
break;
|
|
|
|
default:
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
STDMETHODIMP C_dxj_DirectInputDevice8Object::setDataFormat(
|
|
/* [in] */ DIDATAFORMAT_CDESC __RPC_FAR *format,
|
|
SAFEARRAY __RPC_FAR * __RPC_FAR *formatArray)
|
|
{
|
|
HRESULT hr;
|
|
LPDIDATAFORMAT pFormat=(LPDIDATAFORMAT)format;
|
|
GUID *pGuid = NULL;
|
|
GUID *pGuidArray = NULL;
|
|
DIOBJECTDATAFORMAT_CDESC *pDiDataFormat=NULL;
|
|
|
|
|
|
if ((!format) || (!formatArray))
|
|
{
|
|
DPF(1,"------ DXVB: Nothing passed in.. \n");
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
if (((SAFEARRAY*)*formatArray)->cDims != 1)
|
|
{
|
|
return E_INVALIDARG;
|
|
}
|
|
if (((SAFEARRAY*)*formatArray)->rgsabound[0].cElements < pFormat->dwNumObjs)
|
|
{
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
__try {
|
|
pFormat->dwSize=sizeof(DIDATAFORMAT);
|
|
pFormat->rgodf = NULL;
|
|
pFormat->rgodf = new DIOBJECTDATAFORMAT[pFormat->dwNumObjs];
|
|
|
|
if (!pFormat->rgodf)
|
|
{
|
|
DPF(1,"------ DXVB: Out of memory (pFormat->rgodf) \n");
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
pGuidArray=new GUID[pFormat->dwNumObjs];
|
|
if (!pGuidArray){
|
|
DPF(1,"------ DXVB: Out of memory (pGuidArray), Freeing pFormat->rgodf \n");
|
|
SAFE_DELETE(pFormat->rgodf);
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
for (DWORD i=0; i< pFormat->dwNumObjs;i++){
|
|
DPF1(1,"------ DXVB: Filling array item %d \n",i);
|
|
pGuid=&(pGuidArray[i]);
|
|
pDiDataFormat=&(((DIOBJECTDATAFORMAT_CDESC*)((SAFEARRAY*)*formatArray)->pvData)[i]);
|
|
hr=DINPUTBSTRtoGUID(pGuid, pDiDataFormat->strGuid);
|
|
if FAILED(hr) {
|
|
DPF(1,"------ DXVB: DInputBstrToGuid Failed, free memory \n");
|
|
SAFE_DELETE(pGuidArray);
|
|
SAFE_DELETE(pFormat->rgodf);
|
|
pFormat->rgodf=NULL;
|
|
return hr;
|
|
}
|
|
pFormat->rgodf[i].pguid=pGuid;
|
|
pFormat->rgodf[i].dwOfs=pDiDataFormat->lOfs;
|
|
pFormat->rgodf[i].dwType=pDiDataFormat->lType;
|
|
pFormat->rgodf[i].dwFlags=pDiDataFormat->lFlags;
|
|
}
|
|
DPF(1,"------ DXVB: Call SetDataFormat \n");
|
|
hr=m__dxj_DirectInputDevice8->SetDataFormat(pFormat);
|
|
DPF(1,"------ DXVB: Free Memory \n");
|
|
|
|
SAFE_DELETE(pGuidArray);
|
|
SAFE_DELETE(pFormat->rgodf);
|
|
|
|
}
|
|
__except(EXCEPTION_EXECUTE_HANDLER)
|
|
{
|
|
SAFE_DELETE(pGuidArray);
|
|
SAFE_DELETE(pFormat->rgodf);
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
|
|
//indicate we have a custom format
|
|
nFormat=-1;
|
|
|
|
return hr;
|
|
|
|
}
|
|
|
|
|
|
#ifdef _WIN64
|
|
STDMETHODIMP C_dxj_DirectInputDevice8Object::setEventNotification(
|
|
/* [in] */ HANDLE hEvent)
|
|
#else
|
|
STDMETHODIMP C_dxj_DirectInputDevice8Object::setEventNotification(
|
|
/* [in] */ long hEvent)
|
|
#endif
|
|
{
|
|
|
|
HRESULT hr=m__dxj_DirectInputDevice8->SetEventNotification((HANDLE)hEvent);
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// NOTE: - current working implemtation promotes
|
|
// code bloat
|
|
// might want to revist this and do it in a more
|
|
// tidy fasion
|
|
//
|
|
STDMETHODIMP C_dxj_DirectInputDevice8Object::getProperty(
|
|
/* [in] */ BSTR str,
|
|
/* [out] */ void __RPC_FAR *propertyInfo)
|
|
{
|
|
|
|
HRESULT hr;
|
|
|
|
|
|
if (!propertyInfo) return E_INVALIDARG;
|
|
|
|
DIPROPDWORD dipdw;
|
|
DIPROPRANGE dipr;
|
|
DIPROPSTRING dips;
|
|
|
|
//For bug #41819
|
|
DIPROPGUIDANDPATH dipgap;
|
|
DIPROPCPOINTS dipcp;
|
|
DIPROPPOINTER dipp;
|
|
//End bug #41819
|
|
|
|
dipdw.diph.dwSize=sizeof(DIPROPDWORD);
|
|
dipdw.diph.dwHeaderSize=sizeof(DIPROPHEADER);
|
|
dipdw.diph.dwObj=((DIPROPLONG_CDESC*)propertyInfo)->lObj;
|
|
dipdw.diph.dwHow=((DIPROPLONG_CDESC*)propertyInfo)->lHow;
|
|
|
|
dipr.diph.dwSize=sizeof(DIPROPRANGE);
|
|
dipr.diph.dwHeaderSize=sizeof(DIPROPHEADER);
|
|
dipr.diph.dwObj=((DIPROPLONG_CDESC*)propertyInfo)->lObj;
|
|
dipr.diph.dwHow=((DIPROPLONG_CDESC*)propertyInfo)->lHow;
|
|
|
|
dips.diph.dwSize=sizeof(DIPROPSTRING);
|
|
dips.diph.dwHeaderSize=sizeof(DIPROPHEADER);
|
|
dips.diph.dwObj=((DIPROPSTRING_CDESC *)propertyInfo)->lObj;
|
|
dips.diph.dwHow=((DIPROPSTRING_CDESC *)propertyInfo)->lHow;
|
|
|
|
|
|
//For bug #41819
|
|
dipgap.diph.dwSize=sizeof(DIPROPGUIDANDPATH);
|
|
dipgap.diph.dwHeaderSize=sizeof(DIPROPHEADER);
|
|
dipgap.diph.dwObj=0;
|
|
dipgap.diph.dwHow=((DIPROPLONG_CDESC *)propertyInfo)->lHow;
|
|
|
|
dipcp.diph.dwSize=sizeof(DIPROPCPOINTS);
|
|
dipcp.diph.dwHeaderSize=sizeof(DIPROPHEADER);
|
|
dipcp.diph.dwObj=((DIPROPLONG_CDESC *)propertyInfo)->lObj;
|
|
dipcp.diph.dwHow=((DIPROPLONG_CDESC *)propertyInfo)->lHow;
|
|
|
|
dipp.diph.dwSize=sizeof(DIPROPPOINTER);
|
|
dipp.diph.dwHeaderSize=sizeof(DIPROPHEADER);
|
|
dipp.diph.dwObj=((DIPROPLONG_CDESC *)propertyInfo)->lObj;
|
|
dipp.diph.dwHow=((DIPROPLONG_CDESC *)propertyInfo)->lHow;
|
|
//End bug #41819
|
|
|
|
|
|
if( 0==_wcsicmp(str,L"diprop_buffersize")){
|
|
hr=m__dxj_DirectInputDevice8->GetProperty(DIPROP_BUFFERSIZE,(DIPROPHEADER*)&dipdw);
|
|
((DIPROPLONG_CDESC*)propertyInfo)->lData=(long)dipdw.dwData;
|
|
}
|
|
else if( 0==_wcsicmp(str,L"diprop_axismode")){
|
|
hr=m__dxj_DirectInputDevice8->GetProperty(DIPROP_AXISMODE,(DIPROPHEADER*)&dipdw);
|
|
((DIPROPLONG_CDESC*)propertyInfo)->lData=(long)dipdw.dwData;
|
|
}
|
|
else if( 0==_wcsicmp(str,L"diprop_granularity")){
|
|
hr=m__dxj_DirectInputDevice8->GetProperty(DIPROP_GRANULARITY,(DIPROPHEADER*)&dipdw);
|
|
((DIPROPLONG_CDESC*)propertyInfo)->lData=(long)dipdw.dwData;
|
|
|
|
}
|
|
|
|
//else if( 0==_wcsicmp(str,L"diprop_getlogicalrange")){
|
|
// hr=m__dxj_DirectInputDevice8->GetProperty(DIPROP_GETLOGICALRANGE,(DIPROPHEADER*)&dipr);
|
|
// ((DIPROPRANGE_CDESC*)propertyInfo)->lMin=(long)dipdw.lMin;
|
|
// ((DIPROPRANGE_CDESC*)propertyInfo)->lMax=(long)dipdw.lMax;
|
|
//}
|
|
|
|
//else if( 0==_wcsicmp(str,L"diprop_getlogicalrange")){
|
|
// hr=m__dxj_DirectInputDevice8->GetProperty(DIPROP_GETPHYSICALLRANGE,(DIPROPHEADER*)&dipr);
|
|
// ((DIPROPRANGE_CDESC*)propertyInfo)->lMin=(long)dipdw.lMin;
|
|
// ((DIPROPRANGE_CDESC*)propertyInfo)->lMax=(long)dipdw.lMax;
|
|
//}
|
|
|
|
else if( 0==_wcsicmp(str,L"diprop_range")){
|
|
hr=m__dxj_DirectInputDevice8->GetProperty(DIPROP_RANGE,(DIPROPHEADER*)&dipr);
|
|
((DIPROPRANGE_CDESC*)propertyInfo)->lMin=(long)dipr.lMin;
|
|
((DIPROPRANGE_CDESC*)propertyInfo)->lMax=(long)dipr.lMax;
|
|
}
|
|
else if( 0==_wcsicmp(str,L"diprop_deadzone")){
|
|
hr=m__dxj_DirectInputDevice8->GetProperty(DIPROP_DEADZONE,(DIPROPHEADER*)&dipdw);
|
|
((DIPROPLONG_CDESC*)propertyInfo)->lData=(long)dipdw.dwData;
|
|
}
|
|
else if( 0==_wcsicmp(str,L"diprop_ffgain")){
|
|
hr=m__dxj_DirectInputDevice8->GetProperty(DIPROP_FFGAIN,(DIPROPHEADER*)&dipdw);
|
|
((DIPROPLONG_CDESC*)propertyInfo)->lData=(long)dipdw.dwData;
|
|
}
|
|
else if( 0==_wcsicmp(str,L"diprop_ffload")){
|
|
hr=m__dxj_DirectInputDevice8->GetProperty(DIPROP_FFLOAD,(DIPROPHEADER*)&dipdw);
|
|
((DIPROPLONG_CDESC*)propertyInfo)->lData=(long)dipdw.dwData;
|
|
}
|
|
else if( 0==_wcsicmp(str,L"diprop_getportdisplayname")){
|
|
hr=m__dxj_DirectInputDevice8->GetProperty(DIPROP_GETPORTDISPLAYNAME,(DIPROPHEADER*)&dips);
|
|
if FAILED(hr) return hr;
|
|
((DIPROPSTRING_CDESC*)propertyInfo)->PropString=SysAllocString(dips.wsz);
|
|
}
|
|
else if( 0==_wcsicmp(str,L"diprop_instancename")){
|
|
hr=m__dxj_DirectInputDevice8->GetProperty(DIPROP_INSTANCENAME,(DIPROPHEADER*)&dips);
|
|
if FAILED(hr) return hr;
|
|
((DIPROPSTRING_CDESC*)propertyInfo)->PropString=SysAllocString(dips.wsz);
|
|
}
|
|
else if( 0==_wcsicmp(str,L"diprop_keyname")){
|
|
hr=m__dxj_DirectInputDevice8->GetProperty(DIPROP_KEYNAME,(DIPROPHEADER*)&dips);
|
|
if FAILED(hr) return hr;
|
|
((DIPROPSTRING_CDESC*)propertyInfo)->PropString=SysAllocString(dips.wsz);
|
|
}
|
|
else if( 0==_wcsicmp(str,L"diprop_productname")){
|
|
hr=m__dxj_DirectInputDevice8->GetProperty(DIPROP_PRODUCTNAME,(DIPROPHEADER*)&dips);
|
|
if FAILED(hr) return hr;
|
|
((DIPROPSTRING_CDESC*)propertyInfo)->PropString=SysAllocString(dips.wsz);
|
|
}
|
|
else if( 0==_wcsicmp(str,L"diprop_username")){
|
|
hr=m__dxj_DirectInputDevice8->GetProperty(DIPROP_USERNAME,(DIPROPHEADER*)&dips);
|
|
if FAILED(hr) return hr;
|
|
((DIPROPSTRING_CDESC*)propertyInfo)->PropString=SysAllocString(dips.wsz);
|
|
}
|
|
|
|
else if( 0==_wcsicmp(str,L"diprop_saturation")){
|
|
hr=m__dxj_DirectInputDevice8->GetProperty(DIPROP_SATURATION,(DIPROPHEADER*)&dipdw);
|
|
((DIPROPLONG_CDESC*)propertyInfo)->lData=(long)dipdw.dwData;
|
|
}
|
|
else if( 0==_wcsicmp(str,L"diprop_scancode")){
|
|
hr=m__dxj_DirectInputDevice8->GetProperty(DIPROP_SCANCODE,(DIPROPHEADER*)&dipdw);
|
|
((DIPROPLONG_CDESC*)propertyInfo)->lData=(long)dipdw.dwData;
|
|
}
|
|
else if( 0==_wcsicmp(str,L"diprop_autocenter")){
|
|
hr=m__dxj_DirectInputDevice8->GetProperty(DIPROP_AUTOCENTER,(DIPROPHEADER*)&dipdw);
|
|
((DIPROPLONG_CDESC*)propertyInfo)->lData=(long)dipdw.dwData;
|
|
}
|
|
else if( 0==_wcsicmp(str,L"diprop_joystickid")){
|
|
hr=m__dxj_DirectInputDevice8->GetProperty(DIPROP_JOYSTICKID,(DIPROPHEADER*)&dipdw);
|
|
((DIPROPLONG_CDESC*)propertyInfo)->lData=(long)dipdw.dwData;
|
|
}
|
|
|
|
|
|
//Added for bug #41819
|
|
|
|
else if(0==_wcsicmp(str, L"diprop_calibration")){
|
|
hr=m__dxj_DirectInputDevice8->GetProperty(DIPROP_CALIBRATION,(DIPROPHEADER*)&dipdw);
|
|
if (hr == S_OK) ((DIPROPLONG_CDESC*)propertyInfo)->lData=(long)dipdw.dwData;
|
|
}
|
|
else if (0==_wcsicmp(str, L"diprop_guidandpath")){
|
|
hr=m__dxj_DirectInputDevice8->GetProperty(DIPROP_GUIDANDPATH,(DIPROPHEADER*)&dipgap);
|
|
if (hr == S_OK)
|
|
{
|
|
((DIPROPGUIDANDPATH_CDESC*)propertyInfo)->Guid=DINPUTGUIDtoBSTR(&dipgap.guidClass);
|
|
((DIPROPGUIDANDPATH_CDESC*)propertyInfo)->Path=SysAllocString(dipgap.wszPath);
|
|
}
|
|
}
|
|
else if (0==_wcsicmp(str, L"diprop_physicalrange")){
|
|
hr=m__dxj_DirectInputDevice8->GetProperty(DIPROP_PHYSICALRANGE,(DIPROPHEADER*)&dipr);
|
|
if (hr == S_OK)
|
|
{
|
|
((DIPROPRANGE_CDESC*)propertyInfo)->lMin=(long)dipr.lMin;
|
|
((DIPROPRANGE_CDESC*)propertyInfo)->lMax=(long)dipr.lMax;
|
|
}
|
|
}
|
|
else if( 0==_wcsicmp(str,L"diprop_logicalrange")){
|
|
hr=m__dxj_DirectInputDevice8->GetProperty(DIPROP_LOGICALRANGE,(DIPROPHEADER*)&dipr);
|
|
if (hr == S_OK)
|
|
{
|
|
((DIPROPRANGE_CDESC*)propertyInfo)->lMin=(long)dipr.lMin;
|
|
((DIPROPRANGE_CDESC*)propertyInfo)->lMax=(long)dipr.lMax;
|
|
}
|
|
}
|
|
else if( 0==_wcsicmp(str,L"diprop_cpoints")){
|
|
hr=m__dxj_DirectInputDevice8->GetProperty(DIPROP_CPOINTS,(DIPROPHEADER*)&dipcp);
|
|
if (hr == S_OK)
|
|
{
|
|
((DIPROPCPOINTS_CDESC*)propertyInfo)->dwCPointsNum=(long)dipcp.dwCPointsNum;
|
|
|
|
__try{
|
|
memcpy( (void*) (((DIPROPCPOINTS_CDESC*)propertyInfo)->cp), (void*)dipcp.cp, sizeof(CPOINT_CDESC) * dipcp.dwCPointsNum);
|
|
}
|
|
__except(1,1){
|
|
return E_INVALIDARG;
|
|
}
|
|
}
|
|
}
|
|
|
|
else if(0==_wcsicmp(str,L"diprop_appdata")){
|
|
hr=m__dxj_DirectInputDevice8->GetProperty(DIPROP_APPDATA,(DIPROPHEADER*)&dipp);
|
|
if (hr == S_OK)
|
|
{
|
|
if FAILED(hr) return hr;
|
|
((DIPROPPOINTER_CDESC*)propertyInfo)->uData=(long)dipp.uData;
|
|
}
|
|
}
|
|
|
|
//End bug #41819
|
|
|
|
else {
|
|
DPF(1, "DXVB: Invalid arguments passed in.\n");
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
/*
|
|
__try{
|
|
((DIPROPHEADER*)propertyInfo)->dwHeaderSize=sizeof(DIPROPHEADER);
|
|
hr=m__dxj_DirectInputDevice8->GetProperty((REFGUID)g,(DIPROPHEADER*)propertyInfo);
|
|
}
|
|
__except(1,1){
|
|
return E_INVALIDARG;
|
|
}
|
|
*/
|
|
|
|
if (FAILED(hr)) {
|
|
DPF1(1, "DXVB: GetProperty returned: %d \n", hr);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
STDMETHODIMP C_dxj_DirectInputDevice8Object::setProperty(
|
|
/* [in] */ BSTR __RPC_FAR str,
|
|
/* [out] */ void __RPC_FAR *propertyInfo)
|
|
{
|
|
|
|
if (!propertyInfo) return E_INVALIDARG;
|
|
|
|
HRESULT hr;
|
|
DIPROPDWORD dipdw;
|
|
dipdw.diph.dwSize=sizeof(DIPROPDWORD);
|
|
dipdw.diph.dwHeaderSize=sizeof(DIPROPHEADER);
|
|
dipdw.diph.dwObj=((DIPROPLONG_CDESC*)propertyInfo)->lObj;
|
|
dipdw.diph.dwHow=((DIPROPLONG_CDESC*)propertyInfo)->lHow;
|
|
|
|
DIPROPSTRING dips;
|
|
dips.diph.dwSize=sizeof(DIPROPSTRING);
|
|
dips.diph.dwHeaderSize=sizeof(DIPROPHEADER);
|
|
dips.diph.dwObj=((DIPROPSTRING_CDESC *)propertyInfo)->lObj;
|
|
dips.diph.dwHow=((DIPROPSTRING_CDESC *)propertyInfo)->lHow;
|
|
|
|
DIPROPRANGE dipr;
|
|
dipr.diph.dwSize=sizeof(DIPROPRANGE);
|
|
dipr.diph.dwHeaderSize=sizeof(DIPROPHEADER);
|
|
dipr.diph.dwObj=((DIPROPLONG_CDESC*)propertyInfo)->lObj;
|
|
dipr.diph.dwHow=((DIPROPLONG_CDESC*)propertyInfo)->lHow;
|
|
|
|
|
|
//Added for bug #41819
|
|
DIPROPPOINTER dipp;
|
|
dipp.diph.dwSize=sizeof(DIPROPPOINTER);
|
|
dipp.diph.dwHeaderSize=sizeof(DIPROPHEADER);
|
|
dipp.diph.dwObj=((DIPROPLONG_CDESC*)propertyInfo)->lObj;
|
|
dipp.diph.dwHow=((DIPROPLONG_CDESC*)propertyInfo)->lHow;
|
|
|
|
DIPROPCPOINTS dipcp;
|
|
dipcp.diph.dwSize=sizeof(DIPROPCPOINTS);
|
|
dipcp.diph.dwHeaderSize=sizeof(DIPROPHEADER);
|
|
dipcp.diph.dwObj=((DIPROPLONG_CDESC*)propertyInfo)->lObj;
|
|
dipcp.diph.dwHow=((DIPROPLONG_CDESC*)propertyInfo)->lHow;
|
|
//End bug #41819
|
|
|
|
if( 0==_wcsicmp(str,L"diprop_buffersize")){
|
|
dipdw.dwData=((DIPROPLONG_CDESC*)propertyInfo)->lData;
|
|
hr=m__dxj_DirectInputDevice8->SetProperty(DIPROP_BUFFERSIZE,(DIPROPHEADER*)&dipdw);
|
|
}
|
|
else if( 0==_wcsicmp(str,L"diprop_axismode")){
|
|
dipdw.dwData=((DIPROPLONG_CDESC*)propertyInfo)->lData;
|
|
hr=m__dxj_DirectInputDevice8->SetProperty(DIPROP_AXISMODE,(DIPROPHEADER*)&dipdw);
|
|
}
|
|
else if( 0==_wcsicmp(str,L"diprop_range")){
|
|
dipr.lMin=((DIPROPRANGE_CDESC*)propertyInfo)->lMin;
|
|
dipr.lMax=((DIPROPRANGE_CDESC*)propertyInfo)->lMax;
|
|
|
|
hr=m__dxj_DirectInputDevice8->SetProperty(DIPROP_RANGE,(DIPROPHEADER*)&dipr);
|
|
}
|
|
else if( 0==_wcsicmp(str,L"diprop_deadzone")){
|
|
dipdw.dwData=((DIPROPLONG_CDESC*)propertyInfo)->lData;
|
|
hr=m__dxj_DirectInputDevice8->SetProperty(DIPROP_DEADZONE,(DIPROPHEADER*)&dipdw);
|
|
}
|
|
else if( 0==_wcsicmp(str,L"diprop_ffgain")){
|
|
dipdw.dwData=((DIPROPLONG_CDESC*)propertyInfo)->lData;
|
|
hr=m__dxj_DirectInputDevice8->SetProperty(DIPROP_FFGAIN,(DIPROPHEADER*)&dipdw);
|
|
}
|
|
else if( 0==_wcsicmp(str,L"diprop_saturation")){
|
|
dipdw.dwData=((DIPROPLONG_CDESC*)propertyInfo)->lData;
|
|
hr=m__dxj_DirectInputDevice8->SetProperty(DIPROP_SATURATION,(DIPROPHEADER*)&dipdw);
|
|
}
|
|
else if( 0==_wcsicmp(str,L"diprop_autocenter")){
|
|
dipdw.dwData=((DIPROPLONG_CDESC*)propertyInfo)->lData;
|
|
hr=m__dxj_DirectInputDevice8->SetProperty(DIPROP_AUTOCENTER,(DIPROPHEADER*)&dipdw);
|
|
}
|
|
else if( 0==_wcsicmp(str,L"diprop_calibrationmode")){
|
|
dipdw.dwData=((DIPROPLONG_CDESC*)propertyInfo)->lData;
|
|
hr=m__dxj_DirectInputDevice8->SetProperty(DIPROP_CALIBRATIONMODE,(DIPROPHEADER*)&dipdw);
|
|
}
|
|
|
|
//Added for bug #41819
|
|
|
|
else if( 0==_wcsicmp(str,L"diprop_appdata")){
|
|
dipp.uData=((DIPROPPOINTER_CDESC *)propertyInfo)->uData;
|
|
hr=m__dxj_DirectInputDevice8->SetProperty(DIPROP_APPDATA,(DIPROPHEADER*)&dipp);
|
|
}
|
|
else if( 0==_wcsicmp(str,L"diprop_instancename")){
|
|
wcscpy(dips.wsz,((DIPROPSTRING_CDESC *)propertyInfo)->PropString);
|
|
hr=m__dxj_DirectInputDevice8->SetProperty(DIPROP_INSTANCENAME,(DIPROPHEADER*)&dips);
|
|
}
|
|
else if( 0==_wcsicmp(str,L"diprop_productname")){
|
|
wcscpy(dips.wsz, ((DIPROPSTRING_CDESC *)propertyInfo)->PropString);
|
|
hr=m__dxj_DirectInputDevice8->SetProperty(DIPROP_PRODUCTNAME,(DIPROPHEADER*)&dips);
|
|
}
|
|
else if( 0==_wcsicmp(str,L"diprop_cpoints")){
|
|
dipcp.dwCPointsNum=((DIPROPCPOINTS_CDESC *)propertyInfo)->dwCPointsNum;
|
|
__try{
|
|
memcpy( (void*)dipcp.cp, (void*)((DIPROPCPOINTS_CDESC*)propertyInfo)->cp, sizeof(CPOINT_CDESC) * MAXCPOINTSNUM);
|
|
}
|
|
__except(1,1){
|
|
DPF(1, "Invalid arguments passed in.\n");
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
hr=m__dxj_DirectInputDevice8->SetProperty(DIPROP_CPOINTS,(DIPROPHEADER*)&dipcp);
|
|
}
|
|
//End bug #41819
|
|
|
|
else {
|
|
DPF(1, "Invalid arguments passed in.\n");
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
/*
|
|
__try {
|
|
((DIPROPHEADER*)propertyInfo)->dwHeaderSize=sizeof(DIPROPHEADER);
|
|
hr=m__dxj_DirectInputDevice8->SetProperty((REFGUID)g,(DIPROPHEADER*)propertyInfo);
|
|
}
|
|
__except (1,1){
|
|
return E_INVALIDARG;
|
|
}
|
|
*/
|
|
if (FAILED(hr)) {
|
|
DPF1(1, "DXVB: SetProperty returned: %d \n", hr);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
|
|
STDMETHODIMP C_dxj_DirectInputDevice8Object::unacquire()
|
|
{
|
|
HRESULT hr=m__dxj_DirectInputDevice8->Unacquire();
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
|
|
STDMETHODIMP C_dxj_DirectInputDevice8Object::createEffect(
|
|
/* [in] */ BSTR effectGuid,
|
|
/* [in] */ DIEFFECT_CDESC __RPC_FAR *effectInfo,
|
|
/* [retval][out] */ I_dxj_DirectInputEffect __RPC_FAR *__RPC_FAR *ret)
|
|
{
|
|
HRESULT hr;
|
|
GUID g;
|
|
|
|
DIEFFECT realEffect;
|
|
LPDIRECTINPUTEFFECT pRealEffect=NULL;
|
|
|
|
hr=DINPUTBSTRtoGUID(&g,effectGuid);
|
|
if FAILED(hr) return hr;
|
|
|
|
hr=FixUpRealEffect(g,&realEffect,effectInfo);
|
|
if FAILED(hr) return hr;
|
|
|
|
hr=m__dxj_DirectInputDevice8->CreateEffect(g,&realEffect,&pRealEffect,NULL);
|
|
if FAILED(hr) return hr;
|
|
|
|
INTERNAL_CREATE(_dxj_DirectInputEffect,pRealEffect,ret)
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP C_dxj_DirectInputDevice8Object::createCustomEffect(
|
|
/* [in] */ DIEFFECT_CDESC __RPC_FAR *effectInfo,
|
|
/* [in] */ long channels,
|
|
/* [in] */ long samplePeriod,
|
|
/* [in] */ long nSamples,
|
|
/* [in] */ SAFEARRAY __RPC_FAR * __RPC_FAR *sampledata,
|
|
/* [retval][out] */ I_dxj_DirectInputEffect __RPC_FAR *__RPC_FAR *ret)
|
|
{
|
|
HRESULT hr;
|
|
GUID g=GUID_CustomForce;
|
|
|
|
DIEFFECT realEffect;
|
|
LPDIRECTINPUTEFFECT pRealEffect=NULL;
|
|
|
|
hr=FixUpRealEffect(g,&realEffect,effectInfo);
|
|
if FAILED(hr) return hr;
|
|
|
|
|
|
DICUSTOMFORCE customData;
|
|
customData.cChannels =(DWORD)channels;
|
|
customData.cSamples =(DWORD)nSamples;
|
|
customData.dwSamplePeriod =(DWORD)samplePeriod;
|
|
customData.rglForceData = (long*)(*sampledata)->pvData;
|
|
|
|
realEffect.lpvTypeSpecificParams=&customData;
|
|
realEffect.cbTypeSpecificParams=sizeof(DICUSTOMFORCE);
|
|
|
|
__try {
|
|
hr=m__dxj_DirectInputDevice8->CreateEffect(g,&realEffect,&pRealEffect,NULL);
|
|
}
|
|
__except(1,1){
|
|
return E_INVALIDARG;
|
|
}
|
|
if FAILED(hr) return hr;
|
|
|
|
INTERNAL_CREATE(_dxj_DirectInputEffect,pRealEffect,ret)
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
|
|
STDMETHODIMP C_dxj_DirectInputDevice8Object::sendDeviceData(
|
|
/* [in] */ long count,
|
|
/* [in] */ SAFEARRAY __RPC_FAR * __RPC_FAR *data,
|
|
/* [in] */ long flags,
|
|
/* [retval][out] */ long __RPC_FAR *retcount)
|
|
{
|
|
DWORD dwCount=count;
|
|
HRESULT hr;
|
|
__try {
|
|
hr=m__dxj_DirectInputDevice8->SendDeviceData(
|
|
sizeof(DIDEVICEOBJECTDATA),
|
|
(DIDEVICEOBJECTDATA*)(*data)->pvData,
|
|
&dwCount,
|
|
(DWORD)flags);
|
|
|
|
}
|
|
__except(1,1){
|
|
return E_INVALIDARG;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP C_dxj_DirectInputDevice8Object::sendForceFeedbackCommand(
|
|
/* [in] */ long flags)
|
|
{
|
|
HRESULT hr;
|
|
hr=m__dxj_DirectInputDevice8->SendForceFeedbackCommand((DWORD)flags);
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP C_dxj_DirectInputDevice8Object::getForceFeedbackState(
|
|
/* [retval][out] */ long __RPC_FAR *state)
|
|
{
|
|
if (!state) return E_INVALIDARG;
|
|
HRESULT hr;
|
|
hr=m__dxj_DirectInputDevice8->GetForceFeedbackState((DWORD*)state);
|
|
return hr;
|
|
|
|
}
|
|
|
|
STDMETHODIMP C_dxj_DirectInputDevice8Object::getEffectsEnum( long effType,
|
|
I_dxj_DirectInputEnumEffects **ret)
|
|
{
|
|
HRESULT hr=C_dxj_DirectInputEnumEffectsObject::create(m__dxj_DirectInputDevice8,effType,ret);
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
|
|
STDMETHODIMP C_dxj_DirectInputDevice8Object::BuildActionMap(
|
|
/* [out][in] */ DIACTIONFORMAT_CDESC __RPC_FAR *format,
|
|
BSTR userName,
|
|
/* [in] */ long flags)
|
|
|
|
{
|
|
HRESULT hr;
|
|
DIACTIONFORMATW frmt;
|
|
hr=FillRealActionFormat(&frmt, format, &(format->ActionArray), format->lActionCount);
|
|
|
|
if FAILED(hr) return hr;
|
|
|
|
hr=m__dxj_DirectInputDevice8->BuildActionMap(&frmt,(WCHAR*)userName,(DWORD) flags);
|
|
return hr;
|
|
|
|
}
|
|
|
|
STDMETHODIMP C_dxj_DirectInputDevice8Object::SetActionMap(
|
|
/* [out][in] */ DIACTIONFORMAT_CDESC __RPC_FAR *format,
|
|
/* [in] */ BSTR username,
|
|
/* [in] */ long flags)
|
|
{
|
|
HRESULT hr;
|
|
DIACTIONFORMATW frmt;
|
|
|
|
|
|
hr=FillRealActionFormat(&frmt, format, &(format->ActionArray), format->lActionCount);
|
|
if FAILED(hr) return hr;
|
|
|
|
hr=m__dxj_DirectInputDevice8->SetActionMap(&frmt,(LPWSTR) username,(DWORD) flags);
|
|
return hr;
|
|
|
|
}
|
|
|
|
|
|
STDMETHODIMP C_dxj_DirectInputDevice8Object::GetImageInfoCount(
|
|
long *retCount)
|
|
{
|
|
HRESULT hr;
|
|
|
|
DIDEVICEIMAGEINFOHEADERW RealHeader;
|
|
ZeroMemory(&RealHeader,sizeof(DIDEVICEIMAGEINFOHEADERW));
|
|
RealHeader.dwSize= sizeof(DIDEVICEIMAGEINFOHEADERW);
|
|
RealHeader.dwSizeImageInfo= sizeof(DIDEVICEIMAGEINFOW);
|
|
|
|
//figure out how big to make our buffer
|
|
hr=m__dxj_DirectInputDevice8->GetImageInfo(&RealHeader);
|
|
if FAILED(hr) return hr;
|
|
|
|
*retCount=RealHeader.dwBufferUsed / sizeof(DIDEVICEIMAGEINFOW);
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP C_dxj_DirectInputDevice8Object::GetImageInfo(
|
|
/* [out] */ DIDEVICEIMAGEINFOHEADER_CDESC __RPC_FAR *info)
|
|
{
|
|
HRESULT hr;
|
|
|
|
if (!info) return E_INVALIDARG;
|
|
DIDEVICEIMAGEINFOHEADERW RealHeader;
|
|
ZeroMemory(&RealHeader,sizeof(DIDEVICEIMAGEINFOHEADERW));
|
|
RealHeader.dwSize= sizeof(DIDEVICEIMAGEINFOHEADERW);
|
|
RealHeader.dwSizeImageInfo= sizeof(DIDEVICEIMAGEINFOW);
|
|
|
|
//figure out how big to make our buffer
|
|
hr=m__dxj_DirectInputDevice8->GetImageInfo(&RealHeader);
|
|
if FAILED(hr) return hr;
|
|
|
|
//allocate the buffer
|
|
RealHeader.lprgImageInfoArray =(DIDEVICEIMAGEINFOW*)malloc(RealHeader.dwBufferSize);
|
|
if (!RealHeader.lprgImageInfoArray) return E_OUTOFMEMORY;
|
|
|
|
|
|
//TODO validate that the safe array passed to us is large enough
|
|
|
|
info->ImageCount =RealHeader.dwBufferSize / sizeof(DIDEVICEIMAGEINFOW);
|
|
|
|
if (info->Images->rgsabound[0].cElements < (DWORD)info->ImageCount)
|
|
{
|
|
free(RealHeader.lprgImageInfoArray);
|
|
return E_INVALIDARG;
|
|
}
|
|
for (long i =0 ;i<info->ImageCount;i++)
|
|
{
|
|
DIDEVICEIMAGEINFO_CDESC *pInfo=&( ( (DIDEVICEIMAGEINFO_CDESC*) (info->Images->pvData) )[i]);
|
|
DIDEVICEIMAGEINFOW *pRealInfo= &(RealHeader.lprgImageInfoArray[i]);
|
|
pInfo->ImagePath=SysAllocString(pRealInfo->tszImagePath);
|
|
pInfo->Flags= (long)pRealInfo->dwFlags;
|
|
pInfo->ViewID= (long)pRealInfo->dwViewID;
|
|
pInfo->ObjId= (long)pRealInfo->dwObjID;
|
|
pInfo->ValidPts= (long)pRealInfo->dwcValidPts;
|
|
pInfo->TextAlign= (long)pRealInfo->dwTextAlign;
|
|
|
|
|
|
memcpy(&(pInfo->OverlayRect),&(pRealInfo->rcOverlay),sizeof(RECT));
|
|
memcpy(&(pInfo->CalloutLine[0]),&(pRealInfo->rgptCalloutLine[0]),sizeof(POINT)*5);
|
|
memcpy(&(pInfo->CalloutRect),&(pRealInfo->rcCalloutRect),sizeof(RECT));
|
|
}
|
|
|
|
info->Views=RealHeader.dwcViews;
|
|
info->Buttons=RealHeader.dwcButtons;
|
|
info->Axes=RealHeader.dwcAxes;
|
|
info->POVs=RealHeader.dwcPOVs;
|
|
|
|
free(RealHeader.lprgImageInfoArray);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
|
|
BOOL CALLBACK DIEnumEffectsInFileCallback( LPCDIFILEEFFECT lpDiFileEf, LPVOID pvRef)
|
|
{
|
|
HRESULT hr;
|
|
|
|
EFFECTSINFILE *pData=(EFFECTSINFILE*)pvRef;
|
|
|
|
if (0==lstrcmp(lpDiFileEf->szFriendlyName,pData->szEffect))
|
|
{
|
|
pData->hr=pData->pDev->CreateEffect(
|
|
lpDiFileEf->GuidEffect,
|
|
lpDiFileEf->lpDiEffect,
|
|
&pData->pEff,
|
|
NULL);
|
|
|
|
return DIENUM_STOP;
|
|
}
|
|
|
|
return DIENUM_CONTINUE;
|
|
}
|
|
|
|
STDMETHODIMP C_dxj_DirectInputDevice8Object::CreateEffectFromFile(
|
|
BSTR filename,
|
|
long flags,
|
|
BSTR effectName,
|
|
I_dxj_DirectInputEffect **ret)
|
|
{
|
|
HRESULT hr;
|
|
USES_CONVERSION;
|
|
EFFECTSINFILE data;
|
|
ZeroMemory(&data,sizeof(EFFECTSINFILE));
|
|
|
|
data.hr=E_INVALIDARG; //returned if we dont find the file
|
|
data.pDev=m__dxj_DirectInputDevice8;
|
|
|
|
if (!effectName) return E_INVALIDARG;
|
|
if (effectName[0]==0) return E_INVALIDARG;
|
|
|
|
ZeroMemory(data.szEffect,sizeof(MAX_PATH));
|
|
char *szOut = NULL;
|
|
__try { szOut=W2T(effectName); } __except(EXCEPTION_EXECUTE_HANDLER) { return E_FAIL; }
|
|
strcpy (data.szEffect, szOut);
|
|
|
|
hr=m__dxj_DirectInputDevice8->EnumEffectsInFile((WCHAR*)filename,DIEnumEffectsInFileCallback,(void*)&data ,(DWORD)flags);
|
|
if FAILED(hr) return hr;
|
|
if FAILED(data.hr) return data.hr;
|
|
|
|
INTERNAL_CREATE(_dxj_DirectInputEffect,data.pEff,ret);
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
STDMETHODIMP C_dxj_DirectInputDevice8Object::WriteEffectToFile(
|
|
BSTR filename, long flags, BSTR guid,BSTR name, DIEFFECT_CDESC *CoverEffect)
|
|
{
|
|
|
|
USES_CONVERSION;
|
|
|
|
|
|
HRESULT hr;
|
|
DIEFFECT RealEffect;
|
|
DIFILEEFFECT FileEffect;
|
|
|
|
if (!filename) return E_INVALIDARG;
|
|
if (!guid) return E_INVALIDARG;
|
|
if (!name) return E_INVALIDARG;
|
|
|
|
FileEffect.dwSize=sizeof(DIFILEEFFECT);
|
|
FileEffect.lpDiEffect=&RealEffect;
|
|
|
|
ZeroMemory(FileEffect.szFriendlyName,sizeof(MAX_PATH));
|
|
char *szOut = NULL;
|
|
__try { szOut=W2T(name); } __except(EXCEPTION_EXECUTE_HANDLER) { return E_FAIL; }
|
|
strcpy (FileEffect.szFriendlyName, szOut);
|
|
|
|
|
|
hr=DINPUTBSTRtoGUID(&FileEffect.GuidEffect,guid);
|
|
if FAILED(hr) return hr;
|
|
|
|
hr=FixUpRealEffect(FileEffect.GuidEffect,&RealEffect,CoverEffect);
|
|
if FAILED(hr) return hr;
|
|
|
|
hr=m__dxj_DirectInputDevice8->WriteEffectToFile(
|
|
(WCHAR*) filename,
|
|
1,
|
|
&FileEffect,
|
|
(DWORD) flags);
|
|
|
|
return hr;
|
|
}
|