//
// Class for creating OLE automation controllers.
//
// CreateObject() creates an automation object
// Invoke() will call a property or method of the automation object.
// GetProperty() returns a property
// SetProperty() changes a property
// Method() invokes a method
//
// For example, the following VB code will control Microsoft Word:
//
//    Private Sub Form_Load()
//    Dim wb As Object
//    Set wb = CreateObject("Word.Basic")
//    wb.AppShow
//    wb.FileNewDefault
//    wb.Insert "This is a test"
//    wb.FileSaveAs "c:\sample.doc)"
//    End Sub
//
// A C++ automation controller that does the same can be written as follows:
// the helper functions:
//
//   Void FormLoad ()
//   {
//       COleAutomationControl Aut;
//       Aut.CreateObject("Word.Basic");
//       Aut.Method ("AppShow");
//       Aut.Method ("FileNewDefault");
//       Aut.Method ("Insert", "s", (LPOLESTR) OLESTR ("This is a test"));
//       Aut.Method ("FileSaveAs", "s", OLESTR ("c:\\sample.doc"));
//   }
//
//

#include "stdafx.h"
#include <stdarg.h>
#include "oleaut.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif


static bool CountArgsInFormat (LPCTSTR Format, UINT* nArgs);
static LPCTSTR GetNextVarType (LPCTSTR Format, VARTYPE* pVarType);


COleAutomationControl::COleAutomationControl ()
{
	m_pDispatch = NULL;
	m_hResult = NOERROR;
	m_nErrArg = 0;
	VariantInit (&m_VariantResult);
}

COleAutomationControl::~COleAutomationControl ()
{
	DeleteObject ();
}

void COleAutomationControl::DeleteObject ()
{
	if (m_pDispatch)
	{
		m_pDispatch->Release ();
		m_pDispatch = NULL;
	}
}

// Creates an instance of the Automation object and
// obtains it's IDispatch interface.
//
// Parameters:
// ProgId	  ProgID of Automation object
//
bool COleAutomationControl::CreateObject (char* ProgId)
{
	CLSID ClsId;			// CLSID of automation object
	LPUNKNOWN pUnknown = NULL;	// IUnknown of automation object

	// Retrieve CLSID from the progID that the user specified
	LPOLESTR OleProgId = TO_OLE_STR (ProgId);
	m_hResult = CLSIDFromProgID (OleProgId, &ClsId);
	if (FAILED (m_hResult))
		goto error;

	// Create an instance of the automation object and ask for the
	// IDispatch interface
	m_hResult = CoCreateInstance (ClsId, NULL, CLSCTX_SERVER,
			       IID_IUnknown, (void**) &pUnknown);
	if (FAILED (m_hResult))
		goto error;

	m_hResult = pUnknown->QueryInterface (IID_IDispatch, (void**) &m_pDispatch);
	if (FAILED (m_hResult))
		goto error;

	pUnknown->Release ();
	return true;

error:
	if (pUnknown)
		pUnknown->Release ();
	if (m_pDispatch)
		m_pDispatch->Release ();
	return false;
}

// Return the dispatch id of a named service
// This id can be used in subsequent calls to GetProperty (), SetProperty () and
// Method (). This is the preferred method when performance is important.
//
DISPID COleAutomationControl::GetDispatchId (char* Name)
{
	DISPID DispatchId;

	ASSERT (m_pDispatch);

	// Get DISPID of property/method
	LPOLESTR OleName = TO_OLE_STR (Name);
	m_hResult = m_pDispatch->GetIDsOfNames (IID_NULL, &OleName, 1,
						LOCALE_USER_DEFAULT, &DispatchId);
	if (FAILED (m_hResult))
		return NULL;
	return DispatchId;
}

