Windows NT 4.0 source code leak
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

999 lines
32 KiB

// This is a part of the Microsoft Foundation Classes C++ library.
// Copyright (C) 1992-1995 Microsoft Corporation
// All rights reserved.
//
// This source code is only intended as a supplement to the
// Microsoft Foundation Classes Reference and related
// electronic documentation provided with the library.
// See these sources for detailed information regarding the
// Microsoft Foundation Classes product.
#include "stdafx.h"
#ifdef AFX_INIT_SEG
#pragma code_seg(AFX_INIT_SEG)
#endif
#ifdef _AFXDLL
#ifndef _MAC
/////////////////////////////////////////////////////////////////////////////
// Win32 function loader helpers
// inline functions for loading the DLLs
inline HINSTANCE AfxLoadOle(FARPROC* proc, LPCSTR lpsz)
{ return AfxLoadDll(_afxOleState->m_hInstOLE, "OLE32.DLL", proc, lpsz); }
inline HINSTANCE AfxLoadOleAut(FARPROC* proc, LPCSTR lpsz)
{ return AfxLoadDll(_afxOleState->m_hInstOLEAUT, "OLEAUT32.DLL", proc, lpsz); }
inline HINSTANCE AfxLoadOleDlg(FARPROC* proc, LPCSTR lpsz)
{ return AfxLoadDll(_afxOleState->m_hInstOLEDLG, "OLEDLG.DLL", proc, lpsz); }
// non-mapped ole loading macros
#define OLELOAD(x) \
AfxLoadOle((FARPROC*)_afxOLE.pfn##x, #x)
#define OLEAUTLOAD(x) \
AfxLoadOleAut((FARPROC*)_afxOLE.pfn##x, #x)
#ifdef _UNICODE
#define OLEDLGLOADT(x) \
AfxLoadOleDlg((FARPROC*)_afxOLE.pfn##x, #x "W")
#else
#define OLEDLGLOADT(x) \
AfxLoadOleDlg((FARPROC*)_afxOLE.pfn##x, #x "A")
#endif
#define OLEDLGLOAD(x) \
AfxLoadOleDlg((FARPROC*)_afxOLE.pfn##x, #x)
// mapped (for mac) do not need special mapping on Win32 platforms
#define OLELOAD_M1(x) \
AfxLoadOle((FARPROC*)_afxOLE.pfn##x, #x)
#define OLELOAD_M2(x) \
AfxLoadOle((FARPROC*)_afxOLE.pfn##x, #x)
#define OLEAUTLOAD_M1(x) \
AfxLoadOleAut((FARPROC*)_afxOLE.pfn##x, #x)
#else //_MAC
/////////////////////////////////////////////////////////////////////////////
// _MAC function loader helpers
// inline functions for loading the DLLs
inline HINSTANCE AfxLoadOle(FARPROC* proc, LPCSTR lpsz)
{ return AfxLoadDll(_afxOleState->m_hInstOLE, "Microsoft_OLE2", proc, lpsz); }
inline HINSTANCE AfxLoadWlmOle(FARPROC* proc, LPCSTR lpsz)
#ifdef _DEBUG
{ return AfxLoadDll(_afxOleState->m_hInstWLMOLE, "DebugMicrosoftOLEPortabilityLib", proc, lpsz); }
#else
{ return AfxLoadDll(_afxOleState->m_hInstWLMOLE, "MicrosoftOLEPortabilityLib", proc, lpsz); }
#endif
inline HINSTANCE AfxLoadOleAut(FARPROC* proc, LPCSTR lpsz)
{ return AfxLoadDll(_afxOleState->m_hInstOLEAUT, "MicrosoftOLE2AutomationLib", proc, lpsz); }
inline HINSTANCE AfxLoadOleDlg(FARPROC* proc, LPCSTR lpsz)
#ifdef _DEBUG
{ return AfxLoadDll(_afxOleState->m_hInstOLEDLG, "DebugMicrosoftOLEUIPortabilityLib", proc, lpsz); }
#else
{ return AfxLoadDll(_afxOleState->m_hInstOLEDLG, "MicrosoftOLEUIPortabilityLib", proc, lpsz); }
#endif
// non-mapped ole loading macros
#define OLELOAD(x) \
AfxLoadOle((FARPROC*)_afxOLE.pfn##x, #x)
#define OLEAUTLOAD(x) \
AfxLoadOleAut((FARPROC*)_afxOLE.pfn##x, #x)
#define OLEDLGLOADT(x) \
AfxLoadOleDlg((FARPROC*)_afxOLE.pfn##x, #x)
// mapped (for mac) do not need special mapping on Win32 platforms
#define OLELOAD_M1(x) \
AfxLoadWlmOle((FARPROC*)_afxOLE.pfn##x, "WlmOle" #x)
#define OLELOAD_M2(x) \
AfxLoadWlmOle((FARPROC*)_afxOLE.pfn##x, #x)
#define OLEAUTLOAD_M1(x) \
AfxLoadWlmOle((FARPROC*)_afxOLE.pfn##x, "WlmOle" #x)
#define REGLOAD_M(x) \
AfxLoadWlmOle((FARPROC*)_afxOLE.pfn##x, #x)
#endif
///////////////////////////////////////////////////////////////////////////////
// OLEAUT32
void STDAPICALLTYPE AfxThunkSysFreeString(BSTR bstr)
{
OLEAUTLOAD(SysFreeString);
_afxOLE.pfnSysFreeString[1](bstr);
}
BSTR STDAPICALLTYPE AfxThunkSysAllocStringByteLen(const char FAR* psz, unsigned int len)
{
OLEAUTLOAD(SysAllocStringByteLen);
return _afxOLE.pfnSysAllocStringByteLen[1](psz, len);
}
HRESULT STDAPICALLTYPE AfxThunkVariantCopy(VARIANTARG FAR* pvargDest, VARIANTARG FAR* pvargSrc)
{
OLEAUTLOAD(VariantCopy);
return _afxOLE.pfnVariantCopy[1](pvargDest, pvargSrc);
}
HRESULT STDAPICALLTYPE AfxThunkVariantClear(VARIANTARG FAR* pvarg)
{
OLEAUTLOAD(VariantClear);
return _afxOLE.pfnVariantClear[1](pvarg);
}
HRESULT STDAPICALLTYPE AfxThunkVariantChangeType(VARIANTARG FAR* pvargDest, VARIANTARG FAR* pvarSrc, unsigned short wFlags, VARTYPE vt)
{
OLEAUTLOAD(VariantChangeType);
return _afxOLE.pfnVariantChangeType[1](pvargDest, pvarSrc, wFlags, vt);
}
BSTR STDAPICALLTYPE AfxThunkSysAllocStringLen(const OLECHAR FAR* psz, unsigned int len)
{
OLEAUTLOAD(SysAllocStringLen);
return _afxOLE.pfnSysAllocStringLen[1](psz, len);
}
unsigned int STDAPICALLTYPE AfxThunkSysStringLen(BSTR bstr)
{
OLEAUTLOAD(SysStringLen);
return _afxOLE.pfnSysStringLen[1](bstr);
}
int STDAPICALLTYPE AfxThunkSysReAllocStringLen(BSTR FAR* pbstr, const OLECHAR FAR* psz, unsigned int len)
{
OLEAUTLOAD(SysReAllocStringLen);
return _afxOLE.pfnSysReAllocStringLen[1](pbstr, psz, len);
}
BSTR STDAPICALLTYPE AfxThunkSysAllocString(const OLECHAR FAR* psz)
{
OLEAUTLOAD(SysAllocString);
return _afxOLE.pfnSysAllocString[1](psz);
}
unsigned int STDAPICALLTYPE AfxThunkSysStringByteLen(BSTR bstr)
{
OLEAUTLOAD(SysStringByteLen);
return _afxOLE.pfnSysStringByteLen[1](bstr);
}
HRESULT STDAPICALLTYPE AfxThunkVarCyFromStr(OLECHAR FAR* strIn, LCID lcid, unsigned long dwFlags, CY FAR* pcyOut)
{
OLEAUTLOAD(VarCyFromStr);
return _afxOLE.pfnVarCyFromStr[1](strIn, lcid, dwFlags, pcyOut);
}
HRESULT STDAPICALLTYPE AfxThunkVarBstrFromCy(CY cyIn, LCID lcid, unsigned long dwFlags, BSTR FAR* pbstrOut)
{
OLEAUTLOAD(VarBstrFromCy);
return _afxOLE.pfnVarBstrFromCy[1](cyIn, lcid, dwFlags, pbstrOut);
}
HRESULT STDAPICALLTYPE AfxThunkVarDateFromStr(OLECHAR FAR* strIn, LCID lcid, unsigned long dwFlags, DATE FAR* pdateOut)
{
OLEAUTLOAD(VarDateFromStr);
return _afxOLE.pfnVarDateFromStr[1](strIn, lcid, dwFlags, pdateOut);
}
HRESULT STDAPICALLTYPE AfxThunkVarBstrFromDate(DATE dateIn, LCID lcid, unsigned long dwFlags, BSTR FAR* pbstrOut)
{
OLEAUTLOAD(VarBstrFromDate);
return _afxOLE.pfnVarBstrFromDate[1](dateIn, lcid, dwFlags, pbstrOut);
}
HRESULT STDAPICALLTYPE AfxThunkLoadTypeLib(const OLECHAR FAR *szFile, ITypeLib FAR* FAR* pptlib)
{
OLEAUTLOAD_M1(LoadTypeLib);
return _afxOLE.pfnLoadTypeLib[1](szFile, pptlib);
}
HRESULT STDAPICALLTYPE AfxThunkRegisterTypeLib(ITypeLib FAR* ptlib, OLECHAR FAR *szFullPath, OLECHAR FAR *szHelpDir)
{
OLEAUTLOAD(RegisterTypeLib);
return _afxOLE.pfnRegisterTypeLib[1](ptlib, szFullPath, szHelpDir);
}
int STDAPICALLTYPE AfxThunkDosDateTimeToVariantTime(unsigned short wDosDate, unsigned short wDosTime, double FAR* pvtime)
{
OLEAUTLOAD(DosDateTimeToVariantTime);
return _afxOLE.pfnDosDateTimeToVariantTime[1](wDosDate, wDosTime, pvtime);
}
SAFEARRAY FAR* STDAPICALLTYPE AfxThunkSafeArrayCreate(VARTYPE vt, unsigned int cDims, SAFEARRAYBOUND FAR* rgsabound)
{
OLEAUTLOAD(SafeArrayCreate);
return _afxOLE.pfnSafeArrayCreate[1](vt, cDims, rgsabound);
}
HRESULT STDAPICALLTYPE AfxThunkSafeArrayRedim(SAFEARRAY FAR* psa, SAFEARRAYBOUND FAR* psaboundNew)
{
OLEAUTLOAD(SafeArrayRedim);
return _afxOLE.pfnSafeArrayRedim[1](psa, psaboundNew);
}
HRESULT STDAPICALLTYPE AfxThunkSafeArrayAccessData(SAFEARRAY FAR* psa, void HUGEP* FAR* ppvData)
{
OLEAUTLOAD(SafeArrayAccessData);
return _afxOLE.pfnSafeArrayAccessData[1](psa, ppvData);
}
HRESULT STDAPICALLTYPE AfxThunkSafeArrayUnaccessData(SAFEARRAY FAR* psa)
{
OLEAUTLOAD(SafeArrayUnaccessData);
return _afxOLE.pfnSafeArrayUnaccessData[1](psa);
}
HRESULT STDAPICALLTYPE AfxThunkSafeArrayGetUBound(SAFEARRAY FAR* psa, unsigned int nDim, long FAR* plUbound)
{
OLEAUTLOAD(SafeArrayGetUBound);
return _afxOLE.pfnSafeArrayGetUBound[1](psa, nDim, plUbound);
}
HRESULT STDAPICALLTYPE AfxThunkSafeArrayGetLBound(SAFEARRAY FAR* psa, unsigned int nDim, long FAR* plLbound)
{
OLEAUTLOAD(SafeArrayGetLBound);
return _afxOLE.pfnSafeArrayGetLBound[1](psa, nDim, plLbound);
}
unsigned int STDAPICALLTYPE AfxThunkSafeArrayGetElemsize(SAFEARRAY FAR* psa)
{
OLEAUTLOAD(SafeArrayGetElemsize);
return _afxOLE.pfnSafeArrayGetElemsize[1](psa);
}
unsigned int STDAPICALLTYPE AfxThunkSafeArrayGetDim(SAFEARRAY FAR* psa)
{
OLEAUTLOAD(SafeArrayGetDim);
return _afxOLE.pfnSafeArrayGetDim[1](psa);
}
///////////////////////////////////////////////////////////////////////////////
// OLEDLG
BOOL STDAPICALLTYPE AfxThunkOleUIAddVerbMenu(LPOLEOBJECT lpOleObj, LPCTSTR lpszShortType, HMENU hMenu, UINT uPos, UINT uIDVerbMin, UINT uIDVerbMax, BOOL bAddConvert, UINT idConvert, HMENU FAR *lphMenu)
{
OLEDLGLOADT(OleUIAddVerbMenu);
return _afxOLE.pfnOleUIAddVerbMenu[1](lpOleObj, lpszShortType, hMenu, uPos, uIDVerbMin, uIDVerbMax, bAddConvert, idConvert, lphMenu);
}
UINT STDAPICALLTYPE AfxThunkOleUIBusy(LPOLEUIBUSY lp)
{
OLEDLGLOADT(OleUIBusy);
return _afxOLE.pfnOleUIBusy[1](lp);
}
UINT STDAPICALLTYPE AfxThunkOleUIChangeIcon(LPOLEUICHANGEICON lp)
{
OLEDLGLOADT(OleUIChangeIcon);
return _afxOLE.pfnOleUIChangeIcon[1](lp);
}
UINT STDAPICALLTYPE AfxThunkOleUIChangeSource(LPOLEUICHANGESOURCE lp)
{
OLEDLGLOADT(OleUIChangeSource);
return _afxOLE.pfnOleUIChangeSource[1](lp);
}
UINT STDAPICALLTYPE AfxThunkOleUIConvert(LPOLEUICONVERT lp)
{
OLEDLGLOADT(OleUIConvert);
return _afxOLE.pfnOleUIConvert[1](lp);
}
UINT STDAPICALLTYPE AfxThunkOleUIEditLinks(LPOLEUIEDITLINKS lp)
{
OLEDLGLOADT(OleUIEditLinks);
return _afxOLE.pfnOleUIEditLinks[1](lp);
}
UINT STDAPICALLTYPE AfxThunkOleUIInsertObject(LPOLEUIINSERTOBJECT lp)
{
OLEDLGLOADT(OleUIInsertObject);
return _afxOLE.pfnOleUIInsertObject[1](lp);
}
UINT STDAPICALLTYPE AfxThunkOleUIObjectProperties(LPOLEUIOBJECTPROPS lp)
{
OLEDLGLOADT(OleUIObjectProperties);
return _afxOLE.pfnOleUIObjectProperties[1](lp);
}
UINT STDAPICALLTYPE AfxThunkOleUIPasteSpecial(LPOLEUIPASTESPECIAL lp)
{
OLEDLGLOADT(OleUIPasteSpecial);
return _afxOLE.pfnOleUIPasteSpecial[1](lp);
}
BOOL STDAPICALLTYPE AfxThunkOleUIUpdateLinks(LPOLEUILINKCONTAINER lpOleUILinkCntr, HWND hwndParent, LPTSTR lpszTitle, int cLinks)
{
OLEDLGLOADT(OleUIUpdateLinks);
return _afxOLE.pfnOleUIUpdateLinks[1](lpOleUILinkCntr, hwndParent, lpszTitle, cLinks);
}
/////////////////////////////////////////////////////////////////////////////
// Special Mac registry APIs
#ifdef _MAC
LONG APIENTRY AfxThunkRegCloseKey(HKEY hKey)
{
REGLOAD_M(AfxRegCloseKey);
return _afxOLE.pfnAfxRegCloseKey[1](hKey);
}
LONG APIENTRY AfxThunkRegOpenKey(HKEY hKey, LPCSTR lpSubKey, PHKEY phkResult)
{
REGLOAD_M(RegOpenKey);
return _afxOLE.pfnRegOpenKey[1](hKey, lpSubKey, phkResult);
}
LONG APIENTRY AfxThunkRegSetValue(HKEY hKey, LPCSTR lpSubKey, DWORD dwType,
LPCSTR lpData, DWORD cbData)
{
REGLOAD_M(RegSetValue);
return _afxOLE.pfnRegSetValue[1](hKey, lpSubKey, dwType, lpData, cbData);
}
LONG APIENTRY AfxThunkRegQueryValue(HKEY hKey, LPCSTR lpSubKey, LPSTR lpValue,
PLONG lpcbValue)
{
REGLOAD_M(RegQueryValue);
return _afxOLE.pfnRegQueryValue[1](hKey, lpSubKey, lpValue, lpcbValue);
}
#endif
///////////////////////////////////////////////////////////////////////////////
// OLE32
HRESULT STDAPICALLTYPE AfxThunkReadFmtUserTypeStg(LPSTORAGE pstg, CLIPFORMAT FAR* pcf, LPOLESTR FAR* lplpszUserType)
{
OLELOAD_M1(ReadFmtUserTypeStg);
return _afxOLE.pfnReadFmtUserTypeStg[1](pstg, pcf, lplpszUserType);
}
HRESULT STDAPICALLTYPE AfxThunkReadClassStg(LPSTORAGE pStg, CLSID FAR* pclsid)
{
OLELOAD_M1(ReadClassStg);
return _afxOLE.pfnReadClassStg[1](pStg, pclsid);
}
HRESULT STDAPICALLTYPE AfxThunkCreateFileMoniker(LPCOLESTR lpszPathName, LPMONIKER FAR* ppmk)
{
OLELOAD_M1(CreateFileMoniker);
return _afxOLE.pfnCreateFileMoniker[1](lpszPathName, ppmk);
}
HRESULT STDAPICALLTYPE AfxThunkStgIsStorageFile(const OLECHAR * pwcsName)
{
OLELOAD_M1(StgIsStorageFile);
return _afxOLE.pfnStgIsStorageFile[1](pwcsName);
}
HRESULT STDAPICALLTYPE AfxThunkStgOpenStorage(const OLECHAR * pwcsName, IStorage *pstgPriority, DWORD grfMode, SNB snbExclude, DWORD reserved, IStorage ** ppstgOpen)
{
OLELOAD_M1(StgOpenStorage);
return _afxOLE.pfnStgOpenStorage[1](pwcsName, pstgPriority, grfMode, snbExclude, reserved, ppstgOpen);
}
HRESULT STDAPICALLTYPE AfxThunkDoDragDrop(LPDATAOBJECT pDataObj, LPDROPSOURCE pDropSource, DWORD dwOKEffects, LPDWORD pdwEffect)
{
OLELOAD_M1(DoDragDrop);
return _afxOLE.pfnDoDragDrop[1](pDataObj, pDropSource, dwOKEffects, pdwEffect);
}
HRESULT STDAPICALLTYPE AfxThunkCoLockObjectExternal(LPUNKNOWN pUnk, BOOL fLock, BOOL fLastUnlockReleases)
{
OLELOAD_M1(CoLockObjectExternal);
return _afxOLE.pfnCoLockObjectExternal[1](pUnk, fLock, fLastUnlockReleases);
}
HRESULT STDAPICALLTYPE AfxThunkRegisterDragDrop(HWND hwnd, LPDROPTARGET pDropTarget)
{
OLELOAD_M1(RegisterDragDrop);
return _afxOLE.pfnRegisterDragDrop[1](hwnd, pDropTarget);
}
HRESULT STDAPICALLTYPE AfxThunkOleRegGetUserType (REFCLSID clsid, DWORD dwFormOfType, LPOLESTR * pszUserType)
{
OLELOAD(OleRegGetUserType);
return _afxOLE.pfnOleRegGetUserType[1](clsid, dwFormOfType, pszUserType);
}
HRESULT STDAPICALLTYPE AfxThunkStgCreateDocfile(const OLECHAR * pwcsName, DWORD grfMode, DWORD reserved, IStorage** ppstgOpen)
{
OLELOAD_M1(StgCreateDocfile);
return _afxOLE.pfnStgCreateDocfile[1](pwcsName, grfMode, reserved, ppstgOpen);
}
HRESULT STDAPICALLTYPE AfxThunkRevokeDragDrop(HWND hwnd)
{
OLELOAD_M1(RevokeDragDrop);
return _afxOLE.pfnRevokeDragDrop[1](hwnd);
}
HRESULT STDAPICALLTYPE AfxThunkCoRegisterClassObject(REFCLSID rclsid, LPUNKNOWN pUnk, DWORD dwClsContext, DWORD flags, LPDWORD lpdwRegister)
{
OLELOAD_M1(CoRegisterClassObject);
return _afxOLE.pfnCoRegisterClassObject[1](rclsid, pUnk, dwClsContext, flags, lpdwRegister);
}
HRESULT STDAPICALLTYPE AfxThunkCoRevokeClassObject(DWORD dwRegister)
{
OLELOAD_M1(CoRevokeClassObject);
return _afxOLE.pfnCoRevokeClassObject[1](dwRegister);
}
HRESULT STDAPICALLTYPE AfxThunkOleTranslateAccelerator(LPOLEINPLACEFRAME lpFrame, LPOLEINPLACEFRAMEINFO lpFrameInfo, LPMSG lpmsg)
{
OLELOAD_M1(OleTranslateAccelerator);
return _afxOLE.pfnOleTranslateAccelerator[1](lpFrame, lpFrameInfo, lpmsg);
}
BOOL STDAPICALLTYPE AfxThunkIsAccelerator(HACCEL hAccel, INT cAccelEntries, LPMSG lpMsg, WORD* lpwCmd)
{
OLELOAD_M1(IsAccelerator);
return _afxOLE.pfnIsAccelerator[1](hAccel, cAccelEntries, lpMsg, lpwCmd);
}
HOLEMENU STDAPICALLTYPE AfxThunkOleCreateMenuDescriptor(HMENU hmenuCombined, LPOLEMENUGROUPWIDTHS lpMenuWidths)
{
OLELOAD_M2(OleCreateMenuDescriptor);
return _afxOLE.pfnOleCreateMenuDescriptor[1](hmenuCombined, lpMenuWidths);
}
HRESULT STDAPICALLTYPE AfxThunkOleDestroyMenuDescriptor(HOLEMENU holemenu)
{
OLELOAD_M2(OleDestroyMenuDescriptor);
return _afxOLE.pfnOleDestroyMenuDescriptor[1](holemenu);
}
HRESULT STDAPICALLTYPE AfxThunkGetRunningObjectTable(DWORD reserved, LPRUNNINGOBJECTTABLE FAR* pprot)
{
OLELOAD_M1(GetRunningObjectTable);
return _afxOLE.pfnGetRunningObjectTable[1](reserved, pprot);
}
HRESULT STDAPICALLTYPE AfxThunkWriteClassStg(LPSTORAGE pStg, REFCLSID rclsid)
{
OLELOAD_M1(WriteClassStg);
return _afxOLE.pfnWriteClassStg[1](pStg, rclsid);
}
HRESULT STDAPICALLTYPE AfxThunkOleQueryLinkFromData(LPDATAOBJECT pSrcDataObject)
{
OLELOAD_M1(OleQueryLinkFromData);
return _afxOLE.pfnOleQueryLinkFromData[1](pSrcDataObject);
}
HRESULT STDAPICALLTYPE AfxThunkCoRegisterMessageFilter(LPMESSAGEFILTER lpMessageFilter, LPMESSAGEFILTER * lplpMessageFilter)
{
OLELOAD_M1(CoRegisterMessageFilter);
return _afxOLE.pfnCoRegisterMessageFilter[1](lpMessageFilter, lplpMessageFilter);
}
HRESULT STDAPICALLTYPE AfxThunkCoCreateInstance(REFCLSID rclsid, LPUNKNOWN * pUnkOuter, DWORD dwClsContext, REFIID riid, LPVOID* ppv)
{
OLELOAD_M1(CoCreateInstance);
return _afxOLE.pfnCoCreateInstance[1](rclsid, pUnkOuter, dwClsContext, riid, ppv);
}
HRESULT STDAPICALLTYPE AfxThunkCreateBindCtx(DWORD reserved, LPBC FAR* ppbc)
{
OLELOAD_M1(CreateBindCtx);
return _afxOLE.pfnCreateBindCtx[1](reserved, ppbc);
}
HRESULT STDAPICALLTYPE AfxThunkStringFromCLSID(REFCLSID rclsid, LPOLESTR FAR* lplpsz)
{
OLELOAD(StringFromCLSID);
return _afxOLE.pfnStringFromCLSID[1](rclsid, lplpsz);
}
HRESULT STDAPICALLTYPE AfxThunkCoDisconnectObject(LPUNKNOWN pUnk, DWORD dwReserved)
{
OLELOAD_M1(CoDisconnectObject);
return _afxOLE.pfnCoDisconnectObject[1](pUnk, dwReserved);
}
HRESULT STDAPICALLTYPE AfxThunkOleRegEnumVerbs (REFCLSID clsid, LPENUMOLEVERB FAR* ppenum)
{
OLELOAD_M1(OleRegEnumVerbs);
return _afxOLE.pfnOleRegEnumVerbs[1](clsid, ppenum);
}
void STDAPICALLTYPE AfxThunkOleUninitialize(void)
{
OLELOAD_M1(OleUninitialize);
_afxOLE.pfnOleUninitialize[1]();
}
HRESULT STDAPICALLTYPE AfxThunkCreateOleAdviseHolder(LPOLEADVISEHOLDER FAR* ppOAHolder)
{
OLELOAD_M1(CreateOleAdviseHolder);
return _afxOLE.pfnCreateOleAdviseHolder[1](ppOAHolder);
}
HRESULT STDAPICALLTYPE AfxThunkCreateDataAdviseHolder(LPDATAADVISEHOLDER FAR* ppDAHolder)
{
OLELOAD_M1(CreateDataAdviseHolder);
return _afxOLE.pfnCreateDataAdviseHolder[1](ppDAHolder);
}
HRESULT STDAPICALLTYPE AfxThunkOleGetAutoConvert(REFCLSID clsidOld, LPCLSID pClsidNew)
{
OLELOAD(OleGetAutoConvert);
return _afxOLE.pfnOleGetAutoConvert[1](clsidOld, pClsidNew);
}
HRESULT STDAPICALLTYPE AfxThunkCoGetClassObject(REFCLSID rclsid, DWORD dwClsContext, LPVOID pvReserved, REFIID riid, LPVOID* ppv)
{
OLELOAD_M1(CoGetClassObject);
return _afxOLE.pfnCoGetClassObject[1](rclsid, dwClsContext, pvReserved, riid, ppv);
}
HRESULT STDAPICALLTYPE AfxThunkOleCreateDefaultHandler(REFCLSID clsid, LPUNKNOWN pUnkOuter, REFIID riid, LPVOID* lplpvObj)
{
OLELOAD_M1(OleCreateDefaultHandler);
return _afxOLE.pfnOleCreateDefaultHandler[1](clsid, pUnkOuter, riid, lplpvObj);
}
HRESULT STDAPICALLTYPE AfxThunkCreateDataCache(LPUNKNOWN pUnkOuter, REFCLSID clsid, REFIID riid, LPVOID* lplpvObj)
{
OLELOAD_M1(CreateDataCache);
return _afxOLE.pfnCreateDataCache[1](pUnkOuter, clsid, riid, lplpvObj);
}
HRESULT STDAPICALLTYPE AfxThunkReadClassStm(LPSTREAM pStm, CLSID FAR* pclsid)
{
OLELOAD_M1(ReadClassStm);
return _afxOLE.pfnReadClassStm[1](pStm, pclsid);
}
HRESULT STDAPICALLTYPE AfxThunkOleLoadFromStream(LPSTREAM pStm, REFIID iidInterface, LPVOID FAR* ppvObj)
{
OLELOAD_M1(OleLoadFromStream);
return _afxOLE.pfnOleLoadFromStream[1](pStm, iidInterface, ppvObj);
}
int STDAPICALLTYPE AfxThunkStringFromGUID2(REFGUID rguid, LPOLESTR lpsz, int cbMax)
{
OLELOAD(StringFromGUID2);
return _afxOLE.pfnStringFromGUID2[1](rguid, lpsz, cbMax);
}
void STDAPICALLTYPE AfxThunkCoUninitialize(void)
{
OLELOAD_M1(CoUninitialize);
_afxOLE.pfnCoUninitialize[1]();
}
HRESULT STDAPICALLTYPE AfxThunkCoInitialize(LPVOID pvReserved)
{
OLELOAD_M1(CoInitialize);
return _afxOLE.pfnCoInitialize[1](pvReserved);
}
HRESULT STDAPICALLTYPE AfxThunkOleInitialize(LPVOID pvReserved)
{
OLELOAD_M1(OleInitialize);
return _afxOLE.pfnOleInitialize[1](pvReserved);
}
void STDAPICALLTYPE AfxThunkCoFreeUnusedLibraries(void)
{
OLELOAD(CoFreeUnusedLibraries);
_afxOLE.pfnCoFreeUnusedLibraries[1]();
}
HRESULT STDAPICALLTYPE AfxThunkOleCreateFromData(LPDATAOBJECT pSrcDataObj, REFIID riid, DWORD renderopt, LPFORMATETC pFormatEtc, LPOLECLIENTSITE pClientSite, LPSTORAGE pStg, LPVOID* ppvObj)
{
OLELOAD_M1(OleCreateFromData);
return _afxOLE.pfnOleCreateFromData[1](pSrcDataObj, riid, renderopt, pFormatEtc, pClientSite, pStg, ppvObj);
}
HRESULT STDAPICALLTYPE AfxThunkOleSetContainedObject(LPUNKNOWN pUnknown, BOOL fContained)
{
OLELOAD_M1(OleSetContainedObject);
return _afxOLE.pfnOleSetContainedObject[1](pUnknown, fContained);
}
HRESULT STDAPICALLTYPE AfxThunkOleLockRunning(LPUNKNOWN pUnknown, BOOL fLock, BOOL fLastUnlockCloses)
{
OLELOAD_M1(OleLockRunning);
return _afxOLE.pfnOleLockRunning[1](pUnknown, fLock, fLastUnlockCloses);
}
LPVOID STDAPICALLTYPE AfxThunkCoTaskMemAlloc(ULONG cb)
{
OLELOAD_M1(CoTaskMemAlloc);
return _afxOLE.pfnCoTaskMemAlloc[1](cb);
}
HRESULT STDAPICALLTYPE AfxThunkCLSIDFromString(LPOLESTR lpsz, LPCLSID pclsid)
{
OLELOAD(CLSIDFromString);
return _afxOLE.pfnCLSIDFromString[1](lpsz, pclsid);
}
HRESULT STDAPICALLTYPE AfxThunkCLSIDFromProgID (LPCOLESTR lpszProgID, LPCLSID lpclsid)
{
OLELOAD(CLSIDFromProgID);
return _afxOLE.pfnCLSIDFromProgID[1](lpszProgID, lpclsid);
}
HRESULT STDAPICALLTYPE AfxThunkOleIsCurrentClipboard(LPDATAOBJECT pDataObj)
{
OLELOAD_M1(OleIsCurrentClipboard);
return _afxOLE.pfnOleIsCurrentClipboard[1](pDataObj);
}
HRESULT STDAPICALLTYPE AfxThunkOleFlushClipboard(void)
{
OLELOAD_M1(OleFlushClipboard);
return _afxOLE.pfnOleFlushClipboard[1]();
}
HRESULT STDAPICALLTYPE AfxThunkOleSetClipboard(LPDATAOBJECT pDataObj)
{
OLELOAD_M1(OleSetClipboard);
return _afxOLE.pfnOleSetClipboard[1](pDataObj);
}
BOOL STDAPICALLTYPE AfxThunkOleIsRunning(LPOLEOBJECT pObject)
{
OLELOAD_M1(OleIsRunning);
return _afxOLE.pfnOleIsRunning[1](pObject);
}
HRESULT STDAPICALLTYPE AfxThunkOleRun(LPUNKNOWN pUnknown)
{
OLELOAD_M1(OleRun);
return _afxOLE.pfnOleRun[1](pUnknown);
}
HRESULT STDAPICALLTYPE AfxThunkOleGetClipboard(LPDATAOBJECT FAR* ppDataObj)
{
OLELOAD_M1(OleGetClipboard);
return _afxOLE.pfnOleGetClipboard[1](ppDataObj);
}
HRESULT STDAPICALLTYPE AfxThunkCoTreatAsClass(REFCLSID clsidOld, REFCLSID clsidNew)
{
OLELOAD(CoTreatAsClass);
return _afxOLE.pfnCoTreatAsClass[1](clsidOld, clsidNew);
}
HRESULT STDAPICALLTYPE AfxThunkOleQueryCreateFromData(LPDATAOBJECT pSrcDataObject)
{
OLELOAD_M1(OleQueryCreateFromData);
return _afxOLE.pfnOleQueryCreateFromData[1](pSrcDataObject);
}
HRESULT STDAPICALLTYPE AfxThunkOleSetMenuDescriptor (HOLEMENU holemenu, HWND hwndFrame, HWND hwndActiveObject, LPOLEINPLACEFRAME lpFrame, LPOLEINPLACEACTIVEOBJECT lpActiveObj)
{
OLELOAD_M2(OleSetMenuDescriptor);
return _afxOLE.pfnOleSetMenuDescriptor[1](holemenu, hwndFrame, hwndActiveObject, lpFrame, lpActiveObj);
}
HRESULT STDAPICALLTYPE AfxThunkCreateItemMoniker(LPCOLESTR lpszDelim, LPCOLESTR lpszItem, LPMONIKER* ppmk)
{
OLELOAD_M1(CreateItemMoniker);
return _afxOLE.pfnCreateItemMoniker[1](lpszDelim, lpszItem, ppmk);
}
HRESULT STDAPICALLTYPE AfxThunkCreateGenericComposite(LPMONIKER pmkFirst, LPMONIKER pmkRest, LPMONIKER* ppmkComposite)
{
OLELOAD_M1(CreateGenericComposite);
return _afxOLE.pfnCreateGenericComposite[1](pmkFirst, pmkRest, ppmkComposite);
}
HRESULT STDAPICALLTYPE AfxThunkCreateStreamOnHGlobal(HGLOBAL hGlobal, BOOL fDeleteOnRelease, LPSTREAM* ppstm)
{
OLELOAD_M1(CreateStreamOnHGlobal);
return _afxOLE.pfnCreateStreamOnHGlobal[1](hGlobal, fDeleteOnRelease, ppstm);
}
HRESULT STDAPICALLTYPE AfxThunkOleSaveToStream(LPPERSISTSTREAM pPStm, LPSTREAM pStm)
{
OLELOAD_M1(OleSaveToStream);
return _afxOLE.pfnOleSaveToStream[1](pPStm, pStm);
}
HRESULT STDAPICALLTYPE AfxThunkWriteClassStm(LPSTREAM pStm, REFCLSID rclsid)
{
OLELOAD_M1(WriteClassStm);
return _afxOLE.pfnWriteClassStm[1](pStm, rclsid);
}
void STDAPICALLTYPE AfxThunkCoTaskMemFree(LPVOID pv)
{
OLELOAD_M1(CoTaskMemFree);
_afxOLE.pfnCoTaskMemFree[1](pv);
}
HGLOBAL STDAPICALLTYPE AfxThunkOleGetIconOfClass(REFCLSID rclsid, LPOLESTR lpszLabel, BOOL fUseTypeAsLabel)
{
OLELOAD_M1(OleGetIconOfClass);
return _afxOLE.pfnOleGetIconOfClass[1](rclsid, lpszLabel, fUseTypeAsLabel);
}
void STDAPICALLTYPE AfxThunkReleaseStgMedium(LPSTGMEDIUM lp)
{
OLELOAD_M1(ReleaseStgMedium);
_afxOLE.pfnReleaseStgMedium[1](lp);
}
HRESULT STDAPICALLTYPE AfxThunkGetHGlobalFromILockBytes (LPLOCKBYTES plkbyt, HGLOBAL FAR* phglobal)
{
OLELOAD_M1(GetHGlobalFromILockBytes);
return _afxOLE.pfnGetHGlobalFromILockBytes[1](plkbyt, phglobal);
}
HRESULT STDAPICALLTYPE AfxThunkStgOpenStorageOnILockBytes(LPLOCKBYTES plkbyt, LPSTORAGE pstgPriority, DWORD grfMode, SNB snbExclude, DWORD reserved, LPSTORAGE* ppstgOpen)
{
OLELOAD_M1(StgOpenStorageOnILockBytes);
return _afxOLE.pfnStgOpenStorageOnILockBytes[1](plkbyt, pstgPriority, grfMode, snbExclude, reserved, ppstgOpen);
}
HRESULT STDAPICALLTYPE AfxThunkCreateILockBytesOnHGlobal(HGLOBAL hGlobal, BOOL fDeleteOnRelease, LPLOCKBYTES* pplkbyt)
{
OLELOAD_M1(CreateILockBytesOnHGlobal);
return _afxOLE.pfnCreateILockBytesOnHGlobal[1](hGlobal, fDeleteOnRelease, pplkbyt);
}
HRESULT STDAPICALLTYPE AfxThunkStgCreateDocfileOnILockBytes(LPLOCKBYTES plkbyt, DWORD grfMode, DWORD reserved, LPSTORAGE* ppstgOpen)
{
OLELOAD_M1(StgCreateDocfileOnILockBytes);
return _afxOLE.pfnStgCreateDocfileOnILockBytes[1](plkbyt, grfMode, reserved, ppstgOpen);
}
HRESULT STDAPICALLTYPE AfxThunkOleSave(LPPERSISTSTORAGE pPS, LPSTORAGE pStg, BOOL fSameAsLoad)
{
OLELOAD_M1(OleSave);
return _afxOLE.pfnOleSave[1](pPS, pStg, fSameAsLoad);
}
HRESULT STDAPICALLTYPE AfxThunkOleLoad(LPSTORAGE pStg, REFIID riid, LPOLECLIENTSITE pClientSite, LPVOID* ppvObj)
{
OLELOAD_M1(OleLoad);
return _afxOLE.pfnOleLoad[1](pStg, riid, pClientSite, ppvObj);
}
HRESULT STDAPICALLTYPE AfxThunkOleCreate(REFCLSID rclsid, REFIID riid, DWORD renderopt, LPFORMATETC pFormatEtc, LPOLECLIENTSITE pClientSite, LPSTORAGE pStg, LPVOID* ppvObj)
{
OLELOAD_M1(OleCreate);
return _afxOLE.pfnOleCreate[1](rclsid, riid, renderopt, pFormatEtc, pClientSite, pStg, ppvObj);
}
HRESULT STDAPICALLTYPE AfxThunkOleCreateLinkToFile(LPCOLESTR lpszFileName, REFIID riid, DWORD renderopt, LPFORMATETC lpFormatEtc, LPOLECLIENTSITE pClientSite, LPSTORAGE pStg, LPVOID* ppvObj)
{
OLELOAD_M1(OleCreateLinkToFile);
return _afxOLE.pfnOleCreateLinkToFile[1](lpszFileName, riid, renderopt, lpFormatEtc, pClientSite, pStg, ppvObj);
}
HRESULT STDAPICALLTYPE AfxThunkOleCreateFromFile(REFCLSID rclsid, LPCOLESTR lpszFileName, REFIID riid, DWORD renderopt, LPFORMATETC pFormatEtc, LPOLECLIENTSITE pClientSite, LPSTORAGE pStg, LPVOID* ppvObj)
{
OLELOAD_M1(OleCreateFromFile);
return _afxOLE.pfnOleCreateFromFile[1](rclsid, lpszFileName, riid, renderopt, pFormatEtc, pClientSite, pStg, ppvObj);
}
HRESULT STDAPICALLTYPE AfxThunkOleCreateStaticFromData(LPDATAOBJECT pSrcDataObj, REFIID riid, DWORD renderopt, LPFORMATETC pFormatEtc, LPOLECLIENTSITE pClientSite, LPSTORAGE pStg, LPVOID* ppvObj)
{
OLELOAD_M1(OleCreateStaticFromData);
return _afxOLE.pfnOleCreateStaticFromData[1](pSrcDataObj, riid, renderopt, pFormatEtc, pClientSite, pStg, ppvObj);
}
HRESULT STDAPICALLTYPE AfxThunkOleCreateLinkFromData(LPDATAOBJECT pSrcDataObj, REFIID riid, DWORD renderopt, LPFORMATETC pFormatEtc, LPOLECLIENTSITE pClientSite, LPSTORAGE pStg, LPVOID* ppvObj)
{
OLELOAD_M1(OleCreateLinkFromData);
return _afxOLE.pfnOleCreateLinkFromData[1](pSrcDataObj, riid, renderopt, pFormatEtc, pClientSite, pStg, ppvObj);
}
HRESULT STDAPICALLTYPE AfxThunkSetConvertStg(LPSTORAGE pStg, BOOL fConvert)
{
OLELOAD_M1(SetConvertStg);
return _afxOLE.pfnSetConvertStg[1](pStg, fConvert);
}
HANDLE STDAPICALLTYPE AfxThunkOleDuplicateData(HANDLE hSrc, CLIPFORMAT cfFormat, UINT uiFlags)
{
OLELOAD_M1(OleDuplicateData);
return _afxOLE.pfnOleDuplicateData[1](hSrc, cfFormat, uiFlags);
}
HRESULT STDAPICALLTYPE AfxThunkWriteFmtUserTypeStg (LPSTORAGE pstg, CLIPFORMAT cf, LPOLESTR lpszUserType)
{
OLELOAD_M1(WriteFmtUserTypeStg);
return _afxOLE.pfnWriteFmtUserTypeStg[1](pstg, cf, lpszUserType);
}
HRESULT STDAPICALLTYPE AfxThunkOleRegGetMiscStatus(REFCLSID clsid, DWORD dwAspect, DWORD* pdwStatus)
{
OLELOAD(OleRegGetMiscStatus);
return _afxOLE.pfnOleRegGetMiscStatus[1](clsid, dwAspect, pdwStatus);
}
HRESULT STDAPICALLTYPE AfxThunkCoGetMalloc(DWORD dwMemContext, LPMALLOC * ppMalloc)
{
OLELOAD_M1(CoGetMalloc);
return _afxOLE.pfnCoGetMalloc[1](dwMemContext, ppMalloc);
}
HRESULT STDAPICALLTYPE AfxThunkStgIsStorageILockBytes(LPLOCKBYTES plkbyt)
{
OLELOAD_M1(StgIsStorageILockBytes);
return _afxOLE.pfnStgIsStorageILockBytes[1](plkbyt);
}
AFX_DATADEF AFX_OLE_CALL _afxOLE =
{
// OLE32.DLL entry points
{ AfxThunkReadFmtUserTypeStg, },
{ AfxThunkReadClassStg, },
{ AfxThunkCreateFileMoniker, },
{ AfxThunkStgIsStorageFile, },
{ AfxThunkStgOpenStorage, },
{ AfxThunkDoDragDrop, },
{ AfxThunkCoLockObjectExternal, },
{ AfxThunkRegisterDragDrop, },
{ AfxThunkOleRegGetUserType, },
{ AfxThunkStgCreateDocfile, },
{ AfxThunkRevokeDragDrop, },
{ AfxThunkCoRegisterClassObject, },
{ AfxThunkCoRevokeClassObject, },
{ AfxThunkOleTranslateAccelerator, },
{ AfxThunkIsAccelerator, },
{ AfxThunkOleCreateMenuDescriptor, },
{ AfxThunkOleDestroyMenuDescriptor, },
{ AfxThunkGetRunningObjectTable, },
{ AfxThunkWriteClassStg, },
{ AfxThunkOleQueryLinkFromData, },
{ AfxThunkCoRegisterMessageFilter, },
{ AfxThunkCoCreateInstance, },
{ AfxThunkCreateBindCtx, },
{ AfxThunkStringFromCLSID, },
{ AfxThunkCoDisconnectObject, },
{ AfxThunkOleRegEnumVerbs, },
{ AfxThunkOleUninitialize, },
{ AfxThunkCreateOleAdviseHolder, },
{ AfxThunkCreateDataAdviseHolder, },
{ AfxThunkOleGetAutoConvert, },
{ AfxThunkCoGetClassObject, },
{ AfxThunkOleCreateDefaultHandler, },
{ AfxThunkCreateDataCache, },
{ AfxThunkReadClassStm, },
{ AfxThunkOleLoadFromStream, },
{ AfxThunkStringFromGUID2, },
{ AfxThunkCoUninitialize, },
{ AfxThunkCoInitialize, },
{ AfxThunkOleInitialize, },
{ AfxThunkCoFreeUnusedLibraries, },
{ AfxThunkOleCreateFromData, },
{ AfxThunkOleSetContainedObject, },
{ AfxThunkOleLockRunning, },
{ AfxThunkCoTaskMemAlloc, },
{ AfxThunkCLSIDFromString, },
{ AfxThunkCLSIDFromProgID, },
{ AfxThunkOleIsCurrentClipboard, },
{ AfxThunkOleFlushClipboard, },
{ AfxThunkOleSetClipboard, },
{ AfxThunkOleIsRunning, },
{ AfxThunkOleRun, },
{ AfxThunkOleGetClipboard, },
{ AfxThunkCoTreatAsClass, },
{ AfxThunkOleQueryCreateFromData, },
{ AfxThunkOleSetMenuDescriptor, },
{ AfxThunkCreateItemMoniker, },
{ AfxThunkCreateGenericComposite, },
{ AfxThunkCreateStreamOnHGlobal, },
{ AfxThunkOleSaveToStream, },
{ AfxThunkWriteClassStm, },
{ AfxThunkCoTaskMemFree, },
{ AfxThunkOleGetIconOfClass, },
{ AfxThunkReleaseStgMedium, },
{ AfxThunkGetHGlobalFromILockBytes, },
{ AfxThunkStgOpenStorageOnILockBytes, },
{ AfxThunkCreateILockBytesOnHGlobal, },
{ AfxThunkStgCreateDocfileOnILockBytes, },
{ AfxThunkOleSave, },
{ AfxThunkOleLoad, },
{ AfxThunkOleCreate, },
{ AfxThunkOleCreateLinkToFile, },
{ AfxThunkOleCreateFromFile, },
{ AfxThunkOleCreateStaticFromData, },
{ AfxThunkOleCreateLinkFromData, },
{ AfxThunkSetConvertStg, },
{ AfxThunkOleDuplicateData, },
{ AfxThunkWriteFmtUserTypeStg, },
{ AfxThunkOleRegGetMiscStatus, },
{ AfxThunkCoGetMalloc, },
{ AfxThunkStgIsStorageILockBytes, },
// OLEAUT32.DLL entry points
{ AfxThunkSysFreeString, },
{ AfxThunkSysAllocStringByteLen, },
{ AfxThunkVariantCopy, },
{ AfxThunkVariantClear, },
{ AfxThunkVariantChangeType, },
{ AfxThunkSysAllocStringLen, },
{ AfxThunkSysStringLen, },
{ AfxThunkSysReAllocStringLen, },
{ AfxThunkSysAllocString, },
{ AfxThunkSysStringByteLen, },
{ AfxThunkVarCyFromStr, },
{ AfxThunkVarBstrFromCy, },
{ AfxThunkVarDateFromStr, },
{ AfxThunkVarBstrFromDate, },
{ AfxThunkLoadTypeLib, },
{ AfxThunkRegisterTypeLib, },
{ AfxThunkDosDateTimeToVariantTime, },
{ AfxThunkSafeArrayCreate, },
{ AfxThunkSafeArrayRedim, },
{ AfxThunkSafeArrayAccessData, },
{ AfxThunkSafeArrayUnaccessData, },
{ AfxThunkSafeArrayGetUBound, },
{ AfxThunkSafeArrayGetLBound, },
{ AfxThunkSafeArrayGetElemsize, },
{ AfxThunkSafeArrayGetDim, },
// OLEDLG.DLL entry points
{ AfxThunkOleUIAddVerbMenu, },
{ AfxThunkOleUIBusy, },
{ AfxThunkOleUIChangeIcon, },
{ AfxThunkOleUIChangeSource, },
{ AfxThunkOleUIConvert, },
{ AfxThunkOleUIEditLinks, },
{ AfxThunkOleUIInsertObject, },
{ AfxThunkOleUIObjectProperties, },
{ AfxThunkOleUIPasteSpecial, },
{ AfxThunkOleUIUpdateLinks, },
// Special Mac registry entry points
#ifdef _MAC
{ AfxThunkRegCloseKey, },
{ AfxThunkRegOpenKey, },
{ AfxThunkRegSetValue, },
{ AfxThunkRegQueryValue, },
#endif
};
#endif // _AFXDLL
/////////////////////////////////////////////////////////////////////////////
// _AFX_OLE_STATE implementation
_AFX_OLE_STATE::_AFX_OLE_STATE()
{
// Note: it is only necessary to intialize non-zero data.
#ifdef _AFXDLL
m_mapExtraData.InitHashTable(67, FALSE);
#endif
}
_AFX_OLE_STATE::~_AFX_OLE_STATE()
{
// AfxOleTerm should have already been called by now!
ASSERT(!m_bNeedTerm);
// unload OLE DLLs if loaded
#ifdef _AFXDLL
if (m_hInstOLEDLG != NULL)
FreeLibrary(m_hInstOLEDLG);
if (m_hInstOLEAUT != NULL)
FreeLibrary(m_hInstOLEAUT);
if (m_hInstOLE != NULL)
FreeLibrary(m_hInstOLE);
#ifdef _MAC
if (m_hInstWLMOLE != NULL)
FreeLibrary(m_hInstWLMOLE);
#endif //_MAC
#endif //_AFXDLL
}
#pragma warning(disable: 4074)
#pragma init_seg(lib)
PROCESS_LOCAL(_AFX_OLE_STATE, _afxOleState)
/////////////////////////////////////////////////////////////////////////////