mirror of
https://github.com/vim/vim
synced 2025-07-15 08:41:54 +00:00
782 lines
20 KiB
C++
782 lines
20 KiB
C++
//
|
|
// 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 its 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
|
|
|