//  The following functions use these parameters:
//
// Parameters:
//
//  Name      Name of property or method.
//
//  Format    Format string that describes the variable list of parameters that
//	      follows. The format string can contain the following characters.
//	      & = mark the following format character as VT_BYREF
//	      B = VT_BOOL
//	      i = VT_I2
//	      I = VT_I4
//	      r = VT_R2
//	      R = VT_R4
//	      c = VT_CY
//	      s = VT_BSTR (string pointer can be passed,
//			BSTR will be allocated by this function).
//	      e = VT_ERROR
//	      d = VT_DATE
//	      v = VT_VARIANT. Use this to pass data types that are not described
//			in the format string. (For example SafeArrays).
//	      D = VT_DISPATCH
//	      U = VT_UNKNOWN
//
//  ...       Arguments of the property or method.
//	      Arguments are described by Format.
//

bool COleAutomationControl::GetProperty (char* Name)
{
	return Invoke (DISPATCH_PROPERTYGET, Name, NULL, NULL);
}

bool COleAutomationControl::GetProperty (DISPID DispatchId)
{
	return Invoke (DISPATCH_PROPERTYGET, DispatchId, NULL, NULL);
}

bool COleAutomationControl::PutProperty (char* Name, LPCTSTR Format, ...)
{
	va_list ArgList;

	va_start (ArgList, Format);
	bool bRet = Invoke (DISPATCH_PROPERTYPUT, Name, Format, ArgList);
	va_end (ArgList);
	return bRet;
}

bool COleAutomationControl::PutProperty (DISPID DispatchId, LPCTSTR Format, ...)
{
	va_list ArgList;

	va_start (ArgList, Format);
	bool bRet = Invoke (DISPATCH_PROPERTYPUT, DispatchId, Format, ArgList);
	va_end (ArgList);
	return bRet;
}

bool COleAutomationControl::Method (char* Name, LPCTSTR Format, ...)
{
	va_list ArgList;

	va_start (ArgList, Format);
	bool bRet = Invoke (DISPATCH_METHOD, Name, Format, ArgList);
	va_end (ArgList);
	return bRet;
}

bool COleAutomationControl::Method (DISPID DispatchId, LPCTSTR Format, ...)
{
	va_list ArgList;

	va_start (ArgList, Format);
	bool bRet = Invoke (DISPATCH_METHOD, DispatchId, Format, ArgList);
	va_end (ArgList);
	return bRet;
}

bool COleAutomationControl::Invoke (WORD Flags, char* Name,
				    LPCTSTR Format, va_list ArgList)
{
	DISPID DispatchId = GetDispatchId (Name);
	if (! DispatchId)
		return false;
	return Invoke (Flags, DispatchId, Format, ArgList);
}

