able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/multimedia/directx/dxvb/dx8vb/dinputdeviceobj.cpp

1126 lines
32 KiB
C++
Raw Permalink Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//+-------------------------------------------------------------------------
//
// 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;
//<2F> c_dfDIKeyboard
//<2F> c_dfDIMouse
//<2F> c_dfDIJoystick
//<2F> 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=W2T(effectName);
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=W2T(name);
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;
}
Reference in a new issue Copy permalink