VC++ 后期绑定使用COM组件

最新推荐文章于 2016-10-17 17:13:42 发布
最新推荐文章于 2016-10-17 17:13:42 发布
阅读量1.6k 收藏 1
点赞数
分类专栏： programmer matlab VC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fonjames/article/details/51543846
版权
programmer 同时被 3 个专栏收录
36 篇文章 0 订阅
订阅专栏
matlab
11 篇文章 0 订阅
订阅专栏
VC
7 篇文章 0 订阅
订阅专栏

在使用COM组件时，在编译时就获得接口类型定义等信息，为早期绑定。又称VTABLE绑定，所有com组件都支持。


后期绑定要求组件接口为自动化接口，即后期绑定接口必须继承自IDispatch.  


(MATLAB编译的组件都有双接口，也支持后期绑定）


后期绑定可以借助XYDispDriver，原作者发布的C++类  http://www.codeproject.com/com/comdispatchdriver.asp 已经不能访问了。

在网络上找到代码，测试了下可以用。

XYDispDriver.h

#ifndef XYDISPDRIVER_H 
#define XYDISPDRIVER_H 
 
// uncomment the following line if you are exporting the XYDispDriver class 
// #define XYDISPDRIVER_BUILDDLL 
// uncomment the following line if you are importing the XYDispDriver class 
// #define XYDISPDRIVER_USEDLL 
// uncomment the following line if you want to output debug messages 
// #define XYDISPDRIVER_DEBUG 
 
#ifdef XYDISPDRIVER_BUILDDLL 
	#define XYDISPDRIVER_EXPORT __declspec(dllexport) 
#else 
	# ifdef XYDISPDRIVER_USEDLL 
		#define XYDISPDRIVER_EXPORT __declspec(dllimport) 
	#else 
		#define XYDISPDRIVER_EXPORT  
	#endif 
#endif 
 
//#include <windows.h> 
#include <atlbase.h> 
#include <tchar.h> 
#include <stdio.h> 
#include <oaidl.h> 
#include <ocidl.h> 
 
#define XYDISPDRIVER_OLENAMELEN 120 
 
 
// XYDispInfo: private helper class to store type info of a method or a property 
class XYDispInfo 
{ 
	friend class XYDispDriver; 
	XYDispInfo(); 
	~XYDispInfo(); 
	// dispatch id 
	DISPID m_dispID; 
	// method or property name 
	BSTR m_bstrName; 
	// invoke flag 
	WORD m_wFlag; 
	// offset of virtual function 
	short m_oVft; 
	// calling convention 
	CALLCONV m_callconv; 
	// output type 
	VARTYPE m_vtOutputType; 
	// output data 
	VARIANT* m_pOutput; 
	// number of parameters 
	int m_nParamCount; 
	// parameter type array 
	WORD* m_pParamTypes; 
	// assignment operator 
	XYDispInfo& operator=(const XYDispInfo& src); 
}; 
 
// helper class to initialize/uninitialize com 
// declare one such object in each thread is enough 
// but it doesn't hurt to have multiples 
class XYDISPDRIVER_EXPORT CoInit 
{ 
public: 
	CoInit() { CoInitialize(NULL); } 
	~CoInit() { CoUninitialize(); } 
}; 
 
// XYDispDriver: the main class 
class XYDISPDRIVER_EXPORT XYDispDriver 
{ 
	// initialize/uninitialize com 
	CoInit m_coInit; 
	// pointer to the IDispatch interface 
	IDispatch* m_pDisp; 
	// pointer to the IConnectionPoint interface 
	IConnectionPoint* m_pCP; 
	// used by IConnectionPoint::Advise/Unadvise 
	DWORD m_dwCookie; 
	// number of methods and properties 
	int m_nDispInfoCount; 
	// array of type info 
	XYDispInfo* m_pDispInfo; 
	// error return code 
	HRESULT m_hRet; 
	// exception info 
	EXCEPINFO* m_pExceptInfo; 
	// private helper functions/members 
	int m_nVarCount; 
	int m_nMethodCount; 
	int FindDispInfo(LPCTSTR strName, const WORD wFlag = DISPATCH_METHOD); 
	HRESULT InvokeMethodV(const int nIndex, va_list argList); 
	static HRESULT InvokeVariantMethodV(IDispatch* pDisp, const DISPID dispidMethod, WORD wInvokeFlag, VARIANT* pVarRet, EXCEPINFO* pExcepInfo, const nParamCount, va_list argList); 
	bool LoadTypeInfo(); 
public: 
	XYDispDriver(); 
	~XYDispDriver(); 
	// clean up 
	void Clear(); 
	// copy contructor 
	XYDispDriver(const XYDispDriver& src); 
	// assignment operator 
	XYDispDriver& operator=(const XYDispDriver& src); 
	// create a com object with given prog id 
	bool CreateObject(LPCTSTR strProgID, DWORD dwClsContext = CLSCTX_ALL); 
	// create a com object with given class id 
	bool CreateObject(CLSID clsid,  DWORD dwClsContext = CLSCTX_ALL); 
	// attach a IDispatch pointer to the obejct 
	bool Attach(IDispatch* pDisp); 
	// return the IDispatch pointer 
	IDispatch* GetDispatch() { return m_pDisp; } 
	// return the pointer to ith XYDispInfo  
	XYDispInfo* GetDispInfo(const int i) { return (i>=0&&i<m_nDispInfoCount)?(m_pDispInfo+i):NULL; } 
	// return the index of a property in the internal storage 
	int FindProperty(LPCTSTR strPropertyName); 
	// return the index of a method in the internal storage 
	int FindMethod(LPCTSTR strMethodName); 
	// get the type of a property by name 
	WORD GetPropertyType(LPCTSTR strPropertyName); 
	// get the type of a property by index 
	WORD GetPropertyType(int nPropertyIndex); 
	// get a property value by name 
	VARIANT* GetProperty(LPCTSTR strPropertyName); 
	// get a property value by index 
	VARIANT* GetProperty(int nPropertyIndex); 
	// set a property value by name 
	bool SetProperty(LPCTSTR strPropertyName, ...); 
	// set a property value by index 
	bool SetProperty(int nPropertyIndex, ...); 
	// set a property value (ref) by name 
	bool SetPropertyRef(LPCTSTR strPropertyName, ...); 
	// set a property value (ref) by index 
	bool SetPropertyRef(int nPropertyIndex, ...); 
	// get return type of a method by name 
	WORD GetReturnType(LPCTSTR strMethodName); 
	// get return type of a method by index 
	WORD GetReturnType(int nMethodIndex); 
	// get number of parameters in a method by name 
	int GetParamCount(LPCTSTR strMethodName); 
	// get number of parameters in a method by index 
	int GetParamCount(int nMethodIndex); 
	// get the type of a parameter in a method by name 
	WORD GetParamType(LPCTSTR strMethodName, const int nParamIndex); 
	// get the type of a parameter in a method by index 
	WORD GetParamType(int nMethodIndex, const int nParamIndex); 
	// invoke a method by name 
	VARIANT* InvokeMethod(LPCTSTR strMethodName, ...); 
	// invoke a method by index 
	VARIANT* InvokeMethod(int nMethodIndex, ...); 
	// invoke a method without type info 
	static HRESULT InvokeVariantMethod(IDispatch* pDisp, LPCTSTR strMethodName, WORD wInvokeFlag, VARIANT* pVarRet, EXCEPINFO* pExcepInfo, const nParamCount, ...); 
	static HRESULT InvokeVariantMethod(IDispatch* pDisp, const DISPID dispidMethod, WORD wInvokeFlag, VARIANT* pVarRet, EXCEPINFO* pExcepInfo, const nParamCount, ...); 
	// add event handler 
	bool Advise(IUnknown *pUnkSink, REFIID riid); 
    // remove event handler 
    void Unadvise(); 
	// get the last error code as HRESULT 
	HRESULT GetLastError() { return m_hRet; } 
	// get exception info 
	EXCEPINFO* GetExceptionInfo() { return m_pExceptInfo; } 
}; 
 
#endif

XYDispDriver.cpp 

//#include "stdAfx.h"
#include "XYDispDriver.h" 
 
void CharToWChar(unsigned short* pTarget, const char* pSource) 
{ 
	while(*pSource) 
	{ 
		*pTarget = *pSource; 
		pSource++; 
		pTarget++; 
	} 
	*pTarget = 0; 
} 
 
XYDispInfo::XYDispInfo() 
{ 
	m_dispID = 0; 
	m_bstrName = NULL; 
	m_wFlag = 0; 
	m_oVft = -1; 
	m_callconv = CC_STDCALL; 
	m_vtOutputType = VT_NULL; 
	m_pOutput = NULL; 
	m_nParamCount = 0; 
	m_pParamTypes = NULL; 
} 
 
XYDispInfo::~XYDispInfo() 
{ 
	if(m_bstrName!=NULL) 
	{ 
		::SysFreeString(m_bstrName); 
	} 
	if(m_pOutput!=NULL) 
	{ 
		::VariantClear(m_pOutput); 
	} 
	delete m_pOutput; 
	delete []m_pParamTypes; 
} 
 
XYDispInfo& XYDispInfo::operator=(const XYDispInfo& src) 
{ 
	m_dispID = src.m_dispID; 
	if(m_bstrName) ::SysFreeString(m_bstrName); 
	if(src.m_bstrName) m_bstrName = ::SysAllocString(src.m_bstrName); 
	else m_bstrName = NULL; 
	m_wFlag = src.m_wFlag; 
	m_oVft = src.m_oVft; 
	m_callconv = src.m_callconv; 
	m_vtOutputType = src.m_vtOutputType; 
	if(m_pOutput) delete m_pOutput; 
	m_pOutput = new VARIANT; 
	::VariantInit(m_pOutput); 
	m_nParamCount = src.m_nParamCount; 
	if(m_pParamTypes) delete []m_pParamTypes; 
	if(m_nParamCount>0) 
	{ 
		m_pParamTypes = new WORD[m_nParamCount+1]; 
		memcpy(m_pParamTypes,src.m_pParamTypes,(m_nParamCount+1)*sizeof(WORD)); 
	} 
	else m_pParamTypes = NULL; 
	return *this; 
} 
 
XYDispDriver::XYDispDriver() 
{ 
	m_pCP = NULL; 
	m_dwCookie = 0; 
	m_pDisp = NULL; 
	m_nVarCount = 0; 
	m_nMethodCount = 0; 
	m_nDispInfoCount = 0; 
	m_pDispInfo = NULL; 
	m_hRet = S_OK; 
	m_pExceptInfo = NULL; 
} 
 
XYDispDriver::~XYDispDriver() 
{ 
	Clear(); 
} 
 
XYDispDriver::XYDispDriver(const XYDispDriver& src) 
{ 
	m_pCP = NULL; 
	m_dwCookie = 0; 
	m_pDisp = NULL; 
	m_nVarCount = 0; 
	m_nMethodCount = 0; 
	m_nDispInfoCount = 0; 
	m_pDispInfo = NULL; 
	m_hRet = S_OK; 
	m_pExceptInfo = NULL; 
	*this = src; 
} 
 
XYDispDriver& XYDispDriver::operator=(const XYDispDriver& src) 
{ 
	Clear(); 
	m_pDisp = src.m_pDisp; 
	if(m_pDisp) 
	{ 
		m_pDisp->AddRef(); 
		if(src.m_nDispInfoCount>0) 
		{ 
			m_nDispInfoCount = src.m_nDispInfoCount; 
			m_pDispInfo = new XYDispInfo[m_nDispInfoCount]; 
			for(int i=0;i<m_nDispInfoCount;i++) m_pDispInfo[i] = src.m_pDispInfo[i]; 
		} 
	} 
	return *this; 
} 
 
void XYDispDriver::Clear() 
{ 
	m_hRet = S_OK; 
	Unadvise(); 
	if(m_pExceptInfo!=NULL) 
	{ 
		::SysFreeString(m_pExceptInfo->bstrSource); 
		::SysFreeString(m_pExceptInfo->bstrDescription); 
		::SysFreeString(m_pExceptInfo->bstrHelpFile); 
		delete m_pExceptInfo; 
		m_pExceptInfo = NULL; 
	} 
	if(m_pDisp!=NULL) 
	{ 
		m_pDisp->Release();	 
		m_pDisp = NULL; 
	} 
	if(m_pDispInfo) 
	{ 
		delete []m_pDispInfo; 
		m_pDispInfo = NULL; 
	} 
	m_nVarCount = 0; 
	m_nMethodCount = 0; 
	m_nDispInfoCount = 0; 
} 
	 
bool XYDispDriver::CreateObject(LPCTSTR strProgID, DWORD dwClsContext) 
{ 
	Clear(); 
	CLSID clsid; 
	#ifdef _UNICODE 
	WCHAR* pProgID = (WCHAR*)strProgID; 
	#else 
	WCHAR pProgID[XYDISPDRIVER_OLENAMELEN+1]; 
	CharToWChar(pProgID,strProgID); 
	#endif 
	m_hRet = ::CLSIDFromProgID(pProgID, &clsid); 
	if(m_hRet==S_OK) return CreateObject(clsid, dwClsContext); 
	else 
	{ 
		#ifdef XYDISPDRIVER_DEBUG 
		_tprintf(_T("CLSIDFromProgID failed: %x\n"),m_hRet); 
		#endif 
		return false; 
	} 
} 
 
bool XYDispDriver::CreateObject(CLSID clsid, DWORD dwClsContext) 
{ 
	Clear(); 
	m_hRet = ::CoCreateInstance(clsid,NULL,dwClsContext,IID_IDispatch,(void**)(&m_pDisp)); 
	if(m_hRet!=S_OK) 
	{ 
		#ifdef XYDISPDRIVER_DEBUG 
		_tprintf(_T("CoCreateInstance failed: %x\n"),m_hRet); 
		#endif 
		return false; 
	} 
	return LoadTypeInfo(); 
} 
 
bool XYDispDriver::LoadTypeInfo() 
{ 
	/*UINT nTypeInfoCount; 
	m_hRet = m_pDisp->GetTypeInfoCount(&nTypeInfoCount); 
	if(m_hRet!=S_OK||nTypeInfoCount==0) 
	{ 
		#ifdef XYDISPDRIVER_DEBUG 
		_tprintf(_T("GetTypeInfoCount failed or no type info: %x\n"),m_hRet); 
		#endif 
	}*/ 
 
	ITypeInfo* pTypeInfo; 
	m_hRet = m_pDisp->GetTypeInfo(0,LOCALE_SYSTEM_DEFAULT,&pTypeInfo); 
	if(m_hRet!=S_OK||pTypeInfo==NULL) 
	{ 
		#ifdef XYDISPDRIVER_DEBUG 
		_tprintf(_T("GetTypeInfo failed: %x\n"),m_hRet); 
		#endif 
		return false; 
	} 
 
	TYPEATTR* pTypeAttr; 
	m_hRet = pTypeInfo->GetTypeAttr(&pTypeAttr); 
	if(m_hRet!=S_OK) 
	{ 
		pTypeInfo->Release(); 
		#ifdef XYDISPDRIVER_DEBUG 
		_tprintf(_T("GetTypeAttr failed: %x\n"),m_hRet); 
		#endif 
		return false; 
	} 
 
	if(pTypeAttr->typekind!=TKIND_DISPATCH&&pTypeAttr->typekind!=TKIND_COCLASS) 
	{ 
		pTypeInfo->ReleaseTypeAttr(pTypeAttr); 
		pTypeInfo->Release(); 
		#ifdef XYDISPDRIVER_DEBUG 
		_tprintf(_T("Cannot get type info\n")); 
		#endif 
		m_hRet = S_FALSE; 
		return false; 
	} 
 
	if(pTypeAttr->typekind==TKIND_COCLASS) 
	{ 
		int nFlags; 
		HREFTYPE hRefType; 
		ITypeInfo* pTempInfo; 
		TYPEATTR* pTempAttr = NULL;	 
		for (int i=0;i < pTypeAttr->cImplTypes;i++) 
		{ 
			if(pTypeInfo->GetImplTypeFlags(i,&nFlags)==S_OK&&(nFlags&IMPLTYPEFLAG_FDEFAULT)) 
			{ 
				m_hRet = pTypeInfo->GetRefTypeOfImplType(i,&hRefType); 
				if(m_hRet==S_OK) m_hRet = pTypeInfo->GetRefTypeInfo(hRefType,&pTempInfo); 
				if(m_hRet==S_OK) 
				{ 
					m_hRet = pTempInfo->GetTypeAttr(&pTempAttr); 
					if(m_hRet!=S_OK) 
					{ 
						pTempInfo->Release(); 
						pTempInfo = NULL; 
						break; 
					} 
				} 
				else break; 
			} 
		} 
		pTypeInfo->ReleaseTypeAttr(pTypeAttr); 
		pTypeInfo->Release();		 
		if(pTempAttr==NULL) 
		{ 
			#ifdef XYDISPDRIVER_DEBUG 
			_tprintf(_T("Failed to get reference type info: %x\n"),m_hRet); 
			#endif 
			if(m_hRet==S_OK) m_hRet = S_FALSE; 
			return false; 
		} 
		else 
		{ 
			pTypeInfo = pTempInfo; 
			pTypeAttr = pTempAttr; 
		} 
	} 
 
	m_nMethodCount = pTypeAttr->cFuncs; 
	m_nVarCount = pTypeAttr->cVars; 
	m_nDispInfoCount = m_nMethodCount+2*m_nVarCount; 
	#ifdef XYDISPDRIVER_DEBUG 
	_tprintf(_T("Method and variable count = %d\n"), m_nMethodCount+m_nVarCount); 
	#endif 
	m_pDispInfo = new XYDispInfo[m_nDispInfoCount]; 
 
	for(int i=0;i < m_nMethodCount;i++) 
	{ 
		FUNCDESC* pFuncDesc; 
		m_hRet = pTypeInfo->GetFuncDesc(i, &pFuncDesc); 
		if(m_hRet!=S_OK) 
		{ 
			#ifdef XYDISPDRIVER_DEBUG 
			_tprintf(_T("GetFuncDesc failed: %x\n"),m_hRet); 
			#endif 
			pTypeInfo->ReleaseTypeAttr(pTypeAttr); 
			pTypeInfo->Release(); 
			m_nMethodCount = m_nVarCount = m_nDispInfoCount = 0; 
			return false; 
		} 
		m_pDispInfo[i].m_dispID = pFuncDesc->memid; 
		#ifdef XYDISPDRIVER_DEBUG 
		_tprintf(_T("%d: DispID = %d\n"),i, m_pDispInfo[i].m_dispID); 
		#endif 
 
		unsigned int nCount; 
		m_hRet = pTypeInfo->GetNames(m_pDispInfo[i].m_dispID ,&m_pDispInfo[i].m_bstrName,1,&nCount); 
		if(m_hRet!=S_OK) 
		{ 
			#ifdef XYDISPDRIVER_DEBUG 
			_tprintf(_T("GetNames failed: %x\n"),m_hRet); 
			#endif 
			pTypeInfo->ReleaseFuncDesc(pFuncDesc); 
			pTypeInfo->ReleaseTypeAttr(pTypeAttr); 
			pTypeInfo->Release(); 
			m_nMethodCount = m_nVarCount = m_nDispInfoCount = 0; 
			return false; 
		} 
		#ifdef XYDISPDRIVER_DEBUG 
		wprintf(L"MethodName = %s\n", m_pDispInfo[i].m_bstrName); 
		#endif 
		 
		switch(pFuncDesc->invkind) 
		{ 
		case INVOKE_PROPERTYGET: 
			m_pDispInfo[i].m_wFlag = DISPATCH_PROPERTYGET; 
			#ifdef XYDISPDRIVER_DEBUG 
			_tprintf(_T("PropertyGet\n")); 
			#endif 
			break; 
		case INVOKE_PROPERTYPUT: 
			m_pDispInfo[i].m_wFlag = DISPATCH_PROPERTYPUT; 
			#ifdef XYDISPDRIVER_DEBUG 
			_tprintf(_T("PropertyPut\n")); 
			#endif 
			break; 
		case INVOKE_PROPERTYPUTREF: 
			m_pDispInfo[i].m_wFlag = DISPATCH_PROPERTYPUTREF; 
			#ifdef XYDISPDRIVER_DEBUG 
			_tprintf(_T("PropertyPutRef\n")); 
			#endif 
			break; 
		case INVOKE_FUNC: 
			#ifdef XYDISPDRIVER_DEBUG 
			_tprintf(_T("DispatchMethod\n")); 
			#endif 
			m_pDispInfo[i].m_wFlag = DISPATCH_METHOD; 
			break; 
		default: 
			break; 
		} 
		 
		m_pDispInfo[i].m_oVft = pFuncDesc->oVft; 
		#ifdef XYDISPDRIVER_DEBUG 
		_tprintf(_T("VTable offset: %d\n"),m_pDispInfo[i].m_oVft); 
		#endif 
 
		m_pDispInfo[i].m_callconv = pFuncDesc->callconv; 
		#ifdef XYDISPDRIVER_DEBUG 
		_tprintf(_T("Calling convention: %d\n"),m_pDispInfo[i].m_callconv); 
		#endif 
 
		m_pDispInfo[i].m_pOutput = new VARIANT; 
		::VariantInit(m_pDispInfo[i].m_pOutput); 
		m_pDispInfo[i].m_vtOutputType = pFuncDesc->elemdescFunc.tdesc.vt; 
		#ifdef XYDISPDRIVER_DEBUG 
		_tprintf(_T("Return type = %d\n"), m_pDispInfo[i].m_vtOutputType); 
		#endif 
		if(m_pDispInfo[i].m_vtOutputType==VT_VOID||m_pDispInfo[i].m_vtOutputType==VT_NULL) 
		{ 
			m_pDispInfo[i].m_vtOutputType = VT_EMPTY; 
		} 
		 
		m_pDispInfo[i].m_nParamCount = pFuncDesc->cParams; 
		#ifdef XYDISPDRIVER_DEBUG 
		_tprintf(_T("ParamCount = %d\n"), m_pDispInfo[i].m_nParamCount); 
		#endif 
		 
		m_pDispInfo[i].m_pParamTypes = new WORD[m_pDispInfo[i].m_nParamCount+1]; 
		for(int j=0;j<m_pDispInfo[i].m_nParamCount;j++) 
		{ 
			if(pFuncDesc->lprgelemdescParam[j].tdesc.vt==VT_PTR||pFuncDesc->lprgelemdescParam[j].tdesc.vt==VT_SAFEARRAY) 
			{ 
				m_pDispInfo[i].m_pParamTypes[j] = (pFuncDesc->lprgelemdescParam[j].tdesc.lptdesc->vt)|VT_BYREF; 
			} 
			else 
			{ 
				m_pDispInfo[i].m_pParamTypes[j] = pFuncDesc->lprgelemdescParam[j].tdesc.vt; 
			} 
			#ifdef XYDISPDRIVER_DEBUG 
			_tprintf(_T("Param(%d) type = %d\n"),j,m_pDispInfo[i].m_pParamTypes[j]); 
			#endif 
		} 
		m_pDispInfo[i].m_pParamTypes[m_pDispInfo[i].m_nParamCount] = 0; 
		pTypeInfo->ReleaseFuncDesc(pFuncDesc); 
	} 
 
	for(i=m_nMethodCount;i<m_nMethodCount+m_nVarCount;i++) 
	{ 
		VARDESC* pVarDesc; 
		m_hRet = pTypeInfo->GetVarDesc(i-m_nMethodCount, &pVarDesc); 
		if(m_hRet!=S_OK) 
		{ 
			#ifdef XYDISPDRIVER_DEBUG 
			_tprintf(_T("GetVarDesc failed: %x\n"),m_hRet); 
			#endif 
			pTypeInfo->ReleaseTypeAttr(pTypeAttr); 
			pTypeInfo->Release(); 
			m_nMethodCount = m_nVarCount = m_nDispInfoCount = 0; 
			return false; 
		} 
		m_pDispInfo[i].m_dispID = pVarDesc->memid; 
		m_pDispInfo[i+m_nVarCount].m_dispID = m_pDispInfo[i].m_dispID; 
		#ifdef XYDISPDRIVER_DEBUG 
		_tprintf(_T("%d: DispID = %d\n"),i, m_pDispInfo[i].m_dispID); 
		#endif 
 
		unsigned int nCount; 
		m_hRet = pTypeInfo->GetNames(m_pDispInfo[i].m_dispID ,&m_pDispInfo[i].m_bstrName,1,&nCount); 
		if(m_hRet!=S_OK) 
		{ 
			#ifdef XYDISPDRIVER_DEBUG 
			_tprintf(_T("GetNames failed: %x\n"),m_hRet); 
			#endif 
			pTypeInfo->ReleaseVarDesc(pVarDesc); 
			pTypeInfo->ReleaseTypeAttr(pTypeAttr); 
			pTypeInfo->Release(); 
			m_nMethodCount = m_nVarCount = m_nDispInfoCount = 0; 
			return false; 
		} 
		m_pDispInfo[i+m_nVarCount].m_bstrName = ::SysAllocString(m_pDispInfo[i].m_bstrName); 
		#ifdef XYDISPDRIVER_DEBUG 
		wprintf(L"VarName = %s\n", m_pDispInfo[i].m_bstrName); 
		#endif 
		 
		switch(pVarDesc->varkind) 
		{ 
		case VAR_DISPATCH: 
			m_pDispInfo[i].m_wFlag = DISPATCH_PROPERTYGET; 
			m_pDispInfo[i+m_nVarCount].m_wFlag = DISPATCH_PROPERTYPUT; 
			#ifdef XYDISPDRIVER_DEBUG 
			_tprintf(_T("VarKind = VAR_DISPATCH\n")); 
			#endif 
			m_pDispInfo[i].m_vtOutputType = pVarDesc->elemdescVar.tdesc.vt; 
			m_pDispInfo[i+m_nVarCount].m_vtOutputType = VT_EMPTY; 
			#ifdef XYDISPDRIVER_DEBUG 
			_tprintf(_T("VarType = %d\n"), m_pDispInfo[i].m_vtOutputType); 
			#endif 
			m_pDispInfo[i+m_nVarCount].m_nParamCount = 1; 
			m_pDispInfo[i+m_nVarCount].m_pParamTypes = new WORD[2]; 
			m_pDispInfo[i+m_nVarCount].m_pParamTypes[0] = m_pDispInfo[i].m_vtOutputType; 
			m_pDispInfo[i+m_nVarCount].m_pParamTypes[1] = 0; 
			break; 
		default: 
			#ifdef XYDISPDRIVER_DEBUG 
			_tprintf(_T("VarKind = %d\n"),pVarDesc->varkind); 
			#endif 
			m_pDispInfo[i].m_wFlag = 0; 
			m_pDispInfo[i+m_nVarCount].m_wFlag = 0; 
			break; 
		} 
		m_pDispInfo[i].m_pOutput = new VARIANT; 
		::VariantInit(m_pDispInfo[i].m_pOutput); 
		m_pDispInfo[i+m_nVarCount].m_pOutput = new VARIANT; 
		::VariantInit(m_pDispInfo[i+m_nVarCount].m_pOutput);			 
		pTypeInfo->ReleaseVarDesc(pVarDesc); 
	} 
 
	pTypeInfo->ReleaseTypeAttr(pTypeAttr);	 
	pTypeInfo->Release(); 
	return true; 
} 
 
bool XYDispDriver::Attach(IDispatch* pDisp) 
{ 
	Clear(); 
	if(pDisp==NULL) 
	{ 
		#ifdef XYDISPDRIVER_DEBUG 
		_tprintf(_T("Invalid dipatch pointer"),m_hRet); 
		#endif 
		return false; 
	} 
	m_pDisp = pDisp; 
	m_pDisp->AddRef(); 
	return LoadTypeInfo(); 
} 
 
int XYDispDriver::FindProperty(LPCTSTR strPropertyName) 
{ 
	return FindDispInfo(strPropertyName,DISPATCH_PROPERTYGET); 
} 
	 
int XYDispDriver::FindMethod(LPCTSTR strMethodName) 
{ 
	return FindDispInfo(strMethodName); 
} 
 
WORD XYDispDriver::GetPropertyType(LPCTSTR strPropertyName) 
{ 
	int nPropertyIndex = FindProperty(strPropertyName); 
	return GetPropertyType(nPropertyIndex); 
} 
	 
WORD XYDispDriver::GetPropertyType(int nPropertyIndex) 
{ 
	if(nPropertyIndex>=0) return m_pDispInfo[nPropertyIndex].m_vtOutputType; 
	else return VT_EMPTY; 
} 
	 
VARIANT* XYDispDriver::GetProperty(LPCTSTR strPropertyName) 
{ 
	int nPropertyIndex = FindProperty(strPropertyName); 
	if(nPropertyIndex>=0) 
	{ 
		return GetProperty(nPropertyIndex); 
	} 
	return NULL; 
} 
	 
VARIANT* XYDispDriver::GetProperty(int nPropertyIndex) 
{ 
	if(m_pDispInfo[nPropertyIndex].m_wFlag==DISPATCH_PROPERTYGET) 
	{ 
		va_list argList; 
		va_start(argList,nPropertyIndex); 
		m_hRet = InvokeMethodV(nPropertyIndex, argList); 
		va_end(argList); 
		return m_hRet==S_OK?m_pDispInfo[nPropertyIndex].m_pOutput:NULL; 
	} 
	return NULL; 
} 
	 
bool XYDispDriver::SetProperty(LPCTSTR strPropertyName, ...) 
{ 
	int nPropertyIndex = FindDispInfo(strPropertyName,DISPATCH_PROPERTYPUT); 
	if(nPropertyIndex>=0) 
	{ 
		va_list argList; 
		va_start(argList,strPropertyName); 
		m_hRet = InvokeMethodV(nPropertyIndex, argList); 
		va_end(argList); 
		return m_hRet==S_OK; 
	} 
	return false; 
} 
	 
bool XYDispDriver::SetProperty(int nPropertyIndex, ...) 
{ 
	if(m_pDispInfo[nPropertyIndex].m_wFlag==DISPATCH_PROPERTYPUT) 
	{ 
		va_list argList; 
		va_start(argList,nPropertyIndex); 
		m_hRet = InvokeMethodV(nPropertyIndex, argList); 
		va_end(argList); 
		return m_hRet==S_OK; 
	} 
	return false;	 
} 
	 
bool XYDispDriver::SetPropertyRef(LPCTSTR strPropertyName, ...) 
{ 
	int nPropertyIndex = FindDispInfo(strPropertyName,DISPATCH_PROPERTYPUTREF); 
	if(nPropertyIndex>=0) 
	{ 
		va_list argList; 
		va_start(argList,strPropertyName); 
		m_hRet = InvokeMethodV(nPropertyIndex, argList); 
		va_end(argList); 
		return m_hRet==S_OK; 
	} 
	return false; 
} 
	 
bool XYDispDriver::SetPropertyRef(int nPropertyIndex, ...) 
{ 
	if(m_pDispInfo[nPropertyIndex].m_wFlag==DISPATCH_PROPERTYPUTREF) 
	{ 
		va_list argList; 
		va_start(argList,nPropertyIndex); 
		m_hRet = InvokeMethodV(nPropertyIndex, argList); 
		va_end(argList); 
		return m_hRet==S_OK; 
	} 
	return false;	 
} 
	 
WORD XYDispDriver::GetReturnType(LPCTSTR strMethodName) 
{ 
	int nMethodIndex = FindMethod(strMethodName); 
	return GetReturnType(nMethodIndex); 
} 
	 
WORD XYDispDriver::GetReturnType(int nMethodIndex) 
{ 
	if(nMethodIndex>=0) return m_pDispInfo[nMethodIndex].m_vtOutputType; 
	else return VT_EMPTY; 
} 
	 
int XYDispDriver::GetParamCount(LPCTSTR strMethodName) 
{ 
	int nMethodIndex = FindMethod(strMethodName); 
	return GetParamCount(nMethodIndex); 
} 
	 
int XYDispDriver::GetParamCount(int nMethodIndex) 
{ 
	if(nMethodIndex>=0) return m_pDispInfo[nMethodIndex].m_nParamCount; 
	else return -1; 
} 
	 
WORD XYDispDriver::GetParamType(LPCTSTR strMethodName, const int nParamIndex) 
{ 
	int nMethodIndex = FindMethod(strMethodName); 
	return GetParamType(nMethodIndex, nParamIndex); 
} 
	 
WORD XYDispDriver::GetParamType(int nMethodIndex, const int nParamIndex) 
{ 
	if(nMethodIndex>=0&&nParamIndex>=0&&nParamIndex<m_pDispInfo[nMethodIndex].m_nParamCount) 
	{ 
		return m_pDispInfo[nMethodIndex].m_pParamTypes[nParamIndex]; 
	} 
	else return VT_EMPTY; 
} 
	 
VARIANT* XYDispDriver::InvokeMethod(LPCTSTR strMethodName, ...) 
{ 
	int nMethodIndex = FindMethod(strMethodName); 
	if(nMethodIndex>=0) 
	{ 
		va_list argList; 
		va_start(argList,strMethodName); 
		m_hRet = InvokeMethodV(nMethodIndex, argList); 
		va_end(argList); 
		return m_hRet==S_OK?m_pDispInfo[nMethodIndex].m_pOutput:NULL; 
	} 
	return NULL; 
} 
	 
VARIANT* XYDispDriver::InvokeMethod(int nMethodIndex, ...) 
{ 
	if(m_pDispInfo[nMethodIndex].m_wFlag==DISPATCH_METHOD) 
	{ 
		va_list argList; 
		va_start(argList,nMethodIndex); 
		m_hRet = InvokeMethodV(nMethodIndex, argList); 
		va_end(argList); 
		return m_hRet==S_OK?m_pDispInfo[nMethodIndex].m_pOutput:NULL; 
	} 
	return NULL; 
} 
 
int XYDispDriver::FindDispInfo(LPCTSTR strName, const WORD wFlag) 
{ 
	#ifdef _UNICODE 
	WCHAR* pName = (WCHAR*)strName; 
	#else 
	WCHAR pName[XYDISPDRIVER_OLENAMELEN+1]; 
	CharToWChar(pName,strName); 
	#endif 
	int nRet = -1; 
	for(int i=0;i<m_nDispInfoCount;i++) 
	{ 
		if(wcscmp(pName,m_pDispInfo[i].m_bstrName)==0&&m_pDispInfo[i].m_wFlag==wFlag) 
		{ 
			nRet = i; 
			break; 
		} 
	} 
	return nRet; 
} 
 
HRESULT XYDispDriver::InvokeMethodV(int nIndex, va_list argList) 
{ 
	m_hRet = S_OK; 
 
	if(m_pDispInfo[nIndex].m_wFlag==0) 
	{ 
		#ifdef XYDISPDRIVER_DEBUG 
		_tprintf(_T("Invalid invokation flag\n")); 
		#endif 
		m_hRet = S_FALSE; 
		return m_hRet; 
	} 
	 
	DISPPARAMS dispparams; 
	memset(&dispparams, 0, sizeof dispparams); 
	dispparams.cArgs = m_pDispInfo[nIndex].m_nParamCount; 
 
	DISPID dispidNamed = DISPID_PROPERTYPUT; 
	if(m_pDispInfo[nIndex].m_wFlag&(DISPATCH_PROPERTYPUT|DISPATCH_PROPERTYPUTREF)) 
	{ 
		dispparams.cNamedArgs = 1; 
		dispparams.rgdispidNamedArgs = &dispidNamed; 
	} 
 
	if(dispparams.cArgs!=0) 
	{ 
		// allocate memory for all VARIANT parameters 
		VARIANT* pArg = new VARIANT[dispparams.cArgs]; 
		dispparams.rgvarg = pArg; 
		memset(pArg, 0, sizeof(VARIANT) * dispparams.cArgs); 
 
		// get ready to walk vararg list 
		const WORD* pb = m_pDispInfo[nIndex].m_pParamTypes; 
		pArg += dispparams.cArgs - 1;   // params go in opposite order 
 
		while(*pb!=0) 
		{ 
			pArg->vt = *pb; // set the variant type 
			switch (pArg->vt) 
			{ 
			case VT_UI1: 
				pArg->bVal = va_arg(argList, BYTE); 
				break; 
			case VT_I2: 
				pArg->iVal = va_arg(argList, short); 
				break; 
			case VT_I4: 
				pArg->lVal = va_arg(argList, long); 
				break; 
			case VT_R4: 
				pArg->vt = VT_R4; 
				pArg->fltVal = va_arg(argList, float); 
				break; 
			case VT_R8: 
				pArg->dblVal = va_arg(argList, double); 
				break; 
			case VT_BOOL: 
				pArg->boolVal = (VARIANT_BOOL)(va_arg(argList, BOOL) ? -1 : 0); 
				break; 
			case VT_ERROR: 
				pArg->scode = va_arg(argList, SCODE); 
				break; 
			case VT_DATE: 
				pArg->date = va_arg(argList, DATE); 
				break; 
			case VT_CY: 
				pArg->cyVal = va_arg(argList, CY); 
				break; 
			case VT_BSTR: 
				{ 
				#ifdef _UNICODE 
					LPCOLESTR lpsz = va_arg(argList, LPOLESTR); 
					pArg->bstrVal = ::SysAllocString(lpsz); 
				#else 
					LPCSTR lpsz = va_arg(argList, LPSTR); 
					WCHAR* pData = new WCHAR[strlen(lpsz)+1]; 
					CharToWChar(pData,lpsz); 
					pArg->bstrVal = ::SysAllocString(pData); 
					delete []pData; 
				#endif 
				} 
				break; 
			 
			case VT_UNKNOWN: 
				pArg->punkVal = va_arg(argList, LPUNKNOWN); 
				break; 
			case VT_DISPATCH: 
				pArg->pdispVal = va_arg(argList, LPDISPATCH); 
				break; 
			case VT_ARRAY: 
				pArg->parray = va_arg(argList, SAFEARRAY*); 
				break; 
			case VT_VARIANT: 
				*pArg = va_arg(argList, VARIANT); 
				break; 
			case VT_UI1|VT_BYREF: 
				pArg->pbVal = va_arg(argList,unsigned char*); 
				break; 
			case VT_I2|VT_BYREF: 
				pArg->piVal = va_arg(argList, short*); 
				break; 
			case VT_I4|VT_BYREF: 
				pArg->plVal = va_arg(argList, long*); 
				break; 
			case VT_R4|VT_BYREF: 
				pArg->pfltVal = va_arg(argList, float*); 
				break; 
			case VT_R8|VT_BYREF: 
				pArg->pdblVal = va_arg(argList, double*); 
				break; 
			case VT_BOOL|VT_BYREF: 
				{ 
					// coerce BOOL into VARIANT_BOOL 
					BOOL* pboolVal = va_arg(argList, BOOL*); 
					*pboolVal = (*pboolVal)?MAKELONG(0,-1):0; 
					pArg->pboolVal = (VARIANT_BOOL*)pboolVal; 
				} 
				break; 
			case VT_ERROR|VT_BYREF: 
				pArg->pscode = va_arg(argList, SCODE*); 
				break; 
			case VT_DATE|VT_BYREF: 
				pArg->pdate = va_arg(argList, DATE*); 
				break; 
			case VT_CY|VT_BYREF: 
				pArg->pcyVal = va_arg(argList, CY*); 
				break; 
			case VT_BSTR|VT_BYREF: 
				pArg->pbstrVal = va_arg(argList, BSTR*); 
				break; 
			case VT_UNKNOWN|VT_BYREF: 
				pArg->ppunkVal = va_arg(argList, LPUNKNOWN*); 
				break; 
			case VT_DISPATCH|VT_BYREF: 
				pArg->ppdispVal = va_arg(argList, LPDISPATCH*); 
				break; 
			case VT_ARRAY|VT_BYREF: 
				pArg->pparray = va_arg(argList, SAFEARRAY**); 
				break; 
			case VT_VARIANT|VT_BYREF: 
				pArg->pvarVal = va_arg(argList, VARIANT*); 
				break; 
			default: 
				break; 
			} 
			--pArg; // get ready to fill next argument 
			++pb; 
		} 
	} 
 
	// initialize return value 
	VARIANT* pvarResult = m_pDispInfo[nIndex].m_pOutput; 
	::VariantClear(pvarResult); 
 
	// initialize EXCEPINFO struct 
	if(m_pExceptInfo!=NULL) 
	{ 
		::SysFreeString(m_pExceptInfo->bstrSource); 
		::SysFreeString(m_pExceptInfo->bstrDescription); 
		::SysFreeString(m_pExceptInfo->bstrHelpFile); 
		delete m_pExceptInfo; 
	} 
	m_pExceptInfo = new EXCEPINFO; 
	memset(m_pExceptInfo, 0, sizeof(*m_pExceptInfo)); 
 
	UINT nArgErr = (UINT)-1;  // initialize to invalid arg 
 
	// make the call 
	m_hRet = m_pDisp->Invoke(m_pDispInfo[nIndex].m_dispID,IID_NULL,LOCALE_SYSTEM_DEFAULT,m_pDispInfo[nIndex].m_wFlag,&dispparams,pvarResult,m_pExceptInfo,&nArgErr); 
 
	// cleanup any arguments that need cleanup 
	if (dispparams.cArgs != 0) 
	{ 
		VARIANT* pArg = dispparams.rgvarg + dispparams.cArgs - 1; 
		const WORD* pb = m_pDispInfo[nIndex].m_pParamTypes; 
		while (*pb != 0) 
		{ 
			switch (*pb) 
			{ 
			case VT_BSTR: 
				::SysFreeString(pArg->bstrVal); 
				break; 
			} 
			--pArg; 
			++pb; 
		} 
	} 
	delete[] dispparams.rgvarg; 
 
	// throw exception on failure 
	if(m_hRet<0) 
	{ 
		::VariantClear(m_pDispInfo[nIndex].m_pOutput); 
		if(m_hRet!=DISP_E_EXCEPTION) 
		{ 
			#ifdef XYDISPDRIVER_DEBUG 
			_tprintf(_T("Invoke failed, no exception: %x\n"),m_hRet); 
			#endif 
			delete m_pExceptInfo; 
			m_pExceptInfo = NULL; 
			return m_hRet; 
		} 
 
		// make sure excepInfo is filled in 
		if(m_pExceptInfo->pfnDeferredFillIn != NULL) 
			m_pExceptInfo->pfnDeferredFillIn(m_pExceptInfo); 
 
		#ifdef XYDISPDRIVER_DEBUG 
		wprintf(L"Exception source: %s\n",m_pExceptInfo->bstrSource); 
		wprintf(L"Exception description: %s\n",m_pExceptInfo->bstrDescription); 
		wprintf(L"Exception help file: %s\n",m_pExceptInfo->bstrHelpFile); 
		#endif 
		return m_hRet; 
	} 
 
	if(m_pDispInfo[nIndex].m_vtOutputType!=VT_EMPTY) 
	{ 
		m_pDispInfo[nIndex].m_pOutput->vt = m_pDispInfo[nIndex].m_vtOutputType; 
	} 
 
	delete m_pExceptInfo; 
	m_pExceptInfo = NULL; 
	return m_hRet; 
} 
	 
bool XYDispDriver::Advise(IUnknown __RPC_FAR *pUnkSink, REFIID riid) 
{ 
	if(m_pDisp==NULL) 
	{ 
		#ifdef XYDISPDRIVER_DEBUG 
		_tprintf(_T("Null dipatch pointer\n")); 
		#endif 
		m_hRet = S_FALSE; 
		return false; 
	} 
	Unadvise(); 
	IConnectionPointContainer* pCPContainer = NULL; 
	m_hRet = m_pDisp->QueryInterface(IID_IConnectionPointContainer,(void**)&pCPContainer); 
	if(m_hRet!=S_OK) 
	{ 
		#ifdef XYDISPDRIVER_DEBUG 
		_tprintf(_T("Failed to call QueryInterface to get the IConnectionPointContainer interface: %x\n"),m_hRet); 
		#endif 
		return false; 
	} 
	m_hRet = pCPContainer->FindConnectionPoint(riid,&m_pCP); 
	pCPContainer->Release(); 
	if(m_hRet!=S_OK) 
	{ 
		#ifdef XYDISPDRIVER_DEBUG 
		_tprintf(_T("Failed to call FindConnectionPoint to get the IConnectionPoint interface: %x\n"),m_hRet); 
		#endif 
		return false; 
	} 
	m_hRet = m_pCP->Advise(pUnkSink,&m_dwCookie); 
	if(m_hRet!=S_OK) 
	{ 
		#ifdef XYDISPDRIVER_DEBUG 
		_tprintf(_T("Failed to call Advise: %x\n"),m_hRet); 
		#endif 
		m_pCP->Release(); 
		m_pCP = NULL; 
		return false; 
	} 
	return true; 
} 
 
void XYDispDriver::Unadvise() 
{ 
	if(m_pCP!=NULL) 
	{ 
		m_hRet = m_pCP->Unadvise(m_dwCookie); 
		if(m_hRet!=S_OK) 
		{ 
			#ifdef XYDISPDRIVER_DEBUG 
			_tprintf(_T("Failed to call Unadvise: %x\n"),m_hRet); 
			#endif 
		} 
		m_pCP->Release(); 
		m_pCP = NULL; 
		m_dwCookie = 0; 
	} 
} 
 
HRESULT XYDispDriver::InvokeVariantMethod(IDispatch* pDisp, LPCTSTR strMethodName, WORD wInvokeFlag, VARIANT* pVarRet, EXCEPINFO* pExcepInfo, const nParamCount, ...) 
{ 
	if(pDisp==NULL||strMethodName==NULL||nParamCount<0) 
	{ 
		#ifdef XYDISPDRIVER_DEBUG 
		_tprintf(_T("Invalid parameters to InvokeVariantMethod")); 
		#endif 
		return S_FALSE; 
	} 
	#ifdef _UNICODE 
	WCHAR* pName = (WCHAR*)strMethodName; 
	#else 
	WCHAR* pName = new WCHAR[XYDISPDRIVER_OLENAMELEN+1]; 
	CharToWChar(pName,strMethodName); 
	#endif 
	DISPID dispid; 
	HRESULT hRet = pDisp->GetIDsOfNames(IID_NULL,&pName,1,LOCALE_SYSTEM_DEFAULT,&dispid); 
	#ifndef _UNICODE 
	delete []pName; 
	#endif 
	if(hRet!=S_OK) 
	{ 
		#ifdef XYDISPDRIVER_DEBUG 
		_tprintf(_T("GetIDsOfNames failed: %x\n"),hRet); 
		#endif 
		return hRet; 
	} 
	else 
	{ 
		va_list argList; 
		va_start(argList,nParamCount); 
		hRet = InvokeVariantMethodV(pDisp, dispid, wInvokeFlag, pVarRet, pExcepInfo, nParamCount, argList); 
		va_end(argList); 
	} 
	return hRet; 
} 
 
 
 
HRESULT XYDispDriver::InvokeVariantMethod(IDispatch* pDisp, const DISPID dispidMethod, WORD wInvokeFlag, VARIANT* pVarRet, EXCEPINFO* pExcepInfo, const nParamCount, ...) 
{ 
	if(pDisp==NULL||nParamCount<0) 
	{ 
		#ifdef XYDISPDRIVER_DEBUG 
		_tprintf(_T("Invalid parameters to InvokeVariantMethod")); 
		#endif 
		return S_FALSE; 
	} 
	va_list argList; 
	va_start(argList,nParamCount); 
	HRESULT hRet = InvokeVariantMethodV(pDisp, dispidMethod, wInvokeFlag, pVarRet, pExcepInfo, nParamCount, argList); 
	va_end(argList); 
	return hRet; 
} 
 
HRESULT XYDispDriver::InvokeVariantMethodV(IDispatch* pDisp, const DISPID dispidMethod, WORD wInvokeFlag, VARIANT* pVarRet, EXCEPINFO* pExcepInfo, const nParamCount, va_list argList) 
{ 
	DISPPARAMS dispparams; 
	memset(&dispparams, 0, sizeof dispparams); 
	dispparams.cArgs = nParamCount; 
	if(nParamCount>0) 
	{ 
		dispparams.rgvarg = new VARIANT[nParamCount]; 
		memset(dispparams.rgvarg, 0, sizeof(VARIANT)*nParamCount);	 
		VARIANT* pArg; 
		for(int i=nParamCount-1;i>=0;i--) 
		{ 
			pArg = dispparams.rgvarg+i; 
			*pArg = va_arg(argList, VARIANT); 
		} 
	} 
	else dispparams.rgvarg = NULL; 
	if(pVarRet) ::VariantInit(pVarRet); 
	UINT nArgErr = (UINT)-1; 
	HRESULT hRet = pDisp->Invoke(dispidMethod,IID_NULL,LOCALE_SYSTEM_DEFAULT,wInvokeFlag,&dispparams,pVarRet,pExcepInfo,&nArgErr); 
	if(nParamCount>0) delete[] dispparams.rgvarg; 
	if(hRet!=S_OK) 
	{ 
		#ifdef XYDISPDRIVER_DEBUG 
		_tprintf(_T("Invoke failed: %x\n"),hRet); 
		#endif 
		if(pVarRet) ::VariantClear(pVarRet); 
		if(hRet==DISP_E_EXCEPTION) 
		{ 
			#ifdef XYDISPDRIVER_DEBUG 
			_tprintf(_T("Exception occurred\n")); 
			#endif 
			if(pExcepInfo) 
			{ 
				if(pExcepInfo->pfnDeferredFillIn != NULL) 
					pExcepInfo->pfnDeferredFillIn(pExcepInfo); 
 
				#ifdef XYDISPDRIVER_DEBUG 
				wprintf(L"Exception source: %s\n",pExcepInfo->bstrSource); 
				wprintf(L"Exception description: %s\n",pExcepInfo->bstrDescription); 
				wprintf(L"Exception help file: %s\n",pExcepInfo->bstrHelpFile); 
				#endif 
			} 
		} 
	} 
	return hRet; 
}


使用example

//初始化COM库

HRESULT hr = CoInitialize(NULL);

//创建接口实例指针

XYDispDriver disp;

bool res = disp.CreateObject("XXXXX.YYYYYY");    //progid

....

//调用 方法

disp.InvokeMethod("somefunction", 1 , &out, in1, in2);





fonjames
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
COM组件开发（四）——VC++调用COM组件的方法
Fish的专栏
02-16 1万+
ActiveX 控件          对于ActiveX控件，可以在Visual Studio中使用ClassWizard的方法引入，在MFC项目中选择菜单“项目”——> “添加类”——>“ActiveX控件中的MFC类”，然后可以分别从注册表和文件两种方式中选择自己想要的组件。选择注册表中的方式获取的都是在本系统中注册了的组件，而文件则是从磁盘目录下获取COM组件。 代
java的前期绑定和后期绑定使用示例
09-04
java的前期绑定在程序执行前根据编译时类型绑定，调用开销较小，如C语言只有前期绑定这种方法调用
vc++ 中SetProperty（）的使用解答
11-27
vc++ 中SetProperty（）的使用解答,这个问题好像没几个人去关心,但是又有很多人想用,又不知道该怎么用,这里给出解答.
COM三大接口:IUnknown、IClassFactory、IDispatch
chenyujing1234的专栏
07-17 1万+
转载自：http://blog.sina.com.cn/s/blog_86d10dc701014m2v.html (1)COM组件有三个最基本的接口类，分别是IUnknown、IClassFactory、IDispatch。 （1、1）  COM规范规定任何组件、任何接口都必须从IUnknown继承，IUnknown包含三个函数，分别是 QueryInterface、AddRef
细谈com编程----vc++篇，我的笔记
weixin_34221073的博客
12-26 255
2019独角兽企业重金招聘Python工程师标准>>> ...
VC++文件操作之最全篇(总结一下希望对大家有用)
独旅天涯
04-25 3650
一、剖析VC中的文件操作       各种关于文件的操作在程序设计中是十分常见，如果能对其各种操作都了如指掌，就可以根据实际情况找到最佳的解决方案，从而在较短的时间内编写出高效的代码，因而熟练的掌握文件操作是十分重要的。本文将对Visual C++中有关文件操作进行全面的介绍，并对在文件操作中经常遇到的一些疑难问题进行详细的分析。 　　1．文件的查找 　　当对一个文件操作时，如果
.NET与COM互操作(1)-绑定与com对象创建
weixin_33762130的博客
08-26 143
早期绑定 即定义了强类型 分两种方式 1.使用工具自动生成    1.1添加引用，则自动声明命名空间    1.2运行TlbImp命令来声明，可修改命名空间 2.手动编写,可以使用   可调用部分com接口，无需全部声明,但非常麻烦 以下为示例 1.自动声明的代码 可用实例或接口static void CreateInstanceByWrapper() { int num0 = 6...
vc++导入com组件
Sailor of World
09-17 2614
1.生成dll 2.工程属性->C/C++->常规->附加库目录：添加dll所在路径 3.#import "组件所在目录myCom.dll" no_namespace
PHP后期静态绑定实例浅析
10-17
主要介绍了PHP后期静态绑定,结合实例形式分析了php后期静态绑定相关概念、原理、使用方法与相关注意事项,需要的朋友可以参考下
cocos creator 音乐组件 直接绑定使用
08-10
可以直接把该组件，绑定到节点上使用。 支持绑定音乐 音效， 播放自定义 音乐 音效
COM组件设计与应用之VC6的IDispatch接口.doc
07-23
COM组件设计与应用之VC6的IDispatch接口.doc
c++如何采用com组件的方法直接调用动态库
06-08
com组件方法调用dll
详解基于Vue的支持数据双向绑定的select组件
10-16
主要介绍了详解基于Vue的支持数据双向绑定的select组件，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
详解Vue 动态组件与全局事件绑定总结
10-17
主要介绍了详解Vue 动态组件与全局事件绑定总结，从示例中发现并解决问题，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
[Matlab] matlab与C/C++混合编程汇总
热门推荐
fonjames的专栏
06-01 1万+
matlab 与外部程序的编程接口两大类：                一是 如何在matlab里调用其他语言写的代码。 （见例子：使用C-MEX技术，ActiveX技术）                二是 如何在其他语言里调用matlab。 （见 使用matlab引擎, MAT数据交换, matlab发布com组件, DeployTool）
SAXParseException: The encoding "GBK" is not supported --- 解决办法与分析
fonjames的专栏
07-08 1万+
The encoding "GBK" is not supported --- 解决办法与分析     1.读取XML文件,获得document对象                                SAXReader reader = new SAXReader();
C# 格式化输出
fonjames的专栏
10-17 8819
格式化表示的一般格式 { N [ , M ] [ :格式码 ] } N:  指定参数序列中的输出序号，比如{0} , {1}, {2}等。 M: 指定参数输出的最小长度。 如果参数长度小于M，则空格填充；若大于等于M，则按实际长度输出；      如果M为负，则左对齐，如果M为正，则右对齐；若未指定M，默认为0，如{1,5}表示将参数的值转换为字符串后按照5位右对齐输出。 格式码： 可选
[Matlab] MxArray 与 MwArray 使用区别
fonjames的专栏
06-10 7090
引子 在外部编程语言与matlab的交互中，Array是最单元的交互元素，怎么都绕不过去。 在matlab提供的Array接口有两个，一个是C的MxArray, 另一个是Cpp（C++)的MwArray. 看下两着的分别介绍： mxArray：Matlab C 函数库的结构体 mwArray：Matlab C++ 函数库中对mxArray的包装类 声明：
excel 跨表格数据汇总
fonjames的专栏
01-20 6683
背景： 几十个sheet的页面数据要汇总到一个sheet，每个sheet的结构相同。 比如：a1，c3，d6存储具体数据，每个sheet都是交易日命名，比如20151113之类。 方法： 跨sheet取数据直接用sheetX！Yn   '20151113'!A1 即可获取数据，然后汇总。 难点在于sheet的名字没有办法按照序列填充。 解决方法： 1. 生成交易日时间
vue3使用分页组件时怎么绑定动态值
最新发布
06-07
在Vue3中使用分页组件时，可以通过v-model指令来绑定动态值。具体实现步骤如下： 1. 在组件中定义一个currentPage属性，用来表示当前页码。 2. 在模板中使用分页组件，通过v-model指令将currentPage属性与分页组件...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值