bool COleAutomationControl::Invoke (WORD Flags, DISPID DispatchId,
				    LPCTSTR Format, va_list ArgList)
{
	UINT ArgCount = 0;
	VARIANTARG* ArgVector = NULL;

	ASSERT (m_pDispatch);

	DISPPARAMS DispatchParams;
	memset (&DispatchParams, 0, sizeof (DispatchParams));

	// Determine number of arguments
	if (Format)
		CountArgsInFormat (Format, &ArgCount);

	// Property puts have a named argument that represents the value that
	// the property is being assigned.
	DISPID DispIdNamed = DISPID_PROPERTYPUT;
	if (Flags & DISPATCH_PROPERTYPUT)
	{
		if (ArgCount == 0)
		{
			m_hResult = ResultFromScode (E_INVALIDARG);
			return false;
		}
		DispatchParams.cNamedArgs = 1;
		DispatchParams.rgdispidNamedArgs = &DispIdNamed;
	}

	if (ArgCount)
	{
		// Allocate memory for all VARIANTARG parameters
		ArgVector = (VARIANTARG*) CoTaskMemAlloc (
				ArgCount * sizeof (VARIANTARG));
		if (! ArgVector)
		{
			m_hResult = ResultFromScode (E_OUTOFMEMORY);
			return false;
		}
		memset (ArgVector, 0, sizeof (VARIANTARG) * ArgCount);

		// Get ready to walk vararg list
		LPCTSTR s = Format;

		VARIANTARG *p = ArgVector + ArgCount - 1;  // Params go in opposite order

		for (;;)
		{
			VariantInit (p);
			if (! (s = GetNextVarType (s, &p->vt)))
				break;

			if (p < ArgVector)
			{
				m_hResult = ResultFromScode (E_INVALIDARG);
				goto Cleanup;
			}
			switch (p->vt)
			{
			    case VT_I2:
				V_I2 (p) = va_arg (ArgList, short);
				break;
			    case VT_I4:
				V_I4 (p) = va_arg (ArgList, long);
				break;
			    case VT_R4:
				V_R4 (p) = va_arg (ArgList, float);
				break;
			    case VT_DATE:
			    case VT_R8:
				V_R8 (p) = va_arg (ArgList, double);
				break;
			    case VT_CY:
				V_CY (p) = va_arg (ArgList, CY);
				break;
			    case VT_BSTR:
				V_BSTR (p) = SysAllocString (va_arg (ArgList,
								     OLECHAR*));
				if (! p->bstrVal)
				{
					m_hResult = ResultFromScode (E_OUTOFMEMORY);
					p->vt = VT_EMPTY;
					goto Cleanup;
				}
				break;
			    case VT_DISPATCH:
				V_DISPATCH (p) = va_arg (ArgList, LPDISPATCH);
				break;
			    case VT_ERROR:
				V_ERROR (p) = va_arg (ArgList, SCODE);
				break;
			    case VT_BOOL:
				V_BOOL (p) = va_arg (ArgList, BOOL) ? -1 : 0;
				break;
			    case VT_VARIANT:
				*p = va_arg (ArgList, VARIANTARG);
				break;
			    case VT_UNKNOWN:
				V_UNKNOWN (p) = va_arg (ArgList, LPUNKNOWN);
				break;

			    case VT_I2 | VT_BYREF:
				V_I2REF (p) = va_arg (ArgList, short*);
				break;
			    case VT_I4 | VT_BYREF:
				V_I4REF (p) = va_arg (ArgList, long*);
				break;
			    case VT_R4 | VT_BYREF:
				V_R4REF (p) = va_arg (ArgList, float*);
				break;
			    case VT_R8 | VT_BYREF:
				V_R8REF (p) = va_arg (ArgList, double*);
				break;
			    case VT_DATE | VT_BYREF:
				V_DATEREF (p) = va_arg (ArgList, DATE*);
				break;
			    case VT_CY | VT_BYREF:
				V_CYREF (p) = va_arg (ArgList, CY*);
				break;
			    case VT_BSTR | VT_BYREF:
				V_BSTRREF (p) = va_arg (ArgList, BSTR*);
				break;
			    case VT_DISPATCH | VT_BYREF:
				V_DISPATCHREF (p) = va_arg (ArgList, LPDISPATCH*);
				break;
			    case VT_ERROR | VT_BYREF:
				V_ERRORREF (p) = va_arg (ArgList, SCODE*);
				break;
			    case VT_BOOL | VT_BYREF:
				{
					BOOL* pBool = va_arg (ArgList, BOOL*);

					*pBool = 0;
					V_BOOLREF (p) = (VARIANT_BOOL*) pBool;
				}
				break;
			    case VT_VARIANT | VT_BYREF:
				V_VARIANTREF (p) = va_arg (ArgList, VARIANTARG*);
				break;
			    case VT_UNKNOWN | VT_BYREF:
				V_UNKNOWNREF (p) = va_arg (ArgList, LPUNKNOWN*);
				break;

			    default:
				{
					m_hResult = ResultFromScode (E_INVALIDARG);
					goto Cleanup;
				}
				break;
			}

			--p;	// Get ready to fill next argument
		}
	}

	DispatchParams.cArgs = ArgCount;
	DispatchParams.rgvarg = ArgVector;

	// Initialize return variant, in case caller forgot. Caller can pass
	// NULL if return value is not expected.
	VariantInit (&m_VariantResult);

	// Make the call
	m_hResult = m_pDispatch->Invoke (DispatchId, IID_NULL, LOCALE_USER_DEFAULT,
					 Flags, &DispatchParams, &m_VariantResult,
					 &m_ExceptionInfo, &m_nErrArg);

    Cleanup:
	// Cleanup any arguments that need cleanup
	if (ArgCount)
	{
		VARIANTARG* p = ArgVector;

		while (ArgCount--)
		{
			switch (p->vt)
			{
			    case VT_BSTR:
				VariantClear (p);
				break;
			}
			++p;
		}
		CoTaskMemFree (ArgVector);
	}

	return FAILED (m_hResult) ? false : true;
}

