able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/multimedia/directx/dinput/dx8/dimap/dimap.cpp

4616 lines
145 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/******************************************************************************
*
* dimap.cpp
*
* Copyright (c) 1999, 2000 Microsoft Corporation. All Rights Reserved.
*
* Abstract:
*
* Contents:
*
*****************************************************************************/
#include "dimapp.h"
#include "objbase.h"
#include "stdio.h"
#include "shlwapi.h"
#include "shlobj.h"
#include "lmcons.h"
#include "dimap.h"
#include "dinputp.h"
#include "string"
#include "list"
#include "algorithm"
#include "dinputd.h"
/******************************************************************************
*
* Definitions
*
*****************************************************************************/
using namespace std;
#undef STRICT_DEV_DEF
//MAKE SURE THIS FOUR ARE CONSISTENT
#define MAP_DIR _T("\\DirectX\\DirectInput\\User Maps")
#define DIRECTX _T("\\DirectX")
#define DIRECTINPUT _T("\\DirectInput")
#define USER_MAPS _T("\\User Maps")
#define NAME _T("Name")
#define RESERVED_STRING _T("Error")
#define DIRECT_INPUT _T("DirectInput")
#define DIRECTX_VERSION _T("DirectXVersion")
#define DEVICES _T("Devices")
#define DEVICE _T("Device")
#define VENDORID _T("VID")
#define PRODUCTID _T("PID")
#define CONTROLS _T("Controls")
#define CONTROL _T("Control")
#define USAGE _T("Usage")
#define USAGEPAGE _T("UsagePage")
#define GENRE _T("Genre")
#define MAPEXISTS _T("MapExists")
#define APPLICATION _T("Application")
#define IMAGE_FILENAME _T("ImageFileName")
#define OVERLAY_FILENAME _T("OverlayFileName")
#define SELECTION_FILENAME _T("SelectionFileName")
#define VIEWSELECT_FILENAME _T("ViewSelectFileName")
#define IMAGE_FORMAT _T("ImageFormat")
#define OVERLAY_FORMAT _T("OverlayFormat")
#define SELECTION_FORMAT _T("SelectionFormat")
#define VIEWSELECT_FORMAT _T("ViewSelectFormat")
#define OVERLAY_RECT _T("OverlayRect")
#define CONTROL_STRING_ALIGN _T("Align")
#define CONTROL_VISIBLE _T("Visible")
#define STRING_POS _T("StringPos")
#define LINE_DATA _T("LineData")
#define CALLOUTMAX _T("CallOutMax")
#define OVERLAYRECT _T("OverlayRect")
#define OFFSET _T("Type")
#define TIMESTAMPHIGH _T("TimestampHigh")
#define TIMESTAMPLOW _T("TimestampLow")
#define NUMACTIONS _T("NumActions")
#define SEPARATOR _T(',')
#define RESERVED_DX_VER 0xffffffff
#define RESERVED_VENDORID 0
#define RESERVED_PRODUCTID 0
#define RESERVED_OFFSET 0xffffffff
#define RESERVED_USAGE 0
#define RESERVED_USAGEPAGE 0
#define RESERVED_ACTION 0xffffffff
#define _MAX_SECTION_NAME 64
#define _MAX_KEY_NAME 64
GUID NULLGUID;
#ifdef UNICODE
#define String wstring
#define IsSpace iswspace
#else
#define String string
#define IsSpace isspace
#endif // !UNICODE
typedef String::iterator StrIter;
class CS:public String{};
typedef list<CS> STRINGLIST;
/******************************************************************************
*
* Classes
*
*****************************************************************************/
template <class p> class AutoRelease
{
p m_p;
public:
AutoRelease(){m_p=NULL;};
~AutoRelease(){if(m_p){m_p->Release();m_p=NULL;};};
inline LPVOID* Addr() { return (LPVOID*) &m_p;};
operator p(){return m_p;};
operator p*(){return &m_p;};
p P(){return m_p;};
};
typedef AutoRelease<LPDIRECTINPUT8> LPDIRECTINPUT_AR;
typedef AutoRelease<LPDIRECTINPUTDEVICE8> LPDIRECTINPUTDEVICE_AR;
struct DeviceObjData;
struct ControlData
{
DeviceObjData *pDevObj;
String ControlName;//Name in .ini file
String Name;
DWORD dwUsage;
DWORD dwUsagePage;
DWORD dwAction;//<---workspace for mapping...
DWORD dwOffset;
};
typedef list<ControlData> CONTROLLIST;
struct DeviceObjData
{
ControlData *pUCtrlData;
ControlData *pVCtrlData;
String Name;//Name for device object returned by DInput
DWORD dwUsage;
DWORD dwUsagePage;
DWORD dwOffset;
DWORD dwType;
DWORD dwFlags;
bool bMapped;//<---workspace for mapping...
};
typedef list<DeviceObjData> DEVICEOBJLIST;
struct DEVCNT
{
LPDIDEVICEINSTANCE pDIDI;
int *m_pnCnt;
};
class IDirectInputMapperTrA:
public IDirectInputMapperA,public IDirectInputMapperVendorA
{
virtual HRESULT InitializeI(
LPCGUID lpThisGUIDInstance,
LPCTSTR lpcstrFileName,
DWORD dwFlags)=0;
HRESULT STDMETHODCALLTYPE Initialize(
LPCGUID lpThisGUIDInstance,
LPCSTR lpcstrFileName,
DWORD dwFlags);
virtual HRESULT GetActionMapI(
LPDIACTIONFORMAT lpDiActionFormat,
LPCTSTR lpctstrUserName,
FILETIME *pTimestamp,DWORD dwFlags)=0;
HRESULT STDMETHODCALLTYPE GetActionMap(
LPDIACTIONFORMATA lpDiActionFormat,
LPCSTR lpctstrUserName,
FILETIME *pTimestamp,DWORD dwFlags);
virtual HRESULT SaveActionMapI(
LPDIACTIONFORMAT lpDiActionFormat,
LPCTSTR lpctstrUserName,
DWORD dwFlags)=0;
HRESULT STDMETHODCALLTYPE SaveActionMap(
LPDIACTIONFORMATA lpDiActionFormat,
LPCSTR lpctstrUserName,
DWORD dwFlags);
virtual HRESULT GetImageInfoI(
LPDIDEVICEIMAGEINFOHEADER lpdiDevImageInfoHeader)=0;
HRESULT STDMETHODCALLTYPE GetImageInfo(
LPDIDEVICEIMAGEINFOHEADERA lpdiDevImageInfoHeader);
virtual HRESULT WriteVendorFileI(
LPDIACTIONFORMAT lpDiActionFormat,
LPDIDEVICEIMAGEINFOHEADER lpdiDevImageInfoHeader,
DWORD dwFlags)=0;
HRESULT STDMETHODCALLTYPE WriteVendorFile(
LPDIACTIONFORMATA lpDiActionFormat,
LPDIDEVICEIMAGEINFOHEADERA lpdiDevImageInfoHeader,
DWORD dwFlags);
};
class IDirectInputMapperTrW:
public IDirectInputMapperW,public IDirectInputMapperVendorW
{
virtual HRESULT InitializeI(
LPCGUID lpThisGUIDInstance,
LPCTSTR lpcstrFileName,
DWORD dwFlags)=0;
HRESULT STDMETHODCALLTYPE Initialize(
LPCGUID lpThisGUIDInstance,
LPCWSTR lpcstrFileName,
DWORD dwFlags);
virtual HRESULT GetActionMapI(
LPDIACTIONFORMAT lpDiActionFormat,
LPCTSTR lpctstrUserName,
FILETIME *pTimestamp,DWORD dwFlags)=0;
HRESULT STDMETHODCALLTYPE GetActionMap(
LPDIACTIONFORMATW lpDiActionFormat,
LPCWSTR lpctstrUserName,
FILETIME *pTimestamp,DWORD dwFlags);
virtual HRESULT SaveActionMapI(
LPDIACTIONFORMAT lpDiActionFormat,
LPCTSTR lpctstrUserName,
DWORD dwFlags)=0;
HRESULT STDMETHODCALLTYPE SaveActionMap(
LPDIACTIONFORMATW lpDiActionFormat,
LPCWSTR lpctstrUserName,
DWORD dwFlags);
virtual HRESULT GetImageInfoI(
LPDIDEVICEIMAGEINFOHEADER lpdiDevImageInfoHeader)=0;
HRESULT STDMETHODCALLTYPE GetImageInfo(
LPDIDEVICEIMAGEINFOHEADERW lpdiDevImageInfoHeader);
virtual HRESULT WriteVendorFileI(
LPDIACTIONFORMAT lpDiActionFormat,
LPDIDEVICEIMAGEINFOHEADER lpdiDevImageInfoHeader,
DWORD dwFlags)=0;
HRESULT STDMETHODCALLTYPE WriteVendorFile(
LPDIACTIONFORMATW lpDiActionFormat,
LPDIDEVICEIMAGEINFOHEADERW lpdiDevImageInfoHeader,
DWORD dwFlags);
};
class CDIMapObj:public IDirectInputMapperTrA,public IDirectInputMapperTrW
{
#ifdef _CHECKED
static int m_DeviceCount;
int m_DeviceNo;
#endif
ULONG m_ulRefCnt;
bool m_bInitialized;
DWORD m_dwThisVendorID;
DWORD m_dwThisProductID;
String m_DeviceName;
GUID m_DeviceGuid;
int m_nDeviceInstanceNo;
//Vendor file name data
String m_VFileName;
LPCTSTR m_lpVFileName;
String m_VFileDevName;
CONTROLLIST m_VCtrlData;
bool m_bVLoaded;
//User file name data
String m_UName;
LPCTSTR m_lpUName;
String m_UFileName;
String m_UserDir;
String m_UFileDevName;
CONTROLLIST m_UCtrlData;
bool m_bULoaded;
FILETIME m_UTimestamp;
bool m_bImageBufferSize;
DWORD m_dwImageBufferSize;
HRESULT InitializeI(
LPCGUID lpThisGUIDInstance,
LPCTSTR lpcstrFileName,
DWORD dwFlags);
HRESULT GetActionMapI(
LPDIACTIONFORMAT lpDiActionFormat,
LPCTSTR lpctstrUserName,
FILETIME *pTimestamp,DWORD dwFlags);
HRESULT SaveActionMapI(
LPDIACTIONFORMAT lpDiActionFormat,
LPCTSTR lpctstrUserName,
DWORD dwFlags);
HRESULT GetImageInfoI(
LPDIDEVICEIMAGEINFOHEADER lpdiDevImageInfoHeader);
HRESULT WriteVendorFileI(
LPDIACTIONFORMAT lpDiActionFormat,
LPDIDEVICEIMAGEINFOHEADER lpdiDevImageInfoHeader,
DWORD dwFlags);
HRESULT GetImageInfoInternal(
LPDIDEVICEIMAGEINFOHEADER lpdiDevImageInfoHeader,
bool bGettingSize);
void SaveActionMapUV(
LPDIACTIONFORMAT lpDiActionFormat,
bool bDevInFileLoaded,
LPCTSTR pFileName,
String &FileDevName,
CONTROLLIST &ControlsData,
LPDIDEVICEIMAGEINFOHEADER lpdiDevImageInfoHeader,
DWORD dwHow1,DWORD dwHow2,bool bUserFile);
void WriteImageInfo(LPCTSTR lpFileKeyName,LPCTSTR lpFormatKeyName,
LPCTSTR lpSectionName,LPDIDEVICEIMAGEINFO lpImageInfo,
bool bAddIndex,bool bDelete);
void MakeNewControlName(String &CtrlName,
DEVICEOBJLIST::iterator DevObjIt,
CONTROLLIST &ControlsData,
String &FileDevName,
STRINGLIST &ControlsAllDevs,
STRINGLIST &Controls);
void Resinc(LPDIACTIONFORMAT lpDiActionFormat);
HRESULT GetImageInfo(
DeviceObjData *pDevObj,
DWORD dwIndex,
LPDIDEVICEIMAGEINFO lpImageInfo,
DWORD dwImageType);
bool GetImageInfoFileName(LPCTSTR lpKeyName,LPCTSTR lpSectionName,
DWORD dwIndex,LPDIDEVICEIMAGEINFO lpImageInfo);
//keep flags for a while just in case we change our minds again
#if 0
void GetImageInfoFormat(LPCTSTR lpKeyName,LPCTSTR lpSectionName,
DWORD dwIndex,LPDIDEVICEIMAGEINFO lpImageInfo);
#endif
void LoadFileData(LPCTSTR lpFileName,LPCTSTR lpThisName,
DWORD dwThisVendorID,DWORD dwThisProductID,
String &FileDeviceName,CONTROLLIST &ControlsData,
bool &bLoaded,FILETIME *pT,LPDIACTIONFORMAT lpDiActionFormat);
void LoadUserData(LPCTSTR lpctstrUserName,
LPDIACTIONFORMAT lpDiActionFormat,
bool bForceReload=false,
bool bCreateDir=false);
void Clear();
bool IsVIDPID(){if(m_dwThisVendorID&&m_dwThisProductID)
return true;return false;};
bool CompareData(DeviceObjData &DOD,ControlData &CD);
bool GetOffset(ControlData &CD,DEVICEOBJLIST &DevObjList,DWORD dwSemantic,
DEVICEOBJLIST::iterator &DevObjItOut);
void MapGenre(LPDIACTIONFORMAT lpDiActionFormat,CONTROLLIST &ControlsData,
LPCTSTR lpGenreName,LPCTSTR lpFileName,
LPCGUID lpThisGUIDInstance,
DEVICEOBJLIST &DevObjList,DWORD dwHow,
DWORD &dwNOfMappedActions);
void MapDevice(LPDIACTIONFORMAT lpDiActionFormat,
LPCTSTR lpFileName,
LPCTSTR lpFileDevName,LPCGUID lpThisGUIDInstance,
DEVICEOBJLIST &DevObjList,CONTROLLIST &ControlsData,
DWORD dwHow,DWORD dwHowApp,DWORD &dwNOfMappedActions,
bool *pbMapExists,bool bUserFile);
public:
#ifdef _CHECKED
int GetDeviceNo(){return m_DeviceNo;};
#endif
DEVICEOBJLIST m_DevObjList;
CDIMapObj();
~CDIMapObj();
ULONG STDMETHODCALLTYPE AddRef()
{DllAddRef();m_ulRefCnt++;return m_ulRefCnt;};
ULONG STDMETHODCALLTYPE Release();
HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, LPVOID * ppvObj);
};
/******************************************************************************
*
* Debug code
*
*****************************************************************************/
#ifdef _CHECKED
#include <tchar.h>
#include <crtdbg.h>
#include <stdio.h>
enum BlockType{
eObjectEntryBT,
eFunctionBT,
eSubBT,
eException,
};
enum ObjectEntry{
eInitialize=1,
eGetActionMap=2,
eSaveActionMap=4,
eGetImageInfo=8,
eWriteVendorFile=16,
eCDIMapObj=32,
e_CDIMapObj=64,
eAddRef=128,
eRelease=256,
eUnknownMethod=4096
};
class CAdvancedTracer
{
static DWORD s_dwFlags;
static DWORD s_dwFlagsEx;
static DWORD s_dwObjNo;
static DWORD s_dwObjNoEx;
static int s_nDeviceNo;
static DWORD s_dwLevels;
static String s_ExceptionBuffer;
static LPCTSTR s_lpMethodName;
static ObjectEntry s_eObjectEntry;
static CDIMapObj* s_lpMapObj;
static FILE *s_pLogFile; // File handle used for outputing to file
static bool s_bException;
static bool ExProcessing(){return s_bException;};
BlockType m_eBlockType;
int m_nExceptionBufferPos;
static bool DumpFlagEx();
static bool DumpFlag(bool bInfoEx);
public:
CAdvancedTracer(
BlockType eBlockType=eSubBT,
LPCTSTR pMethodName=NULL,
ObjectEntry eObjectEntry=eUnknownMethod,
CDIMapObj*lpMapObj=NULL);
CAdvancedTracer(LPCTSTR lpSourceFile,DWORD dwLine,HRESULT hRes);
~CAdvancedTracer();
static void OutputTraceString(LPCTSTR szFmt, ...);
static void OutputTraceStringInfoEx(LPCTSTR szFmt, ...);
static void OutputTraceStringI(bool bInfoEx,LPCTSTR szFmt,
va_list argptr);
static void Dump(LPCTSTR szName,DWORD dwVal);
static void Dump(LPCTSTR szName,int nVal);
static void Dump(LPCTSTR szName,bool bVal);
static void Dump(LPCTSTR szName,LPDIACTIONFORMAT lpVal);
static void Dump(LPCTSTR szName,LPDIDEVICEIMAGEINFOHEADER lpVal);
static void Dump(LPCTSTR szName,LPCTSTR lpVal);
static void Dump(LPCTSTR szName,LPTSTR lpVal);
static void Dump(LPCTSTR szName,LPCGUID lpVal);
static void Dump(LPCTSTR szName,LPCDIDEVICEOBJECTINSTANCE lpVal);
static void Dump(LPCTSTR szName,const GUID &guid);
static void Dump(LPCTSTR szName,String &Val);
static void Dump(LPCTSTR szName,DEVICEOBJLIST &Val);
};
// Initialize to 0 implicitly
DWORD CAdvancedTracer::s_dwFlags;
DWORD CAdvancedTracer::s_dwFlagsEx;
DWORD CAdvancedTracer::s_dwObjNo;
DWORD CAdvancedTracer::s_dwObjNoEx;
int CAdvancedTracer::s_nDeviceNo;
DWORD CAdvancedTracer::s_dwLevels;
String CAdvancedTracer::s_ExceptionBuffer;
LPCTSTR CAdvancedTracer::s_lpMethodName=_T("");
ObjectEntry CAdvancedTracer::s_eObjectEntry=eUnknownMethod;
CDIMapObj* CAdvancedTracer::s_lpMapObj;
FILE *CAdvancedTracer::s_pLogFile;
bool CAdvancedTracer::s_bException;
#define USETRACER() \
CAdvancedTracer \
There_can_be_only_one_USETRACER_macro_per_block;
#define METHOD_ENTRY(MethodName) \
CAdvancedTracer \
There_can_be_only_one_USETRACER_macro_per_block\
(eFunctionBT,_T(#MethodName));
#define OBJECT_ENTRY(MethodName,MethodID) \
CAdvancedTracer \
There_can_be_only_one_USETRACER_macro_per_block\
(eObjectEntryBT,MethodName,MethodID,this);
#define EXCEPTION(lpSourceFile,dwLine,hRes) \
CAdvancedTracer \
There_can_be_only_one_USETRACER_macro_per_block\
(lpSourceFile,dwLine,hRes);
#define CDIMAPOBJ_ENTERED OBJECT_ENTRY\
(_T("CDIMapObj"),eCDIMapObj);
#define _CDIMAPOBJ_ENTERED OBJECT_ENTRY\
(_T("~CDIMapObj"),e_CDIMapObj);
#define ADDREF_ENTERED OBJECT_ENTRY\
(_T("AddRef"),eAddRef);
#define RELEASE_ENTERED OBJECT_ENTRY\
(_T("Release"),eRelease);
#define INITIALIZE_ENTERED OBJECT_ENTRY\
(_T("Initialize"),eInitialize);
#define GETACTIONMAP_ENTERED OBJECT_ENTRY\
(_T("GetActionMap"),eGetActionMap);
#define SAVEACTIONMAP_ENTERED OBJECT_ENTRY\
(_T("SaveActionMap"),eSaveActionMap);
#define GETIMAGEINFO_ENTERED OBJECT_ENTRY\
(_T("GetImageInfo"),eGetImageInfo);
#define WRITEVENDORFILE_ENTERED OBJECT_ENTRY\
(_T("WriteVendorFile"),eWriteVendorFile);
#define TRACE CAdvancedTracer::OutputTraceString
#define TRACEI CAdvancedTracer::OutputTraceStringInfoEx
#define DUMP(P) CAdvancedTracer::Dump(_T(#P),P)
#define DUMPN(N,V) CAdvancedTracer::Dump(N,V)
#define TRACEGUID OutputDebugGuid
void OutputDebugGuid(const GUID &guid);
#define MAP_EXCEPTION(A) MapException(_T(__FILE__),__LINE__,A)
#else //_CHECKED
#define TRACE 1 ? 0 :
#define TRACEI 1 ? 0 :
#define DUMP(a)
#define DUMPN(a,b)
#define USETRACER()
#define METHOD_ENTRY(a)
#define OBJECT_ENTRY(a,b)
#define EXCEPTION(a,b,c)
#define CDIMAPOBJ_ENTERED
#define _CDIMAPOBJ_ENTERED
#define ADDREF_ENTERED
#define RELEASE_ENTERED
#define INITIALIZE_ENTERED
#define GETACTIONMAP_ENTERED
#define SAVEACTIONMAP_ENTERED
#define GETIMAGEINFO_ENTERED
#define WRITEVENDORFILE_ENTERED
#define TRACEGUID 0 ? 1 : (DWORD)&
#define MAP_EXCEPTION(A) MapException(A)
#endif //_CHECKED
#ifdef _CHECKED
CAdvancedTracer::CAdvancedTracer(
BlockType eBlockType,
LPCTSTR pMethodName,
ObjectEntry eObjectEntry,
CDIMapObj*lpMapObj)
{
m_eBlockType=eBlockType;
switch(m_eBlockType)
{
case eObjectEntryBT:
s_bException=false;
//default - no method is dumped
s_dwFlags=GetProfileInt(_T("DEBUG"),_T("dinput.map"),0);
//default - all methods are dumped during exception
s_dwFlagsEx=GetProfileInt(_T("DEBUG"),_T("dinput.mapex"),-1);
//default - all objects are dumped
s_dwObjNo=GetProfileInt(_T("DEBUG"),_T("dinput.mapobj"),-1);
//default - all objects are dumped during exception
s_dwObjNoEx=GetProfileInt(_T("DEBUG"),_T("dinput.mapobjex"),-1);
s_nDeviceNo=lpMapObj->GetDeviceNo();
s_dwLevels=0;
s_ExceptionBuffer.resize(0);
s_lpMethodName=pMethodName;
s_eObjectEntry=eObjectEntry;
s_lpMapObj=lpMapObj;
s_pLogFile=NULL; // File handle used for outputing to file
m_nExceptionBufferPos=0;
TCHAR F[1024];
if((GetProfileString(_T("DEBUG"),
_T("dinput.maplogfile"),_T(""),
F,1024)!=1023)&&F[0])
{
F[1023]=0;
s_pLogFile=_tfopen(F,_T("a+"));
}
TRACE(_T("____________________________________\
___________________________________________\n"));
TRACE(_T("%s() entered, dump method id=%u, dump object id=%u\n"),
s_lpMethodName,s_eObjectEntry,s_nDeviceNo);
TRACE(_T("{\n"));
break;
case eFunctionBT:
m_nExceptionBufferPos=s_ExceptionBuffer.size();
TRACE(_T("%s()\n"),pMethodName);
TRACE(_T("{\n"));
break;
case eSubBT:
m_nExceptionBufferPos=s_ExceptionBuffer.size();
break;
}
s_dwLevels++;
}
CAdvancedTracer::CAdvancedTracer(
LPCTSTR lpSourceFile,
DWORD dwLine,
HRESULT hRes)
{
m_eBlockType=eException;
s_bException=true;
DWORD dwOldLevels=s_dwLevels;
s_dwLevels=0;
TRACE(_T("MAPPER ERROR ******************************\n"));
TRACE(_T("ERROR IN FILE: %s\n"),lpSourceFile);
TRACE(_T("ERROR ON LINE: %d\n"),dwLine);
TRACE(_T("hRes=0x%x\n"),hRes);
switch(hRes)
{
case E_SYNTAX_ERROR:
TRACE(_T("hRes=E_SYNTAX_ERROR\n"));
break;
case E_DEFINITION_NOT_FOUND:
TRACE(_T("hRes=E_DEFINITION_NOT_FOUND\n"));
break;
case E_LINE_TO_LONG:
TRACE(_T("hRes=E_LINE_TO_LONG\n"));
break;
case E_ACTION_NOT_DEFINED:
TRACE(_T("hRes=E_ACTION_NOT_DEFINED\n"));
break;
case E_DEVICE_NOT_DEFINED:
TRACE(_T("hRes=E_DEVICE_NOT_DEFINED\n"));
break;
case E_VENDORID_NOT_FOUND:
TRACE(_T("hRes=E_VENDORID_NOT_FOUND\n"));
break;
case E_PRODUCTID_NOT_FOUND:
TRACE(_T("hRes=E_PRODUCTID_NOT_FOUND\n"));
break;
case E_USAGE_NOT_FOUND:
TRACE(_T("hRes=E_USAGE_NOT_FOUND\n"));
break;
case E_USAGEPAGE_NOT_FOUND:
TRACE(_T("hRes=E_USAGEPAGE_NOT_FOUND\n"));
break;
case E_DEVICE_NOT_FOUND:
TRACE(_T("hRes=E_DEVICE_NOT_FOUND\n"));
break;
case E_BAD_VERSION:
TRACE(_T("hRes=E_BAD_VERSION\n"));
break;
case E_DEVICE_MISSING_CONTROL:
TRACE(_T("hRes=E_DEVICE_MISSING_CONTROL\n"));
break;
case E_DEV_OBJ_NOT_FOUND:
TRACE(_T("hRes=E_DEV_OBJ_NOT_FOUND\n"));
break;
case E_CTRL_W_OFFSET_NOTFOUND:
TRACE(_T("hRes=E_CTRL_W_OFFSET_NOTFOUND\n"));
break;
case E_FILENAME_TO_LONG:
TRACE(_T("hRes=E_FILENAME_TO_LONG\n"));
break;
case E_WRONG_ALIGN_DATA:
TRACE(_T("hRes=E_WRONG_ALIGN_DATA\n"));
break;
case E_CORRUPT_IMAGE_DATA:
TRACE(_T("hRes=E_CORRUPT_IMAGE_DATA\n"));
break;
case E_OUTOFMEMORY:
TRACE(_T("hRes=E_OUTOFMEMORY\n"));
break;
case E_INVALIDARG:
TRACE(_T("hRes=E_INVALIDARG\n"));
break;
case DIERR_NOTINITIALIZED:
TRACE(_T("hRes=DIERR_NOTINITIALIZED\n"));
break;
case E_FAIL:
TRACE(_T("hRes=E_FAIL\n"));
break;
default :
TRACE(_T("hRes=UNKNOWN ERROR.\n"));
break;
}
TRACE(_T("ERROR INFO:\n"));
if(DumpFlagEx())
{
if(s_ExceptionBuffer.data())
{
LPCTSTR p=s_ExceptionBuffer.data();
TCHAR C[2];
C[1]=0;
while(*p)
{
C[0]=*p;
OutputDebugString(C);
Sleep(0);
p++;
};
//OutputDebugString(s_ExceptionBuffer.data());
if (s_pLogFile)
{
_ftprintf(s_pLogFile,s_ExceptionBuffer.data());
}
}
}
TRACE(_T("ERROR HAPPENED HERE -->\n"));
s_ExceptionBuffer.resize(0);
s_dwLevels=dwOldLevels+1;
}
CAdvancedTracer::~CAdvancedTracer()
{
--s_dwLevels;
switch(m_eBlockType)
{
case eObjectEntryBT:
TRACE(_T("}\n"));
TRACE(_T("%s leaving\n"),s_lpMethodName);
TRACE(_T("____________________________________\
___________________________________________\n"));
s_dwFlags=0;
s_dwFlagsEx=-1;
s_dwObjNo=-1;
s_dwObjNoEx=-1;
s_nDeviceNo=-1;
s_dwLevels=0;
s_ExceptionBuffer.resize(0);
s_lpMethodName=_T("");
s_eObjectEntry=eUnknownMethod;
s_lpMapObj=NULL;
if(s_pLogFile)
fclose(s_pLogFile);
s_pLogFile=NULL;
break;
case eFunctionBT:
TRACE(_T("}\n"));
break;
case eSubBT:
break;
case eException:
break;
}
if((m_eBlockType!=eObjectEntryBT)&&
(m_eBlockType!=eSubBT))
{
if(!ExProcessing())
s_ExceptionBuffer.resize(m_nExceptionBufferPos);
}
}
bool CAdvancedTracer::DumpFlag(bool bInfoEx)
{
if((s_dwObjNo==-1)||(s_dwObjNo==s_nDeviceNo))
if(s_dwFlags&s_eObjectEntry)
return true;
if(bInfoEx)
if((s_dwObjNoEx==-1)||(s_dwObjNoEx==s_nDeviceNo))
if(s_dwFlagsEx&s_eObjectEntry)
return true;
return false;
}
bool CAdvancedTracer::DumpFlagEx()
{
if((s_dwObjNoEx==-1)||(s_dwObjNoEx==s_nDeviceNo))
if(s_dwFlagsEx&s_eObjectEntry)
return true;
return false;
}
void CAdvancedTracer::OutputTraceString(LPCTSTR szFmt, ...)
{
va_list argptr;
va_start(argptr, szFmt);
OutputTraceStringI(false,szFmt,argptr);
va_end(argptr);
}
void CAdvancedTracer::OutputTraceStringInfoEx(LPCTSTR szFmt, ...)
{
va_list argptr;
va_start(argptr, szFmt);
OutputTraceStringI(true,szFmt,argptr);
va_end(argptr);
}
// Warning: This function is not thread safe.
void CAdvancedTracer::OutputTraceStringI(bool bInfoEx,
LPCTSTR szFmt,va_list argptr)
{
const cBufSize=1024;
TCHAR szBuf[cBufSize];
szBuf[cBufSize-1]=0;
// Print the identation first
int nCnt=s_dwLevels;
if(nCnt>cBufSize-1)nCnt=cBufSize-1;
for (DWORD i = 0; i < nCnt; ++i)
{
szBuf[i]=_T(' ');
}
szBuf[i]=0;
// Then print the content
#ifdef WIN95
{
char *psz = NULL;
char szDfs[1024]={0};
strcpy(szDfs,szFmt); // make a local copy of format string
while (psz = strstr(szDfs,"%p")) // find each %p
*(psz+1) = 'x'; // replace each %p with %x
_vsntprintf(&szBuf[i], cBufSize-1-i, szDfs, argptr); // use the local format string
}
#else
{
_vsntprintf(&szBuf[i], cBufSize-1-i, szFmt, argptr);
}
#endif
szBuf[cBufSize-1]=0;
if((!ExProcessing())&&DumpFlagEx())
s_ExceptionBuffer+=szBuf;
if(DumpFlag(bInfoEx)||(ExProcessing()&&DumpFlagEx()))
{
OutputDebugString(szBuf);
if (s_pLogFile)
{
_ftprintf(s_pLogFile, szBuf);
}
}
}
void CAdvancedTracer::Dump(LPCTSTR szName,DWORD dwVal)
{
TRACE(_T("%s=%u\n"),szName,(unsigned int)dwVal);
}
void CAdvancedTracer::Dump(LPCTSTR szName,int nVal)
{
TRACE(_T("%s=%d\n"),szName,(unsigned int)nVal);
}
void CAdvancedTracer::Dump(LPCTSTR szName,String &Val)
{
if(Val.data())
TRACE(_T("%s=%s\n"),szName,Val.data());
else
TRACE(_T("%s=NULL\n"),szName);
}
void CAdvancedTracer::Dump(LPCTSTR szName,bool bVal)
{
TRACE(_T("%s=%u\n"),szName,(unsigned int)bVal);
}
void CAdvancedTracer::Dump(LPCTSTR szName,DEVICEOBJLIST &Val)
{
TRACE(_T("%s:\n"),szName);
USETRACER();
TRACE(_T("UsagePage\tUsage\tType\tFlags\tName\n"));
DEVICEOBJLIST::iterator DevObjIt;
for(DevObjIt=Val.begin();DevObjIt!=Val.end();DevObjIt++)
{
TRACE(_T("%u\t%u\t0x%x\t0x%x\t%s\n"),
DevObjIt->dwUsagePage,
DevObjIt->dwUsage,
DevObjIt->dwType,
DevObjIt->dwFlags,
DevObjIt->Name.data());
}
}
void CAdvancedTracer::Dump(LPCTSTR szName,LPDIACTIONFORMAT lpVal)
{
// 7/18/2000(a-JiTay): IA64: Use %p format specifier for 32/64-bit pointers.
TRACE(_T("%s=0x%p\n"),szName,lpVal);
if(lpVal)
{
USETRACER();
TRACE(_T("dwSize=%u\tdwActionSize=%u\n"),
(unsigned int)lpVal->dwSize,
(unsigned int)lpVal->dwActionSize);
TRACE(_T("guidActionMap="));TRACEGUID(lpVal->guidActionMap);
TRACE(_T("dwGenre=0x%x\tGenre=%u\n"),
(unsigned int)lpVal->dwGenre,
(unsigned int)DISEM_GENRE_GET(lpVal->dwGenre));
TRACE(_T("dwNumActions=%u\trgoAction=0x%x\n"),
(unsigned int)lpVal->dwNumActions,
lpVal->rgoAction);
TRACE(_T("ftTimeStamp.dwHighDateTime=0x%x\t"),
(unsigned int)lpVal->ftTimeStamp.dwHighDateTime);
TRACE(_T("ftTimeStamp.dwLowDateTime=0x%x\n"),
(unsigned int)lpVal->ftTimeStamp.dwLowDateTime);
// 7/18/2000(a-JiTay): IA64: Use %p format specifier for 32/64-bit pointers.
TRACE(_T("rgoAction=0x%p\n"),lpVal);
if(lpVal->rgoAction)
{
USETRACER();
TRACE(_T("Action No\tdwSemantic\tSemantic\tSemantic type\tdwFlags\t\
dwObjID\tdwHow\tguidInstance\n"));
for(DWORD i=0;i<lpVal->dwNumActions;i++)
{
LPCTSTR p;
if(DISEM_TYPE_GET(lpVal->rgoAction[i].dwSemantic)==
DISEM_TYPE_GET(DISEM_TYPE_AXIS))
p=_T("DISEM_TYPE_AXIS");
else if(DISEM_TYPE_GET(lpVal->rgoAction[i].dwSemantic)==
DISEM_TYPE_GET(DISEM_TYPE_BUTTON))
p=_T("DISEM_TYPE_BUTTON");
else if(DISEM_TYPE_GET(lpVal->rgoAction[i].dwSemantic)==
DISEM_TYPE_GET(DISEM_TYPE_POV))
p=_T("DISEM_TYPE_POV");
else
p=_T("");
TRACE(_T("%u\t0x%x\t%u\t%u %s\t0x%x\t0x%x\t0x%x\t"),
i,
(unsigned int)lpVal->rgoAction[i].dwSemantic,
(unsigned int)DISEM_INDEX_GET
(lpVal->rgoAction[i].dwSemantic),
(unsigned int)DISEM_TYPE_GET
(lpVal->rgoAction[i].dwSemantic),p,
(unsigned int)lpVal->rgoAction[i].dwFlags,
(unsigned int)lpVal->rgoAction[i].dwObjID,
(unsigned int)lpVal->rgoAction[i].dwHow);
TRACEGUID(lpVal->rgoAction[i].guidInstance);
}
}
}
}
void CAdvancedTracer::Dump(LPCTSTR szName,LPDIDEVICEIMAGEINFOHEADER lpVal)
{
// 7/18/2000(a-JiTay): IA64: Use %p format specifier for 32/64-bit pointers.
TRACE(_T("%s=0x%p\n"),szName,lpVal);
if(lpVal)
{
USETRACER();
TRACE(_T("dwSize=%u\tdwSizeImageInfo=%u\n"),
(unsigned int)lpVal->dwSize,
(unsigned int)lpVal->dwSizeImageInfo);
TRACE(_T("dwcViews=%u\tdwcButtons=%u\n"),
(unsigned int)lpVal->dwcViews,
(unsigned int)lpVal->dwcButtons);
TRACE(_T("dwcAxes=%u\tdwcPOVs=%u\n"),
(unsigned int)lpVal->dwcAxes,
(unsigned int)lpVal->dwcPOVs);
TRACE(_T("dwBufferSize=%u\tdwBufferUsed=%u\n"),
(unsigned int)lpVal->dwBufferSize,
(unsigned int)lpVal->dwBufferUsed);
// 7/18/2000(a-JiTay): IA64: Use %p format specifier for 32/64-bit pointers.
TRACE(_T("lprgImageInfoArray=0x%p\n"),lpVal->lprgImageInfoArray);
if(lpVal->lprgImageInfoArray)
{
USETRACER();
TRACE(_T("tszImagePath\ndwFlags\tdwViewID\trcOverlay\tdwObjID\t\
dwcValidPts\trcCalloutRect\tdwTextAlign\n"));
for(DWORD i=0;i<(lpVal->dwBufferSize/
sizeof(lpVal->lprgImageInfoArray[0]));i++)
{
TCHAR tszImagePath[MAX_PATH];
memcpy(&tszImagePath,
&lpVal->lprgImageInfoArray[i].tszImagePath,
sizeof(tszImagePath));
tszImagePath[MAX_PATH-1]=0;
TRACE(_T("%s\n"),&tszImagePath);
TRACE(_T("0x%x\t"),lpVal->lprgImageInfoArray[i].dwFlags);
TRACE(_T("%u\t"),lpVal->lprgImageInfoArray[i].dwViewID);
TRACE(_T("[%u,%u],[%u,%u]\t"),
lpVal->lprgImageInfoArray[i].rcOverlay.left,
lpVal->lprgImageInfoArray[i].rcOverlay.top,
lpVal->lprgImageInfoArray[i].rcOverlay.right,
lpVal->lprgImageInfoArray[i].rcOverlay.bottom);
TRACE(_T("0x%x\t"),lpVal->lprgImageInfoArray[i].dwObjID);
TRACE(_T("%u\t"),lpVal->lprgImageInfoArray[i].dwcValidPts);
const int nPnts=
sizeof(lpVal->lprgImageInfoArray[i].rgptCalloutLine)/
sizeof(lpVal->lprgImageInfoArray[i].rgptCalloutLine[0]);
TRACE(_T("[%u,%u],[%u,%u]\t"),
lpVal->lprgImageInfoArray[i].rcCalloutRect.left,
lpVal->lprgImageInfoArray[i].rcCalloutRect.top,
lpVal->lprgImageInfoArray[i].rcCalloutRect.right,
lpVal->lprgImageInfoArray[i].rcCalloutRect.bottom);
TRACE(_T("0x%x\n"),lpVal->lprgImageInfoArray[i].dwTextAlign);
}
}
}
}
void CAdvancedTracer::Dump(LPCTSTR szName,LPCTSTR lpVal)
{
if(lpVal)
TRACE(_T("%s=%s\n"),szName,lpVal);
else
TRACE(_T("%s=NULL\n"),szName);
}
void CAdvancedTracer::Dump(LPCTSTR szName,LPTSTR lpVal)
{
Dump(szName,(LPCTSTR)lpVal);
}
void CAdvancedTracer::Dump(LPCTSTR szName,LPCDIDEVICEOBJECTINSTANCE lpVal)
{
// 7/18/2000(a-JiTay): IA64: Use %p format specifier for 32/64-bit pointers.
TRACE(_T("%s=0x%p\n"),szName,lpVal);
if(lpVal)
{
USETRACER();
// 7/18/2000(a-JiTay): IA64: Use %p format specifier for 32/64-bit pointers.
TRACE(_T("tszName=0x%p\n"),lpVal->tszName);
if(lpVal->tszName)
{
USETRACER();
TRACE(_T("%s\n"),lpVal->tszName);
}
TRACE(_T("dwOfs=%u\n"),(unsigned int)lpVal->dwOfs);
TRACE(_T("wUsagePage=%u\n"),(unsigned int)lpVal->wUsagePage);
TRACE(_T("wUsage=%u\n"),(unsigned int)lpVal->wUsage);
TRACE(_T("dwType=%u\n"),(unsigned int)lpVal->dwType);
if(lpVal->dwType&DIDFT_RELAXIS)
TRACE(_T("dwType&=DIDFT_RELAXIS\n"));
if(lpVal->dwType&DIDFT_ABSAXIS)
TRACE(_T("dwType&=DIDFT_ABSAXIS\n"));
if(lpVal->dwType&DIDFT_PSHBUTTON)
TRACE(_T("dwType&=DIDFT_PSHBUTTON\n"));
if(lpVal->dwType&DIDFT_TGLBUTTON)
TRACE(_T("dwType&=DIDFT_TGLBUTTON\n"));
if(lpVal->dwType&DIDFT_POV)
TRACE(_T("dwType&=DIDFT_POV\n"));
}
}
void CAdvancedTracer::Dump(LPCTSTR szName,const GUID &guid)
{
TRACE(_T("%s="),szName);
OutputDebugGuid(guid);
}
void CAdvancedTracer::Dump(LPCTSTR szName,LPCGUID lpVal)
{
if(lpVal)
{
TRACE(_T("%s="),szName);
OutputDebugGuid(*lpVal);
}
else
TRACE(_T("%s=NULL\n"),szName);
}
void OutputDebugGuid(const GUID &guid)
{
TRACE(_T("{%08X-%04hX-%04hX-%02hX%02hX-%02X%02X%02X%02X%02X%02X}\n"),
guid.Data1,
guid.Data2,
guid.Data3,
(WORD)guid.Data4[0], (WORD)guid.Data4[1],
(WORD)guid.Data4[2], (WORD)guid.Data4[3],
(WORD)guid.Data4[4], (WORD)guid.Data4[5],
(WORD)guid.Data4[6], (WORD)guid.Data4[7]);
}
#endif //_CHECKED
/******************************************************************************
*
* Exception Handler
*
*****************************************************************************/
MapException::MapException(
#ifdef _CHECKED
LPCTSTR lpSourceFile,DWORD dwLine,
#endif
HRESULT hRes)
{
m_hRes=hRes;
EXCEPTION(lpSourceFile,dwLine,hRes);
}
/******************************************************************************
*
* String Processing
*
*****************************************************************************/
void ToUpper(String &S)
{
CharUpperBuff((LPTSTR)S.data(),S.size());
for(StrIter B=S.begin();B<S.end();B++)
{
if(!IsSpace(*B))break;
}
for(StrIter E=S.end();E>S.begin();E--)
{
if(!(IsSpace(*(E-1))||(0==*(E-1))))break;
}
String R;
while(B<E)
{
if(*B)
R+=*B;
B++;
}
S=R;
}
String GUID2String(const GUID &G)
{
String Ret;
OLECHAR S[256];
if(!StringFromGUID2(G,S,255))
throw MAP_EXCEPTION(E_OUTOFMEMORY);
S[255]=0;
int i;
for(i=0;i<256;i++)
{
if(!S[i])break;
Ret+=(TCHAR)__toascii(S[i]);
}
ToUpper(Ret);
return Ret;
}
String N2Str(DWORD N)
{
String Ret;
_TCHAR S[32];
if(_sntprintf(S,32,_T("%d"),N)<0)
throw MAP_EXCEPTION(E_OUTOFMEMORY);
S[31]=0;
Ret=S;
return Ret;
}
void SkipWS(StrIter &Pos)
{
while(IsSpace(*Pos))
Pos++;
}
BOOL IsComma(StrIter &Pos)
{
if(*Pos==SEPARATOR)
{
Pos++;
return TRUE;
}
return FALSE;
}
void Eat(StrIter &Pos,TCHAR Ch)
{
if(*Pos!=Ch)
{
TRACE(_T("Error in ini file, key value.\n"));
throw MAP_EXCEPTION(E_SYNTAX_ERROR);
}
Pos++;
}
DWORD GetNum(StrIter &Pos)
{
DWORD dwRet=0;
String S;
StrIter OldPos;
OldPos=Pos;
//Read each character, verify it is a number and append
while(isdigit(*Pos))
{
S+=*Pos;
Pos++;
}
if(Pos==OldPos)//There must be a string
{
TRACE(_T("Error in ini file, in key numeric value.\n"));
throw MAP_EXCEPTION(E_SYNTAX_ERROR);
}
int nR=_stscanf(S.data(),_T("%d"),&dwRet);
if((nR==EOF)||(nR=0))
{
TRACE(_T("Error in ini file, in key numeric value.\n"));
throw MAP_EXCEPTION(E_SYNTAX_ERROR);
}
return dwRet;
}
bool ReadString(StrIter &Pos,String &S,bool bNoStringOK=false)
{
StrIter OldPos;
//String has no white spaces
OldPos=Pos;
//Read each character, verify it is a string character and append
while(!((*Pos==SEPARATOR)||(*Pos==0)))
{
S+=*Pos;
Pos++;
}
if(Pos==OldPos)//If no string
{
if(!bNoStringOK)
{
TRACE(_T("Error in ini file, in key string.\n"));
throw MAP_EXCEPTION(E_SYNTAX_ERROR);
}
else
return false;
}
return true;
}
bool LoadString(String &S,LPCTSTR lpFileName,LPCTSTR lpSectionName,
LPCTSTR lpKeyName,bool bNoThrow=false)
{
METHOD_ENTRY(LoadString);
DUMP(lpFileName);
DUMP(lpSectionName);
DUMP(lpKeyName);
//Load line from a file
TCHAR L[1024];
if(GetPrivateProfileString(lpSectionName,lpKeyName,RESERVED_STRING,
L,1024,lpFileName)==1023)
{
TRACE(_T("Line in file is too long.\n"));
throw MAP_EXCEPTION(E_LINE_TO_LONG);
}
L[1023]=0;
String Line=L;
if((Line==RESERVED_STRING)||(Line==_T("")))
{
if(!bNoThrow)
{
TRACE(_T("No such section, key or key is empty.\n"));
throw MAP_EXCEPTION(E_DEFINITION_NOT_FOUND);
}
else
return false;
}
S=_T("");
StrIter Pos=Line.begin();
//Read single string
ReadString(Pos,S);
//To upper case and throw away spaces infront and back
ToUpper(S);
if(S==_T(""))//There must be a string
{
TRACE(_T("No such section, key or key is empty.\n"));
throw MAP_EXCEPTION(E_SYNTAX_ERROR);
}
//Must end with 0
if(*Pos!=0)
{
TRACE(_T("String corrupted.\n"));
throw MAP_EXCEPTION(E_SYNTAX_ERROR);
}
return true;
}
bool LoadPointArray(LPCTSTR lpFileName,LPCTSTR lpSectionName,
LPCTSTR lpKeyName,LPPOINT pPt,DWORD &dwCount,DWORD dwSize)
{
METHOD_ENTRY(LoadPointArray);
DUMP(lpFileName);
DUMP(lpSectionName);
DUMP(lpKeyName);
dwCount=0;
//Load line with strings
TCHAR L[1024];
if(GetPrivateProfileString(lpSectionName,lpKeyName,RESERVED_STRING,
L,1024,lpFileName)==1023)
{
TRACE(_T("Line in file is too long.\n"));
throw MAP_EXCEPTION(E_LINE_TO_LONG);
}
L[1023]=0;
String Line=L;
if((Line==RESERVED_STRING)||(Line==_T("")))
return false;
ToUpper(Line);
StrIter Pos=Line.begin();
do
{
if(dwCount==dwSize)
break;
SkipWS(Pos);
Eat(Pos,_T('('));
pPt[dwCount].x=GetNum(Pos);
SkipWS(Pos);
Eat(Pos,_T(','));
SkipWS(Pos);
pPt[dwCount].y=GetNum(Pos);
SkipWS(Pos);
Eat(Pos,_T(')'));
SkipWS(Pos);
dwCount++;
//Repeat while comma is found
}while(IsComma(Pos));
// if(!dwCount)
// throw MAP_EXCEPTION4(E_SYNTAX_ERROR);
return true;
}
bool LoadListOfStrings(LPCTSTR lpFileName,LPCTSTR lpSectionName,
LPCTSTR lpKeyName,STRINGLIST &StrList,
bool bNoThrow=false)
{
METHOD_ENTRY(LoadListOfStrings);
DUMP(lpFileName);
DUMP(lpSectionName);
DUMP(lpKeyName);
//Load line with strings
TCHAR L[1024];
if(GetPrivateProfileString(lpSectionName,lpKeyName,RESERVED_STRING,
L,1024,lpFileName)==1023)
{
TRACE(_T("Line in file is too long.\n"));
throw MAP_EXCEPTION(E_LINE_TO_LONG);
}
L[1023]=0;
String Line=L;
if((Line==RESERVED_STRING)||(Line==_T("")))
{
if(!bNoThrow)
{
TRACE(_T("No such section, key or key is empty.\n"));
throw MAP_EXCEPTION(E_DEFINITION_NOT_FOUND);
}
else
return false;
}
StrIter Pos=Line.begin();
CS S;
//Read first string, must be there
ReadString(Pos,S);
//To upper case and throw away spaces infront and back
ToUpper(S);
if(S==_T(""))//There must be a string
{
TRACE(_T("No such section, key or key is empty.\n"));
throw MAP_EXCEPTION(E_SYNTAX_ERROR);
}
//Store string into the list
StrList.push_back(S);
//Repeat while comma is found
while(IsComma(Pos))
{
CS S;
//Read next string, does not have to be there
if(ReadString(Pos,S,true))
{
//String found
//To upper case and throw away spaces infront and back
ToUpper(S);
//Check if string, if no cont.
if(S==_T(""))
continue;
//Store string into the list
StrList.push_back(S);
}
}
if(*Pos!=0)//Must end with 0
{
TRACE(_T("Corrupt string list.\n"));
throw MAP_EXCEPTION(E_SYNTAX_ERROR);
}
return true;
}
void WritePrivateProfileIntX(LPCTSTR lpAppName,LPCTSTR lpKeyName,
UINT Value,LPCTSTR lpFileName)
{
METHOD_ENTRY(WritePrivateProfileIntX);
DUMP(lpFileName);
DUMP(lpAppName);
DUMP(lpKeyName);
TCHAR ValBuf[16];
wsprintf(ValBuf,TEXT("0x%X"),Value);
if(!WritePrivateProfileString(lpAppName,lpKeyName,
ValBuf,lpFileName))
{
TRACE(_T("Error writing ini file.\n"));
throw MAP_EXCEPTION(HRESULT_FROM_WIN32(GetLastError()));
}
}
void WritePrivateProfileInt(LPCTSTR lpAppName,LPCTSTR lpKeyName,
INT Value,LPCTSTR lpFileName)
{
METHOD_ENTRY(WritePrivateProfileInt);
DUMP(lpFileName);
DUMP(lpAppName);
DUMP(lpKeyName);
TCHAR ValBuf[16];
wsprintf(ValBuf,TEXT("%i"),Value);
if(!WritePrivateProfileString(lpAppName,lpKeyName,
ValBuf,lpFileName))
{
TRACE(_T("Error writing ini file.\n"));
throw MAP_EXCEPTION(HRESULT_FROM_WIN32(GetLastError()));
}
}
void WriteRect(LPCTSTR pSection,LPCTSTR pKey,LPRECT pR,LPCTSTR pFile)
{
METHOD_ENTRY(WriteRect);
DUMP(pFile);
DUMP(pSection);
DUMP(pKey);
String Rect;
Rect+=_T("(")+N2Str(pR->left)+_T(",")+N2Str(pR->top)+
_T("),(")+N2Str(pR->right)+_T(",")+N2Str(pR->bottom)+_T(")");
if(!WritePrivateProfileString(pSection,pKey,Rect.data(),pFile))
{
TRACE(_T("Error writing ini file.\n"));
throw MAP_EXCEPTION(HRESULT_FROM_WIN32(GetLastError()));
}
}
void WritePointArray(LPCTSTR pSection,LPCTSTR pKey,LPPOINT pP,
int N,LPCTSTR pFile)
{
METHOD_ENTRY(WritePointArray);
DUMP(pFile);
DUMP(pSection);
DUMP(pKey);
String LineData;
for(DWORD i=0;i<N;i++)
{
LineData+=_T("(")+N2Str(pP[i].x)+_T(",")+N2Str(pP[i].y)+_T(")");
if(i<(N-1))
LineData+=_T(",");
}
if(!WritePrivateProfileString(pSection,pKey,LineData.data(),pFile))
{
TRACE(_T("Error writing ini file.\n"));
throw MAP_EXCEPTION(HRESULT_FROM_WIN32(GetLastError()));
}
}
void WriteListOfStrings(LPCTSTR pSection,LPCTSTR pKey,
STRINGLIST &Values,LPCTSTR pFile)
{
METHOD_ENTRY(WriteListOfStrings);
DUMP(pFile);
DUMP(pSection);
DUMP(pKey);
if(!Values.size())return;
String List;
List=*Values.begin();
STRINGLIST::iterator ValuesIt=Values.begin();
ValuesIt++;
for(;ValuesIt!=Values.end();ValuesIt++)
List=List+_T(",")+*ValuesIt;
if(!WritePrivateProfileString(pSection,pKey,List.data(),pFile))
{
TRACE(_T("Error writing ini file.\n"));
throw MAP_EXCEPTION(HRESULT_FROM_WIN32(GetLastError()));
}
}
void MakeUniqueName(String &InitialName,STRINGLIST &Names)
{
METHOD_ENTRY(MakeUniqueName);
for(int i=0;i<10000;i++)
{
CS S;
S.assign(InitialName);
if(i)
{
S+=_T("_");;
S+=N2Str(i);
}
if(find(Names.begin(),Names.end(),S)==Names.end())
{
InitialName=S;
Names.push_back(S);
break;
}
}
if(i==10000)//Could not find unique name after 10000 tries ???!!!
{
TRACE(_T("Could not generate unique name!?!?\n"));
throw MAP_EXCEPTION(E_DEVICE_NOT_DEFINED);
}
}
/******************************************************************************
*
* Directory/filename functions
*
*****************************************************************************/
void GetDirectory(LPCTSTR lpFullName,String &FullDir)
{
if(lpFullName)
{
TCHAR Drive[_MAX_DRIVE];Drive[0]=0;
TCHAR Dir[_MAX_DIR];Dir[0]=0;
// TCHAR FName[_MAX_FNAME];
// TCHAR Ext[_MAX_EXT];
_tsplitpath(lpFullName,Drive,Dir,NULL,NULL);
FullDir=Drive;
FullDir+=Dir;
}
}
void StripDirectory(LPCTSTR lpFullName,String &FileName)
{
if(lpFullName)
{
// TCHAR Drive[_MAX_DRIVE];Drive[0]=0;
// TCHAR Dir[_MAX_DIR];Dir[0]=0;
TCHAR FName[_MAX_FNAME];
TCHAR Ext[_MAX_EXT];
_tsplitpath(lpFullName,NULL,NULL,FName,Ext);
FileName=FName;
FileName+=Ext;
}
}
void GetHexCode(String &Ret,char In)
{
switch(In&0x0f)
{
case 0x00:Ret+=_T('0');break;
case 0x01:Ret+=_T('1');break;
case 0x02:Ret+=_T('2');break;
case 0x03:Ret+=_T('3');break;
case 0x04:Ret+=_T('4');break;
case 0x05:Ret+=_T('5');break;
case 0x06:Ret+=_T('6');break;
case 0x07:Ret+=_T('7');break;
case 0x08:Ret+=_T('8');break;
case 0x09:Ret+=_T('9');break;
case 0x0A:Ret+=_T('A');break;
case 0x0B:Ret+=_T('B');break;
case 0x0C:Ret+=_T('C');break;
case 0x0D:Ret+=_T('D');break;
case 0x0E:Ret+=_T('E');break;
case 0x0F:Ret+=_T('F');break;
}
}
void MakeUniqueUserName(String &Ret,
LPCTSTR pIn)
{
Ret=_T("");
for(const TCHAR *p=pIn;*p!=0;p++)
{
switch(*p)
{
case _T('A'):
case _T('a'):Ret+=_T('A');break;
case _T('B'):
case _T('b'):Ret+=_T('B');break;
case _T('C'):
case _T('c'):Ret+=_T('C');break;
case _T('D'):
case _T('d'):Ret+=_T('D');break;
case _T('E'):
case _T('e'):Ret+=_T('E');break;
case _T('F'):
case _T('f'):Ret+=_T('F');break;
case _T('G'):
case _T('g'):Ret+=_T('G');break;
case _T('H'):
case _T('h'):Ret+=_T('H');break;
case _T('I'):
case _T('i'):Ret+=_T('I');break;
case _T('J'):
case _T('j'):Ret+=_T('J');break;
case _T('K'):
case _T('k'):Ret+=_T('K');break;
case _T('L'):
case _T('l'):Ret+=_T('L');break;
case _T('M'):
case _T('m'):Ret+=_T('M');break;
case _T('N'):
case _T('n'):Ret+=_T('N');break;
case _T('O'):
case _T('o'):Ret+=_T('O');break;
case _T('P'):
case _T('p'):Ret+=_T('P');break;
case _T('Q'):
case _T('q'):Ret+=_T('Q');break;
case _T('R'):
case _T('r'):Ret+=_T('R');break;
case _T('S'):
case _T('s'):Ret+=_T('S');break;
case _T('T'):
case _T('t'):Ret+=_T('T');break;
case _T('U'):
case _T('u'):Ret+=_T('U');break;
case _T('V'):
case _T('v'):Ret+=_T('V');break;
case _T('W'):
case _T('w'):Ret+=_T('W');break;
//X: Special case. Make sure it is consistent
//with special case elsewhere.
case _T('X'):
case _T('x'):Ret+=_T("XX");break;
case _T('Y'):
case _T('y'):Ret+=_T('Y');break;
case _T('Z'):
case _T('z'):Ret+=_T('Z');break;
case _T('1'):Ret+=_T('1');break;
case _T('2'):Ret+=_T('2');break;
case _T('3'):Ret+=_T('3');break;
case _T('4'):Ret+=_T('4');break;
case _T('5'):Ret+=_T('5');break;
case _T('6'):Ret+=_T('6');break;
case _T('7'):Ret+=_T('7');break;
case _T('8'):Ret+=_T('8');break;
case _T('9'):Ret+=_T('9');break;
case _T('0'):Ret+=_T('0');break;
case _T(' '):Ret+=_T(' ');break;
case _T('('):Ret+=_T('(');break;
case _T(')'):Ret+=_T(')');break;
case _T('.'):Ret+=_T('.');break;
case _T('_'):Ret+=_T('_');break;
case _T('-'):Ret+=_T('-');break;
case _T('&'):Ret+=_T('&');break;
default:
//X: Special case. Make sure it is consistent
//with special case elsewhere.
Ret+=_T("X");
GetHexCode(Ret,(*p)>>12);
GetHexCode(Ret,(*p)>>8);
GetHexCode(Ret,(*p)>>4);
GetHexCode(Ret,*p);
break;
}
}
}
void MakeUniqueDeviceName(String &Ret,
LPCWSTR pIn/*This is hardcoded in dinput to WSTR*/)
{
Ret=_T("");
for(LPCWCH p=pIn;*p!=0;p++)
{
switch(*p)
{
case L'A':
case L'a':Ret+=_T('A');break;
case L'B':
case L'b':Ret+=_T('B');break;
case L'C':
case L'c':Ret+=_T('C');break;
case L'D':
case L'd':Ret+=_T('D');break;
case L'E':
case L'e':Ret+=_T('E');break;
case L'F':
case L'f':Ret+=_T('F');break;
case L'G':
case L'g':Ret+=_T('G');break;
case L'H':
case L'h':Ret+=_T('H');break;
case L'I':
case L'i':Ret+=_T('I');break;
case L'J':
case L'j':Ret+=_T('J');break;
case L'K':
case L'k':Ret+=_T('K');break;
case L'L':
case L'l':Ret+=_T('L');break;
case L'M':
case L'm':Ret+=_T('M');break;
case L'N':
case L'n':Ret+=_T('N');break;
case L'O':
case L'o':Ret+=_T('O');break;
case L'P':
case L'p':Ret+=_T('P');break;
case L'Q':
case L'q':Ret+=_T('Q');break;
case L'R':
case L'r':Ret+=_T('R');break;
case L'S':
case L's':Ret+=_T('S');break;
case L'T':
case L't':Ret+=_T('T');break;
case L'U':
case L'u':Ret+=_T('U');break;
case L'V':
case L'v':Ret+=_T('V');break;
case L'W':
case L'w':Ret+=_T('W');break;
//X: Special case. Make sure it is consistent
//with special case elsewhere.
case L'X':
case L'x':Ret+=_T("XX");break;
case L'Y':
case L'y':Ret+=_T('Y');break;
case L'Z':
case L'z':Ret+=_T('Z');break;
case L'1':Ret+=_T('1');break;
case L'2':Ret+=_T('2');break;
case L'3':Ret+=_T('3');break;
case L'4':Ret+=_T('4');break;
case L'5':Ret+=_T('5');break;
case L'6':Ret+=_T('6');break;
case L'7':Ret+=_T('7');break;
case L'8':Ret+=_T('8');break;
case L'9':Ret+=_T('9');break;
case L'0':Ret+=_T('0');break;
case L' ':Ret+=_T(' ');break;
case L'(':Ret+=_T('(');break;
case L')':Ret+=_T(')');break;
case L'.':Ret+=_T('.');break;
case L'_':Ret+=_T('_');break;
case L'-':Ret+=_T('-');break;
case L'&':Ret+=_T('&');break;
default:
//X: Special case. Make sure it is consistent
//with special case elsewhere.
Ret+=_T("X");
GetHexCode(Ret,(*p)>>12);
GetHexCode(Ret,(*p)>>8);
GetHexCode(Ret,(*p)>>4);
GetHexCode(Ret,*p);
break;
}
}
}
void MakeSubDir(LPCTSTR lpDir)
{
String DirCreationString=lpDir;
DirCreationString+=_T("\\");
LPTSTR lpPos=_tcschr(DirCreationString.data(),_T('\\'));
if(!lpPos)
{
TRACE(_T("Error creating user directory. Invalid parent directory.\n"));
throw MAP_EXCEPTION(E_FAIL);
}
lpPos=_tcschr(lpPos+1,_T('\\'));
if(!lpPos)
{
TRACE(_T("Error creating user directory. Invalid parent directory.\n"));
throw MAP_EXCEPTION(E_FAIL);
}
while(lpPos)
{
*lpPos=0;
if(!CreateDirectory(DirCreationString.data(),NULL))
{
DWORD dwErr=GetLastError();
if(dwErr!=ERROR_ALREADY_EXISTS)
{
TRACE(_T("Error creating user directory.\n"));
throw MAP_EXCEPTION(HRESULT_FROM_WIN32(dwErr));
}
}
*lpPos=_T('\\');
lpPos=_tcschr(lpPos+1,_T('\\'));
}
}
void GetMapFileName(LPCTSTR lpctstrUserName,LPCTSTR lpctstrDeviceName,
int nDeviceInstanceNo,
LPTSTR szFileName/*_MAX_PATH*/,bool bCreateDir=false,
String *lpUserDir=NULL)
{
//Allocate a pointer to an Item ID list
LPITEMIDLIST pidl;
//Get a pointer to an item ID list that
//represents the path of a special folder
HRESULT hRes=S_OK;
DWORD dwVersion=GetVersion();
if(dwVersion<0x80000000)// Windows NT
{
// hRes=SHGetSpecialFolderLocation(NULL,CSIDL_COMMON_APPDATA,&pidl);
hRes=SHGetSpecialFolderLocation(NULL,CSIDL_PROGRAM_FILES_COMMON,&pidl);
if(FAILED(hRes))
{
TRACE(_T("Error calling SHGetSpecialFolderLocation().\n"));
throw MAP_EXCEPTION(hRes);
}
//Convert the item ID list's binary
//representation into a file system path
if(!SHGetPathFromIDList(pidl,szFileName))
{
TRACE(_T("Error calling SHGetPathFromIDList().\n"));
}
//Allocate a pointer to an IMalloc interface
LPMALLOC pMalloc=NULL;
//Get the address of our task allocator's IMalloc interface
SHGetMalloc(&pMalloc);
if((hRes==NOERROR)&&pMalloc)
{
//Free the item ID list allocated by SHGetSpecialFolderLocation
pMalloc->Free(pidl);
//Free our task allocator
pMalloc->Release();
}
#ifdef _CHECKED
else
{
TRACE(_T("RESOURCE LEAK! SHGetMalloc failed, can not free resource.\n"));
}
#endif
}
else// WIn9x
{
//For win9x get directory name from the registry
HKEY Key=0;
if(RegOpenKeyEx(HKEY_LOCAL_MACHINE,
_T("SOFTWARE\\Microsoft\\Windows\\CurrentVersion"),
(DWORD)0,
KEY_QUERY_VALUE,
&Key)!=ERROR_SUCCESS)
{
TRACE(_T("Error calling RegOpenKeyEx(HKEY_LOCAL_MACHINE\
\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion).\n"));
throw MAP_EXCEPTION(E_FAIL);
}
DWORD dwType=REG_SZ;
DWORD dwSize=MAX_PATH*sizeof(TCHAR);
if(RegQueryValueEx(Key,_T("CommonFilesDir"),
NULL,&dwType,(LPBYTE)szFileName,&dwSize)!=ERROR_SUCCESS)
{
TRACE(_T("Error calling RegQueryValueEx(CommonFilesDir).\n"));
throw MAP_EXCEPTION(E_FAIL);
}
RegCloseKey(Key);
}
String DirCreationString=szFileName;
//Check if directory name is too long
if((_tcslen(szFileName)+_tcslen(MAP_DIR)+1)>_MAX_PATH)
{
TRACE(_T("User dir name too long.\n"));
throw MAP_EXCEPTION(E_FAIL);
}
_tcscat(szFileName,MAP_DIR);
if(lpUserDir)*lpUserDir=szFileName;
//Create directory for map files
if(bCreateDir)
{
//Create subdirs one by one
TRACE(_T("Creating user directory %s.\n"),szFileName);
DirCreationString+=DIRECTX;
if(!CreateDirectory(DirCreationString.data(),NULL))
{
DWORD dwErr=GetLastError();
if(dwErr!=ERROR_ALREADY_EXISTS)
{
//could be that Win95 Gold does not have "Common Files" dir
MakeSubDir(DirCreationString.data());
// TRACE(_T("Error creating user directory.\n"));
// throw MAP_EXCEPTION(HRESULT_FROM_WIN32(dwErr));
}
}
DirCreationString+=DIRECTINPUT;
if(!CreateDirectory(DirCreationString.data(),NULL))
{
DWORD dwErr=GetLastError();
if(dwErr!=ERROR_ALREADY_EXISTS)
{
TRACE(_T("Error creating user directory.\n"));
throw MAP_EXCEPTION(HRESULT_FROM_WIN32(dwErr));
}
}
DirCreationString+=USER_MAPS;
if(!CreateDirectory(DirCreationString.data(),NULL))
{
DWORD dwErr=GetLastError();
if(dwErr!=ERROR_ALREADY_EXISTS)
{
TRACE(_T("Error creating user directory.\n"));
throw MAP_EXCEPTION(HRESULT_FROM_WIN32(dwErr));
}
}
}
//Create full path filename
//Get user name
TCHAR UN[UNLEN+1];
if(!lpctstrUserName)
{
DWORD dwLen=UNLEN+1;
GetUserName(UN,&dwLen);
lpctstrUserName=UN;
}
//Unique user name
String UniqueUserName;
MakeUniqueUserName(UniqueUserName,lpctstrUserName);
//Device instance string
String DevInst;
DevInst=N2Str(nDeviceInstanceNo);
if((_tcslen(szFileName)+1+_tcslen(UniqueUserName.data())+2+
_tcslen(lpctstrDeviceName)+2+
_tcslen(DevInst.data())+4+1)>_MAX_PATH)
{
TRACE(_T("User path file name too long.\n"));
throw MAP_EXCEPTION(E_FAIL);
}
_tcscat(szFileName,_T("\\"));
_tcscat(szFileName,UniqueUserName.data());
//X: Special case. Make sure it is consistent
//with special case elsewhere.
_tcscat(szFileName,_T("X_"));
_tcscat(szFileName,lpctstrDeviceName);
//X: Special case. Make sure it is consistent
//with special case elsewhere.
_tcscat(szFileName,_T("X_"));
_tcscat(szFileName,DevInst.data());
_tcscat(szFileName,_T(".INI"));
}
/******************************************************************************
*
* ANSI/UNICODE parameter translation templates
*
*****************************************************************************/
int TrCopy(LPCSTR pszA,size_t nCharacters,LPWSTR pszW,size_t nSizeW)
{return MultiByteToWideChar(CP_ACP,0,pszA,nCharacters,pszW,nSizeW);};
int TrCopy(LPCOLESTR pszW,size_t nCharacters,LPSTR pszA,size_t nSizeA)
{return WideCharToMultiByte(CP_ACP,0,pszW,nCharacters,
pszA,nSizeA,NULL,NULL);};
size_t TrSize(LPCSTR pszA,size_t nSizeA){return nSizeA;};
size_t TrSize(LPCWSTR pszW,size_t nSizeW){return nSizeW*2;};
size_t TrStrLen(LPCSTR pszA){return strlen(pszA);};
size_t TrStrLen(LPCWSTR pszW){return wcslen(pszW);};
template <class StrTypeFrom,class StrTypeTo>
void Tr(StrTypeFrom *pszFrom,size_t nSizeFrom,
StrTypeTo* pszTo,size_t nSizeTo)
{
if(!TrCopy(pszFrom,TrStrLen(pszFrom)+1,pszTo,nSizeTo))
throw MAP_EXCEPTION(HRESULT_FROM_WIN32(GetLastError()));
pszTo[nSizeTo-1]=0;
};
template <class StrTypeFrom,class StrTypeTo> class C2Base
{
protected:
StrTypeTo *m_pszStrTo;
size_t m_nSizeTo;
StrTypeFrom *m_pszStrFrom;
size_t m_nSizeFrom;
bool m_bReturn;
public:
C2Base(){m_pszStrTo=NULL;};
~C2Base(){delete m_pszStrTo;};
operator StrTypeTo*(){return m_pszStrTo;};
size_t Size(){return m_nSizeTo;};
void Set(const StrTypeFrom *pszStrFrom=NULL,size_t nSizeFrom=-1)
{
//Delete old buffer
delete m_pszStrTo;
//Initialize members
m_pszStrTo=NULL;
m_nSizeTo=0;
m_pszStrFrom=(StrTypeFrom*)pszStrFrom;
m_nSizeFrom=nSizeFrom;
m_bReturn=false;
//Check if in string is 0
if((!m_pszStrFrom)||(!nSizeFrom))
{
m_nSizeFrom=0;
return;
}
//Get len of the in string
if(m_nSizeFrom==-1)
m_nSizeFrom=TrStrLen(m_pszStrFrom)+1;
//Allocate buffer for translated string
m_nSizeTo=TrSize(m_pszStrFrom,m_nSizeFrom);
m_pszStrTo=new StrTypeTo[m_nSizeTo];
if(m_nSizeTo)
m_pszStrTo[0]=0;
//Check if this is in or out param
if((nSizeFrom!=-1))
m_bReturn=true;
//Translate
if(!m_bReturn)
Tr(m_pszStrFrom,m_nSizeFrom,m_pszStrTo,m_nSizeTo);
}
};
template <class StrTypeFrom,class StrTypeTo> class C2:
public C2Base<StrTypeFrom,StrTypeTo>
{
public:
C2(const StrTypeFrom *pszStrFrom=NULL,size_t nSizeFrom=-1)
{Set(pszStrFrom,nSizeFrom);};
~C2(){if(m_bReturn)
Tr(m_pszStrTo,m_nSizeTo,m_pszStrFrom,m_nSizeFrom);};
};
//This template translates between DIACTIONFORMATA and DIACTIONFORMATW
template <class IDFrom,class IDTo,class Act>
class CTrDIACTIONFORMAT:public IDTo
{
IDTo* m_pIDTo;
IDFrom* m_pIDFrom;
public:
CTrDIACTIONFORMAT(IDFrom *pIn)
{
m_pIDTo=NULL;
m_pIDFrom=pIn;
if(pIn)
{
dwSize=sizeof(IDTo);
dwActionSize=pIn->dwActionSize;
dwDataSize=0;
dwNumActions=pIn->dwNumActions;
guidActionMap=pIn->guidActionMap;
dwGenre=pIn->dwGenre;
rgoAction=(Act*)(pIn->rgoAction);
dwBufferSize=0;
lAxisMin=0;
lAxisMax=0;
hInstString=0;
tszActionMap[0]=0;
ftTimeStamp.dwLowDateTime=
pIn->ftTimeStamp.dwLowDateTime;
ftTimeStamp.dwHighDateTime=
pIn->ftTimeStamp.dwHighDateTime;
m_pIDTo=(IDTo*)this;
}
};
~CTrDIACTIONFORMAT()
{
if(m_pIDFrom&&m_pIDTo)
{
m_pIDFrom->ftTimeStamp.dwLowDateTime=
m_pIDTo->ftTimeStamp.dwLowDateTime;
m_pIDFrom->ftTimeStamp.dwHighDateTime=
m_pIDTo->ftTimeStamp.dwHighDateTime;
}
}
operator IDTo*(){return m_pIDTo;};
};
//This templates translate between DIDEVICEIMAGEINFOHEADERA and
//DIDEVICEIMAGEINFOHEADERW
template <class IDTo> class CTrDIDEVICEIMAGEINFOHEADERB:public IDTo
{
public:
CTrDIDEVICEIMAGEINFOHEADERB(){lprgImageInfoArray=NULL;};
~CTrDIDEVICEIMAGEINFOHEADERB(){delete lprgImageInfoArray;};
};
template <class StrTypeFrom,class StrTypeTo>
void TrDIDEVICEIMAGEINFO(StrTypeFrom *pszFrom,StrTypeTo* pszTo)
{
Tr(pszFrom->tszImagePath,
sizeof(pszFrom->tszImagePath)/sizeof(pszFrom->tszImagePath[0]),
pszTo->tszImagePath,
sizeof(pszTo->tszImagePath)/sizeof(pszTo->tszImagePath[0]));
pszTo->dwFlags=pszFrom->dwFlags;
pszTo->dwViewID=pszFrom->dwViewID;
pszTo->rcOverlay=pszFrom->rcOverlay;
pszTo->dwObjID=pszFrom->dwObjID;
pszTo->rgptCalloutLine[0]=pszFrom->rgptCalloutLine[0];
pszTo->rgptCalloutLine[1]=pszFrom->rgptCalloutLine[1];
pszTo->rgptCalloutLine[2]=pszFrom->rgptCalloutLine[2];
pszTo->rgptCalloutLine[3]=pszFrom->rgptCalloutLine[3];
pszTo->rgptCalloutLine[4]=pszFrom->rgptCalloutLine[4];
pszTo->dwcValidPts=pszFrom->dwcValidPts;
pszTo->rcCalloutRect=pszFrom->rcCalloutRect;
pszTo->dwTextAlign=pszFrom->dwTextAlign;
}
template <class IDFrom,class IDTo,class IDFromImgInfo,class IDToImgInfo>
class CTrDIDEVICEIMAGEINFOHEADER:public CTrDIDEVICEIMAGEINFOHEADERB<IDTo>
{
IDTo* m_pIDTo;
IDFrom* m_pIDFrom;
bool m_bGet;
public:
CTrDIDEVICEIMAGEINFOHEADER(IDFrom *pIn,bool bGet=true)
{
m_pIDTo=NULL;
m_pIDFrom=pIn;
m_bGet=bGet;
if(pIn)
{
memset((IDTo*)this,0,sizeof(IDTo));
if(pIn->dwSize==sizeof(IDFrom))
dwSize=sizeof(IDTo);
else
dwSize=0;
if(pIn->dwSizeImageInfo==sizeof(IDFromImgInfo))
dwSizeImageInfo=sizeof(IDToImgInfo);
else
dwSizeImageInfo=0;
//dwcViews=pIn->dwcViews;
//dwcButtons=pIn->dwcButtons;
//dwcAxes=pIn->dwcAxes;
dwBufferSize=(pIn->dwBufferSize/
sizeof(IDFromImgInfo))*sizeof(IDToImgInfo);
dwBufferUsed=(pIn->dwBufferUsed/
sizeof(IDFromImgInfo))*sizeof(IDToImgInfo);
if(dwBufferSize&&pIn->lprgImageInfoArray)
{
lprgImageInfoArray=(IDToImgInfo*)new char[dwBufferSize];
//PREFIX #171787 new does not return NULL. Instead, exception is thrown and
//handled properly inside of catch block.
memset(lprgImageInfoArray,0,dwBufferSize);
for(int i=0;i<(dwBufferSize/sizeof(IDToImgInfo));i++)
{
//PREFIX #34520 I do not see how m_pIDFrom or m_pIDFrom->lprgImageInfoArray
//can be NULL at this point.
if(!m_bGet)
{
TrDIDEVICEIMAGEINFO(
&m_pIDFrom->lprgImageInfoArray[i],
&lprgImageInfoArray[i]);
}
}
}
m_pIDTo=(IDTo*)this;
}
};
~CTrDIDEVICEIMAGEINFOHEADER()
{
if(m_pIDFrom)
{
m_pIDFrom->dwcViews=dwcViews;
//m_pIDFrom->dwcButtons=dwcButtons;
//m_pIDFrom->dwcAxes=dwcAxes;
m_pIDFrom->dwBufferUsed=(dwBufferUsed/
sizeof(IDToImgInfo))*sizeof(IDFromImgInfo);
if(m_pIDFrom->dwBufferSize)
{
for(int i=0;i<(dwBufferSize/sizeof(IDToImgInfo));i++)
{
if(m_bGet)
{
TrDIDEVICEIMAGEINFO(&lprgImageInfoArray[i],
&m_pIDFrom->lprgImageInfoArray[i]);
}
}
}
delete lprgImageInfoArray;
lprgImageInfoArray=NULL;
}
};
operator IDTo*(){return m_pIDTo;};
};
/*
template <class ActionFormat,class Action,class Str> class CDIAFAUBase
{
protected:
Str m_ApplicationName;
ActionFormat *m_pDIAF;
ActionFormat m_DIAF;
Action* m_lpDIA;
Str *m_pA2U;
public:
CDIAFAUBase()
{
m_pDIAF=NULL;
m_lpDIA=NULL;
m_pA2U=NULL;
};
~CDIAFAUBase()
{
delete[] m_lpDIA;
delete[] m_pA2U;
};
operator ActionFormat*(){return m_pDIAF;};
};
template <class ActionFormat,class Action,class Str,class ActionFormatFrom>
class CDIAFAU:
public CDIAFAUBase <ActionFormat,Action,Str>
{
public:
CDIAFAU(ActionFormatFrom lpDiActionFormat)
{
if(!lpDiActionFormat)return;
memcpy(&m_DIAF,lpDiActionFormat,sizeof(m_DIAF));
m_ApplicationName.Set(lpDiActionFormat->lptszActionMap);
m_DIAF.lptszActionMap=m_ApplicationName;
if(!(m_DIAF.dwNumActions&&m_DIAF.rgoAction))return;
m_lpDIA=new Action[m_DIAF.dwNumActions];
m_DIAF.rgoAction=m_lpDIA;
m_pA2U=new Str[m_DIAF.dwNumActions];
for(DWORD i=0;i<m_DIAF.dwNumActions;i++)
{
memcpy(&m_lpDIA[i],&lpDiActionFormat->rgoAction[i],
sizeof(m_lpDIA[i]));
m_pA2U[i].Set(lpDiActionFormat->rgoAction[i].lptszActionName);
m_lpDIA[i].lptszActionName=m_pA2U[i];
}
m_pDIAF=&m_DIAF;
};
};
*/
#define STARTTR try{
#define ENDTR }catch(MapException E){return E.GetResult();}\
catch(exception){return E_OUTOFMEMORY;}
#ifdef UNICODE
#define U2A(P) P
#define DIAFU2A(P) P
#define IDW(P) P
typedef C2<CHAR,WCHAR> CA2U;
#define A2U(P) CA2U(P)
#define STARTTRA STARTTR
#define ENDTRA ENDTR
#define STARTTRW
#define ENDTRW
//DIACTIONFORMAT translation
typedef CTrDIACTIONFORMAT<DIACTIONFORMATA,DIACTIONFORMATW,DIACTIONW>
CDIACTIONFORMAT;
#define AFA(P) CDIACTIONFORMAT(P)
#define AFW(P) P
//DIDEVICEIMAGEINFOHEADER translation
typedef CTrDIDEVICEIMAGEINFOHEADER<DIDEVICEIMAGEINFOHEADERA,
DIDEVICEIMAGEINFOHEADERW,DIDEVICEIMAGEINFOA,DIDEVICEIMAGEINFOW>
CDIDEVICEIMAGEINFOHEADER;
#define DIIHA(P) CDIDEVICEIMAGEINFOHEADER(P)
#define DIIHW(P) P
#define SETDIIHA(P) CDIDEVICEIMAGEINFOHEADER(P,false)
#define SETDIIHW(P) P
#else //ANSI
#define A2U(P) P
#define DIAFA2U(P) P
#define IDA(P) P
typedef C2<WCHAR,CHAR> CU2A;
#define U2A(P) CU2A(P)
#define STARTTRA
#define ENDTRA
#define STARTTRW STARTTR
#define ENDTRW ENDTR
//DIACTIONFORMAT translation
typedef CTrDIACTIONFORMAT<DIACTIONFORMATW,DIACTIONFORMATA,DIACTIONA>
CDIACTIONFORMAT;
#define AFA(P) P
#define AFW(P) CDIACTIONFORMAT(P)
//DIDEVICEIMAGEINFOHEADER translation
typedef CTrDIDEVICEIMAGEINFOHEADER<DIDEVICEIMAGEINFOHEADERW,
DIDEVICEIMAGEINFOHEADERA,DIDEVICEIMAGEINFOW,DIDEVICEIMAGEINFOA>
CDIDEVICEIMAGEINFOHEADER;
#define DIIHA(P) P
#define DIIHW(P) CDIDEVICEIMAGEINFOHEADER(P)
#define SETDIIHA(P) P
#define SETDIIHW(P) CDIDEVICEIMAGEINFOHEADER(P,false)
#endif //ANSI
/******************************************************************************
*
* ANSI/UNICODE parameter translation
*
*****************************************************************************/
HRESULT STDMETHODCALLTYPE IDirectInputMapperTrA::
Initialize(
LPCGUID lpThisGUIDInstance,
LPCSTR lpcstrFileName,
DWORD dwFlags)
{
STARTTRA
return InitializeI(lpThisGUIDInstance,A2U(lpcstrFileName),dwFlags);
ENDTRA
}
HRESULT STDMETHODCALLTYPE IDirectInputMapperTrA::
GetActionMap(
LPDIACTIONFORMATA lpDiActionFormat,
LPCSTR lpcstrUserName,
FILETIME *pTimestamp,DWORD dwFlags)
{
STARTTRA
return GetActionMapI(AFA(lpDiActionFormat),A2U(lpcstrUserName),
pTimestamp,dwFlags);
ENDTRA
}
HRESULT STDMETHODCALLTYPE IDirectInputMapperTrA::
SaveActionMap(
LPDIACTIONFORMATA lpDiActionFormat,
LPCSTR lpcstrUserName,
DWORD dwFlags)
{
STARTTRA
return SaveActionMapI(AFA(lpDiActionFormat),A2U(lpcstrUserName),
dwFlags);
ENDTRA
}
HRESULT STDMETHODCALLTYPE IDirectInputMapperTrA::
GetImageInfo(
LPDIDEVICEIMAGEINFOHEADERA lpdiDevImageInfoHeader)
{
STARTTRA
return GetImageInfoI(DIIHA(lpdiDevImageInfoHeader));
ENDTRA
}
HRESULT STDMETHODCALLTYPE IDirectInputMapperTrA::
WriteVendorFile(
LPDIACTIONFORMATA lpDiActionFormat,
LPDIDEVICEIMAGEINFOHEADERA lpdiDevImageInfoHeader,
DWORD dwFlags)
{
STARTTRA
return WriteVendorFileI(AFA(lpDiActionFormat),
SETDIIHA(lpdiDevImageInfoHeader),dwFlags);
ENDTRA
}
HRESULT STDMETHODCALLTYPE IDirectInputMapperTrW::
Initialize(
LPCGUID lpThisGUIDInstance,
LPCWSTR lpcwstrFileName,
DWORD dwFlags)
{
STARTTRA
return InitializeI(lpThisGUIDInstance,U2A(lpcwstrFileName),dwFlags);
ENDTRA
}
HRESULT STDMETHODCALLTYPE IDirectInputMapperTrW::
GetActionMap(
LPDIACTIONFORMATW lpDiActionFormat,
LPCWSTR lpcwstrUserName,
FILETIME *pTimestamp,DWORD dwFlags)
{
STARTTRW
return GetActionMapI(AFW(lpDiActionFormat),U2A(lpcwstrUserName),
pTimestamp,dwFlags);
ENDTRW
}
HRESULT STDMETHODCALLTYPE IDirectInputMapperTrW::
SaveActionMap(
LPDIACTIONFORMATW lpDiActionFormat,
LPCWSTR lpcwstrUserName,
DWORD dwFlags)
{
STARTTRW
return SaveActionMapI(AFW(lpDiActionFormat),U2A(lpcwstrUserName),
dwFlags);
ENDTRW
}
HRESULT STDMETHODCALLTYPE IDirectInputMapperTrW::
GetImageInfo(
LPDIDEVICEIMAGEINFOHEADERW lpdiDevImageInfoHeader)
{
STARTTRW
return GetImageInfoI(DIIHW(lpdiDevImageInfoHeader));
ENDTRW
}
HRESULT STDMETHODCALLTYPE IDirectInputMapperTrW::
WriteVendorFile(
LPDIACTIONFORMATW lpDiActionFormat,
LPDIDEVICEIMAGEINFOHEADERW lpdiDevImageInfoHeader,
DWORD dwFlags)
{
STARTTRW
return WriteVendorFileI(AFW(lpDiActionFormat),
SETDIIHW(lpdiDevImageInfoHeader),dwFlags);
ENDTRW
}
/******************************************************************************
*
* Mapper object implementation
*
*****************************************************************************/
BOOL CALLBACK DIEnumDeviceObjectsProcC(LPCDIDEVICEOBJECTINSTANCE lpddoi,
LPVOID pvRef)
{
//Read offset, usage page, usage and name and store into private list
DEVICEOBJLIST *pDevObjList=&(((CDIMapObj*)pvRef)->m_DevObjList);
DeviceObjData D;
/* We decided to use dwType (ObjID) instead of dwOffset.
This place and exports are the only places where this data enters into
the module so there should not be problem. Latter rename the code
from dwOffset. Also, it is valid to use 0xffffffff value of dwType for
special purposes.
*/ //D.dwOffset=lpddoi->dwOfs;
D.dwOffset=lpddoi->dwType;
D.dwUsage=lpddoi->wUsage;
D.dwUsagePage=lpddoi->wUsagePage;
D.dwType=lpddoi->dwType;
D.dwFlags=lpddoi->dwFlags;
D.Name=lpddoi->tszName;
ToUpper(D.Name);
pDevObjList->push_back(D);
return DIENUM_CONTINUE;
}
void MakeGenreName(String &S,LPCTSTR lpDeviceName,
DWORD dwGenre,LPCGUID lpAppGUID=NULL)
{
S=lpDeviceName;
S+=_T(".");
//If application genre
if(lpAppGUID)
{
S=S+APPLICATION+_T(".")+GUID2String(*lpAppGUID)+_T(".");
}
S=S+GENRE+_T(".")+N2Str(DISEM_GENRE_GET(dwGenre));
DUMPN(_T("Genre section name"),S);
}
bool CompareTypeObjAct(DWORD dwObjType,DWORD dwActType)
{
if((dwObjType&DIDFT_AXIS)&&
(DISEM_TYPE_GET(dwActType)==DISEM_TYPE_GET(DISEM_TYPE_AXIS)))
return true;
if((dwObjType&DIDFT_BUTTON)&&
(DISEM_TYPE_GET(dwActType)==DISEM_TYPE_GET(DISEM_TYPE_BUTTON)))
return true;
if((dwObjType&DIDFT_POV)&&
(DISEM_TYPE_GET(dwActType)==DISEM_TYPE_GET(DISEM_TYPE_POV)))
return true;
return false;
}
bool CDIMapObj::CompareData(DeviceObjData &DOD,ControlData &CD)
{
if(IsVIDPID())
{
//Assume for now that the DOD.dwOffset and DOD.dwType fields are
//both always set as they are actually the same thing
//under W2K. If this isn't the case we need to work out
//which one to check against CD.dwOffset
#ifdef _CHECKED
if (DOD.dwOffset!=DOD.dwType)
DUMP(_T("CDIMapObj::CompareData. Problem - DeviceObjData has differing dwOffset and dwType fields should not differ!"));
#endif
if((DOD.dwUsagePage==CD.dwUsagePage)&&
(DOD.dwUsage==CD.dwUsage) &&
(DIDFT_FINDMASK&DOD.dwOffset)==(DIDFT_FINDMASK&CD.dwOffset))
//Device object found
return true;
}
else
{
//Ignore FF bits since some drivers do not report properly.
//Also, this way same ini file can be used for both FF and
//non-FF device.
if((DIDFT_FINDMASK&DOD.dwOffset)==(DIDFT_FINDMASK&CD.dwOffset))
//Device object found
return true;
}
return false;
}
bool CDIMapObj::GetOffset(ControlData &CD,
DEVICEOBJLIST &DevObjList,DWORD dwSemantic,
DEVICEOBJLIST::iterator &DevObjItOut)
{
METHOD_ENTRY(GetOffset);
bool bFoundDevice=false;
//Find DI device object with usage/usage page or name
DEVICEOBJLIST::iterator DevObjIt;
for(DevObjIt=DevObjList.begin();DevObjIt!=DevObjList.end();DevObjIt++)
{
if(CompareData(*DevObjIt,CD))
{
bFoundDevice=true;
if(CompareTypeObjAct(DevObjIt->dwType,dwSemantic)&&
!(DevObjIt->bMapped))
{
DevObjItOut=DevObjIt;
return true;
}
}
}
if(!bFoundDevice)
{
TRACE(_T("Control with filename '%s' does not exist in device.\n"),
CD.ControlName.data());
throw MAP_EXCEPTION(E_DEVICE_MISSING_CONTROL);
}
return false;
}
/*This three functions TBD*/
//Use when writing
DWORD GetFileSemantic(DWORD dwSemantic,DWORD dwHow)
{
if(dwHow==DIAH_USERCONFIG)
return dwSemantic;
return DISEM_INDEX_SET(DISEM_INDEX_GET(dwSemantic));
}
//Use to get value from file
DWORD GetCmpFileGenreSemantic(DWORD dwSemantic,DWORD dwHow,DWORD dwGenre)
{
if(dwHow==DIAH_USERCONFIG)
return dwSemantic;
return DISEM_INDEX_SET(DISEM_INDEX_GET(dwSemantic))|
DISEM_GENRE_SET(DISEM_GENRE_GET(dwGenre));
}
//Use to get value from action array
DWORD GetCmpActionGenreSemantic(DWORD dwSemantic,DWORD dwHow)
{
if(dwHow==DIAH_USERCONFIG)
return dwSemantic;
return DISEM_INDEX_SET(DISEM_INDEX_GET(dwSemantic))|
DISEM_GENRE_SET(DISEM_GENRE_GET(dwSemantic));
}
/**/
void WhichDeviceObjectIsMapped(LPDIACTIONFORMAT lpDiActionFormat,
DEVICEOBJLIST &DevObjList,
LPCGUID lpThisGUIDInstance)
{
DEVICEOBJLIST::iterator DevObjIt;
for(DevObjIt=DevObjList.begin();DevObjIt!=DevObjList.end();DevObjIt++)
{
DevObjIt->bMapped=false;
for(DWORD i=0;i<lpDiActionFormat->dwNumActions;i++)
{
if((lpDiActionFormat->rgoAction[i].guidInstance!=
*lpThisGUIDInstance)||
(lpDiActionFormat->rgoAction[i].dwHow==DIAH_UNMAPPED)||
((DIDFT_FINDMASK&lpDiActionFormat->rgoAction[i].dwObjID)!=
(DIDFT_FINDMASK&DevObjIt->dwOffset)))
continue;
else
{
DevObjIt->bMapped=true;
break;
}
}
}
}
void CDIMapObj::MapGenre(LPDIACTIONFORMAT lpDiActionFormat,
CONTROLLIST &ControlsData,
LPCTSTR lpGenreName,LPCTSTR lpFileName,
LPCGUID lpThisGUIDInstance,
DEVICEOBJLIST &DevObjList,DWORD dwHow,
DWORD &dwNOfMappedActions)
{
METHOD_ENTRY(MapGenre);
//For all file control names, read the genre action mapping
CONTROLLIST::iterator CtrlIt;
for(CtrlIt=ControlsData.begin();CtrlIt!=ControlsData.end();CtrlIt++)
{
DWORD dwAction=GetPrivateProfileInt(lpGenreName,
CtrlIt->ControlName.data(),RESERVED_ACTION,lpFileName);
CtrlIt->dwAction=dwAction;
}
//Find actions which are not mapped yet
TRACE(_T("Iterate through action array and controls in ini file.\n"));
for(DWORD i=0;i<lpDiActionFormat->dwNumActions;i++)
{
if(((lpDiActionFormat->rgoAction[i].guidInstance!=NULLGUID)
&&(lpDiActionFormat->rgoAction[i].guidInstance!=*lpThisGUIDInstance))||
(lpDiActionFormat->rgoAction[i].dwFlags&DIA_APPNOMAP)||
(lpDiActionFormat->rgoAction[i].dwHow!=DIAH_UNMAPPED))
continue;
//Find control which maps to this action
for(CtrlIt=ControlsData.begin();CtrlIt!=ControlsData.end();CtrlIt++)
{
if(GetCmpFileGenreSemantic(CtrlIt->dwAction,dwHow,
lpDiActionFormat->dwGenre)==
GetCmpActionGenreSemantic(
lpDiActionFormat->rgoAction[i].dwSemantic,dwHow))
{
//Find offset and initialize it in the action structure
DEVICEOBJLIST::iterator DevObjIt;
if(GetOffset(*CtrlIt,DevObjList,
lpDiActionFormat->rgoAction[i].dwSemantic,DevObjIt))
{
if((lpDiActionFormat->rgoAction[i].dwFlags&
DIA_FORCEFEEDBACK)&&
!((DevObjIt->dwFlags&DIDOI_FFEFFECTTRIGGER)||
(DevObjIt->dwFlags&DIDOI_FFACTUATOR)))
{
TRACE(_T("Action array %u has DIA_FORCEFEEDBACK set but devobj \
does not have DIDOI_FFEFFECTTRIGGER or DIDOI_FFACTUATOR set. Not mapped.\n"),i);
continue;
}
TRACE(_T("Action array %u mapped to ini file \
control and devobj with dwObjID 0x%x\n"),i,DevObjIt->dwOffset);
lpDiActionFormat->rgoAction[i].dwObjID=DevObjIt->dwOffset;
DevObjIt->bMapped=true;
dwNOfMappedActions++;
lpDiActionFormat->rgoAction[i].guidInstance=
*lpThisGUIDInstance;
lpDiActionFormat->rgoAction[i].dwHow=dwHow;
break;
}
else
{
TRACE(_T("Action array %u related to ini file \
control but devobj not found. Not mapping.\n"),i);
}
}
}
}
}
void WriteTimestamp(LPCTSTR lpFileName,LPCTSTR lpDeviceName,
GUID &AppGUID,LPDIACTIONFORMAT lpDiActionFormat)
{
String S,SH,SL;
S=GUID2String(AppGUID)+_T(".");
SH=S+TIMESTAMPHIGH;
SL=S+TIMESTAMPLOW;
FILETIME T;
if((lpDiActionFormat->ftTimeStamp.dwLowDateTime==DIAFTS_NEWDEVICELOW)&&
(lpDiActionFormat->ftTimeStamp.dwHighDateTime==DIAFTS_NEWDEVICEHIGH))
{
T.dwHighDateTime=DIAFTS_UNUSEDDEVICEHIGH;
T.dwLowDateTime=DIAFTS_UNUSEDDEVICELOW;
}
else
{
GetSystemTimeAsFileTime(&T);
}
WritePrivateProfileIntX(lpDeviceName,SH.data(),
T.dwHighDateTime,lpFileName);
WritePrivateProfileIntX(lpDeviceName,SL.data(),
T.dwLowDateTime,lpFileName);
}
void ReadTimestamp(FILETIME &T,LPCTSTR lpFileName,
LPCTSTR lpDeviceName,GUID &AppGUID)
{
String S,SH,SL;
S=GUID2String(AppGUID)+_T(".");
SH=S+TIMESTAMPHIGH;
SL=S+TIMESTAMPLOW;
T.dwHighDateTime=GetPrivateProfileInt(lpDeviceName,SH.data(),
DIAFTS_NEWDEVICELOW,lpFileName);
T.dwLowDateTime=GetPrivateProfileInt(lpDeviceName,SL.data(),
DIAFTS_NEWDEVICEHIGH,lpFileName);
}
#ifdef _CHECKED
int CDIMapObj::m_DeviceCount=0;
#endif
CDIMapObj::CDIMapObj()
{
#ifdef _CHECKED
m_DeviceNo=m_DeviceCount++;
#endif
m_ulRefCnt=0;
Clear();
}
void CDIMapObj::Clear()
{
//m_ulRefCnt must not be set here, only in constructor
bool m_bInitialized=false;
m_dwThisVendorID=0;
m_dwThisProductID=0;
m_DeviceName=_T("");
memset(&m_DeviceGuid,0,sizeof(m_DeviceGuid));
//Vendor file name data
m_VFileName=_T("");
m_lpVFileName=NULL;
m_VFileDevName=_T("");
m_VCtrlData.clear();
m_bVLoaded=false;
//User file name data
m_UName=_T("");
m_lpUName=NULL;
m_UFileName=_T("");
m_UserDir=_T("");
m_UFileDevName=_T("");
m_UCtrlData.clear();
m_bULoaded=false;
m_UTimestamp.dwHighDateTime=0;
m_UTimestamp.dwLowDateTime=0;
m_bImageBufferSize=false;
m_dwImageBufferSize=0;
}
CDIMapObj::~CDIMapObj()
{
}
void CDIMapObj::LoadFileData(LPCTSTR lpFileName,LPCTSTR lpThisName,
DWORD dwThisVendorID,DWORD dwThisProductID,
String &FileDeviceName,CONTROLLIST &ControlsData,
bool &bLoaded,FILETIME *pT,
LPDIACTIONFORMAT lpDiActionFormat)
{
METHOD_ENTRY(LoadFileData);
DUMPN(_T("Filename"),lpFileName);
bLoaded=false;
FileDeviceName=_T("");
ControlsData.clear();
//Clear DevObj pointers to controls
for(DEVICEOBJLIST::iterator DevObjIt=m_DevObjList.begin();DevObjIt!=
m_DevObjList.end();DevObjIt++)
{
if(&ControlsData==&m_UCtrlData)
DevObjIt->pUCtrlData=NULL;
else
DevObjIt->pVCtrlData=NULL;
}
if(pT)
{
pT->dwLowDateTime=DIAFTS_NEWDEVICELOW;
pT->dwHighDateTime=DIAFTS_NEWDEVICEHIGH;
}
//Read file version and choose file parser
DWORD dwVersion=GetPrivateProfileInt(DIRECT_INPUT,DIRECTX_VERSION,
RESERVED_DX_VER,lpFileName);
if(dwVersion==0x800)
{
//Load all file device names
STRINGLIST Devices;
LoadListOfStrings(lpFileName,DIRECT_INPUT,DEVICES,Devices);
BOOL bDeviceFound=FALSE;
//Iterate through all file device names
STRINGLIST::iterator DevIt=Devices.begin();
while(DevIt!=Devices.end())
{
String DeviceName=(*DevIt);
DUMPN(_T("Trying to match device with ini file name"),
DeviceName);
//Read VID, PID and type name.
String NameCur;
DWORD dwVendorIDCur=GetPrivateProfileInt(DeviceName.data(),
VENDORID,RESERVED_VENDORID,lpFileName);
DWORD dwProductIDCur=GetPrivateProfileInt(DeviceName.data(),
PRODUCTID,RESERVED_PRODUCTID,lpFileName);
LoadString(NameCur,lpFileName,DeviceName.data(),NAME);
if((IsVIDPID()&&
((dwVendorIDCur==dwThisVendorID)&&
(dwProductIDCur==dwThisProductID)))||
((!IsVIDPID())&&
(NameCur==lpThisName)))
{
TRACE(_T("Device found in ini file!\n"));
//Definition of a device is found in the file
bDeviceFound=TRUE;
FileDeviceName=DeviceName;
if(pT&&lpDiActionFormat)
ReadTimestamp(*pT,lpFileName,FileDeviceName.data(),
lpDiActionFormat->guidActionMap);
//Load all file control names
STRINGLIST Controls;
LoadListOfStrings(lpFileName,DeviceName.data(),CONTROLS,
Controls,true);
//Iterate through all file control names for this device
STRINGLIST::iterator CtrlIt=Controls.begin();
while(CtrlIt!=Controls.end())
{
DUMPN(_T("Read control data with ini file name"),
CtrlIt->data());
String ControlSectionName=*CtrlIt;
ControlData ControlDataCur;
ControlDataCur.pDevObj=NULL;
ControlDataCur.ControlName=*CtrlIt;
ControlDataCur.dwOffset=RESERVED_OFFSET;
ControlDataCur.dwUsagePage=RESERVED_USAGEPAGE;
ControlDataCur.dwUsage=RESERVED_USAGE;
//Read offset, Usage and UsagePage for a file control name
ControlDataCur.dwOffset=
GetPrivateProfileInt(ControlSectionName.data(),
OFFSET,RESERVED_OFFSET,lpFileName);
ControlDataCur.dwUsage=
GetPrivateProfileInt(ControlSectionName.data(),
USAGE,RESERVED_USAGE,lpFileName);
ControlDataCur.dwUsagePage=
GetPrivateProfileInt(
ControlSectionName.data(),
USAGEPAGE,RESERVED_USAGEPAGE,
lpFileName);
// LoadString(ControlDataCur.Name,lpFileName,
// ControlSectionName.data(),NAME);
#ifdef STRICT_DEV_DEF
//Store data for this control into the list
ControlsData.push_back(ControlDataCur);
#endif STRICT_DEV_DEF
//Here bind device obj and control data
//Find DI device object with usage/usage page or name
for(DEVICEOBJLIST::iterator DevObjIt=m_DevObjList.begin();
DevObjIt!=m_DevObjList.end();DevObjIt++)
{
if(CompareData(*DevObjIt,ControlDataCur))
{
#ifndef STRICT_DEV_DEF
//Store data for this control into the list
ControlsData.push_back(ControlDataCur);
#endif STRICT_DEV_DEF
ControlsData.back().pDevObj=&(*DevObjIt);
if(&ControlsData==&m_UCtrlData)
DevObjIt->pUCtrlData=&ControlsData.back();
else
DevObjIt->pVCtrlData=&ControlsData.back();
}
}
#ifdef STRICT_DEV_DEF
if(!ControlsData.back().pDevObj)
{
TRACE(_T("Could not match control in file with device object.\n"));
throw MAP_EXCEPTION(E_DEVICE_MISSING_CONTROL);
}
#endif STRICT_DEV_DEF
CtrlIt++;
}
break;
}
DevIt++;
}
if(!bDeviceFound)
{
TRACE(_T("Device description not present in this file!!!!!!!!!!!!!\n"));
//throw MAP_EXCEPTION(E_DEVICE_NOT_FOUND); Currently this is legal
}
else
{
TRACE(_T("Device data loaded from ini file.\n"));
bLoaded=true;
}
}
else if(dwVersion!=RESERVED_DX_VER)
{
TRACE(_T("Bad file version\n"));
throw MAP_EXCEPTION(E_BAD_VERSION);
}
else
{
TRACE(_T("File not found, or no version info. Continuing...\n"));
}
}
void CDIMapObj::LoadUserData(LPCTSTR lpctstrUserName,
LPDIACTIONFORMAT lpDiActionFormat,
bool bForceReload/*=false*/,bool bCreateDir/*=false*/)
{
METHOD_ENTRY(LoadUserData);
String UserName;
if(bForceReload)
lpctstrUserName=m_lpUName;
if(lpctstrUserName)
UserName=lpctstrUserName;
if((m_UFileName==_T(""))||//first run
(UserName!=m_UName)||//different user name
bForceReload)
{
TRACE(_T("First run or new user or forced reload of user data.\n"));
m_UName=_T("");
m_lpUName=NULL;
m_UFileName=_T("");
m_UserDir=_T("");
m_UFileDevName=_T("");
m_UCtrlData.clear();
m_bULoaded=false;
m_UTimestamp.dwHighDateTime;
m_UTimestamp.dwLowDateTime;
if(lpctstrUserName)//just used as logic operation
{
m_UName=UserName;
m_lpUName=m_UName.data();
}
TCHAR lpctstrUserFileName[_MAX_PATH];
GetMapFileName(m_UName.data(),m_DeviceName.data(),
m_nDeviceInstanceNo,
lpctstrUserFileName,false,&m_UserDir);
m_UFileName=lpctstrUserFileName;
DUMPN(_T("User File Name"),lpctstrUserFileName);
LoadFileData(m_UFileName.data(),m_DeviceName.data(),
m_dwThisVendorID,m_dwThisProductID,m_UFileDevName,m_UCtrlData,
m_bULoaded,&m_UTimestamp,lpDiActionFormat);
}
if(bCreateDir)
{
TCHAR lpctstrUserFileName[_MAX_PATH];
GetMapFileName(m_UName.data(),m_DeviceName.data(),
m_nDeviceInstanceNo,
lpctstrUserFileName,true,&m_UserDir);
}
}
BOOL CALLBACK DIEnumDevicesProc(
const DIDEVICEINSTANCE * lpddi,LPVOID pvRef)
{
DEVCNT *pDevCnt=(DEVCNT*)pvRef;
if(!memcmp(&lpddi->guidProduct,
&pDevCnt->pDIDI->guidProduct,
sizeof(lpddi->guidProduct)))
{
if(0<memcmp(&lpddi->guidInstance,
&pDevCnt->pDIDI->guidInstance,
sizeof(lpddi->guidInstance)))
(*(pDevCnt->m_pnCnt))++;
}
return DIENUM_CONTINUE;
}
HRESULT CDIMapObj::InitializeI(
LPCGUID lpThisGUIDInstance,
LPCTSTR lpctstrFileName,
DWORD dwFlags)
{
try
{
INITIALIZE_ENTERED;
TRACE(_T("Parameters:\n"));
DUMP(lpThisGUIDInstance);
DUMP(lpctstrFileName);
TRACE(_T("\n"));
//Check parameters
//Check guid pointer
if(!lpThisGUIDInstance)
{
TRACE(_T("lpThisGUIDInstance is NULL\n"));
throw MAP_EXCEPTION(E_INVALIDARG);
}
HRESULT hRes=S_OK;
Clear();
m_DeviceGuid=*lpThisGUIDInstance;
//Create DInput device and get info
LPDIRECTINPUT_AR lpDI;
HMODULE hM=GetModuleHandle(NULL);
if(!hM)
{
TRACE(_T("ERROR, GetModuleHandle failed\n"));
throw MAP_EXCEPTION(E_FAIL);
}
hRes=DirectInput8Create(hM, DIRECTINPUT_VERSION,
IID_IDirectInput8, lpDI.Addr(),NULL);
if(FAILED(hRes))
{
TRACE(_T("ERROR, DirectInput8Create failed\n"));
throw MAP_EXCEPTION(hRes);
}
LPDIRECTINPUTDEVICE_AR lpDID;
hRes=lpDI.P()->CreateDevice(*lpThisGUIDInstance,lpDID,NULL);
if(FAILED(hRes))
{
TRACE(_T("ERROR, CreateDeviceEx failed\n"));
throw MAP_EXCEPTION(hRes);
}
DIDEVICEINSTANCE DIDI;
DIDI.dwSize=sizeof(DIDI);
hRes=lpDID.P()->GetDeviceInfo(&DIDI);
if(FAILED(hRes))
{
TRACE(_T("ERROR, GetDeviceInfo failed\n"));
throw MAP_EXCEPTION(hRes);
}
//find device instance number
m_nDeviceInstanceNo=0;
DEVCNT DevCnt;
DevCnt.m_pnCnt=&m_nDeviceInstanceNo;
DevCnt.pDIDI=&DIDI;
if(DI_OK!=lpDI.P()->EnumDevices
(0,DIEnumDevicesProc,&DevCnt,DIEDFL_ATTACHEDONLY))
{
TRACE(_T("ERROR, EnumDevices failed\n"));
throw MAP_EXCEPTION(hRes);
}
DUMP(m_nDeviceInstanceNo);
// Code block added by MarcAnd
{
DIPROPDWORD dipdw;
dipdw.diph.dwSize = sizeof( dipdw );
dipdw.diph.dwHeaderSize = sizeof( dipdw.diph );
dipdw.diph.dwObj = 0;
dipdw.diph.dwHow = DIPH_DEVICE;
if(FAILED(lpDID.P()->GetProperty(DIPROP_VIDPID,&dipdw.diph)))
{
m_dwThisVendorID=0;
m_dwThisProductID=0;
}
else
{
m_dwThisVendorID=LOWORD( dipdw.dwData );
m_dwThisProductID=HIWORD( dipdw.dwData );
}
}
DUMP(m_dwThisVendorID);
DUMP(m_dwThisProductID);
DIPROPSTRING dipwsz;
dipwsz.diph.dwSize=sizeof(dipwsz);
dipwsz.diph.dwHeaderSize=sizeof(dipwsz.diph);
dipwsz.diph.dwObj=0;
dipwsz.diph.dwHow=DIPH_DEVICE;
if(FAILED(lpDID.P()->GetProperty(DIPROP_TYPENAME,&dipwsz.diph)))
{
//keyboard, mouse...
m_DeviceName=DIDI.tszInstanceName;
}
else
{
MakeUniqueDeviceName(m_DeviceName,dipwsz.wsz);
}
ToUpper(m_DeviceName);
DUMP(DIDI.tszInstanceName);
DUMP(m_DeviceName);
//Enumerate DI device objects and get info.
//Must go before LoadFileData file control data
//can be binded to object data
hRes=lpDID.P()->EnumObjects(DIEnumDeviceObjectsProcC,this,
DIDFT_AXIS|DIDFT_BUTTON|DIDFT_POV);
if(FAILED(hRes))
{
TRACE(_T("ERROR, EnumObjects failed\n"));
throw MAP_EXCEPTION(hRes);
}
if(!m_DevObjList.size())
{
TRACE(_T("ERROR, No dev objects found\n"));
throw MAP_EXCEPTION(E_DEV_OBJ_NOT_FOUND);
}
DUMP(m_DevObjList);
m_lpVFileName=NULL;
if(lpctstrFileName)
{
m_VFileName=lpctstrFileName;
m_lpVFileName=m_VFileName.data();
LoadFileData(m_lpVFileName,m_DeviceName.data(),m_dwThisVendorID,
m_dwThisProductID,m_VFileDevName,
m_VCtrlData,m_bVLoaded,NULL,NULL);
}
m_bInitialized=true;
TRACE(_T("hRes=0x%x\n"),S_OK);
return S_OK;
}
catch(MapException E)
{
return E.GetResult();
}
catch(exception)
{
USETRACER();
TRACE(_T("Internal error, hRes=0x%x\n"),E_FAIL);
return E_FAIL;
}
}
ULONG STDMETHODCALLTYPE CDIMapObj::Release()
{
m_ulRefCnt--;
if(m_ulRefCnt)return m_ulRefCnt;
delete this;
DllRelease();
return 0;
}
HRESULT STDMETHODCALLTYPE CDIMapObj::QueryInterface(REFIID riid,
LPVOID * ppvOut)
{
if(IsEqualIID(riid,IID_IDirectInputMapIW))
{
AddRef();
*ppvOut=(IDirectInputMapperW*)this;
return S_OK;
}
else if(IsEqualIID(riid,IID_IDirectInputMapIA))
{
AddRef();
*ppvOut=(IDirectInputMapperA*)this;
return S_OK;
}
else if(IsEqualIID(riid,IID_IUnknown))
{
AddRef();
*ppvOut=(IUnknown*)(IDirectInputMapperA*)this;
return S_OK;
}
else if(IsEqualIID(riid,IID_IDirectInputMapVendorIW))
{
AddRef();
*ppvOut=(IDirectInputMapperVendorW*)this;
return S_OK;
}
else if(IsEqualIID(riid,IID_IDirectInputMapVendorIA))
{
AddRef();
*ppvOut=(IDirectInputMapperVendorA*)this;
return S_OK;
}
*ppvOut = 0;
return E_NOINTERFACE;
}
void CDIMapObj::MapDevice(LPDIACTIONFORMAT lpDiActionFormat,
LPCTSTR lpFileName,
LPCTSTR lpFileDevName,LPCGUID lpThisGUIDInstance,
DEVICEOBJLIST &DevObjList,CONTROLLIST &ControlsData,
DWORD dwHow,DWORD dwHowApp,DWORD &dwNOfMappedActions,
bool *pbMapExists,bool bUserFile)
{
METHOD_ENTRY(MapDevice);
DUMPN(_T("Filename"),lpFileName);
DUMPN(_T("Device name file"),lpFileDevName);
//Map genre overrides for a particular game
String ApplicationGenreName;
MakeGenreName(ApplicationGenreName,lpFileDevName,
lpDiActionFormat->dwGenre,
&lpDiActionFormat->guidActionMap);
if(GetPrivateProfileInt(ApplicationGenreName.data(),
MAPEXISTS,0,lpFileName))
{
if(pbMapExists)
{
*pbMapExists=true;
}
if(lpDiActionFormat->dwNumActions!=
GetPrivateProfileInt(
ApplicationGenreName.data(),NUMACTIONS,
-1,lpFileName))
{
TRACEI(_T("WARNING! Action map changed!\n"));
TRACEI(_T("File name=%s\n"),lpFileName);
TRACEI(_T("Genre section name=%s\n"),ApplicationGenreName.data());
}
}
TRACE(_T("Process application specific genre.\n"));
DUMPN(_T("Section name"),ApplicationGenreName.data());
MapGenre(lpDiActionFormat,ControlsData,
ApplicationGenreName.data(),lpFileName,lpThisGUIDInstance,
DevObjList,dwHowApp,dwNOfMappedActions);
//Map remainder of semantics of a genre
if(!bUserFile)//only app. specific maps in user file
{
String GenreName;
MakeGenreName(GenreName,lpFileDevName,
lpDiActionFormat->dwGenre);
if(pbMapExists)
{
if(GetPrivateProfileInt(GenreName.data(),
MAPEXISTS,0,lpFileName))
*pbMapExists=true;
}
TRACE(_T("Process genre.\n"));
DUMPN(_T("Section name"),GenreName.data());
MapGenre(lpDiActionFormat,ControlsData,GenreName.data(),
lpFileName,lpThisGUIDInstance,DevObjList,
dwHow,dwNOfMappedActions);
}
}
bool IsImageInfoFull(DIDEVICEIMAGEINFOHEADER *lpdiDevImageInfoHeader,
DWORD dwImages)
{
if((lpdiDevImageInfoHeader->dwBufferSize!=0)&&
(((dwImages+1)*sizeof(DIDEVICEIMAGEINFO))>
lpdiDevImageInfoHeader->dwBufferSize))
return true;
return false;
}
DIDEVICEIMAGEINFO *GetImageInfoAdr(
DIDEVICEIMAGEINFOHEADER *lpdiDevImageInfoHeader,DWORD dwImages)
{
if(lpdiDevImageInfoHeader->dwBufferSize==0)
return NULL;
return &lpdiDevImageInfoHeader->lprgImageInfoArray[dwImages];
}
HRESULT CDIMapObj::GetImageInfoI(
LPDIDEVICEIMAGEINFOHEADER lpdiDevImageInfoHeader)
{
try
{
GETIMAGEINFO_ENTERED;
return GetImageInfoInternal(lpdiDevImageInfoHeader,false);
}
catch(MapException E)
{
return E.GetResult();
}
catch(exception)
{
USETRACER();
TRACE(_T("Internal error, hRes=0x%x\n"),E_FAIL);
return E_FAIL;
}
}
HRESULT CDIMapObj::GetImageInfoInternal(
LPDIDEVICEIMAGEINFOHEADER lpdiDevImageInfoHeader,
bool bGettingSize)
{
METHOD_ENTRY(GetImageInfoInternal);
TRACE(_T("Parameters:\n"));
// DUMP(lpdiDevImageInfoHeader);Instead of dumping entire struct
// dump only input params
// 7/18/2000(a-JiTay): IA64: Use %p format specifier for 32/64-bit pointers.
TRACE(_T("lpdiDevImageInfoHeader=0x%p\n"),lpdiDevImageInfoHeader);
if(lpdiDevImageInfoHeader)
{
USETRACER();
TRACE(_T("dwSize=%u\tdwSizeImageInfo=%u\n"),
(unsigned int)lpdiDevImageInfoHeader->dwSize,
(unsigned int)lpdiDevImageInfoHeader->dwSizeImageInfo);
TRACE(_T("dwBufferSize=%u\tdwBufferUsed=%u\n"),
(unsigned int)lpdiDevImageInfoHeader->dwBufferSize,
(unsigned int)lpdiDevImageInfoHeader->dwBufferUsed);
// 7/18/2000(a-JiTay): IA64: Use %p format specifier for 32/64-bit pointers.
TRACE(_T("lprgImageInfoArray=0x%p\n"),
lpdiDevImageInfoHeader->lprgImageInfoArray);
}
TRACE(_T("\n"));
//Check if initialized
if(!m_bInitialized)
{
TRACE(_T("Object not initialized\n"));
throw MAP_EXCEPTION(DIERR_NOTINITIALIZED);
}
//Check parameters
if(!lpdiDevImageInfoHeader)
{
TRACE(_T("lpdiDevImageInfoHeader is NULL\n"));
throw MAP_EXCEPTION(E_INVALIDARG);
}
//Check structure sizes
if(lpdiDevImageInfoHeader->dwSize!=sizeof(DIDEVICEIMAGEINFOHEADER))
{
TRACE(_T("lpdiDevImageInfoHeader->dwSize is wrong size\n"));
throw MAP_EXCEPTION(E_INVALIDARG);
}
if(lpdiDevImageInfoHeader->dwBufferSize&&
lpdiDevImageInfoHeader->dwSizeImageInfo!=
sizeof(DIDEVICEIMAGEINFO))
{
TRACE(_T("lpdiDevImageInfoHeader->dwSizeImageInfo is wrong size\n"));
throw MAP_EXCEPTION(E_INVALIDARG);
}
//Check buffer size
if(lpdiDevImageInfoHeader->dwBufferSize&&
!lpdiDevImageInfoHeader->lprgImageInfoArray)
{
TRACE(_T("lpdiDevImageInfoHeader->\
dwBufferSize is not 0 and lpdiDevImageInfoHeader->\
lprgImageInfo is NULL\n"));
throw MAP_EXCEPTION(E_INVALIDARG);
}
DUMPN(_T("Vendor filename"),m_VFileName);
DUMPN(_T("Device name in vendor file"),m_VFileDevName);
HRESULT hRes=S_OK;
if((!m_bImageBufferSize)&&(!bGettingSize)&&
lpdiDevImageInfoHeader->dwBufferSize)
{
TRACE(_T("User forgot to inquire about buffer size.\n"));
DIDEVICEIMAGEINFOHEADER DIIH;
DIIH.dwSize=sizeof(DIIH);
DIIH.dwSizeImageInfo=sizeof(DIDEVICEIMAGEINFO);
DIIH.dwcViews=0;
DIIH.dwcButtons=0;
DIIH.dwcAxes=0;
DIIH.dwcPOVs=0;
DIIH.dwBufferSize=0;
DIIH.dwBufferUsed=0;
hRes=GetImageInfoInternal(&DIIH,true);
if(hRes!=S_OK)
return hRes;
}
//check if image info buffer is big enough
if(lpdiDevImageInfoHeader->dwBufferSize&&
(lpdiDevImageInfoHeader->dwBufferSize<
m_dwImageBufferSize))
{
TRACE(_T("lpdiDevImageInfoHeader->dwBufferSize is too small.\n"));
throw MAP_EXCEPTION(DIERR_MOREDATA );
}
//process configuration images
TRACE(_T("Processing DIDIFT_CONFIGURATION images.\n"));
lpdiDevImageInfoHeader->dwcViews=0;
DWORD dwImages=0;
do
{
if(IsImageInfoFull(lpdiDevImageInfoHeader,dwImages))break;
hRes=GetImageInfo((DeviceObjData*)NULL,
lpdiDevImageInfoHeader->dwcViews,
GetImageInfoAdr(lpdiDevImageInfoHeader,dwImages),
DIDIFT_CONFIGURATION);
if(hRes==S_OK)
{
lpdiDevImageInfoHeader->dwcViews++;
dwImages++;
}
}
while(hRes==S_OK);
#if 0
//process view select images
TRACE(_T("Processing DIDIFT_VIEWSELECT images.\n"));
for(int i=0;i<lpdiDevImageInfoHeader->dwcViews;i++)
{
if(IsImageInfoFull(lpdiDevImageInfoHeader,dwImages))break;
if(GetImageInfo((DeviceObjData*)NULL,i,
GetImageInfoAdr(lpdiDevImageInfoHeader,dwImages),
DIDIFT_VIEWSELECT)==S_OK)
dwImages++;
}
//process device selection image
TRACE(_T("Processing DIDIFT_SELECTION images.\n"));
if(!IsImageInfoFull(lpdiDevImageInfoHeader,dwImages))
{
if(GetImageInfo((DeviceObjData*)NULL,-1,
GetImageInfoAdr(lpdiDevImageInfoHeader,dwImages),
DIDIFT_SELECTION)==S_OK)
dwImages++;
}
#endif
//process control data
TRACE(_T("Processing DIDIFT_OVERLAY images.\n"));
DEVICEOBJLIST::iterator DevObjIt;
for(DevObjIt=m_DevObjList.begin();
DevObjIt!=m_DevObjList.end();DevObjIt++)
{
if(IsImageInfoFull(lpdiDevImageInfoHeader,dwImages))break;
for(int i=0;i<lpdiDevImageInfoHeader->dwcViews;i++)
{
if(IsImageInfoFull(lpdiDevImageInfoHeader,dwImages))break;
if(GetImageInfo(&(*DevObjIt),i,
GetImageInfoAdr(lpdiDevImageInfoHeader,dwImages),
DIDIFT_OVERLAY)==S_OK)
dwImages++;
}
}
lpdiDevImageInfoHeader->dwBufferUsed=
dwImages*sizeof(DIDEVICEIMAGEINFO);
if((!lpdiDevImageInfoHeader->dwBufferSize)&&(!m_bImageBufferSize))
{
m_bImageBufferSize=true;
m_dwImageBufferSize=lpdiDevImageInfoHeader->dwBufferUsed;
}
TRACE(_T("hRes=0x%x\n"),S_OK);
DUMP(lpdiDevImageInfoHeader);
return S_OK;
}
bool CDIMapObj::
GetImageInfoFileName(LPCTSTR lpKeyName,LPCTSTR lpSectionName,
DWORD dwIndex,LPDIDEVICEIMAGEINFO lpImageInfo)
{
METHOD_ENTRY(GetImageInfoFileName);
DUMP(lpSectionName);
DUMP(lpKeyName);
DUMP(dwIndex);
String KeyName=lpKeyName;
if(dwIndex!=-1)
KeyName+=_T(".")+N2Str(dwIndex);
String ImageFileName;
if(lpImageInfo)
lpImageInfo->tszImagePath[0]=0;
if(!LoadString(ImageFileName,m_VFileName.data(),
lpSectionName,KeyName.data(),true))
return false;
String Dir;
GetDirectory(m_VFileName.data(),Dir);
Dir+=ImageFileName;
if(Dir.size()>
(sizeof(lpImageInfo->tszImagePath)/
sizeof(lpImageInfo->tszImagePath[0])))
{
TRACE(_T("Image filename too long.\n"));
throw MAP_EXCEPTION(E_FILENAME_TO_LONG);
}
if(lpImageInfo)
_tcscpy(lpImageInfo->tszImagePath,Dir.data());
return true;
}
//keep flags for a while just in case we change our minds again
#if 0
void CDIMapObj::
GetImageInfoFormat(LPCTSTR lpKeyName,LPCTSTR lpSectionName,
DWORD dwIndex,LPDIDEVICEIMAGEINFO lpImageInfo)
{
if(lpImageInfo)
{
METHOD_ENTRY(GetImageInfoFormat);
DUMP(lpSectionName);
DUMP(lpKeyName);
DUMP(dwIndex);
String ImageFileFormatKeyName=lpKeyName;
if(dwIndex!=-1)
ImageFileFormatKeyName+=_T(".")+N2Str(dwIndex);
String ImageFileFormat;
if(!LoadString(ImageFileFormat,m_VFileName.data(),
lpSectionName,ImageFileFormatKeyName.data(),true))
lpImageInfo->dwFlags|=DIDIFT_IMAGE2D_BMP;
else
{
if(ImageFileFormat==_T("BMP"))
lpImageInfo->dwFlags|=DIDIFT_IMAGE2D_BMP;
else if(ImageFileFormat==_T("PNG"))
lpImageInfo->dwFlags|=DIDIFT_IMAGE2D_PNG;
else
{
TRACE(_T("Corrupt image type.\n"));
throw MAP_EXCEPTION(E_CORRUPT_IMAGE_DATA);
}
}
}
}
#endif
bool ImageDataPresent(DWORD dwIndex,LPCTSTR pControlName,
LPCTSTR pVFileName)
{
TCHAR Ret[2];
String VisibleKeyName;
VisibleKeyName=OVERLAY_FILENAME;
VisibleKeyName+=_T(".")+N2Str(dwIndex);
if(GetPrivateProfileString(pControlName,VisibleKeyName.data(),
_T(""),Ret,2,pVFileName))
return true;
VisibleKeyName=OVERLAY_FORMAT;
VisibleKeyName+=_T(".")+N2Str(dwIndex);
if(GetPrivateProfileString(pControlName,VisibleKeyName.data(),
_T(""),Ret,2,pVFileName))
return true;
VisibleKeyName=OVERLAY_RECT;
VisibleKeyName+=_T(".")+N2Str(dwIndex);
if(GetPrivateProfileString(pControlName,VisibleKeyName.data(),
_T(""),Ret,2,pVFileName))
return true;
VisibleKeyName=CONTROL_STRING_ALIGN;
VisibleKeyName+=_T(".")+N2Str(dwIndex);
if(GetPrivateProfileString(pControlName,VisibleKeyName.data(),
_T(""),Ret,2,pVFileName))
return true;
VisibleKeyName=CALLOUTMAX;
VisibleKeyName+=_T(".")+N2Str(dwIndex);
if(GetPrivateProfileString(pControlName,VisibleKeyName.data(),
_T(""),Ret,2,pVFileName))
return true;
VisibleKeyName=LINE_DATA;
VisibleKeyName+=_T(".")+N2Str(dwIndex);
if(GetPrivateProfileString(pControlName,VisibleKeyName.data(),
_T(""),Ret,2,pVFileName))
return true;
return false;
}
HRESULT CDIMapObj::GetImageInfo(
DeviceObjData *pDevObj,
DWORD dwIndex,
LPDIDEVICEIMAGEINFO lpImageInfo,
DWORD dwImageType)
{
METHOD_ENTRY(GetImageInfo);
DUMPN(_T("Image index"),dwIndex);
HRESULT hRes=S_OK;
//There must be vendor file when getting image data
if(!m_bVLoaded)
{
TRACE(_T("No vendor file or error in Initialize().\n"));
throw MAP_EXCEPTION(E_CORRUPT_IMAGE_DATA);
}
switch(dwImageType)
{
case DIDIFT_CONFIGURATION:
if(GetImageInfoFileName(IMAGE_FILENAME,m_VFileDevName.data(),
dwIndex,lpImageInfo))
{
if(lpImageInfo)//we are not only counting
{
lpImageInfo->dwFlags=dwImageType;
lpImageInfo->dwViewID=dwIndex;
//keep flags for a while just in case we change our minds again
#if 0
GetImageInfoFormat(IMAGE_FORMAT,m_VFileDevName.data(),
dwIndex,lpImageInfo);
#endif
}
return S_OK;
}
else
{
if(dwIndex)
return S_FALSE;
else
{
//there must be at least one device view
TRACE(_T("There must be at least one device view, with index 0.\n"));
throw MAP_EXCEPTION(E_CORRUPT_IMAGE_DATA);
}
}
break;
#if 0
case DIDIFT_SELECTION:
if(GetImageInfoFileName(SELECTION_FILENAME,m_VFileDevName.data(),
-1,lpImageInfo))
{
if(lpImageInfo)//we are not only counting
{
lpImageInfo->dwFlags=dwImageType;
//keep flags for a while just in case we change our minds again
#if 0
GetImageInfoFormat(SELECTION_FORMAT,m_VFileDevName.data(),
-1,lpImageInfo);
#endif
}
return S_OK;
}
else
return S_FALSE;
break;
case DIDIFT_VIEWSELECT:
if(GetImageInfoFileName(VIEWSELECT_FILENAME,m_VFileDevName.data(),
dwIndex,lpImageInfo))
{
if(lpImageInfo)//we are not only counting
{
lpImageInfo->dwFlags=dwImageType;
lpImageInfo->dwViewID=dwIndex;
//keep flags for a while just in case we change our minds again
#if 0
GetImageInfoFormat(VIEWSELECT_FORMAT,m_VFileDevName.data(),
dwIndex,lpImageInfo);
#endif
}
return S_OK;
}
else
return S_FALSE;
break;
#endif
case DIDIFT_OVERLAY:
{
//Get control section name
CONTROLLIST::iterator VCtrlDataIt=m_VCtrlData.begin();
while(VCtrlDataIt!=m_VCtrlData.end())
{
if(CompareData(*pDevObj,*VCtrlDataIt))break;
VCtrlDataIt++;
}
if(VCtrlDataIt==m_VCtrlData.end())
{
TRACE(_T("No control with obj ID in file.\n"));
return S_FALSE;//control with offset not found
}
//Section=VCtrlDataIt->ControlName.data();
DUMPN(_T("Control name in ini file"),VCtrlDataIt->ControlName);
//Is there ctrl image data
String VisibleKeyName=CONTROL_VISIBLE;
VisibleKeyName+=_T(".")+N2Str(dwIndex);
if(!GetPrivateProfileInt(VCtrlDataIt->ControlName.data(),
VisibleKeyName.data(),1,m_VFileName.data()))
{
TRACE(_T("No image data for this control.\n"));
return S_FALSE;//No control data
}
if(!ImageDataPresent(dwIndex,VCtrlDataIt->ControlName.data(),
m_VFileName.data()))
{
TRACE(_T("No image data for this control.\n"));
return S_FALSE;//No control data
}
if(!lpImageInfo)
return S_OK;//Just counting data...
lpImageInfo->dwFlags=dwImageType;
lpImageInfo->dwViewID=dwIndex;
lpImageInfo->dwObjID=pDevObj->dwType;
//Get overlay image data
if(GetImageInfoFileName(OVERLAY_FILENAME,
VCtrlDataIt->ControlName.data(),dwIndex,lpImageInfo))
{
TRACE(_T("There is image file name, reading rest.\n"));
//keep flags for a while just in case we change our minds again
#if 0
GetImageInfoFormat(OVERLAY_FORMAT,
VCtrlDataIt->ControlName.data(),dwIndex,lpImageInfo);
#endif
//Get overlay rect
DWORD dwOverlayRectCnt;
String OverlayRectKeyName=OVERLAY_RECT;
OverlayRectKeyName+=_T(".")+N2Str(dwIndex);
POINT OverlayRect[2];
if(LoadPointArray(m_VFileName.data(),
VCtrlDataIt->ControlName.data(),
OverlayRectKeyName.data(),OverlayRect,
dwOverlayRectCnt,2))
{
if(dwOverlayRectCnt!=2)
{
TRACE(_T("Corrupt overlay rect data.\n"));
throw MAP_EXCEPTION(E_CORRUPT_IMAGE_DATA);
}
lpImageInfo->rcOverlay.left=OverlayRect[0].x;
lpImageInfo->rcOverlay.top=OverlayRect[0].y;
lpImageInfo->rcOverlay.right=OverlayRect[1].x;
lpImageInfo->rcOverlay.bottom=OverlayRect[1].y;
}
else
{
lpImageInfo->rcOverlay.left=0;
lpImageInfo->rcOverlay.top=0;
lpImageInfo->rcOverlay.right=100;
lpImageInfo->rcOverlay.bottom=20;
}
}
//Get string alignment
String KeyName=CONTROL_STRING_ALIGN;
KeyName+=_T(".")+N2Str(dwIndex);
String Align;
if(!LoadString(Align,m_VFileName.data(),
VCtrlDataIt->ControlName.data(),KeyName.data(),true))
lpImageInfo->dwTextAlign=DIDAL_CENTERED|DIDAL_MIDDLE;
else
{
if(Align==_T("C"))
lpImageInfo->dwTextAlign=
DIDAL_CENTERED|DIDAL_MIDDLE;
else if(Align==_T("L"))
lpImageInfo->dwTextAlign=
DIDAL_LEFTALIGNED|DIDAL_MIDDLE;
else if(Align==_T("R"))
lpImageInfo->dwTextAlign=
DIDAL_RIGHTALIGNED|DIDAL_MIDDLE;
else if(Align==_T("T"))
lpImageInfo->dwTextAlign=
DIDAL_CENTERED|DIDAL_TOPALIGNED;
else if(Align==_T("B"))
lpImageInfo->dwTextAlign=
DIDAL_CENTERED|DIDAL_BOTTOMALIGNED;
else if(Align==_T("TL"))
lpImageInfo->dwTextAlign=
DIDAL_LEFTALIGNED|DIDAL_TOPALIGNED;
else if(Align==_T("TR"))
lpImageInfo->dwTextAlign=
DIDAL_RIGHTALIGNED|DIDAL_TOPALIGNED;
else if(Align==_T("BL"))
lpImageInfo->dwTextAlign=
DIDAL_LEFTALIGNED|DIDAL_BOTTOMALIGNED;
else if(Align==_T("BR"))
lpImageInfo->dwTextAlign=
DIDAL_RIGHTALIGNED|DIDAL_BOTTOMALIGNED;
else
{
TRACE(_T("Corrupt align data.\n"));
throw MAP_EXCEPTION(E_WRONG_ALIGN_DATA);
}
}
//Get call out rect
DWORD dwCallOutMaxCnt;
String CallOutMaxKeyName=CALLOUTMAX;
CallOutMaxKeyName+=_T(".")+N2Str(dwIndex);
POINT Callout[2];
if(LoadPointArray(m_VFileName.data(),
VCtrlDataIt->ControlName.data(),
CallOutMaxKeyName.data(),Callout,
dwCallOutMaxCnt,2))
{
if(dwCallOutMaxCnt!=2)
{
TRACE(_T("Corrupt callout rect data.\n"));
throw MAP_EXCEPTION(E_CORRUPT_IMAGE_DATA);
}
lpImageInfo->rcCalloutRect.left=Callout[0].x;
lpImageInfo->rcCalloutRect.top=Callout[0].y;
lpImageInfo->rcCalloutRect.right=Callout[1].x;
lpImageInfo->rcCalloutRect.bottom=Callout[1].y;
}
else
{
lpImageInfo->rcCalloutRect.left=0;
lpImageInfo->rcCalloutRect.top=0;
lpImageInfo->rcCalloutRect.right=100;
lpImageInfo->rcCalloutRect.bottom=20;
}
//Get line data
String PointArrayKeyName=LINE_DATA;
PointArrayKeyName+=_T(".")+N2Str(dwIndex);
LoadPointArray(m_VFileName.data(),
VCtrlDataIt->ControlName.data(),
PointArrayKeyName.data(),
lpImageInfo->rgptCalloutLine,
lpImageInfo->dwcValidPts,
sizeof(lpImageInfo->rgptCalloutLine)/
sizeof(lpImageInfo->rgptCalloutLine[0]));
return S_OK;
}
break;
default:
TRACE(_T("Internal error!!!!\n"));
throw MAP_EXCEPTION(E_INVALIDARG);break;
}
return S_FALSE;
}
HRESULT CDIMapObj::GetActionMapI(
LPDIACTIONFORMAT lpDiActionFormat,
LPCTSTR lpctstrUserName,
FILETIME *pTimestamp,DWORD dwFlags)
{
try
{
GETACTIONMAP_ENTERED;
TRACE(_T("Parameters:\n"));
DUMP(lpDiActionFormat);
DUMP(lpctstrUserName);
TRACE(_T("\n"));
//Check if initialized
if(!m_bInitialized)
{
TRACE(_T("Object not initialized\n"));
throw MAP_EXCEPTION(DIERR_NOTINITIALIZED);
}
//Check parameters
if(!lpDiActionFormat)
{
TRACE(_T("lpDiActionFormat is NULL\n"));
throw MAP_EXCEPTION(E_INVALIDARG);
}
//Check structure sizes
if(lpDiActionFormat->dwSize!=sizeof(*lpDiActionFormat))
{
TRACE(_T("lpDiActionFormat->\
dwSize is wrong size\n"));
throw MAP_EXCEPTION(E_INVALIDARG);
}
if(lpDiActionFormat->dwActionSize!=
sizeof(*(lpDiActionFormat->rgoAction)))
{
TRACE(_T("lpDiActionFormat->\
dwActionSize is wrong size\n"));
throw MAP_EXCEPTION(E_INVALIDARG);
}
//Check how many actions, should be more than 0
if(!lpDiActionFormat->dwNumActions)
{
TRACE(_T("lpDiActionFormat->dwNumActions is 0\n"));
throw MAP_EXCEPTION(E_INVALIDARG);
}
//Check ptr to the action array
if(!lpDiActionFormat->rgoAction)
{
TRACE(_T("lpDiActionFormat->rgoAction is NULL\n"));
throw MAP_EXCEPTION(E_INVALIDARG);
}
DWORD dwNOfMappedActions=0;
bool bDoNotMapControl=false;//is this per control or action???
bool bDoNotMapGenre=false;
WhichDeviceObjectIsMapped(
lpDiActionFormat,m_DevObjList,&m_DeviceGuid);
bool bMapExists=false;//sticky flag, must set to false
if(!(DIDBAM_HWDEFAULTS&dwFlags))
{
TRACE(_T("No DIDBAM_HWDEFAULTS flag, map user file first."));
//Map the user file first
LoadUserData(lpctstrUserName,lpDiActionFormat);
DUMPN(_T("User File Name"),m_UFileName.data());
lpDiActionFormat->ftTimeStamp=m_UTimestamp;
if(m_bULoaded)//file was sucessfully preloaded...
{
TRACE(_T("User file loaded.\n"));
MapDevice(lpDiActionFormat,m_UFileName.data(),
m_UFileDevName.data(),
&m_DeviceGuid,m_DevObjList,m_UCtrlData,
DIAH_USERCONFIG,DIAH_USERCONFIG,
dwNOfMappedActions,&bMapExists,true);
}
}
if(m_lpVFileName&&m_bVLoaded&&
((DIDBAM_HWDEFAULTS&dwFlags)||!bMapExists))
{
TRACE(_T("Vendor file loaded.\n"));
//Check if there are unmapped entries
for(DWORD i=0;i<lpDiActionFormat->dwNumActions;i++)
{
if((lpDiActionFormat->rgoAction[i].guidInstance==NULLGUID)
||((lpDiActionFormat->rgoAction[i].guidInstance==m_DeviceGuid)
&&(lpDiActionFormat->rgoAction[i].dwHow==DIAH_UNMAPPED)
&&((lpDiActionFormat->rgoAction[i].dwFlags&DIA_APPNOMAP)==0)))
{
TRACE(_T("Unmapped action found, mapping vendor file.\n"));
//If there are unmapped entries, map manufacturer file
DUMPN(_T("Vendor file name"),m_lpVFileName);
MapDevice(lpDiActionFormat,m_lpVFileName,
m_VFileDevName.data(),&m_DeviceGuid,m_DevObjList,
m_VCtrlData,DIAH_HWDEFAULT,DIAH_HWAPP,
dwNOfMappedActions,NULL,false);
break;
}
}
}
if(dwNOfMappedActions)
{
DUMP(dwNOfMappedActions);
TRACE(_T("hRes=0x%x\n"),S_OK);
DUMP(lpDiActionFormat);
return S_OK;
}
if((!(DIDBAM_HWDEFAULTS&dwFlags))&&bMapExists)
{
TRACE(_T("hRes=0x%x\n"),S_FALSE);
return S_FALSE;
}
TRACE(_T("hRes=0x%x\n"),S_NOMAP);
return S_NOMAP;
}
catch(MapException E)
{
return E.GetResult();
}
catch(exception)
{
USETRACER();
TRACE(_T("Internal error, hRes=0x%x\n"),E_FAIL);
return E_FAIL;
}
}
void CDIMapObj::Resinc(LPDIACTIONFORMAT lpDiActionFormat)
{
TRACE(_T("Resincing object after writing.\n"));
LoadUserData(NULL,lpDiActionFormat,true);
}
HRESULT CDIMapObj::SaveActionMapI(
LPDIACTIONFORMAT lpDiActionFormat,
LPCTSTR lpctstrUserName,
DWORD dwFlags)
{
try
{
SAVEACTIONMAP_ENTERED;
TRACE(_T("Parameters:\n"));
DUMP(lpDiActionFormat);
DUMP(lpctstrUserName);
TRACE(_T("\n"));
//Check if initialized
if(!m_bInitialized)
{
TRACE(_T("Object not initialized\n"));
throw MAP_EXCEPTION(DIERR_NOTINITIALIZED);
}
//Check parameters
if(!lpDiActionFormat)
{
TRACE(_T("lpDiActionFormat is NULL\n"));
throw MAP_EXCEPTION(E_INVALIDARG);
}
//Check structure sizes
if(lpDiActionFormat->dwSize!=sizeof(*lpDiActionFormat))
{
TRACE(_T("lpDiActionFormat->\
dwSize is wrong size\n"));
throw MAP_EXCEPTION(E_INVALIDARG);
}
if(lpDiActionFormat->dwActionSize!=
sizeof(*(lpDiActionFormat->rgoAction)))
{
TRACE(_T("lpDiActionFormat->\
dwActionSize is wrong size\n"));
throw MAP_EXCEPTION(E_INVALIDARG);
}
//Check how many actions, should be more than 0
if(!lpDiActionFormat->dwNumActions)
{
TRACE(_T("lpDiActionFormat->dwNumActions is 0\n"));
throw MAP_EXCEPTION(E_INVALIDARG);
}
//Check ptr to the action array
if(!lpDiActionFormat->rgoAction)
{
TRACE(_T("lpDiActionFormat->rgoAction is NULL\n"));
throw MAP_EXCEPTION(E_INVALIDARG);
}
//this also creates directory if necessary
LoadUserData(lpctstrUserName,lpDiActionFormat,false,true);
SaveActionMapUV(
lpDiActionFormat,
m_bULoaded,
m_UFileName.data(),
m_UFileDevName,
m_UCtrlData,
NULL,
DIAH_USERCONFIG,DIAH_USERCONFIG,true);
Resinc(lpDiActionFormat);
TRACE(_T("hRes=0x%x\n"),S_OK);
return S_OK;
}
catch(MapException E)
{
return E.GetResult();
}
catch(exception)
{
USETRACER();
TRACE(_T("Internal error, hRes=0x%x\n"),E_FAIL);
return E_FAIL;
}
}
void CDIMapObj::WriteImageInfo(LPCTSTR lpFileKeyName,
LPCTSTR lpFormatKeyName,
LPCTSTR lpSectionName,
LPDIDEVICEIMAGEINFO lpImageInfo,
bool bAddIndex,
bool bDelete)
{
if(lpImageInfo->tszImagePath[0]||bDelete)
{
String FileKeyName=lpFileKeyName;
if(bAddIndex)
FileKeyName+=_T(".")+N2Str(lpImageInfo->dwViewID);
String ImageFileName;
LPCTSTR pImageFileName=NULL;
if(!bDelete)
{
StripDirectory(lpImageInfo->tszImagePath,ImageFileName);
pImageFileName=ImageFileName.data();
}
if(!WritePrivateProfileString(lpSectionName,FileKeyName.data(),
pImageFileName,m_VFileName.data()))
throw MAP_EXCEPTION(HRESULT_FROM_WIN32(GetLastError()));
//keep flags for a while just in case we change our minds again
#if 0
String FormatKeyName=lpFormatKeyName;
if(bAddIndex)
FormatKeyName+=_T(".")+N2Str(lpImageInfo->dwViewID);
String ImageFileFormat;
LPCTSTR pImageFileFormat=NULL;
if(!bDelete)
{
if(lpImageInfo->dwFlags&DIDIFT_IMAGE2D_PNG)
ImageFileFormat=_T("PNG");
else
ImageFileFormat=_T("BMP");
pImageFileFormat=ImageFileFormat.data();
}
if(!WritePrivateProfileString(lpSectionName,FormatKeyName.data(),
pImageFileFormat,m_VFileName.data()))
throw MAP_EXCEPTION(HRESULT_FROM_WIN32(GetLastError()));
#endif
}
}
void CDIMapObj::MakeNewControlName(String &CtrlName,
DEVICEOBJLIST::iterator DevObjIt,
CONTROLLIST &ControlsData,
String &FileDevName,
STRINGLIST &ControlsAllDevs,
STRINGLIST &Controls)
{
ControlData *pCtrlData=NULL;
if(&ControlsData==&m_UCtrlData)
pCtrlData=DevObjIt->pUCtrlData;
else
pCtrlData=DevObjIt->pVCtrlData;
//Was control data allready in the file
if(!pCtrlData)
{
//No control data in the file
//Make unique control name for the file
ControlData ControlDataCur;
ControlDataCur.ControlName=_T("Ctrl");
ControlDataCur.ControlName+=N2Str(DevObjIt->dwOffset);
//ControlDataCur.ControlName+=FileDevName;
ToUpper(ControlDataCur.ControlName);
MakeUniqueName(ControlDataCur.ControlName,ControlsAllDevs);
//Now add this control name into the list
CS S;
S.assign(ControlDataCur.ControlName);
Controls.push_back(S);
//Store data for this control into the list
ControlsData.push_back(ControlDataCur);
//Here bind device obj and control data
ControlsData.back().pDevObj=&(*DevObjIt);
if(&ControlsData==&m_UCtrlData)
pCtrlData=DevObjIt->pUCtrlData=&ControlsData.back();
else
pCtrlData=DevObjIt->pVCtrlData=&ControlsData.back();
}
CtrlName=pCtrlData->ControlName;
}
void WriteCtrlData(DEVICEOBJLIST::iterator DevObjIt,
LPCTSTR pCtrlName,LPCTSTR pFileName)
{
//Write offset
WritePrivateProfileIntX(pCtrlName,OFFSET,
DevObjIt->dwOffset,pFileName);
//Write USB usage/usagepage if available
if(DevObjIt->dwUsage&&DevObjIt->dwUsagePage)
{
WritePrivateProfileIntX(pCtrlName,USAGEPAGE,
DevObjIt->dwUsagePage,pFileName);
WritePrivateProfileIntX(pCtrlName,USAGE,
DevObjIt->dwUsage,pFileName);
}
//Write control name
if(!WritePrivateProfileString(pCtrlName,NAME,
DevObjIt->Name.data(),pFileName))
{
TRACE(_T("Error writing ini file.\n"));
throw MAP_EXCEPTION(HRESULT_FROM_WIN32(GetLastError()));
}
}
void CDIMapObj::
SaveActionMapUV(
LPDIACTIONFORMAT lpDiActionFormat,
bool bDevInFileLoaded,
LPCTSTR pFileName,
String &FileDevName,
CONTROLLIST &ControlsData,
LPDIDEVICEIMAGEINFOHEADER lpdiDevImageInfoHeader,
DWORD dwHowDev,DWORD dwHowApp,bool bUserFile)
{
METHOD_ENTRY(SaveActionMapUV);
DUMPN(_T("Filename"),pFileName);
//Write allways ,just to update name with lattest.
WritePrivateProfileIntX(DIRECT_INPUT,DIRECTX_VERSION,
0x800,pFileName);
//Load list of devices in the file
STRINGLIST Devices;
LoadListOfStrings(pFileName,DIRECT_INPUT,DEVICES,Devices,true);
if(!bDevInFileLoaded)
{
TRACE(_T("Device not in file.\n"));
FileDevName=m_DeviceName;
//Find unique device name and add the list
MakeUniqueName(FileDevName,Devices);
//Write list of devices
WriteListOfStrings(DIRECT_INPUT,DEVICES,Devices,pFileName);
//Write VID and PID
if(m_dwThisVendorID&&m_dwThisProductID)
{
WritePrivateProfileIntX(FileDevName.data(),VENDORID,
m_dwThisVendorID,pFileName);
WritePrivateProfileIntX(FileDevName.data(),PRODUCTID,
m_dwThisProductID,pFileName);
}
//Write device name.
if(!WritePrivateProfileString(FileDevName.data(),NAME,
m_DeviceName.data(),pFileName))
{
TRACE(_T("Error writing ini file.\n"));
throw MAP_EXCEPTION(HRESULT_FROM_WIN32(GetLastError()));
}
}
DUMPN(_T("Device name in file"),FileDevName);
//write timestamp, but only if we are processing user file
if(&ControlsData==&m_UCtrlData)
WriteTimestamp(pFileName,FileDevName.data(),
lpDiActionFormat->guidActionMap,lpDiActionFormat);
//Load list of controls for this device in the file
STRINGLIST Controls;
LoadListOfStrings(pFileName,FileDevName.data(),CONTROLS,Controls,true);
//Load list of controls for all devices in the file
STRINGLIST ControlsAllDevs;
for(STRINGLIST::iterator DevIt=Devices.begin();
DevIt!=Devices.end();DevIt++)
LoadListOfStrings(pFileName,DevIt->data(),CONTROLS,
ControlsAllDevs,true);
// bool bOtherAppFirst=true;
// bool bUserConfig=true;
//Delete old sections and create empty mapping
String GenreName;
//Game specific section
//Get section name
MakeGenreName(GenreName,FileDevName.data(),
lpDiActionFormat->dwGenre,&lpDiActionFormat->guidActionMap);
//Find out if this is first writting
bool bFirstWrite=!GetPrivateProfileInt(GenreName.data(),
MAPEXISTS,0,pFileName);
UINT nNoOfMappings=-1;
if(!bFirstWrite)
{
nNoOfMappings=GetPrivateProfileInt(GenreName.data(),
NUMACTIONS,-1,pFileName);
}
//Delete section
if(!WritePrivateProfileString(GenreName.data(),NULL,
NULL,pFileName))
{
TRACE(_T("Error writing ini file.\n"));
throw MAP_EXCEPTION(
HRESULT_FROM_WIN32(GetLastError()));
}
//Write numbet of actions
if(bUserFile)
{
if(bFirstWrite)
WritePrivateProfileInt(GenreName.data(),NUMACTIONS,
lpDiActionFormat->dwNumActions,pFileName);
else
WritePrivateProfileInt(GenreName.data(),NUMACTIONS,
nNoOfMappings,pFileName);
}
//Mark that section exists
WritePrivateProfileInt(GenreName.data(),
MAPEXISTS,1,pFileName);
//General section (not game specific)
//Delete section
MakeGenreName(GenreName,FileDevName.data(),
lpDiActionFormat->dwGenre,NULL);
if(!WritePrivateProfileString(GenreName.data(),NULL,
NULL,pFileName))
{
TRACE(_T("Error writing ini file.\n"));
throw MAP_EXCEPTION(
HRESULT_FROM_WIN32(GetLastError()));
}
//Mark that section exist
if(!bUserFile)
WritePrivateProfileInt(GenreName.data(),
MAPEXISTS,1,pFileName);
TRACE(_T("Looking for action to write.\n"));
//Iterate through all the actions and store control data
for(DWORD dwAct=0;dwAct<lpDiActionFormat->dwNumActions;dwAct++)
{
DWORD dwHow=lpDiActionFormat->rgoAction[dwAct].dwHow;
if(!(lpDiActionFormat->rgoAction[dwAct].guidInstance==
m_DeviceGuid))
continue;
if(bUserFile)
{
if(!(dwHow&
(DIAH_USERCONFIG|DIAH_APPREQUESTED|DIAH_HWAPP|
DIAH_HWDEFAULT|DIAH_DEFAULT)))
continue;
}
else
{
if(!(dwHow&(DIAH_HWAPP|DIAH_HWDEFAULT)))
continue;
}
if(bUserFile)
dwHow=DIAH_HWAPP;
String CtrlName;
#ifdef _CHECKED
int nObjIndex=-1;
#endif
//Find device object with same offset
for(DEVICEOBJLIST::iterator DevObjIt=m_DevObjList.begin();
DevObjIt!=m_DevObjList.end();DevObjIt++)
{
#ifdef _CHECKED
nObjIndex++;
#endif
if((DIDFT_FINDMASK&DevObjIt->dwOffset)!=
(DIDFT_FINDMASK&lpDiActionFormat->rgoAction[dwAct].dwObjID))
continue;
if(((DIDFT_FINDMASK&DevObjIt->dwOffset)==
(DIDFT_FINDMASK&lpDiActionFormat->rgoAction[dwAct].dwObjID))&&
CompareTypeObjAct(DevObjIt->dwType,
lpDiActionFormat->rgoAction[dwAct].dwSemantic))
{
#ifdef _CHECKED
TRACE(_T("To write found action %u matched with devobj %u\n"),
dwAct,nObjIndex);
#endif
//Device object found
//Now find file control name
MakeNewControlName(CtrlName,DevObjIt,
ControlsData,FileDevName,ControlsAllDevs,Controls);
DUMPN(_T("control name in file"),CtrlName);
WriteCtrlData(DevObjIt,CtrlName.data(),pFileName);
//Make section genre name
String GenreName;
LPCGUID lpAppGUID=NULL;
if(dwHow&DIAH_HWAPP)
lpAppGUID=&lpDiActionFormat->guidActionMap;
MakeGenreName(GenreName,FileDevName.data(),
lpDiActionFormat->dwGenre,lpAppGUID);
/*
bool bDelSect=false;
if(bOtherAppFirst&&(dwHow&DIAH_HWAPP))
{
bOtherAppFirst=false;
bDelSect=true;
}
if(bUserConfig&&(dwHow&DIAH_HWDEFAULT))
{
bUserConfig=false;
bDelSect=true;
}
//Delete section if necessary
if(bDelSect)
{
TRACE(_T("First write to this section, deleting section."));
if(!WritePrivateProfileString(GenreName.data(),NULL,
NULL,pFileName))
{
TRACE(_T("Error writing ini file.\n"));
throw MAP_EXCEPTION(
HRESULT_FROM_WIN32(GetLastError()));
}
//Put flag that this mapping exists
WritePrivateProfileInt(GenreName.data(),
MAPEXISTS,1,pFileName);
}
*/
//Now update genre mapping
WritePrivateProfileIntX(GenreName.data(),CtrlName.data(),
GetFileSemantic(
lpDiActionFormat->rgoAction[dwAct].dwSemantic,
dwHowDev),
pFileName);
break;
}
}
}
if(lpdiDevImageInfoHeader)
{
m_bImageBufferSize=false;
m_dwImageBufferSize=0;
for(int i=0;i<(lpdiDevImageInfoHeader->dwBufferUsed/
lpdiDevImageInfoHeader->dwSizeImageInfo);i++)
{
LPDIDEVICEIMAGEINFO lpImageInfo=
&lpdiDevImageInfoHeader->lprgImageInfoArray[i];
DWORD dwFlags=lpImageInfo->dwFlags;
if(dwFlags&DIDIFT_CONFIGURATION)
{
WriteImageInfo(IMAGE_FILENAME,IMAGE_FORMAT,
FileDevName.data(),
lpImageInfo,true,(dwFlags&DIDIFT_DELETE)?true:false);
}
#if 0
else if(dwFlags&DIDIFT_SELECTION)
{
WriteImageInfo(SELECTION_FILENAME,SELECTION_FORMAT,
FileDevName.data(),
lpImageInfo,false,(dwFlags&DIDIFT_DELETE)?true:false);
}
else if(dwFlags&DIDIFT_VIEWSELECT)
{
WriteImageInfo(VIEWSELECT_FILENAME,VIEWSELECT_FORMAT,
FileDevName.data(),
lpImageInfo,true,(dwFlags&DIDIFT_DELETE)?true:false);
}
#endif
else if(dwFlags&DIDIFT_OVERLAY)
{
String CtrlName;
//Find device object with same offset
for(DEVICEOBJLIST::iterator DevObjIt=m_DevObjList.begin();
DevObjIt!=m_DevObjList.end();DevObjIt++)
{
if((DIDFT_FINDMASK&lpImageInfo->dwObjID)
==(DIDFT_FINDMASK&DevObjIt->dwType))
{
//Device object found
//Now find file control name
String CtrlName;
MakeNewControlName(CtrlName,DevObjIt,
ControlsData,FileDevName,
ControlsAllDevs,Controls);
WriteCtrlData(DevObjIt,CtrlName.data(),pFileName);
//Write file name and format
WriteImageInfo(OVERLAY_FILENAME,
OVERLAY_FORMAT,CtrlName.data(),
lpImageInfo,true,
(dwFlags&DIDIFT_DELETE)?true:false);
//Write overlay rect
if(lpImageInfo->tszImagePath[0]||
(dwFlags&DIDIFT_DELETE))
{
//Get overlay rect
String OverlayRectKeyName=OVERLAY_RECT;
OverlayRectKeyName+=
_T(".")+N2Str(lpImageInfo->dwViewID);
if(dwFlags&DIDIFT_DELETE)
{
if(!WritePrivateProfileString(
CtrlName.data(),
OverlayRectKeyName.data(),
NULL,
m_VFileName.data()))
throw MAP_EXCEPTION(
HRESULT_FROM_WIN32(
GetLastError()));
}
else
WriteRect(CtrlName.data(),
OverlayRectKeyName.data(),
&lpImageInfo->rcOverlay,
m_VFileName.data());
}
//Write string alignment
String AlignKeyName=CONTROL_STRING_ALIGN;
AlignKeyName+=
_T(".")+N2Str(lpImageInfo->dwViewID);
String Align;
LPCTSTR pAlign=NULL;
if(!(dwFlags&DIDIFT_DELETE))
{
if(lpImageInfo->dwTextAlign&
DIDAL_TOPALIGNED)
Align=_T("T");
else if(lpImageInfo->dwTextAlign&
DIDAL_BOTTOMALIGNED)
Align=_T("B");
if(lpImageInfo->dwTextAlign&
DIDAL_LEFTALIGNED)
Align+=_T("L");
else if(lpImageInfo->dwTextAlign&
DIDAL_RIGHTALIGNED)
Align+=_T("R");
if(Align==_T(""))
Align=_T("C");
pAlign=Align.data();
}
if(!WritePrivateProfileString(
CtrlName.data(),
AlignKeyName.data(),
pAlign,
m_VFileName.data()))
throw MAP_EXCEPTION(
HRESULT_FROM_WIN32(GetLastError()));
//Write call out rect
String CallOutMaxKeyName=CALLOUTMAX;
CallOutMaxKeyName+=
_T(".")+N2Str(lpImageInfo->dwViewID);
if(dwFlags&DIDIFT_DELETE)
{
if(!WritePrivateProfileString(
CtrlName.data(),
CallOutMaxKeyName.data(),
NULL,
m_VFileName.data()))
throw MAP_EXCEPTION(
HRESULT_FROM_WIN32(
GetLastError()));
}
else
WriteRect(CtrlName.data(),
CallOutMaxKeyName.data(),
&lpImageInfo->rcCalloutRect,
m_VFileName.data());
//Write line data
String PointArrayKeyName=LINE_DATA;
PointArrayKeyName+=
_T(".")+N2Str(lpImageInfo->dwViewID);
if(dwFlags&DIDIFT_DELETE)
{
if(!WritePrivateProfileString(
CtrlName.data(),
PointArrayKeyName.data(),
NULL,
m_VFileName.data()))
throw MAP_EXCEPTION(
HRESULT_FROM_WIN32(
GetLastError()));
}
else
WritePointArray(
CtrlName.data(),
PointArrayKeyName.data(),
lpImageInfo->rgptCalloutLine,
lpImageInfo->dwcValidPts,
m_VFileName.data());
break;
}
}
}
else
throw MAP_EXCEPTION(E_CORRUPT_IMAGE_DATA);
}
}
//Write new list of controls into the file
if(Controls.size())
WriteListOfStrings(FileDevName.data(),CONTROLS,Controls,pFileName);
}
HRESULT CDIMapObj::
WriteVendorFileI(
LPDIACTIONFORMAT lpDiActionFormat,
LPDIDEVICEIMAGEINFOHEADER lpdiDevImageInfoHeader,
DWORD dwFlags)
{
try
{
WRITEVENDORFILE_ENTERED;
TRACE(_T("Parameters:\n"));
DUMP(lpDiActionFormat);
DUMP(lpdiDevImageInfoHeader);
//DUMP(lpdiDevImageInfoHeader);
TRACE(_T("\n"));
//Check if initialized
if(!m_bInitialized)
{
TRACE(_T("Object not initialized\n"));
throw MAP_EXCEPTION(DIERR_NOTINITIALIZED);
}
//Check lpDiActionFormat structure
//Check structure sizes
if(lpDiActionFormat&&(lpDiActionFormat->dwSize!=
sizeof(*lpDiActionFormat)))
{
TRACE(_T("lpDiActionFormat->dwSize is wrong size\n"));
throw MAP_EXCEPTION(E_INVALIDARG);
}
if(lpDiActionFormat&&(lpDiActionFormat->dwActionSize!=
sizeof(*(lpDiActionFormat->rgoAction))))
{
TRACE(_T("lpDiActionFormat->dwActionSize is wrong size\n"));
throw MAP_EXCEPTION(E_INVALIDARG);
}
//Check how many actions, should be more than 0
if(lpDiActionFormat&&!lpDiActionFormat->dwNumActions)
{
TRACE(_T("lpDiActionFormat->dwNumActions is 0\n"));
throw MAP_EXCEPTION(E_INVALIDARG);
}
//Check ptr to the action array
if(lpDiActionFormat&&!lpDiActionFormat->rgoAction)
{
TRACE(_T("lpDiActionFormat->rgoAction is NULL\n"));
throw MAP_EXCEPTION(E_INVALIDARG);
}
//Check lpdiDevImageInfoHeader structure
//Check structure sizes
if(lpdiDevImageInfoHeader&&
(lpdiDevImageInfoHeader->dwSize!=
sizeof(*lpdiDevImageInfoHeader)))
{
TRACE(_T("lpdiDevImageInfoHeader->dwSize is wrong size\n"));
throw MAP_EXCEPTION(E_INVALIDARG);
}
if(lpdiDevImageInfoHeader&&
(lpdiDevImageInfoHeader->dwSizeImageInfo!=
sizeof(*(lpdiDevImageInfoHeader->lprgImageInfoArray))))
{
TRACE(_T("lpdiDevImageInfoHeader->dwSizeImageInfo is wrong size\n"));
throw MAP_EXCEPTION(E_INVALIDARG);
}
//Check how many images, should be more than 0
if(lpdiDevImageInfoHeader&&!lpdiDevImageInfoHeader->dwBufferSize)
{
TRACE(_T("lpdiDevImageInfoHeader->dwBufferSize is 0\n"));
throw MAP_EXCEPTION(E_INVALIDARG);
}
//Check how many images, should be more than 0
if(lpdiDevImageInfoHeader&&!lpdiDevImageInfoHeader->dwBufferUsed)
{
TRACE(_T("lpdiDevImageInfoHeader->dwBufferUsed is 0\n"));
throw MAP_EXCEPTION(E_INVALIDARG);
}
//Check ptr to the image array
if(lpdiDevImageInfoHeader&&
!lpdiDevImageInfoHeader->lprgImageInfoArray)
{
TRACE(_T("lpdiDevImageInfoHeader->lprgImageInfoArray is NULL\n"));
throw MAP_EXCEPTION(E_INVALIDARG);
}
SaveActionMapUV(
lpDiActionFormat,
m_bVLoaded,
m_VFileName.data(),
m_VFileDevName,
m_VCtrlData,
lpdiDevImageInfoHeader,
DIAH_HWDEFAULT,DIAH_HWAPP,false);
LoadFileData(m_VFileName.data(),m_DeviceName.data(),
m_dwThisVendorID,m_dwThisProductID,
m_VFileDevName,m_VCtrlData,m_bVLoaded,NULL,NULL);
TRACE(_T("hRes=0x%x\n"),S_OK);
return S_OK;
}
catch(MapException E)
{
return E.GetResult();
}
catch(exception)
{
USETRACER();
TRACE(_T("Internal error, hRes=0x%x\n"),E_FAIL);
return E_FAIL;
}
}
HRESULT Map_New(REFIID riid,LPVOID *ppvOut)
{
CDIMapObj *lpDIMapObj=NULL;
try
{
HRESULT hRes=S_OK;
*ppvOut=NULL;
lpDIMapObj=new CDIMapObj;
hRes=lpDIMapObj->QueryInterface(riid,ppvOut);
if(hRes!=S_OK)
throw MAP_EXCEPTION(hRes);
return S_OK;
}
catch(MapException E)
{
delete lpDIMapObj;
return E.GetResult();
}
catch(exception)
{
delete lpDIMapObj;
USETRACER();
TRACE(_T("Internal error, hRes=0x%x\n"),E_FAIL);
return E_FAIL;
}
}
Reference in a new issue Copy permalink