home *** CD-ROM | disk | FTP | other *** search
/ Supercompiler 1997 / SUPERCOMPILER97.iso / MS_VC.50 / VC / MFC / SRC / OLEDATA.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  1996-12-03  |  40.6 KB  |  1,339 lines
  1. // This is a part of the Microsoft Foundation Classes C++ library.
  2. // Copyright (C) 1992-1997 Microsoft Corporation
  3. // All rights reserved.
  4. //
  5. // This source code is only intended as a supplement to the
  6. // Microsoft Foundation Classes Reference and related
  7. // electronic documentation provided with the library.
  8. // See these sources for detailed information regarding the
  9. // Microsoft Foundation Classes product.
  10.  
  11. #include "stdafx.h"
  12.  
  13. #ifdef CoRegisterClassObject
  14. #undef CoRegisterClassObject
  15. #endif
  16.  
  17. #ifdef AFX_INIT_SEG
  18. #pragma code_seg(AFX_INIT_SEG)
  19. #endif
  20.  
  21. #ifdef _AFXDLL
  22.  
  23. #ifndef _MAC
  24. /////////////////////////////////////////////////////////////////////////////
  25. // Win32 function loader helpers
  26.  
  27. // inline functions for loading the DLLs
  28. inline HINSTANCE AfxLoadOle(FARPROC* proc, LPCSTR lpsz)
  29.     { return AfxLoadDll(&_afxOleState->m_hInstOLE, "OLE32.DLL", proc, lpsz); }
  30. inline HINSTANCE AfxLoadOleAut(FARPROC* proc, LPCSTR lpsz)
  31.     { return AfxLoadDll(&_afxOleState->m_hInstOLEAUT, "OLEAUT32.DLL", proc, lpsz); }
  32. inline HINSTANCE AfxLoadOleDlg(FARPROC* proc, LPCSTR lpsz)
  33.     { return AfxLoadDll(&_afxOleState->m_hInstOLEDLG, "OLEDLG.DLL", proc, lpsz); }
  34.  
  35. #ifndef _MAC
  36. inline HINSTANCE AfxLoadUrlMon(FARPROC* proc, LPCSTR lpsz)
  37.     { return AfxLoadDll(&_afxOleState->m_hInstUrlMon, "URLMON.DLL", proc, lpsz); }
  38. #define URLMONLOAD(x) AfxLoadUrlMon((FARPROC*)&_afxUrlMon.pfn##x, #x);
  39. #endif
  40.  
  41. // non-mapped ole loading macros
  42. #define OLELOAD(x) \
  43.     AfxLoadOle((FARPROC*)&_afxOLE.pfn##x, #x)
  44. #define OLEAUTLOAD(x) \
  45.     AfxLoadOleAut((FARPROC*)&_afxOLE.pfn##x, #x)
  46. #ifdef _UNICODE
  47. #define OLEDLGLOADT(x) \
  48.     AfxLoadOleDlg((FARPROC*)&_afxOLE.pfn##x, #x "W")
  49. #else
  50. #define OLEDLGLOADT(x) \
  51.     AfxLoadOleDlg((FARPROC*)&_afxOLE.pfn##x, #x "A")
  52. #endif
  53. #define OLEDLGLOAD(x) \
  54.     AfxLoadOleDlg((FARPROC*)&_afxOLE.pfn##x, #x)
  55.  
  56. // mapped (for mac) do not need special mapping on Win32 platforms
  57. #define OLELOAD_M_COM(x) \
  58.     AfxLoadOle((FARPROC*)&_afxOLE.pfn##x, #x)
  59. #define OLELOAD_M_COMI(x) \
  60.     AfxLoadOle((FARPROC*)&_afxOLE.pfn##x, #x)
  61. #define OLELOAD_M_DEF(x)\
  62.     AfxLoadOle((FARPROC*)&_afxOLE.pfn##x, #x)
  63. #define OLELOAD_M_DF(x) \
  64.     AfxLoadOle((FARPROC*)&_afxOLE.pfn##x, #x)
  65. #define OLELOAD_M_MFCONV(x) \
  66.     AfxLoadOle((FARPROC*)&_afxOLE.pfn##x, #x)
  67. #define OLELOAD_M_WLM1(x) \
  68.     AfxLoadOle((FARPROC*)&_afxOLE.pfn##x, #x)
  69. #define OLELOAD_M_WLM2(x) \
  70.     AfxLoadOle((FARPROC*)&_afxOLE.pfn##x, #x)
  71.  
  72. #define OLEAUTLOAD_M1(x) \
  73.     AfxLoadOleAut((FARPROC*)&_afxOLE.pfn##x, #x)
  74.  
  75. #else //_MAC
  76. /////////////////////////////////////////////////////////////////////////////
  77. // _MAC function loader helpers
  78.  
  79. // inline functions for loading the DLLs
  80. #ifndef NEWOLE
  81. #error Mac MFC now requires the new ole dlls
  82. #endif
  83.  
  84. // docfile, comi, com, metafile conversion, and def handler
  85. // dlls comprise Mac OLE
  86. static char *rgszOleFrag[] = {"com", "comi", "def", "df", "mfconv", "DebugMicrosoftPortabilityLib"};
  87. #define iCom    0
  88. #define iComi   1
  89. #define iDef    2
  90. #define iDf     3
  91. #define iMfconv 4
  92. #define iWlm    5
  93.  
  94. #define iFragLast iWlm
  95. #if iFragLast + 1 != iMaxOleFrag
  96. #error AFX_OLE_STATE.m_rghInstOLE array size wrong
  97. #endif
  98.  
  99. inline HINSTANCE AfxLoadOle(FARPROC* proc, LPCSTR lpsz, int iFrag)
  100.     { return AfxLoadDll(&_afxOleState->m_rghInstOLE[iFrag], rgszOleFrag[iFrag], proc, lpsz); }
  101.  
  102. inline HINSTANCE AfxLoadOleAut(FARPROC* proc, LPCSTR lpsz)
  103.     { return AfxLoadDll(&_afxOleState->m_hInstOLEAUT, "MicrosoftOLE2AutomationLib", proc, lpsz); }
  104. inline HINSTANCE AfxLoadOleDlg(FARPROC* proc, LPCSTR lpsz)
  105. #ifdef _DEBUG
  106.     { return AfxLoadDll(&_afxOleState->m_hInstOLEDLG, "DebugMicrosoftOLEUIPortabilityLib", proc, lpsz); }
  107. #else
  108.     { return AfxLoadDll(&_afxOleState->m_hInstOLEDLG, "MicrosoftOLEUIPortabilityLib", proc, lpsz); }
  109. #endif
  110.  
  111. // non-mapped ole loading macros
  112. #define OLELOAD(x) \
  113.     AfxLoadOle((FARPROC*)&_afxOLE.pfn##x, #x)
  114. #define OLEAUTLOAD(x) \
  115.     AfxLoadOleAut((FARPROC*)&_afxOLE.pfn##x, #x)
  116. #define OLEDLGLOADT(x) \
  117.     AfxLoadOleDlg((FARPROC*)&_afxOLE.pfn##x, #x)
  118.  
  119. // mapped (for mac) do not need special mapping on Win32 platforms
  120.  
  121. #define OLELOAD_M_COM(x) \
  122.     AfxLoadOle((FARPROC*)&_afxOLE.pfn##x, #x, iCom)
  123. #define OLELOAD_M_COMI(x) \
  124.     AfxLoadOle((FARPROC*)&_afxOLE.pfn##x, #x, iComi)
  125. #define REGLOAD_M(x) \
  126.     AfxLoadOle((FARPROC*)&_afxOLE.pfn##x, #x, iComi)
  127. #define OLELOAD_M_DEF(x)\
  128.     AfxLoadOle((FARPROC*)&_afxOLE.pfn##x, #x, iDef)
  129. #define OLELOAD_M_DF(x) \
  130.     AfxLoadOle((FARPROC*)&_afxOLE.pfn##x, #x, iDf)
  131. #define OLELOAD_M_MFCONV(x) \
  132.     AfxLoadOle((FARPROC*)&_afxOLE.pfn##x, #x, iMfconv)
  133. // REVIEW: opt: eliminate OLELOAD_M_WLM thunks if these functions stay in WLM
  134. #define OLELOAD_M_WLM1(x) \
  135.     AfxLoadOle((FARPROC*)&_afxOLE.pfn##x, "WlmOle2" #x, iWlm)
  136. #define OLELOAD_M_WLM2(x) \
  137.     AfxLoadOle((FARPROC*)&_afxOLE.pfn##x, #x, iWlm)
  138.  
  139. #define OLEAUTLOAD_M1(x) \
  140.     AfxLoadOleAut((FARPROC*)&_afxOLE.pfn##x, #x)
  141.  
  142. #endif //_MAC
  143.  
  144. ///////////////////////////////////////////////////////////////////////////////
  145. // OLEAUT32
  146.  
  147. void STDAPICALLTYPE AfxThunkSysFreeString(BSTR bstr)
  148. {
  149.     OLEAUTLOAD(SysFreeString);
  150.     _afxOLE.pfnSysFreeString(bstr);
  151. }
  152.  
  153. #if !defined(_MAC)
  154. // Mac maps SysStringByteLen to SysStringLen
  155. BSTR STDAPICALLTYPE AfxThunkSysAllocStringByteLen(const char FAR* psz, unsigned int len)
  156. {
  157.     OLEAUTLOAD(SysAllocStringByteLen);
  158.     return _afxOLE.pfnSysAllocStringByteLen(psz, len);
  159. }
  160. #endif // !_MAC
  161.  
  162. HRESULT STDAPICALLTYPE AfxThunkVariantCopy(VARIANTARG FAR* pvargDest, VARIANTARG FAR* pvargSrc)
  163. {
  164.     OLEAUTLOAD(VariantCopy);
  165.     return _afxOLE.pfnVariantCopy(pvargDest, pvargSrc);
  166. }
  167.  
  168. HRESULT STDAPICALLTYPE AfxThunkVariantClear(VARIANTARG FAR* pvarg)
  169. {
  170.     OLEAUTLOAD(VariantClear);
  171.     return _afxOLE.pfnVariantClear(pvarg);
  172. }
  173.  
  174. HRESULT STDAPICALLTYPE AfxThunkVariantChangeType(VARIANTARG FAR* pvargDest, VARIANTARG FAR* pvarSrc, unsigned short wFlags, VARTYPE vt)
  175. {
  176.     OLEAUTLOAD(VariantChangeType);
  177.     return _afxOLE.pfnVariantChangeType(pvargDest, pvarSrc, wFlags, vt);
  178. }
  179.  
  180. BSTR STDAPICALLTYPE AfxThunkSysAllocStringLen(const OLECHAR FAR* psz, unsigned int len)
  181. {
  182.     OLEAUTLOAD(SysAllocStringLen);
  183.     return _afxOLE.pfnSysAllocStringLen(psz, len);
  184. }
  185.  
  186. unsigned int STDAPICALLTYPE AfxThunkSysStringLen(BSTR bstr)
  187. {
  188.     OLEAUTLOAD(SysStringLen);
  189.     return _afxOLE.pfnSysStringLen(bstr);
  190. }
  191.  
  192. int STDAPICALLTYPE AfxThunkSysReAllocStringLen(BSTR FAR* pbstr, const OLECHAR FAR* psz, unsigned int len)
  193. {
  194.     OLEAUTLOAD(SysReAllocStringLen);
  195.     return _afxOLE.pfnSysReAllocStringLen(pbstr, psz, len);
  196. }
  197.  
  198. BSTR STDAPICALLTYPE AfxThunkSysAllocString(const OLECHAR FAR* psz)
  199. {
  200.     OLEAUTLOAD(SysAllocString);
  201.     return _afxOLE.pfnSysAllocString(psz);
  202. }
  203.  
  204. #if !defined(_MAC)
  205. // Mac maps SysStringByteLen to SysStringLen
  206. unsigned int STDAPICALLTYPE AfxThunkSysStringByteLen(BSTR bstr)
  207. {
  208.     OLEAUTLOAD(SysStringByteLen);
  209.     return _afxOLE.pfnSysStringByteLen(bstr);
  210. }
  211. #endif // !_MAC
  212.  
  213. HRESULT STDAPICALLTYPE AfxThunkVarCyFromStr(OLECHAR FAR* strIn, LCID lcid, unsigned long dwFlags, CY FAR* pcyOut)
  214. {
  215.     OLEAUTLOAD(VarCyFromStr);
  216.     return _afxOLE.pfnVarCyFromStr(strIn, lcid, dwFlags, pcyOut);
  217. }
  218.  
  219. HRESULT STDAPICALLTYPE AfxThunkVarBstrFromCy(CY cyIn, LCID lcid, unsigned long dwFlags, BSTR FAR* pbstrOut)
  220. {
  221.     OLEAUTLOAD(VarBstrFromCy);
  222.     return _afxOLE.pfnVarBstrFromCy(cyIn, lcid, dwFlags, pbstrOut);
  223. }
  224.  
  225. HRESULT STDAPICALLTYPE AfxThunkVarDateFromStr(OLECHAR FAR* strIn, LCID lcid, unsigned long dwFlags, DATE FAR* pdateOut)
  226. {
  227.     OLEAUTLOAD(VarDateFromStr);
  228.     return _afxOLE.pfnVarDateFromStr(strIn, lcid, dwFlags, pdateOut);
  229. }
  230.  
  231. HRESULT STDAPICALLTYPE AfxThunkVarBstrFromDate(DATE dateIn, LCID lcid, unsigned long dwFlags, BSTR FAR* pbstrOut)
  232. {
  233.     OLEAUTLOAD(VarBstrFromDate);
  234.     return _afxOLE.pfnVarBstrFromDate(dateIn, lcid, dwFlags, pbstrOut);
  235. }
  236.  
  237. HRESULT STDAPICALLTYPE AfxThunkLoadTypeLib(const OLECHAR FAR *szFile, ITypeLib FAR* FAR* pptlib)
  238. {
  239.     OLEAUTLOAD_M1(LoadTypeLib);
  240.     return _afxOLE.pfnLoadTypeLib(szFile, pptlib);
  241. }
  242.  
  243. HRESULT STDAPICALLTYPE AfxThunkLoadRegTypeLib(REFGUID guid, WORD wVerMajor, WORD wVerMinor, LCID lcid, ITypeLib FAR* FAR* pptlib)
  244. {
  245.     OLEAUTLOAD_M1(LoadRegTypeLib);
  246.     return _afxOLE.pfnLoadRegTypeLib(guid, wVerMajor, wVerMinor, lcid, pptlib);
  247. }
  248.  
  249. HRESULT STDAPICALLTYPE AfxThunkRegisterTypeLib(ITypeLib FAR* ptlib, OLECHAR FAR *szFullPath, OLECHAR FAR *szHelpDir)
  250. {
  251.     OLEAUTLOAD(RegisterTypeLib);
  252.     return _afxOLE.pfnRegisterTypeLib(ptlib, szFullPath, szHelpDir);
  253. }
  254.  
  255. int STDAPICALLTYPE AfxThunkDosDateTimeToVariantTime(unsigned short wDosDate, unsigned short wDosTime, double FAR* pvtime)
  256. {
  257.     OLEAUTLOAD(DosDateTimeToVariantTime);
  258.     return _afxOLE.pfnDosDateTimeToVariantTime(wDosDate, wDosTime, pvtime);
  259. }
  260.  
  261. SAFEARRAY FAR* STDAPICALLTYPE AfxThunkSafeArrayCreate(VARTYPE vt, unsigned int cDims, SAFEARRAYBOUND FAR* rgsabound)
  262. {
  263.     OLEAUTLOAD(SafeArrayCreate);
  264.     return _afxOLE.pfnSafeArrayCreate(vt, cDims, rgsabound);
  265. }
  266.  
  267. HRESULT STDAPICALLTYPE AfxThunkSafeArrayRedim(SAFEARRAY FAR* psa, SAFEARRAYBOUND FAR* psaboundNew)
  268. {
  269.     OLEAUTLOAD(SafeArrayRedim);
  270.     return _afxOLE.pfnSafeArrayRedim(psa, psaboundNew);
  271. }
  272.  
  273. HRESULT STDAPICALLTYPE AfxThunkSafeArrayAccessData(SAFEARRAY FAR* psa, void HUGEP* FAR* ppvData)
  274. {
  275.     OLEAUTLOAD(SafeArrayAccessData);
  276.     return _afxOLE.pfnSafeArrayAccessData(psa, ppvData);
  277. }
  278.  
  279. HRESULT STDAPICALLTYPE AfxThunkSafeArrayUnaccessData(SAFEARRAY FAR* psa)
  280. {
  281.     OLEAUTLOAD(SafeArrayUnaccessData);
  282.     return _afxOLE.pfnSafeArrayUnaccessData(psa);
  283. }
  284.  
  285. HRESULT STDAPICALLTYPE AfxThunkSafeArrayGetUBound(SAFEARRAY FAR* psa, unsigned int nDim, long FAR* plUbound)
  286. {
  287.     OLEAUTLOAD(SafeArrayGetUBound);
  288.     return _afxOLE.pfnSafeArrayGetUBound(psa, nDim, plUbound);
  289. }
  290.  
  291. HRESULT STDAPICALLTYPE AfxThunkSafeArrayGetLBound(SAFEARRAY FAR* psa, unsigned int nDim, long FAR* plLbound)
  292. {
  293.     OLEAUTLOAD(SafeArrayGetLBound);
  294.     return _afxOLE.pfnSafeArrayGetLBound(psa, nDim, plLbound);
  295. }
  296.  
  297. unsigned int STDAPICALLTYPE AfxThunkSafeArrayGetElemsize(SAFEARRAY FAR* psa)
  298. {
  299.     OLEAUTLOAD(SafeArrayGetElemsize);
  300.     return _afxOLE.pfnSafeArrayGetElemsize(psa);
  301. }
  302.  
  303. unsigned int STDAPICALLTYPE AfxThunkSafeArrayGetDim(SAFEARRAY FAR* psa)
  304. {
  305.     OLEAUTLOAD(SafeArrayGetDim);
  306.     return _afxOLE.pfnSafeArrayGetDim(psa);
  307. }
  308.  
  309. HRESULT STDAPICALLTYPE AfxThunkSafeArrayCopy(SAFEARRAY FAR* psa,
  310.     SAFEARRAY FAR* FAR* ppsaOut)
  311. {
  312.     OLEAUTLOAD(SafeArrayCopy);
  313.     return _afxOLE.pfnSafeArrayCopy(psa, ppsaOut);
  314. }
  315.  
  316. HRESULT STDAPICALLTYPE AfxThunkSafeArrayAllocData(SAFEARRAY FAR* psa)
  317. {
  318.     OLEAUTLOAD(SafeArrayAllocData);
  319.     return _afxOLE.pfnSafeArrayAllocData(psa);
  320. }
  321.  
  322. HRESULT STDAPICALLTYPE AfxThunkSafeArrayAllocDescriptor(unsigned int cDims,
  323.     SAFEARRAY FAR* FAR* ppsaOut)
  324. {
  325.     OLEAUTLOAD(SafeArrayAllocDescriptor);
  326.     return _afxOLE.pfnSafeArrayAllocDescriptor(cDims, ppsaOut);
  327. }
  328.  
  329. HRESULT STDAPICALLTYPE AfxThunkSafeArrayGetElement(SAFEARRAY FAR* psa,
  330.     long FAR* rgIndices, void FAR* pvData)
  331. {
  332.     OLEAUTLOAD(SafeArrayGetElement);
  333.     return _afxOLE.pfnSafeArrayGetElement(psa, rgIndices, pvData);
  334. }
  335.  
  336. HRESULT STDAPICALLTYPE AfxThunkSafeArrayPutElement(SAFEARRAY FAR* psa,
  337.     long FAR* rgIndices, void FAR* pvData)
  338. {
  339.     OLEAUTLOAD(SafeArrayPutElement);
  340.     return _afxOLE.pfnSafeArrayPutElement(psa, rgIndices, pvData);
  341. }
  342.  
  343. HRESULT STDAPICALLTYPE AfxThunkSafeArrayLock(SAFEARRAY FAR* psa)
  344. {
  345.     OLEAUTLOAD(SafeArrayLock);
  346.     return _afxOLE.pfnSafeArrayLock(psa);
  347. }
  348.  
  349. HRESULT STDAPICALLTYPE AfxThunkSafeArrayUnlock(SAFEARRAY FAR* psa)
  350. {
  351.     OLEAUTLOAD(SafeArrayUnlock);
  352.     return _afxOLE.pfnSafeArrayUnlock(psa);
  353. }
  354.  
  355. HRESULT STDAPICALLTYPE AfxThunkSafeArrayDestroy(SAFEARRAY FAR* psa)
  356. {
  357.     OLEAUTLOAD(SafeArrayDestroy);
  358.     return _afxOLE.pfnSafeArrayDestroy(psa);
  359. }
  360.  
  361. HRESULT STDAPICALLTYPE AfxThunkSafeArrayDestroyData(SAFEARRAY FAR* psa)
  362. {
  363.     OLEAUTLOAD(SafeArrayDestroyData);
  364.     return _afxOLE.pfnSafeArrayDestroyData(psa);
  365. }
  366.  
  367. HRESULT STDAPICALLTYPE AfxThunkSafeArrayDestroyDescriptor(SAFEARRAY FAR* psa)
  368. {
  369.     OLEAUTLOAD(SafeArrayDestroyDescriptor);
  370.     return _afxOLE.pfnSafeArrayDestroyDescriptor(psa);
  371. }
  372.  
  373. HRESULT STDAPICALLTYPE AfxThunkSafeArrayPtrOfIndex(SAFEARRAY FAR* psa,
  374.     long FAR* rgIndices, void HUGEP* FAR* ppvData)
  375. {
  376.     OLEAUTLOAD(SafeArrayPtrOfIndex);
  377.     return _afxOLE.pfnSafeArrayPtrOfIndex(psa, rgIndices, ppvData);
  378. }
  379.  
  380. #if defined(_MAC) && defined(MACOCX)
  381. HRESULT STDAPICALLTYPE AfxThunkLoadTypeLibFSp(const void *pfsspec,
  382.     ITypeLib FAR* FAR* pptlib)
  383. {
  384.     OLEAUTLOAD(LoadTypeLibFSp);
  385.     return _afxOLE.pfnLoadTypeLibFSp(pfsspec, pptlib);
  386. }
  387.  
  388. HRESULT STDAPICALLTYPE AfxThunkRegisterTypeLibFolder(OLECHAR FAR* szFullPath)
  389. {
  390.     OLEAUTLOAD(RegisterTypeLibFolder);
  391.     return _afxOLE.pfnRegisterTypeLibFolder(szFullPath);
  392. }
  393.  
  394. HRESULT STDAPICALLTYPE AfxThunkQueryTypeLibFolder(LPBSTR pbstr)
  395. {
  396.     OLEAUTLOAD(QueryTypeLibFolder);
  397.     return _afxOLE.pfnQueryTypeLibFolder(pbstr);
  398. }
  399.  
  400. LCID WINAPI AfxThunkGetUserDefaultLCID(void)
  401. {
  402.     OLEAUTLOAD(GetUserDefaultLCID);
  403.     return _afxOLE.pfnGetUserDefaultLCID();
  404. }
  405. #endif //_MAC && MACOCX
  406.  
  407. ///////////////////////////////////////////////////////////////////////////////
  408. // OLEDLG
  409.  
  410. BOOL STDAPICALLTYPE AfxThunkOleUIAddVerbMenu(LPOLEOBJECT lpOleObj, LPCTSTR lpszShortType, HMENU hMenu, UINT uPos, UINT uIDVerbMin, UINT uIDVerbMax, BOOL bAddConvert, UINT idConvert, HMENU FAR *lphMenu)
  411. {
  412.     OLEDLGLOADT(OleUIAddVerbMenu);
  413.     return _afxOLE.pfnOleUIAddVerbMenu(lpOleObj, lpszShortType, hMenu, uPos, uIDVerbMin, uIDVerbMax, bAddConvert, idConvert, lphMenu);
  414. }
  415.  
  416. UINT STDAPICALLTYPE AfxThunkOleUIBusy(LPOLEUIBUSY lp)
  417. {
  418.     OLEDLGLOADT(OleUIBusy);
  419.     return _afxOLE.pfnOleUIBusy(lp);
  420. }
  421.  
  422. UINT STDAPICALLTYPE AfxThunkOleUIChangeIcon(LPOLEUICHANGEICON lp)
  423. {
  424.     OLEDLGLOADT(OleUIChangeIcon);
  425.     return _afxOLE.pfnOleUIChangeIcon(lp);
  426. }
  427.  
  428. UINT STDAPICALLTYPE AfxThunkOleUIChangeSource(LPOLEUICHANGESOURCE lp)
  429. {
  430.     OLEDLGLOADT(OleUIChangeSource);
  431.     return _afxOLE.pfnOleUIChangeSource(lp);
  432. }
  433.  
  434. UINT STDAPICALLTYPE AfxThunkOleUIConvert(LPOLEUICONVERT lp)
  435. {
  436.     OLEDLGLOADT(OleUIConvert);
  437.     return _afxOLE.pfnOleUIConvert(lp);
  438. }
  439.  
  440. UINT STDAPICALLTYPE AfxThunkOleUIEditLinks(LPOLEUIEDITLINKS lp)
  441. {
  442.     OLEDLGLOADT(OleUIEditLinks);
  443.     return _afxOLE.pfnOleUIEditLinks(lp);
  444. }
  445.  
  446. UINT STDAPICALLTYPE AfxThunkOleUIInsertObject(LPOLEUIINSERTOBJECT lp)
  447. {
  448.     OLEDLGLOADT(OleUIInsertObject);
  449.     return _afxOLE.pfnOleUIInsertObject(lp);
  450. }
  451.  
  452. UINT STDAPICALLTYPE AfxThunkOleUIObjectProperties(LPOLEUIOBJECTPROPS lp)
  453. {
  454.     OLEDLGLOADT(OleUIObjectProperties);
  455.     return _afxOLE.pfnOleUIObjectProperties(lp);
  456. }
  457.  
  458. UINT STDAPICALLTYPE AfxThunkOleUIPasteSpecial(LPOLEUIPASTESPECIAL lp)
  459. {
  460.     OLEDLGLOADT(OleUIPasteSpecial);
  461.     return _afxOLE.pfnOleUIPasteSpecial(lp);
  462. }
  463.  
  464. BOOL STDAPICALLTYPE AfxThunkOleUIUpdateLinks(LPOLEUILINKCONTAINER lpOleUILinkCntr, HWND hwndParent, LPTSTR lpszTitle, int cLinks)
  465. {
  466.     OLEDLGLOADT(OleUIUpdateLinks);
  467.     return _afxOLE.pfnOleUIUpdateLinks(lpOleUILinkCntr, hwndParent, lpszTitle, cLinks);
  468. }
  469.  
  470. /////////////////////////////////////////////////////////////////////////////
  471. // Special Mac registry APIs
  472.  
  473. #ifdef _MAC
  474.  
  475. LONG APIENTRY AfxThunkRegCloseKey(HKEY hKey)
  476. {
  477.     REGLOAD_M(RegCloseKey);
  478.     return _afxOLE.pfnRegCloseKey(hKey);
  479. }
  480.  
  481. LONG APIENTRY AfxThunkRegOpenKey(HKEY hKey, LPCSTR lpSubKey, PHKEY phkResult)
  482. {
  483.     REGLOAD_M(RegOpenKey);
  484.     return _afxOLE.pfnRegOpenKey(hKey, lpSubKey, phkResult);
  485. }
  486.  
  487. LONG APIENTRY AfxThunkRegSetValue(HKEY hKey, LPCSTR lpSubKey, DWORD dwType,
  488.     LPCSTR lpData, DWORD cbData)
  489. {
  490.     REGLOAD_M(RegSetValue);
  491.     return _afxOLE.pfnRegSetValue(hKey, lpSubKey, dwType, lpData, cbData);
  492. }
  493.  
  494. LONG APIENTRY AfxThunkRegSetValueEx(HKEY hKey, LPCTSTR lpValueName, DWORD Reserved, DWORD dwType, CONST BYTE* lpData, DWORD cbData)
  495. {
  496.     REGLOAD_M(RegSetValueEx);
  497.     return _afxOLE.pfnRegSetValueEx(hKey, lpValueName, Reserved, dwType,
  498.         lpData, cbData);
  499. }
  500.  
  501. LONG APIENTRY AfxThunkRegQueryValue(HKEY hKey, LPCSTR lpSubKey, LPSTR lpValue,
  502.     PLONG lpcbValue)
  503. {
  504.     REGLOAD_M(RegQueryValue);
  505.     return _afxOLE.pfnRegQueryValue(hKey, lpSubKey, lpValue, lpcbValue);
  506. }
  507.  
  508. LONG APIENTRY AfxThunkRegQueryValueEx(HKEY hKey, LPCTSTR lpValueName, LPDWORD lpReserved, LPDWORD lpType, LPBYTE lpData, LPDWORD lpcbData)
  509. {
  510.     REGLOAD_M(RegQueryValueEx);
  511.     return _afxOLE.pfnRegQueryValueEx(hKey, lpValueName, lpReserved,
  512.         lpType, lpData, lpcbData);
  513. }
  514.  
  515. LONG APIENTRY AfxThunkRegEnumKey(HKEY hKey, DWORD dwIndex, LPTSTR lpName, DWORD cbName)
  516. {
  517.     REGLOAD_M(RegEnumKey);
  518.     return _afxOLE.pfnRegEnumKey(hKey, dwIndex, lpName, cbName);
  519. }
  520.  
  521. LONG APIENTRY AfxThunkRegDeleteKey(HKEY hKey, LPCTSTR lpSubKey)
  522. {
  523.     REGLOAD_M(RegDeleteKey);
  524.     return _afxOLE.pfnRegDeleteKey(hKey, lpSubKey);
  525. }
  526.  
  527. LONG APIENTRY AfxThunkRegDeleteValue(HKEY hKey, LPCTSTR lpValueName)
  528. {
  529.     REGLOAD_M(RegDeleteValue);
  530.     return _afxOLE.pfnRegDeleteValue(hKey, lpValueName);
  531. }
  532.  
  533. LONG APIENTRY AfxThunkRegCreateKey(HKEY hKey, LPCTSTR lpSubKey, PHKEY phkResult)
  534. {
  535.     REGLOAD_M(RegCreateKey);
  536.     return _afxOLE.pfnRegCreateKey(hKey, lpSubKey, phkResult);
  537. }
  538.  
  539.  
  540. #endif //_MAC
  541.  
  542. ///////////////////////////////////////////////////////////////////////////////
  543. // OLE32
  544.  
  545. HRESULT STDAPICALLTYPE AfxThunkReadFmtUserTypeStg(LPSTORAGE pstg, CLIPFORMAT FAR* pcf, LPOLESTR FAR* lplpszUserType)
  546. {
  547.     OLELOAD_M_WLM1(ReadFmtUserTypeStg);
  548.     return _afxOLE.pfnReadFmtUserTypeStg(pstg, pcf, lplpszUserType);
  549. }
  550.  
  551. HRESULT STDAPICALLTYPE AfxThunkReadClassStg(LPSTORAGE pStg, CLSID FAR* pclsid)
  552. {
  553. //  iwo (in wlm ole)
  554.     OLELOAD_M_DEF(ReadClassStg);
  555.     return _afxOLE.pfnReadClassStg(pStg, pclsid);
  556. }
  557.  
  558. HRESULT STDAPICALLTYPE AfxThunkCreateFileMoniker(LPCOLESTR lpszPathName, LPMONIKER FAR* ppmk)
  559. {
  560. //  iwo
  561.     OLELOAD_M_DEF(CreateFileMoniker);
  562.     return _afxOLE.pfnCreateFileMoniker(lpszPathName, ppmk);
  563. }
  564.  
  565. HRESULT STDAPICALLTYPE AfxThunkStgIsStorageFile(const OLECHAR * pwcsName)
  566. {
  567.     OLELOAD_M_WLM1(StgIsStorageFile);
  568.     return _afxOLE.pfnStgIsStorageFile(pwcsName);
  569. }
  570.  
  571. HRESULT STDAPICALLTYPE AfxThunkStgOpenStorage(const OLECHAR * pwcsName, IStorage *pstgPriority, DWORD grfMode, SNB snbExclude, DWORD reserved, IStorage ** ppstgOpen)
  572. {
  573.     OLELOAD_M_WLM1(StgOpenStorage);
  574.     return _afxOLE.pfnStgOpenStorage(pwcsName, pstgPriority, grfMode, snbExclude, reserved, ppstgOpen);
  575. }
  576.  
  577. HRESULT STDAPICALLTYPE AfxThunkDoDragDrop(LPDATAOBJECT pDataObj, LPDROPSOURCE pDropSource, DWORD dwOKEffects, LPDWORD pdwEffect)
  578. {
  579. //  iwo
  580.     OLELOAD_M_DEF(DoDragDrop);
  581.     return _afxOLE.pfnDoDragDrop(pDataObj, pDropSource, dwOKEffects, pdwEffect);
  582. }
  583.  
  584. HRESULT STDAPICALLTYPE AfxThunkCoLockObjectExternal(LPUNKNOWN pUnk, BOOL fLock, BOOL fLastUnlockReleases)
  585. {
  586. //  iwo
  587.     OLELOAD_M_COM(CoLockObjectExternal);
  588.     return _afxOLE.pfnCoLockObjectExternal(pUnk, fLock, fLastUnlockReleases);
  589. }
  590.  
  591. HRESULT STDAPICALLTYPE AfxThunkRegisterDragDrop(HWND hwnd, LPDROPTARGET pDropTarget)
  592. {
  593.     OLELOAD_M_WLM1(RegisterDragDrop);
  594.     return _afxOLE.pfnRegisterDragDrop(hwnd, pDropTarget);
  595. }
  596.  
  597. HRESULT STDAPICALLTYPE AfxThunkOleRegGetUserType (REFCLSID clsid, DWORD dwFormOfType, LPOLESTR * pszUserType)
  598. {
  599. //  OLELOAD(OleRegGetUserType);
  600.     OLELOAD_M_DEF(OleRegGetUserType);
  601.     return _afxOLE.pfnOleRegGetUserType(clsid, dwFormOfType, pszUserType);
  602. }
  603.  
  604. HRESULT STDAPICALLTYPE AfxThunkStgCreateDocfile(const OLECHAR * pwcsName, DWORD grfMode, DWORD reserved, IStorage** ppstgOpen)
  605. {
  606.     OLELOAD_M_WLM1(StgCreateDocfile);
  607.     return _afxOLE.pfnStgCreateDocfile(pwcsName, grfMode, reserved, ppstgOpen);
  608. }
  609.  
  610. HRESULT STDAPICALLTYPE AfxThunkRevokeDragDrop(HWND hwnd)
  611. {
  612.     OLELOAD_M_WLM1(RevokeDragDrop);
  613.     return _afxOLE.pfnRevokeDragDrop(hwnd);
  614. }
  615.  
  616. HRESULT STDAPICALLTYPE AfxThunkCoRegisterClassObject(REFCLSID rclsid, LPUNKNOWN pUnk, DWORD dwClsContext, DWORD flags, LPDWORD lpdwRegister)
  617. {
  618. //  iwo
  619.     OLELOAD_M_COM(CoRegisterClassObject);
  620.     return _afxOLE.pfnCoRegisterClassObject(rclsid, pUnk, dwClsContext, flags, lpdwRegister);
  621. }
  622.  
  623. HRESULT STDAPICALLTYPE AfxThunkCoRevokeClassObject(DWORD dwRegister)
  624. {
  625. //  iwo
  626.     OLELOAD_M_COM(CoRevokeClassObject);
  627.     return _afxOLE.pfnCoRevokeClassObject(dwRegister);
  628. }
  629.  
  630. HRESULT STDAPICALLTYPE AfxThunkOleTranslateAccelerator(LPOLEINPLACEFRAME lpFrame, LPOLEINPLACEFRAMEINFO lpFrameInfo, LPMSG lpmsg)
  631. {
  632.     OLELOAD_M_WLM1(OleTranslateAccelerator);
  633.     return _afxOLE.pfnOleTranslateAccelerator(lpFrame, lpFrameInfo, lpmsg);
  634. }
  635.  
  636. BOOL STDAPICALLTYPE AfxThunkIsAccelerator(HACCEL hAccel, INT cAccelEntries, LPMSG lpMsg, WORD* lpwCmd)
  637. {
  638.     OLELOAD_M_WLM1(IsAccelerator);
  639.     return _afxOLE.pfnIsAccelerator(hAccel, cAccelEntries, lpMsg, lpwCmd);
  640. }
  641.  
  642. HOLEMENU STDAPICALLTYPE AfxThunkOleCreateMenuDescriptor(HMENU hmenuCombined, LPOLEMENUGROUPWIDTHS lpMenuWidths)
  643. {
  644. //  notmapped (in wlm ole but name not mapped)
  645.     OLELOAD_M_WLM2(OleCreateMenuDescriptor);
  646.     return _afxOLE.pfnOleCreateMenuDescriptor(hmenuCombined, lpMenuWidths);
  647. }
  648.  
  649. HRESULT STDAPICALLTYPE AfxThunkOleDestroyMenuDescriptor(HOLEMENU holemenu)
  650. {
  651. //  notmapped
  652.     OLELOAD_M_WLM2(OleDestroyMenuDescriptor);
  653.     return _afxOLE.pfnOleDestroyMenuDescriptor(holemenu);
  654. }
  655.  
  656. HRESULT STDAPICALLTYPE AfxThunkGetRunningObjectTable(DWORD reserved, LPRUNNINGOBJECTTABLE FAR* pprot)
  657. {
  658. //  iwo
  659.     OLELOAD_M_DEF(GetRunningObjectTable);
  660.     return _afxOLE.pfnGetRunningObjectTable(reserved, pprot);
  661. }
  662.  
  663. HRESULT STDAPICALLTYPE AfxThunkWriteClassStg(LPSTORAGE pStg, REFCLSID rclsid)
  664. {
  665. //  iwo
  666.     OLELOAD_M_DEF(WriteClassStg);
  667.     return _afxOLE.pfnWriteClassStg(pStg, rclsid);
  668. }
  669.  
  670. HRESULT STDAPICALLTYPE AfxThunkOleQueryLinkFromData(LPDATAOBJECT pSrcDataObject)
  671. {
  672. //  iwo
  673.     OLELOAD_M_DEF(OleQueryLinkFromData);
  674.     return _afxOLE.pfnOleQueryLinkFromData(pSrcDataObject);
  675. }
  676.  
  677. HRESULT STDAPICALLTYPE AfxThunkCoRegisterMessageFilter(LPMESSAGEFILTER lpMessageFilter, LPMESSAGEFILTER * lplpMessageFilter)
  678. {
  679. //  iwo
  680.     OLELOAD_M_COM(CoRegisterMessageFilter);
  681.     return _afxOLE.pfnCoRegisterMessageFilter(lpMessageFilter, lplpMessageFilter);
  682. }
  683.  
  684. HRESULT STDAPICALLTYPE AfxThunkCoCreateInstance(REFCLSID rclsid, LPUNKNOWN * pUnkOuter, DWORD dwClsContext, REFIID riid, LPVOID* ppv)
  685. {
  686. //  iwo
  687.     OLELOAD_M_COM(CoCreateInstance);
  688.     return _afxOLE.pfnCoCreateInstance(rclsid, pUnkOuter, dwClsContext, riid, ppv);
  689. }
  690.  
  691. HRESULT STDAPICALLTYPE AfxThunkCreateBindCtx(DWORD reserved, LPBC FAR* ppbc)
  692. {
  693. //  iwo
  694.     OLELOAD_M_DEF(CreateBindCtx);
  695.     return _afxOLE.pfnCreateBindCtx(reserved, ppbc);
  696. }
  697.  
  698. HRESULT STDAPICALLTYPE AfxThunkStringFromCLSID(REFCLSID rclsid, LPOLESTR FAR* lplpsz)
  699. {
  700. //  OLELOAD(StringFromCLSID);
  701.     OLELOAD_M_COMI(StringFromCLSID);
  702.     return _afxOLE.pfnStringFromCLSID(rclsid, lplpsz);
  703. }
  704.  
  705. HRESULT STDAPICALLTYPE AfxThunkCoDisconnectObject(LPUNKNOWN pUnk, DWORD dwReserved)
  706. {
  707. //  iwo
  708.     OLELOAD_M_COM(CoDisconnectObject);
  709.     return _afxOLE.pfnCoDisconnectObject(pUnk, dwReserved);
  710. }
  711.  
  712. HRESULT STDAPICALLTYPE AfxThunkOleRegEnumVerbs (REFCLSID clsid, LPENUMOLEVERB FAR* ppenum)
  713. {
  714. //  iwo
  715.     OLELOAD_M_DEF(OleRegEnumVerbs);
  716.     return _afxOLE.pfnOleRegEnumVerbs(clsid, ppenum);
  717. }
  718.  
  719. void STDAPICALLTYPE AfxThunkOleUninitialize(void)
  720. {
  721.     OLELOAD_M_WLM1(OleUninitialize);
  722.     _afxOLE.pfnOleUninitialize();
  723. }
  724.  
  725. HRESULT STDAPICALLTYPE AfxThunkCreateOleAdviseHolder(LPOLEADVISEHOLDER FAR* ppOAHolder)
  726. {
  727. //  iwo
  728.     OLELOAD_M_COMI(CreateOleAdviseHolder);
  729.     return _afxOLE.pfnCreateOleAdviseHolder(ppOAHolder);
  730. }
  731.  
  732. HRESULT STDAPICALLTYPE AfxThunkCreateDataAdviseHolder(LPDATAADVISEHOLDER FAR* ppDAHolder)
  733. {
  734.     OLELOAD_M_WLM1(CreateDataAdviseHolder);
  735.     return _afxOLE.pfnCreateDataAdviseHolder(ppDAHolder);
  736. }
  737.  
  738. HRESULT STDAPICALLTYPE AfxThunkOleGetAutoConvert(REFCLSID clsidOld, LPCLSID pClsidNew)
  739. {
  740. //  OLELOAD(OleGetAutoConvert);
  741.     OLELOAD_M_DEF(OleGetAutoConvert);
  742.     return _afxOLE.pfnOleGetAutoConvert(clsidOld, pClsidNew);
  743. }
  744.  
  745. HRESULT STDAPICALLTYPE AfxThunkCoGetClassObject(REFCLSID rclsid, DWORD dwClsContext, LPVOID pvReserved, REFIID riid, LPVOID* ppv)
  746. {
  747. //  iwo
  748.     OLELOAD_M_COMI(CoGetClassObject);
  749.     return _afxOLE.pfnCoGetClassObject(rclsid, dwClsContext, pvReserved, riid, ppv);
  750. }
  751.  
  752. HRESULT STDAPICALLTYPE AfxThunkOleCreateDefaultHandler(REFCLSID clsid, LPUNKNOWN pUnkOuter, REFIID riid, LPVOID* lplpvObj)
  753. {
  754. //  iwo
  755.     OLELOAD_M_DEF(OleCreateDefaultHandler);
  756.     return _afxOLE.pfnOleCreateDefaultHandler(clsid, pUnkOuter, riid, lplpvObj);
  757. }
  758.  
  759. HRESULT STDAPICALLTYPE AfxThunkCreateDataCache(LPUNKNOWN pUnkOuter, REFCLSID clsid, REFIID riid, LPVOID* lplpvObj)
  760. {
  761. // BUG! wlm ole doesn't wrap CreateDataCache
  762. //  OLELOAD(CreateDataCache);
  763.     OLELOAD_M_DEF(CreateDataCache);
  764.     return _afxOLE.pfnCreateDataCache(pUnkOuter, clsid, riid, lplpvObj);
  765. }
  766.  
  767. HRESULT STDAPICALLTYPE AfxThunkReadClassStm(LPSTREAM pStm, CLSID FAR* pclsid)
  768. {
  769. //  iwo
  770.     OLELOAD_M_DEF(ReadClassStm);
  771.     return _afxOLE.pfnReadClassStm(pStm, pclsid);
  772. }
  773.  
  774. HRESULT STDAPICALLTYPE AfxThunkOleLoadFromStream(LPSTREAM pStm, REFIID iidInterface, LPVOID FAR* ppvObj)
  775. {
  776. //  iwo
  777.     OLELOAD_M_DEF(OleLoadFromStream);
  778.     return _afxOLE.pfnOleLoadFromStream(pStm, iidInterface, ppvObj);
  779. }
  780.  
  781. int STDAPICALLTYPE AfxThunkStringFromGUID2(REFGUID rguid, LPOLESTR lpsz, int cbMax)
  782. {
  783. //  OLELOAD(StringFromGUID2);
  784.     OLELOAD_M_COMI(StringFromGUID2);
  785.     return _afxOLE.pfnStringFromGUID2(rguid, lpsz, cbMax);
  786. }
  787.  
  788. void STDAPICALLTYPE AfxThunkCoUninitialize(void)
  789. {
  790.     OLELOAD_M_WLM1(CoUninitialize);
  791.     _afxOLE.pfnCoUninitialize();
  792. }
  793.  
  794. HRESULT STDAPICALLTYPE AfxThunkCoInitialize(LPVOID pvReserved)
  795. {
  796.     OLELOAD_M_WLM1(CoInitialize);
  797.     return _afxOLE.pfnCoInitialize(pvReserved);
  798. }
  799.  
  800. HRESULT STDAPICALLTYPE AfxThunkOleInitialize(LPVOID pvReserved)
  801. {
  802.     OLELOAD_M_WLM1(OleInitialize);
  803.     return _afxOLE.pfnOleInitialize(pvReserved);
  804. }
  805.  
  806. void STDAPICALLTYPE AfxThunkCoFreeUnusedLibraries(void)
  807. {
  808. //  OLELOAD(CoFreeUnusedLibraries);
  809.     OLELOAD_M_COMI(CoFreeUnusedLibraries);
  810.     _afxOLE.pfnCoFreeUnusedLibraries();
  811. }
  812.  
  813. HRESULT STDAPICALLTYPE AfxThunkOleCreateFromData(LPDATAOBJECT pSrcDataObj, REFIID riid, DWORD renderopt, LPFORMATETC pFormatEtc, LPOLECLIENTSITE pClientSite, LPSTORAGE pStg, LPVOID* ppvObj)
  814. {
  815.     OLELOAD_M_WLM1(OleCreateFromData);
  816.     return _afxOLE.pfnOleCreateFromData(pSrcDataObj, riid, renderopt, pFormatEtc, pClientSite, pStg, ppvObj);
  817. }
  818.  
  819. HRESULT STDAPICALLTYPE AfxThunkOleSetContainedObject(LPUNKNOWN pUnknown, BOOL fContained)
  820. {
  821. //  iwo
  822.     OLELOAD_M_DEF(OleSetContainedObject);
  823.     return _afxOLE.pfnOleSetContainedObject(pUnknown, fContained);
  824. }
  825.  
  826. HRESULT STDAPICALLTYPE AfxThunkOleLockRunning(LPUNKNOWN pUnknown, BOOL fLock, BOOL fLastUnlockCloses)
  827. {
  828. //  iwo
  829.     OLELOAD_M_DEF(OleLockRunning);
  830.     return _afxOLE.pfnOleLockRunning(pUnknown, fLock, fLastUnlockCloses);
  831. }
  832.  
  833. LPVOID STDAPICALLTYPE AfxThunkCoTaskMemAlloc(ULONG cb)
  834. {
  835. //  iwo
  836.     OLELOAD_M_COMI(CoTaskMemAlloc);
  837.     return _afxOLE.pfnCoTaskMemAlloc(cb);
  838. }
  839.  
  840. HRESULT STDAPICALLTYPE AfxThunkCLSIDFromString(LPOLESTR lpsz, LPCLSID pclsid)
  841. {
  842. //  OLELOAD(CLSIDFromString);
  843.     OLELOAD_M_COMI(CLSIDFromString);
  844.     return _afxOLE.pfnCLSIDFromString(lpsz, pclsid);
  845. }
  846.  
  847. HRESULT STDAPICALLTYPE AfxThunkCLSIDFromProgID (LPCOLESTR lpszProgID, LPCLSID lpclsid)
  848. {
  849. //  OLELOAD(CLSIDFromProgID);
  850.     OLELOAD_M_COM(CLSIDFromProgID);
  851.     return _afxOLE.pfnCLSIDFromProgID(lpszProgID, lpclsid);
  852. }
  853.  
  854. HRESULT STDAPICALLTYPE AfxThunkOleIsCurrentClipboard(LPDATAOBJECT pDataObj)
  855. {
  856. //  iwo
  857.     OLELOAD_M_DEF(OleIsCurrentClipboard);
  858.     return _afxOLE.pfnOleIsCurrentClipboard(pDataObj);
  859. }
  860.  
  861. HRESULT STDAPICALLTYPE AfxThunkOleFlushClipboard(void)
  862. {
  863. //  iwo
  864.     OLELOAD_M_DEF(OleFlushClipboard);
  865.     return _afxOLE.pfnOleFlushClipboard();
  866. }
  867.  
  868. HRESULT STDAPICALLTYPE AfxThunkOleSetClipboard(LPDATAOBJECT pDataObj)
  869. {
  870. //  iwo
  871.     OLELOAD_M_DEF(OleSetClipboard);
  872.     return _afxOLE.pfnOleSetClipboard(pDataObj);
  873. }
  874.  
  875. BOOL STDAPICALLTYPE AfxThunkOleIsRunning(LPOLEOBJECT pObject)
  876. {
  877. //  iwo
  878.     OLELOAD_M_DEF(OleIsRunning);
  879.     return _afxOLE.pfnOleIsRunning(pObject);
  880. }
  881.  
  882. HRESULT STDAPICALLTYPE AfxThunkOleRun(LPUNKNOWN pUnknown)
  883. {
  884. //  iwo
  885.     OLELOAD_M_DEF(OleRun);
  886.     return _afxOLE.pfnOleRun(pUnknown);
  887. }
  888.  
  889. HRESULT STDAPICALLTYPE AfxThunkOleGetClipboard(LPDATAOBJECT FAR* ppDataObj)
  890. {
  891. //  iwo
  892.     OLELOAD_M_DEF(OleGetClipboard);
  893.     return _afxOLE.pfnOleGetClipboard(ppDataObj);
  894. }
  895.  
  896. HRESULT STDAPICALLTYPE AfxThunkCoTreatAsClass(REFCLSID clsidOld, REFCLSID clsidNew)
  897. {
  898. //  OLELOAD(CoTreatAsClass);
  899.     OLELOAD_M_COMI(CoTreatAsClass);
  900.     return _afxOLE.pfnCoTreatAsClass(clsidOld, clsidNew);
  901. }
  902.  
  903. HRESULT STDAPICALLTYPE AfxThunkOleQueryCreateFromData(LPDATAOBJECT pSrcDataObject)
  904. {
  905. //  iwo
  906.     OLELOAD_M_DEF(OleQueryCreateFromData);
  907.     return _afxOLE.pfnOleQueryCreateFromData(pSrcDataObject);
  908. }
  909.  
  910. HRESULT STDAPICALLTYPE AfxThunkOleSetMenuDescriptor (HOLEMENU holemenu, HWND hwndFrame, HWND hwndActiveObject, LPOLEINPLACEFRAME lpFrame, LPOLEINPLACEACTIVEOBJECT lpActiveObj)
  911. {
  912. //  notmapped
  913.     OLELOAD_M_WLM2(OleSetMenuDescriptor);
  914.     return _afxOLE.pfnOleSetMenuDescriptor(holemenu, hwndFrame, hwndActiveObject, lpFrame, lpActiveObj);
  915. }
  916.  
  917. HRESULT STDAPICALLTYPE AfxThunkCreateItemMoniker(LPCOLESTR lpszDelim, LPCOLESTR lpszItem, LPMONIKER* ppmk)
  918. {
  919. //  iwo
  920.     OLELOAD_M_DEF(CreateItemMoniker);
  921.     return _afxOLE.pfnCreateItemMoniker(lpszDelim, lpszItem, ppmk);
  922. }
  923.  
  924. HRESULT STDAPICALLTYPE AfxThunkCreateGenericComposite(LPMONIKER pmkFirst, LPMONIKER pmkRest, LPMONIKER* ppmkComposite)
  925. {
  926. //  iwo
  927.     OLELOAD_M_DEF(CreateGenericComposite);
  928.     return _afxOLE.pfnCreateGenericComposite(pmkFirst, pmkRest, ppmkComposite);
  929. }
  930.  
  931. HRESULT STDAPICALLTYPE AfxThunkCreateStreamOnHGlobal(HGLOBAL hGlobal, BOOL fDeleteOnRelease, LPSTREAM* ppstm)
  932. {
  933. //  iwo
  934.     OLELOAD_M_WLM1(CreateStreamOnHGlobal);
  935.     return _afxOLE.pfnCreateStreamOnHGlobal(hGlobal, fDeleteOnRelease, ppstm);
  936. }
  937.  
  938. HRESULT STDAPICALLTYPE AfxThunkOleSaveToStream(LPPERSISTSTREAM pPStm, LPSTREAM pStm)
  939. {
  940. //  iwo
  941.     OLELOAD_M_DEF(OleSaveToStream);
  942.     return _afxOLE.pfnOleSaveToStream(pPStm, pStm);
  943. }
  944.  
  945. HRESULT STDAPICALLTYPE AfxThunkWriteClassStm(LPSTREAM pStm, REFCLSID rclsid)
  946. {
  947. //  iwo
  948.     OLELOAD_M_DEF(WriteClassStm);
  949.     return _afxOLE.pfnWriteClassStm(pStm, rclsid);
  950. }
  951.  
  952. void STDAPICALLTYPE AfxThunkCoTaskMemFree(LPVOID pv)
  953. {
  954. //  iwo
  955.     OLELOAD_M_COMI(CoTaskMemFree);
  956.     _afxOLE.pfnCoTaskMemFree(pv);
  957. }
  958.  
  959. HGLOBAL STDAPICALLTYPE AfxThunkOleGetIconOfClass(REFCLSID rclsid, LPOLESTR lpszLabel, BOOL fUseTypeAsLabel)
  960. {
  961.     OLELOAD_M_WLM1(OleGetIconOfClass);
  962.     return _afxOLE.pfnOleGetIconOfClass(rclsid, lpszLabel, fUseTypeAsLabel);
  963. }
  964.  
  965. void STDAPICALLTYPE AfxThunkReleaseStgMedium(LPSTGMEDIUM lp)
  966. {
  967.     OLELOAD_M_WLM1(ReleaseStgMedium);
  968.     _afxOLE.pfnReleaseStgMedium(lp);
  969. }
  970.  
  971. HRESULT STDAPICALLTYPE AfxThunkGetHGlobalFromILockBytes (LPLOCKBYTES plkbyt, HGLOBAL FAR* phglobal)
  972. {
  973.     OLELOAD_M_WLM1(GetHGlobalFromILockBytes);
  974.     return _afxOLE.pfnGetHGlobalFromILockBytes(plkbyt, phglobal);
  975. }
  976.  
  977. HRESULT STDAPICALLTYPE AfxThunkStgOpenStorageOnILockBytes(LPLOCKBYTES plkbyt, LPSTORAGE pstgPriority, DWORD grfMode, SNB snbExclude, DWORD reserved, LPSTORAGE* ppstgOpen)
  978. {
  979. //  iwo
  980. // REVIEW: M_WLM?
  981.     OLELOAD_M_DF(StgOpenStorageOnILockBytes);
  982.     return _afxOLE.pfnStgOpenStorageOnILockBytes(plkbyt, pstgPriority, grfMode, snbExclude, reserved, ppstgOpen);
  983. }
  984.  
  985. HRESULT STDAPICALLTYPE AfxThunkCreateILockBytesOnHGlobal(HGLOBAL hGlobal, BOOL fDeleteOnRelease, LPLOCKBYTES* pplkbyt)
  986. {
  987.     OLELOAD_M_WLM1(CreateILockBytesOnHGlobal);
  988.     return _afxOLE.pfnCreateILockBytesOnHGlobal(hGlobal, fDeleteOnRelease, pplkbyt);
  989. }
  990.  
  991. HRESULT STDAPICALLTYPE AfxThunkStgCreateDocfileOnILockBytes(LPLOCKBYTES plkbyt, DWORD grfMode, DWORD reserved, LPSTORAGE* ppstgOpen)
  992. {
  993. //  iwo
  994. // REVIEW: M_WLM?
  995.     OLELOAD_M_DF(StgCreateDocfileOnILockBytes);
  996.     return _afxOLE.pfnStgCreateDocfileOnILockBytes(plkbyt, grfMode, reserved, ppstgOpen);
  997. }
  998.  
  999. HRESULT STDAPICALLTYPE AfxThunkOleSave(LPPERSISTSTORAGE pPS, LPSTORAGE pStg, BOOL fSameAsLoad)
  1000. {
  1001. //  iwo
  1002.     OLELOAD_M_DEF(OleSave);
  1003.     return _afxOLE.pfnOleSave(pPS, pStg, fSameAsLoad);
  1004. }
  1005.  
  1006. HRESULT STDAPICALLTYPE AfxThunkOleLoad(LPSTORAGE pStg, REFIID riid, LPOLECLIENTSITE pClientSite, LPVOID* ppvObj)
  1007. {
  1008. //  iwo
  1009.     OLELOAD_M_DEF(OleLoad);
  1010.     return _afxOLE.pfnOleLoad(pStg, riid, pClientSite, ppvObj);
  1011. }
  1012.  
  1013. HRESULT STDAPICALLTYPE AfxThunkOleCreate(REFCLSID rclsid, REFIID riid, DWORD renderopt, LPFORMATETC pFormatEtc, LPOLECLIENTSITE pClientSite, LPSTORAGE pStg, LPVOID* ppvObj)
  1014. {
  1015.     OLELOAD_M_WLM1(OleCreate);
  1016.     return _afxOLE.pfnOleCreate(rclsid, riid, renderopt, pFormatEtc, pClientSite, pStg, ppvObj);
  1017. }
  1018.  
  1019. HRESULT STDAPICALLTYPE AfxThunkOleCreateLinkToFile(LPCOLESTR lpszFileName, REFIID riid, DWORD renderopt, LPFORMATETC lpFormatEtc, LPOLECLIENTSITE pClientSite, LPSTORAGE pStg, LPVOID* ppvObj)
  1020. {
  1021.     OLELOAD_M_WLM1(OleCreateLinkToFile);
  1022.     return _afxOLE.pfnOleCreateLinkToFile(lpszFileName, riid, renderopt, lpFormatEtc, pClientSite, pStg, ppvObj);
  1023. }
  1024.  
  1025. HRESULT STDAPICALLTYPE AfxThunkOleCreateFromFile(REFCLSID rclsid, LPCOLESTR lpszFileName, REFIID riid, DWORD renderopt, LPFORMATETC pFormatEtc, LPOLECLIENTSITE pClientSite, LPSTORAGE pStg, LPVOID* ppvObj)
  1026. {
  1027.     OLELOAD_M_WLM1(OleCreateFromFile);
  1028.     return _afxOLE.pfnOleCreateFromFile(rclsid, lpszFileName, riid, renderopt, pFormatEtc, pClientSite, pStg, ppvObj);
  1029. }
  1030.  
  1031. HRESULT STDAPICALLTYPE AfxThunkOleCreateStaticFromData(LPDATAOBJECT pSrcDataObj, REFIID riid, DWORD renderopt, LPFORMATETC pFormatEtc, LPOLECLIENTSITE pClientSite, LPSTORAGE pStg, LPVOID* ppvObj)
  1032. {
  1033.     OLELOAD_M_WLM1(OleCreateStaticFromData);
  1034.     return _afxOLE.pfnOleCreateStaticFromData(pSrcDataObj, riid, renderopt, pFormatEtc, pClientSite, pStg, ppvObj);
  1035. }
  1036.  
  1037. HRESULT STDAPICALLTYPE AfxThunkOleCreateLinkFromData(LPDATAOBJECT pSrcDataObj, REFIID riid, DWORD renderopt, LPFORMATETC pFormatEtc, LPOLECLIENTSITE pClientSite, LPSTORAGE pStg, LPVOID* ppvObj)
  1038. {
  1039.     OLELOAD_M_WLM1(OleCreateLinkFromData);
  1040.     return _afxOLE.pfnOleCreateLinkFromData(pSrcDataObj, riid, renderopt, pFormatEtc, pClientSite, pStg, ppvObj);
  1041. }
  1042.  
  1043. HRESULT STDAPICALLTYPE AfxThunkSetConvertStg(LPSTORAGE pStg, BOOL fConvert)
  1044. {
  1045. //  iwo
  1046.     OLELOAD_M_DEF(SetConvertStg);
  1047.     return _afxOLE.pfnSetConvertStg(pStg, fConvert);
  1048. }
  1049.  
  1050. HANDLE STDAPICALLTYPE AfxThunkOleDuplicateData(HANDLE hSrc, CLIPFORMAT cfFormat, UINT uiFlags)
  1051. {
  1052.     OLELOAD_M_WLM1(OleDuplicateData);
  1053.     return _afxOLE.pfnOleDuplicateData(hSrc, cfFormat, uiFlags);
  1054. }
  1055.  
  1056. HRESULT STDAPICALLTYPE AfxThunkWriteFmtUserTypeStg (LPSTORAGE pstg, CLIPFORMAT cf, LPOLESTR lpszUserType)
  1057. {
  1058.     OLELOAD_M_WLM1(WriteFmtUserTypeStg);
  1059.     return _afxOLE.pfnWriteFmtUserTypeStg(pstg, cf, lpszUserType);
  1060. }
  1061.  
  1062. HRESULT STDAPICALLTYPE AfxThunkOleRegGetMiscStatus(REFCLSID clsid, DWORD dwAspect, DWORD* pdwStatus)
  1063. {
  1064. //  OLELOAD(OleRegGetMiscStatus);
  1065.     OLELOAD_M_DEF(OleRegGetMiscStatus);
  1066.     return _afxOLE.pfnOleRegGetMiscStatus(clsid, dwAspect, pdwStatus);
  1067. }
  1068.  
  1069. HRESULT STDAPICALLTYPE AfxThunkCoGetMalloc(DWORD dwMemContext, LPMALLOC * ppMalloc)
  1070. {
  1071. //  iwo
  1072.     OLELOAD_M_COMI(CoGetMalloc);
  1073.     return _afxOLE.pfnCoGetMalloc(dwMemContext, ppMalloc);
  1074. }
  1075.  
  1076. HRESULT STDAPICALLTYPE AfxThunkStgIsStorageILockBytes(LPLOCKBYTES plkbyt)
  1077. {
  1078. //  iwo
  1079. // REVIEW: M_WLM?
  1080.     OLELOAD_M_DF(StgIsStorageILockBytes);
  1081.     return _afxOLE.pfnStgIsStorageILockBytes(plkbyt);
  1082. }
  1083.  
  1084.  
  1085. AFX_DATADEF AFX_OLE_CALL _afxOLE =
  1086. {
  1087.     // OLE32.DLL entry points
  1088.     AfxThunkReadFmtUserTypeStg,
  1089.     AfxThunkReadClassStg,
  1090.     AfxThunkCreateFileMoniker,
  1091.     AfxThunkStgIsStorageFile,
  1092.     AfxThunkStgOpenStorage,
  1093.     AfxThunkDoDragDrop,
  1094.     AfxThunkCoLockObjectExternal,
  1095.     AfxThunkRegisterDragDrop,
  1096.     AfxThunkOleRegGetUserType,
  1097.     AfxThunkStgCreateDocfile,
  1098.     AfxThunkRevokeDragDrop,
  1099.     AfxThunkCoRegisterClassObject,
  1100.     AfxThunkCoRevokeClassObject,
  1101.     AfxThunkOleTranslateAccelerator,
  1102.     AfxThunkIsAccelerator,
  1103.     AfxThunkOleCreateMenuDescriptor,
  1104.     AfxThunkOleDestroyMenuDescriptor,
  1105.     AfxThunkGetRunningObjectTable,
  1106.     AfxThunkWriteClassStg,
  1107.     AfxThunkOleQueryLinkFromData,
  1108.     AfxThunkCoRegisterMessageFilter,
  1109.     AfxThunkCoCreateInstance,
  1110.     AfxThunkCreateBindCtx,
  1111.     AfxThunkStringFromCLSID,
  1112.     AfxThunkCoDisconnectObject,
  1113.     AfxThunkOleRegEnumVerbs,
  1114.     AfxThunkOleUninitialize,
  1115.     AfxThunkCreateOleAdviseHolder,
  1116.     AfxThunkCreateDataAdviseHolder,
  1117.     AfxThunkOleGetAutoConvert,
  1118.     AfxThunkCoGetClassObject,
  1119.     AfxThunkOleCreateDefaultHandler,
  1120.     AfxThunkCreateDataCache,
  1121.     AfxThunkReadClassStm,
  1122.     AfxThunkOleLoadFromStream,
  1123.     AfxThunkStringFromGUID2,
  1124.     AfxThunkCoUninitialize,
  1125.     AfxThunkCoInitialize,
  1126.     AfxThunkOleInitialize,
  1127.     AfxThunkCoFreeUnusedLibraries,
  1128.     AfxThunkOleCreateFromData,
  1129.     AfxThunkOleSetContainedObject,
  1130.     AfxThunkOleLockRunning,
  1131.     AfxThunkCoTaskMemAlloc,
  1132.     AfxThunkCLSIDFromString,
  1133.     AfxThunkCLSIDFromProgID,
  1134.     AfxThunkOleIsCurrentClipboard,
  1135.     AfxThunkOleFlushClipboard,
  1136.     AfxThunkOleSetClipboard,
  1137.     AfxThunkOleIsRunning,
  1138.     AfxThunkOleRun,
  1139.     AfxThunkOleGetClipboard,
  1140.     AfxThunkCoTreatAsClass,
  1141.     AfxThunkOleQueryCreateFromData,
  1142.     AfxThunkOleSetMenuDescriptor,
  1143.     AfxThunkCreateItemMoniker,
  1144.     AfxThunkCreateGenericComposite,
  1145.     AfxThunkCreateStreamOnHGlobal,
  1146.     AfxThunkOleSaveToStream,
  1147.     AfxThunkWriteClassStm,
  1148.     AfxThunkCoTaskMemFree,
  1149.     AfxThunkOleGetIconOfClass,
  1150.     AfxThunkReleaseStgMedium,
  1151.     AfxThunkGetHGlobalFromILockBytes,
  1152.     AfxThunkStgOpenStorageOnILockBytes,
  1153.     AfxThunkCreateILockBytesOnHGlobal,
  1154.     AfxThunkStgCreateDocfileOnILockBytes,
  1155.     AfxThunkOleSave,
  1156.     AfxThunkOleLoad,
  1157.     AfxThunkOleCreate,
  1158.     AfxThunkOleCreateLinkToFile,
  1159.     AfxThunkOleCreateFromFile,
  1160.     AfxThunkOleCreateStaticFromData,
  1161.     AfxThunkOleCreateLinkFromData,
  1162.     AfxThunkSetConvertStg,
  1163.     AfxThunkOleDuplicateData,
  1164.     AfxThunkWriteFmtUserTypeStg,
  1165.     AfxThunkOleRegGetMiscStatus,
  1166.     AfxThunkCoGetMalloc,
  1167.     AfxThunkStgIsStorageILockBytes,
  1168.  
  1169.     // OLEAUT32.DLL entry points
  1170.     AfxThunkSysFreeString,
  1171. #if !defined(_MAC)
  1172.     AfxThunkSysAllocStringByteLen,
  1173. #endif
  1174.     AfxThunkVariantCopy,
  1175.     AfxThunkVariantClear,
  1176.     AfxThunkVariantChangeType,
  1177.     AfxThunkSysAllocStringLen,
  1178.     AfxThunkSysStringLen,
  1179.     AfxThunkSysReAllocStringLen,
  1180.     AfxThunkSysAllocString,
  1181. #if !defined(_MAC)
  1182.     AfxThunkSysStringByteLen,
  1183. #endif
  1184.     AfxThunkVarCyFromStr,
  1185.     AfxThunkVarBstrFromCy,
  1186.     AfxThunkVarDateFromStr,
  1187.     AfxThunkVarBstrFromDate,
  1188.     AfxThunkLoadTypeLib,
  1189.     AfxThunkLoadRegTypeLib,
  1190.     AfxThunkRegisterTypeLib,
  1191.     AfxThunkDosDateTimeToVariantTime,
  1192.     AfxThunkSafeArrayCreate,
  1193.     AfxThunkSafeArrayRedim,
  1194.     AfxThunkSafeArrayAccessData,
  1195.     AfxThunkSafeArrayUnaccessData,
  1196.     AfxThunkSafeArrayGetUBound,
  1197.     AfxThunkSafeArrayGetLBound,
  1198.     AfxThunkSafeArrayGetElemsize,
  1199.     AfxThunkSafeArrayGetDim,
  1200.     AfxThunkSafeArrayCopy,
  1201.     AfxThunkSafeArrayAllocData,
  1202.     AfxThunkSafeArrayAllocDescriptor,
  1203.     AfxThunkSafeArrayGetElement,
  1204.     AfxThunkSafeArrayPutElement,
  1205.     AfxThunkSafeArrayLock,
  1206.     AfxThunkSafeArrayUnlock,
  1207.     AfxThunkSafeArrayDestroy,
  1208.     AfxThunkSafeArrayDestroyData,
  1209.     AfxThunkSafeArrayDestroyDescriptor,
  1210.     AfxThunkSafeArrayPtrOfIndex,
  1211. #if defined(_MAC) && defined(MACOCX)
  1212.     AfxThunkLoadTypeLibFSp,
  1213.     AfxThunkRegisterTypeLibFolder,
  1214.     AfxThunkQueryTypeLibFolder,
  1215.     AfxThunkGetUserDefaultLCID,
  1216. #endif
  1217.  
  1218.     // OLEDLG.DLL entry points
  1219.     AfxThunkOleUIAddVerbMenu,
  1220.     AfxThunkOleUIBusy,
  1221.     AfxThunkOleUIChangeIcon,
  1222.     AfxThunkOleUIChangeSource,
  1223.     AfxThunkOleUIConvert,
  1224.     AfxThunkOleUIEditLinks,
  1225.     AfxThunkOleUIInsertObject,
  1226.     AfxThunkOleUIObjectProperties,
  1227.     AfxThunkOleUIPasteSpecial,
  1228.     AfxThunkOleUIUpdateLinks,
  1229.  
  1230.     // Special Mac registry entry points
  1231. #ifdef _MAC
  1232.     AfxThunkRegCloseKey,
  1233.     AfxThunkRegOpenKey,
  1234.     AfxThunkRegSetValue,
  1235.     AfxThunkRegSetValueEx,
  1236.     AfxThunkRegQueryValue,
  1237.     AfxThunkRegQueryValueEx,
  1238.     AfxThunkRegEnumKey,
  1239.     AfxThunkRegDeleteKey,
  1240.     AfxThunkRegDeleteValue,
  1241.     AfxThunkRegCreateKey
  1242. #endif
  1243. };
  1244.  
  1245. #ifndef _MAC
  1246. /////////////////////////////////////////////////////////////////////////////
  1247. // _AFX_URLMON_CALL
  1248.  
  1249. HRESULT STDAPICALLTYPE AfxThunkRegisterBindStatusCallback(LPBC pBC,
  1250.     IBindStatusCallback *pBSCb, IBindStatusCallback **pBSCbPrev, DWORD dwReserved)
  1251. {
  1252.     URLMONLOAD(RegisterBindStatusCallback);
  1253.     return _afxUrlMon.pfnRegisterBindStatusCallback(pBC, pBSCb, pBSCbPrev, dwReserved);
  1254. }
  1255.  
  1256. HRESULT STDAPICALLTYPE AfxThunkRevokeBindStatusCallback(LPBC pBC,
  1257.     IBindStatusCallback *pBSCb)
  1258. {
  1259.     URLMONLOAD(RevokeBindStatusCallback);
  1260.     return _afxUrlMon.pfnRevokeBindStatusCallback(pBC, pBSCb);
  1261. }
  1262.  
  1263. HRESULT STDAPICALLTYPE AfxThunkIsAsyncMoniker(IMoniker* pmk)
  1264. {
  1265.     URLMONLOAD(IsAsyncMoniker);
  1266.     return _afxUrlMon.pfnIsAsyncMoniker(pmk);
  1267. }
  1268.  
  1269. HRESULT STDAPICALLTYPE AfxThunkCreateURLMoniker(LPMONIKER pMkCtx, LPCWSTR szURL, LPMONIKER FAR * ppmk)
  1270. {
  1271.     URLMONLOAD(CreateURLMoniker);
  1272.     return _afxUrlMon.pfnCreateURLMoniker(pMkCtx, szURL, ppmk);
  1273. }
  1274.  
  1275. HRESULT STDAPICALLTYPE AfxThunkCreateAsyncBindCtx(DWORD dwReserved, IBindStatusCallback *pBSCb,
  1276.     IEnumFORMATETC *pEFetc, IBindCtx **ppBC)
  1277. {
  1278.     URLMONLOAD(CreateAsyncBindCtx);
  1279.     return _afxUrlMon.pfnCreateAsyncBindCtx(dwReserved, pBSCb, pEFetc, ppBC);
  1280. }
  1281.  
  1282. AFX_DATADEF AFX_URLMON_CALL _afxUrlMon =
  1283. {
  1284.     AfxThunkRegisterBindStatusCallback,
  1285.     AfxThunkRevokeBindStatusCallback,
  1286.     AfxThunkIsAsyncMoniker,
  1287.     AfxThunkCreateURLMoniker,
  1288.     AfxThunkCreateAsyncBindCtx,
  1289. };
  1290. #endif // !_MAC
  1291.  
  1292. #endif // _AFXDLL
  1293.  
  1294. /////////////////////////////////////////////////////////////////////////////
  1295. // _AFX_OLE_STATE implementation
  1296.  
  1297. _AFX_OLE_STATE::_AFX_OLE_STATE()
  1298. {
  1299.     // Note: it is only necessary to intialize non-zero data.
  1300. }
  1301.  
  1302. _AFX_OLE_STATE::~_AFX_OLE_STATE()
  1303. {
  1304.     // unload OLE DLLs if loaded
  1305. #ifdef _AFXDLL
  1306.     if (m_hInstOLEDLG != NULL)
  1307.         FreeLibrary(m_hInstOLEDLG);
  1308.     if (m_hInstOLEAUT != NULL)
  1309.         FreeLibrary(m_hInstOLEAUT);
  1310.  
  1311. #if defined(_MAC)
  1312.     for (int i = iMaxOleFrag; i >= 0; i--)
  1313.     {
  1314.         if (m_rghInstOLE[i] != NULL)
  1315.             FreeLibrary(m_rghInstOLE[i]);
  1316.     }
  1317. #else
  1318.     if (m_hInstOLE != NULL)
  1319.         FreeLibrary(m_hInstOLE);
  1320. #endif
  1321.  
  1322. #ifndef _MAC
  1323.     if (m_hInstUrlMon != NULL)
  1324.         ::FreeLibrary(m_hInstUrlMon);
  1325. #endif
  1326. #ifdef _MAC
  1327.     if (m_hInstWLMOLE != NULL)
  1328.         FreeLibrary(m_hInstWLMOLE);
  1329. #endif //_MAC
  1330. #endif //_AFXDLL
  1331. }
  1332.  
  1333. #pragma warning(disable: 4074)
  1334. #pragma init_seg(lib)
  1335.  
  1336. PROCESS_LOCAL(_AFX_OLE_STATE, _afxOleState)
  1337.  
  1338. /////////////////////////////////////////////////////////////////////////////
  1339.