#define CASE_SCODE(sc)  \
	case sc: \
	lstrcpy((char*)ErrName, (char*)#sc); \
	break;

void COleAutomationControl::ErrDiag ()
{
	char ErrName[200];

	SCODE sc = GetScode (m_hResult);
	switch (sc)
	{
	    // SCODE's defined in SCODE.H
	    CASE_SCODE (S_OK)
	    CASE_SCODE (S_FALSE)
	    CASE_SCODE (E_UNEXPECTED)
	    CASE_SCODE (E_OUTOFMEMORY)
	    CASE_SCODE (E_INVALIDARG)
	    CASE_SCODE (E_NOINTERFACE)
	    CASE_SCODE (E_POINTER)
	    CASE_SCODE (E_HANDLE)
	    CASE_SCODE (E_ABORT)
	    CASE_SCODE (E_FAIL)
	    CASE_SCODE (E_ACCESSDENIED)

	    // SCODE's defined in OLE2.H
	    CASE_SCODE (OLE_E_OLEVERB)
	    CASE_SCODE (OLE_E_ADVF)
	    CASE_SCODE (OLE_E_ENUM_NOMORE)
	    CASE_SCODE (OLE_E_ADVISENOTSUPPORTED)
	    CASE_SCODE (OLE_E_NOCONNECTION)
	    CASE_SCODE (OLE_E_NOTRUNNING)
	    CASE_SCODE (OLE_E_NOCACHE)
	    CASE_SCODE (OLE_E_BLANK)
	    CASE_SCODE (OLE_E_CLASSDIFF)
	    CASE_SCODE (OLE_E_CANT_GETMONIKER)
	    CASE_SCODE (OLE_E_CANT_BINDTOSOURCE)
	    CASE_SCODE (OLE_E_STATIC)
	    CASE_SCODE (OLE_E_PROMPTSAVECANCELLED)
	    CASE_SCODE (OLE_E_INVALIDRECT)
	    CASE_SCODE (OLE_E_WRONGCOMPOBJ)
	    CASE_SCODE (OLE_E_INVALIDHWND)
	    CASE_SCODE (OLE_E_NOT_INPLACEACTIVE)
	    CASE_SCODE (OLE_E_CANTCONVERT)
	    CASE_SCODE (OLE_E_NOSTORAGE)

	    CASE_SCODE (DV_E_FORMATETC)
	    CASE_SCODE (DV_E_DVTARGETDEVICE)
	    CASE_SCODE (DV_E_STGMEDIUM)
	    CASE_SCODE (DV_E_STATDATA)
	    CASE_SCODE (DV_E_LINDEX)
	    CASE_SCODE (DV_E_TYMED)
	    CASE_SCODE (DV_E_CLIPFORMAT)
	    CASE_SCODE (DV_E_DVASPECT)
	    CASE_SCODE (DV_E_DVTARGETDEVICE_SIZE)
	    CASE_SCODE (DV_E_NOIVIEWOBJECT)

	    CASE_SCODE (OLE_S_USEREG)
	    CASE_SCODE (OLE_S_STATIC)
	    CASE_SCODE (OLE_S_MAC_CLIPFORMAT)

	    CASE_SCODE (CONVERT10_E_OLESTREAM_GET)
	    CASE_SCODE (CONVERT10_E_OLESTREAM_PUT)
	    CASE_SCODE (CONVERT10_E_OLESTREAM_FMT)
	    CASE_SCODE (CONVERT10_E_OLESTREAM_BITMAP_TO_DIB)
	    CASE_SCODE (CONVERT10_E_STG_FMT)
	    CASE_SCODE (CONVERT10_E_STG_NO_STD_STREAM)
	    CASE_SCODE (CONVERT10_E_STG_DIB_TO_BITMAP)
	    CASE_SCODE (CONVERT10_S_NO_PRESENTATION)

	    CASE_SCODE (CLIPBRD_E_CANT_OPEN)
	    CASE_SCODE (CLIPBRD_E_CANT_EMPTY)
	    CASE_SCODE (CLIPBRD_E_CANT_SET)
	    CASE_SCODE (CLIPBRD_E_BAD_DATA)
	    CASE_SCODE (CLIPBRD_E_CANT_CLOSE)

	    CASE_SCODE (DRAGDROP_E_NOTREGISTERED)
	    CASE_SCODE (DRAGDROP_E_ALREADYREGISTERED)
	    CASE_SCODE (DRAGDROP_E_INVALIDHWND)
	    CASE_SCODE (DRAGDROP_S_DROP)
	    CASE_SCODE (DRAGDROP_S_CANCEL)
	    CASE_SCODE (DRAGDROP_S_USEDEFAULTCURSORS)

	    CASE_SCODE (OLEOBJ_E_NOVERBS)
	    CASE_SCODE (OLEOBJ_E_INVALIDVERB)
	    CASE_SCODE (OLEOBJ_S_INVALIDVERB)
	    CASE_SCODE (OLEOBJ_S_CANNOT_DOVERB_NOW)
	    CASE_SCODE (OLEOBJ_S_INVALIDHWND)
	    CASE_SCODE (INPLACE_E_NOTUNDOABLE)
	    CASE_SCODE (INPLACE_E_NOTOOLSPACE)
	    CASE_SCODE (INPLACE_S_TRUNCATED)

	    // SCODE's defined in COMPOBJ.H
	    CASE_SCODE (CO_E_NOTINITIALIZED)
	    CASE_SCODE (CO_E_ALREADYINITIALIZED)
	    CASE_SCODE (CO_E_CANTDETERMINECLASS)
	    CASE_SCODE (CO_E_CLASSSTRING)
	    CASE_SCODE (CO_E_IIDSTRING)
	    CASE_SCODE (CO_E_APPNOTFOUND)
	    CASE_SCODE (CO_E_APPSINGLEUSE)
	    CASE_SCODE (CO_E_ERRORINAPP)
	    CASE_SCODE (CO_E_DLLNOTFOUND)
	    CASE_SCODE (CO_E_ERRORINDLL)
	    CASE_SCODE (CO_E_WRONGOSFORAPP)
	    CASE_SCODE (CO_E_OBJNOTREG)
	    CASE_SCODE (CO_E_OBJISREG)
	    CASE_SCODE (CO_E_OBJNOTCONNECTED)
	    CASE_SCODE (CO_E_APPDIDNTREG)
	    CASE_SCODE (CLASS_E_NOAGGREGATION)
	    CASE_SCODE (CLASS_E_CLASSNOTAVAILABLE)
	    CASE_SCODE (REGDB_E_READREGDB)
	    CASE_SCODE (REGDB_E_WRITEREGDB)
	    CASE_SCODE (REGDB_E_KEYMISSING)
	    CASE_SCODE (REGDB_E_INVALIDVALUE)
	    CASE_SCODE (REGDB_E_CLASSNOTREG)
	    CASE_SCODE (REGDB_E_IIDNOTREG)
	    CASE_SCODE (RPC_E_CALL_REJECTED)
	    CASE_SCODE (RPC_E_CALL_CANCELED)
	    CASE_SCODE (RPC_E_CANTPOST_INSENDCALL)
	    CASE_SCODE (RPC_E_CANTCALLOUT_INASYNCCALL)
	    CASE_SCODE (RPC_E_CANTCALLOUT_INEXTERNALCALL)
	    CASE_SCODE (RPC_E_CONNECTION_TERMINATED)
	    CASE_SCODE (RPC_E_SERVER_DIED)
	    CASE_SCODE (RPC_E_CLIENT_DIED)
	    CASE_SCODE (RPC_E_INVALID_DATAPACKET)
	    CASE_SCODE (RPC_E_CANTTRANSMIT_CALL)
	    CASE_SCODE (RPC_E_CLIENT_CANTMARSHAL_DATA)
	    CASE_SCODE (RPC_E_CLIENT_CANTUNMARSHAL_DATA)
	    CASE_SCODE (RPC_E_SERVER_CANTMARSHAL_DATA)
	    CASE_SCODE (RPC_E_SERVER_CANTUNMARSHAL_DATA)
	    CASE_SCODE (RPC_E_INVALID_DATA)
	    CASE_SCODE (RPC_E_INVALID_PARAMETER)
	    CASE_SCODE (RPC_E_CANTCALLOUT_AGAIN)
	    CASE_SCODE (RPC_E_UNEXPECTED)

	    // SCODE's defined in DVOBJ.H
	    CASE_SCODE (DATA_S_SAMEFORMATETC)
	    CASE_SCODE (VIEW_E_DRAW)
	    CASE_SCODE (VIEW_S_ALREADY_FROZEN)
	    CASE_SCODE (CACHE_E_NOCACHE_UPDATED)
	    CASE_SCODE (CACHE_S_FORMATETC_NOTSUPPORTED)
	    CASE_SCODE (CACHE_S_SAMECACHE)
	    CASE_SCODE (CACHE_S_SOMECACHES_NOTUPDATED)

	    // SCODE's defined in STORAGE.H
	    CASE_SCODE (STG_E_INVALIDFUNCTION)
	    CASE_SCODE (STG_E_FILENOTFOUND)
	    CASE_SCODE (STG_E_PATHNOTFOUND)
	    CASE_SCODE (STG_E_TOOMANYOPENFILES)
	    CASE_SCODE (STG_E_ACCESSDENIED)
	    CASE_SCODE (STG_E_INVALIDHANDLE)
	    CASE_SCODE (STG_E_INSUFFICIENTMEMORY)
	    CASE_SCODE (STG_E_INVALIDPOINTER)
	    CASE_SCODE (STG_E_NOMOREFILES)
	    CASE_SCODE (STG_E_DISKISWRITEPROTECTED)
	    CASE_SCODE (STG_E_SEEKERROR)
	    CASE_SCODE (STG_E_WRITEFAULT)
	    CASE_SCODE (STG_E_READFAULT)
	    CASE_SCODE (STG_E_SHAREVIOLATION)
	    CASE_SCODE (STG_E_LOCKVIOLATION)
	    CASE_SCODE (STG_E_FILEALREADYEXISTS)
	    CASE_SCODE (STG_E_INVALIDPARAMETER)
	    CASE_SCODE (STG_E_MEDIUMFULL)
	    CASE_SCODE (STG_E_ABNORMALAPIEXIT)
	    CASE_SCODE (STG_E_INVALIDHEADER)
	    CASE_SCODE (STG_E_INVALIDNAME)
	    CASE_SCODE (STG_E_UNKNOWN)
	    CASE_SCODE (STG_E_UNIMPLEMENTEDFUNCTION)
	    CASE_SCODE (STG_E_INVALIDFLAG)
	    CASE_SCODE (STG_E_INUSE)
	    CASE_SCODE (STG_E_NOTCURRENT)
	    CASE_SCODE (STG_E_REVERTED)
	    CASE_SCODE (STG_E_CANTSAVE)
	    CASE_SCODE (STG_E_OLDFORMAT)
	    CASE_SCODE (STG_E_OLDDLL)
	    CASE_SCODE (STG_E_SHAREREQUIRED)
	    CASE_SCODE (STG_E_NOTFILEBASEDSTORAGE)
	    CASE_SCODE (STG_E_EXTANTMARSHALLINGS)
	    CASE_SCODE (STG_S_CONVERTED)

	    // SCODE's defined in STORAGE.H
	    CASE_SCODE (MK_E_CONNECTMANUALLY)
	    CASE_SCODE (MK_E_EXCEEDEDDEADLINE)
	    CASE_SCODE (MK_E_NEEDGENERIC)
	    CASE_SCODE (MK_E_UNAVAILABLE)
	    CASE_SCODE (MK_E_SYNTAX)
	    CASE_SCODE (MK_E_NOOBJECT)
	    CASE_SCODE (MK_E_INVALIDEXTENSION)
	    CASE_SCODE (MK_E_INTERMEDIATEINTERFACENOTSUPPORTED)
	    CASE_SCODE (MK_E_NOTBINDABLE)
	    CASE_SCODE (MK_E_NOTBOUND)
	    CASE_SCODE (MK_E_CANTOPENFILE)
	    CASE_SCODE (MK_E_MUSTBOTHERUSER)
	    CASE_SCODE (MK_E_NOINVERSE)
	    CASE_SCODE (MK_E_NOSTORAGE)
	    CASE_SCODE (MK_E_NOPREFIX)
	    CASE_SCODE (MK_S_REDUCED_TO_SELF)
	    CASE_SCODE (MK_S_ME)
	    CASE_SCODE (MK_S_HIM)
	    CASE_SCODE (MK_S_US)
	    CASE_SCODE (MK_S_MONIKERALREADYREGISTERED)

	    // SCODE's defined in DISPATCH.H
	    CASE_SCODE (DISP_E_UNKNOWNINTERFACE)
	    CASE_SCODE (DISP_E_MEMBERNOTFOUND)
	    CASE_SCODE (DISP_E_PARAMNOTFOUND)
	    CASE_SCODE (DISP_E_TYPEMISMATCH)
	    CASE_SCODE (DISP_E_UNKNOWNNAME)
	    CASE_SCODE (DISP_E_NONAMEDARGS)
	    CASE_SCODE (DISP_E_BADVARTYPE)
	    CASE_SCODE (DISP_E_EXCEPTION)
	    CASE_SCODE (DISP_E_OVERFLOW)
	    CASE_SCODE (DISP_E_BADINDEX)
	    CASE_SCODE (DISP_E_UNKNOWNLCID)
	    CASE_SCODE (DISP_E_ARRAYISLOCKED)
	    CASE_SCODE (DISP_E_BADPARAMCOUNT)
	    CASE_SCODE (DISP_E_PARAMNOTOPTIONAL)
	    CASE_SCODE (DISP_E_BADCALLEE)
	    CASE_SCODE (DISP_E_NOTACOLLECTION)

	    CASE_SCODE (TYPE_E_BUFFERTOOSMALL)
	    CASE_SCODE (TYPE_E_INVDATAREAD)
	    CASE_SCODE (TYPE_E_UNSUPFORMAT)
	    CASE_SCODE (TYPE_E_REGISTRYACCESS)
	    CASE_SCODE (TYPE_E_LIBNOTREGISTERED)
	    CASE_SCODE (TYPE_E_UNDEFINEDTYPE)
	    CASE_SCODE (TYPE_E_QUALIFIEDNAMEDISALLOWED)
	    CASE_SCODE (TYPE_E_INVALIDSTATE)
	    CASE_SCODE (TYPE_E_WRONGTYPEKIND)
	    CASE_SCODE (TYPE_E_ELEMENTNOTFOUND)
	    CASE_SCODE (TYPE_E_AMBIGUOUSNAME)
	    CASE_SCODE (TYPE_E_NAMECONFLICT)
	    CASE_SCODE (TYPE_E_UNKNOWNLCID)
	    CASE_SCODE (TYPE_E_DLLFUNCTIONNOTFOUND)
	    CASE_SCODE (TYPE_E_BADMODULEKIND)
	    CASE_SCODE (TYPE_E_SIZETOOBIG)
	    CASE_SCODE (TYPE_E_DUPLICATEID)
	    CASE_SCODE (TYPE_E_TYPEMISMATCH)
	    CASE_SCODE (TYPE_E_OUTOFBOUNDS)
	    CASE_SCODE (TYPE_E_IOERROR)
	    CASE_SCODE (TYPE_E_CANTCREATETMPFILE)
	    CASE_SCODE (TYPE_E_CANTLOADLIBRARY)
	    CASE_SCODE (TYPE_E_INCONSISTENTPROPFUNCS)
	    CASE_SCODE (TYPE_E_CIRCULARTYPE)

	    default:
		lstrcpy (ErrName, "UNKNOWN SCODE");
	}

	char Buf[256];
	sprintf (Buf, "An OLE error occurred:\r\nCode = %s\r\nResult = %lx.",
		 (char*) ErrName, m_hResult);
	MessageBox (NULL, Buf, "OLE Error", MB_OK);
}


static bool CountArgsInFormat (LPCTSTR Format, UINT* pArgCount)
{
	*pArgCount = 0;

	if (! Format)
		return true;

	while (*Format)
	{
		if (*Format == '&')
			Format++;

		switch (*Format)
		{
		    case 'b':
		    case 'i':
		    case 'I':
		    case 'r':
		    case 'R':
		    case 'c':
		    case 's':
		    case 'e':
		    case 'd':
		    case 'v':
		    case 'D':
		    case 'U':
			++ (*pArgCount);
			Format++;
			break;
		    case '\0':
		    default:
			return false;
		}
	}
	return true;
}

static LPCTSTR GetNextVarType (LPCTSTR Format, VARTYPE* pVarType)
{
	*pVarType = 0;
	if (*Format == '&')
	{
		*pVarType = VT_BYREF;
		Format++;
		if (!*Format)
			return NULL;
	}
	switch (*Format)
	{
	    case 'b':
		*pVarType |= VT_BOOL;
		break;
	    case 'i':
		*pVarType |= VT_I2;
		break;
	    case 'I':
		*pVarType |= VT_I4;
		break;
	    case 'r':
		*pVarType |= VT_R4;
		break;
	    case 'R':
		*pVarType |= VT_R8;
		break;
	    case 'c':
		*pVarType |= VT_CY;
		break;
	    case 's':
		*pVarType |= VT_BSTR;
		break;
	    case 'e':
		*pVarType |= VT_ERROR;
		break;
	    case 'd':
		*pVarType |= VT_DATE;
		break;
	    case 'v':
		*pVarType |= VT_VARIANT;
		break;
	    case 'U':
		*pVarType |= VT_UNKNOWN;
		break;
	    case 'D':
		*pVarType |= VT_DISPATCH;
		break;
	    case '\0':
		return NULL;	// End of Format string
	    default:
		return NULL;
	}
	return ++Format;
}

#ifndef UNICODE
char* ConvertToAnsi (OLECHAR* sUnicode)
{
	static char BufAscii[MAX_OLE_STR];
	return ConvertToAnsiBuf (sUnicode, BufAscii);
}

char* ConvertToAnsiBuf (OLECHAR* sUnicode, char* BufAscii)
{
	WideCharToMultiByte (CP_ACP, 0, sUnicode, -1, BufAscii, MAX_OLE_STR, NULL, NULL);
	return BufAscii;
}

OLECHAR* ConvertToUnicode (char* sAscii)
{
	static OLECHAR BufUnicode[MAX_OLE_STR];
	return ConvertToUnicodeBuf (sAscii, BufUnicode);
}

OLECHAR* ConvertToUnicodeBuf (char* sAscii, OLECHAR* BufUnicode)
{
	MultiByteToWideChar (CP_ACP, 0, sAscii, -1, BufUnicode, MAX_OLE_STR);
	return BufUnicode;
}
#endif

