home *** CD-ROM | disk | FTP | other *** search
/ Team Palmtops 7 / Palmtops_numero07.iso / WinCE / SDKWindowsCE / HandHeldPCPro30 / sdk.exe / Jupiter SDK / data1.cab / MFC / src / wceoleth.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1999-02-19  |  28.4 KB  |  877 lines
  1. // This is a part of the Microsoft Foundation Classes C++ library.
  2. // Copyright (C) 1992-1998 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. #if defined(_WIN32_WCE_NO_DELAYLOAD)
  13. #if !defined(_WIN32_WCE_NO_OLE_THUNKS)
  14.  
  15. inline HINSTANCE AfxLoadOle(FARPROC* proc, LPCSTR lpsz)
  16.     { return AfxLoadDll(&_afxOleState->m_hInstOLE, WCE_OLE32_DLL, proc, lpsz); }
  17. inline HINSTANCE AfxLoadOleAut(FARPROC* proc, LPCSTR lpsz)
  18.     { return AfxLoadDll(&_afxOleState->m_hInstOLEAUT, WCE_OLEAUT32_DLL, proc, lpsz); }
  19. #define OLELOAD(x) \
  20.     AfxLoadOle((FARPROC*)&_afxOLE.pfn##x, #x)
  21. #define OLELOAD_M_COM(x) \
  22.     AfxLoadOle((FARPROC*)&_afxOLE.pfn##x, #x)
  23. #define OLELOAD_M_COMI(x) \
  24.     AfxLoadOle((FARPROC*)&_afxOLE.pfn##x, #x)
  25. #define OLELOAD_M_DEF(x)\
  26.     AfxLoadOle((FARPROC*)&_afxOLE.pfn##x, #x)
  27. #define OLELOAD_M_DF(x) \
  28.     AfxLoadOle((FARPROC*)&_afxOLE.pfn##x, #x)
  29. #define OLELOAD_M_MFCONV(x) \
  30.     AfxLoadOle((FARPROC*)&_afxOLE.pfn##x, #x)
  31. #define OLELOAD_M_WLM1(x) \
  32.     AfxLoadOle((FARPROC*)&_afxOLE.pfn##x, #x)
  33. #define OLELOAD_M_WLM2(x) \
  34.     AfxLoadOle((FARPROC*)&_afxOLE.pfn##x, #x)
  35. #define OLEAUTLOAD(x) \
  36.     AfxLoadOleAut((FARPROC*)&_afxOLE.pfn##x, #x)
  37. #define OLEAUTLOAD_M1(x) \
  38.     AfxLoadOleAut((FARPROC*)&_afxOLE.pfn##x, #x)
  39.  
  40. void STDAPICALLTYPE AfxThunkSysFreeString(BSTR bstr)
  41. {
  42.     OLEAUTLOAD(SysFreeString);
  43.     _afxOLE.pfnSysFreeString(bstr);
  44. }
  45.  
  46. BSTR STDAPICALLTYPE AfxThunkSysAllocStringByteLen(const char FAR* psz, unsigned int len)
  47. {
  48.     OLEAUTLOAD(SysAllocStringByteLen);
  49.     return _afxOLE.pfnSysAllocStringByteLen(psz, len);
  50. }
  51.  
  52. HRESULT STDAPICALLTYPE AfxThunkVariantCopy(VARIANTARG FAR* pvargDest, VARIANTARG FAR* pvargSrc)
  53. {
  54.     OLEAUTLOAD(VariantCopy);
  55.     return _afxOLE.pfnVariantCopy(pvargDest, pvargSrc);
  56. }
  57.  
  58. HRESULT STDAPICALLTYPE AfxThunkVariantClear(VARIANTARG FAR* pvarg)
  59. {
  60.     OLEAUTLOAD(VariantClear);
  61.     return _afxOLE.pfnVariantClear(pvarg);
  62. }
  63.  
  64. HRESULT STDAPICALLTYPE AfxThunkVariantChangeType(VARIANTARG FAR* pvargDest, VARIANTARG FAR* pvarSrc, unsigned short wFlags, VARTYPE vt)
  65. {
  66.     OLEAUTLOAD(VariantChangeType);
  67.     return _afxOLE.pfnVariantChangeType(pvargDest, pvarSrc, wFlags, vt);
  68. }
  69.  
  70. BSTR STDAPICALLTYPE AfxThunkSysAllocStringLen(const OLECHAR FAR* psz, unsigned int len)
  71. {
  72.     OLEAUTLOAD(SysAllocStringLen);
  73.     return _afxOLE.pfnSysAllocStringLen(psz, len);
  74. }
  75.  
  76. unsigned int STDAPICALLTYPE AfxThunkSysStringLen(BSTR bstr)
  77. {
  78.     OLEAUTLOAD(SysStringLen);
  79.     return _afxOLE.pfnSysStringLen(bstr);
  80. }
  81.  
  82. int STDAPICALLTYPE AfxThunkSysReAllocStringLen(BSTR FAR* pbstr, const OLECHAR FAR* psz, unsigned int len)
  83. {
  84.     OLEAUTLOAD(SysReAllocStringLen);
  85.     return _afxOLE.pfnSysReAllocStringLen(pbstr, psz, len);
  86. }
  87.  
  88. BSTR STDAPICALLTYPE AfxThunkSysAllocString(const OLECHAR FAR* psz)
  89. {
  90.     OLEAUTLOAD(SysAllocString);
  91.     return _afxOLE.pfnSysAllocString(psz);
  92. }
  93.  
  94. unsigned int STDAPICALLTYPE AfxThunkSysStringByteLen(BSTR bstr)
  95. {
  96.     OLEAUTLOAD(SysStringByteLen);
  97.     return _afxOLE.pfnSysStringByteLen(bstr);
  98. }
  99.  
  100. HRESULT STDAPICALLTYPE AfxThunkVarCyFromStr(OLECHAR FAR* strIn, LCID lcid, unsigned long dwFlags, CY FAR* pcyOut)
  101. {
  102.     OLEAUTLOAD(VarCyFromStr);
  103.     return _afxOLE.pfnVarCyFromStr(strIn, lcid, dwFlags, pcyOut);
  104. }
  105.  
  106. HRESULT STDAPICALLTYPE AfxThunkVarBstrFromCy(CY cyIn, LCID lcid, unsigned long dwFlags, BSTR FAR* pbstrOut)
  107. {
  108.     OLEAUTLOAD(VarBstrFromCy);
  109.     return _afxOLE.pfnVarBstrFromCy(cyIn, lcid, dwFlags, pbstrOut);
  110. }
  111.  
  112. HRESULT STDAPICALLTYPE AfxThunkVarDateFromStr(OLECHAR FAR* strIn, LCID lcid, unsigned long dwFlags, DATE FAR* pdateOut)
  113. {
  114.     OLEAUTLOAD(VarDateFromStr);
  115.     return _afxOLE.pfnVarDateFromStr(strIn, lcid, dwFlags, pdateOut);
  116. }
  117.  
  118. HRESULT STDAPICALLTYPE AfxThunkVarBstrFromDate(DATE dateIn, LCID lcid, unsigned long dwFlags, BSTR FAR* pbstrOut)
  119. {
  120.     OLEAUTLOAD(VarBstrFromDate);
  121.     return _afxOLE.pfnVarBstrFromDate(dateIn, lcid, dwFlags, pbstrOut);
  122. }
  123.  
  124. HRESULT STDAPICALLTYPE AfxThunkLoadTypeLib(const OLECHAR FAR *szFile, ITypeLib FAR* FAR* pptlib)
  125. {
  126.     OLEAUTLOAD_M1(LoadTypeLib);
  127.     return _afxOLE.pfnLoadTypeLib(szFile, pptlib);
  128. }
  129.  
  130. HRESULT STDAPICALLTYPE AfxThunkLoadRegTypeLib(REFGUID guid, WORD wVerMajor, WORD wVerMinor, LCID lcid, ITypeLib FAR* FAR* pptlib)
  131. {
  132.     OLEAUTLOAD_M1(LoadRegTypeLib);
  133.     return _afxOLE.pfnLoadRegTypeLib(guid, wVerMajor, wVerMinor, lcid, pptlib);
  134. }
  135.  
  136. HRESULT STDAPICALLTYPE AfxThunkRegisterTypeLib(ITypeLib FAR* ptlib, OLECHAR FAR *szFullPath, OLECHAR FAR *szHelpDir)
  137. {
  138.     OLEAUTLOAD(RegisterTypeLib);
  139.     return _afxOLE.pfnRegisterTypeLib(ptlib, szFullPath, szHelpDir);
  140. }
  141.  
  142. int STDAPICALLTYPE AfxThunkDosDateTimeToVariantTime(unsigned short wDosDate, unsigned short wDosTime, double FAR* pvtime)
  143. {
  144.     OLEAUTLOAD(DosDateTimeToVariantTime);
  145.     return _afxOLE.pfnDosDateTimeToVariantTime(wDosDate, wDosTime, pvtime);
  146. }
  147.  
  148. SAFEARRAY FAR* STDAPICALLTYPE AfxThunkSafeArrayCreate(VARTYPE vt, unsigned int cDims, SAFEARRAYBOUND FAR* rgsabound)
  149. {
  150.     OLEAUTLOAD(SafeArrayCreate);
  151.     return _afxOLE.pfnSafeArrayCreate(vt, cDims, rgsabound);
  152. }
  153.  
  154. HRESULT STDAPICALLTYPE AfxThunkSafeArrayRedim(SAFEARRAY FAR* psa, SAFEARRAYBOUND FAR* psaboundNew)
  155. {
  156.     OLEAUTLOAD(SafeArrayRedim);
  157.     return _afxOLE.pfnSafeArrayRedim(psa, psaboundNew);
  158. }
  159.  
  160. HRESULT STDAPICALLTYPE AfxThunkSafeArrayAccessData(SAFEARRAY FAR* psa, void HUGEP* FAR* ppvData)
  161. {
  162.     OLEAUTLOAD(SafeArrayAccessData);
  163.     return _afxOLE.pfnSafeArrayAccessData(psa, ppvData);
  164. }
  165.  
  166. HRESULT STDAPICALLTYPE AfxThunkSafeArrayUnaccessData(SAFEARRAY FAR* psa)
  167. {
  168.     OLEAUTLOAD(SafeArrayUnaccessData);
  169.     return _afxOLE.pfnSafeArrayUnaccessData(psa);
  170. }
  171.  
  172. HRESULT STDAPICALLTYPE AfxThunkSafeArrayGetUBound(SAFEARRAY FAR* psa, unsigned int nDim, long FAR* plUbound)
  173. {
  174.     OLEAUTLOAD(SafeArrayGetUBound);
  175.     return _afxOLE.pfnSafeArrayGetUBound(psa, nDim, plUbound);
  176. }
  177.  
  178. HRESULT STDAPICALLTYPE AfxThunkSafeArrayGetLBound(SAFEARRAY FAR* psa, unsigned int nDim, long FAR* plLbound)
  179. {
  180.     OLEAUTLOAD(SafeArrayGetLBound);
  181.     return _afxOLE.pfnSafeArrayGetLBound(psa, nDim, plLbound);
  182. }
  183.  
  184. unsigned int STDAPICALLTYPE AfxThunkSafeArrayGetElemsize(SAFEARRAY FAR* psa)
  185. {
  186.     OLEAUTLOAD(SafeArrayGetElemsize);
  187.     return _afxOLE.pfnSafeArrayGetElemsize(psa);
  188. }
  189.  
  190. unsigned int STDAPICALLTYPE AfxThunkSafeArrayGetDim(SAFEARRAY FAR* psa)
  191. {
  192.     OLEAUTLOAD(SafeArrayGetDim);
  193.     return _afxOLE.pfnSafeArrayGetDim(psa);
  194. }
  195.  
  196. HRESULT STDAPICALLTYPE AfxThunkSafeArrayCopy(SAFEARRAY FAR* psa,
  197.     SAFEARRAY FAR* FAR* ppsaOut)
  198. {
  199.     OLEAUTLOAD(SafeArrayCopy);
  200.     return _afxOLE.pfnSafeArrayCopy(psa, ppsaOut);
  201. }
  202.  
  203. HRESULT STDAPICALLTYPE AfxThunkSafeArrayAllocData(SAFEARRAY FAR* psa)
  204. {
  205.     OLEAUTLOAD(SafeArrayAllocData);
  206.     return _afxOLE.pfnSafeArrayAllocData(psa);
  207. }
  208.  
  209. HRESULT STDAPICALLTYPE AfxThunkSafeArrayAllocDescriptor(unsigned int cDims,
  210.     SAFEARRAY FAR* FAR* ppsaOut)
  211. {
  212.     OLEAUTLOAD(SafeArrayAllocDescriptor);
  213.     return _afxOLE.pfnSafeArrayAllocDescriptor(cDims, ppsaOut);
  214. }
  215.  
  216. HRESULT STDAPICALLTYPE AfxThunkSafeArrayGetElement(SAFEARRAY FAR* psa,
  217.     long FAR* rgIndices, void FAR* pvData)
  218. {
  219.     OLEAUTLOAD(SafeArrayGetElement);
  220.     return _afxOLE.pfnSafeArrayGetElement(psa, rgIndices, pvData);
  221. }
  222.  
  223. HRESULT STDAPICALLTYPE AfxThunkSafeArrayPutElement(SAFEARRAY FAR* psa,
  224.     long FAR* rgIndices, void FAR* pvData)
  225. {
  226.     OLEAUTLOAD(SafeArrayPutElement);
  227.     return _afxOLE.pfnSafeArrayPutElement(psa, rgIndices, pvData);
  228. }
  229.  
  230. HRESULT STDAPICALLTYPE AfxThunkSafeArrayLock(SAFEARRAY FAR* psa)
  231. {
  232.     OLEAUTLOAD(SafeArrayLock);
  233.     return _afxOLE.pfnSafeArrayLock(psa);
  234. }
  235.  
  236. HRESULT STDAPICALLTYPE AfxThunkSafeArrayUnlock(SAFEARRAY FAR* psa)
  237. {
  238.     OLEAUTLOAD(SafeArrayUnlock);
  239.     return _afxOLE.pfnSafeArrayUnlock(psa);
  240. }
  241.  
  242. HRESULT STDAPICALLTYPE AfxThunkSafeArrayDestroy(SAFEARRAY FAR* psa)
  243. {
  244.     OLEAUTLOAD(SafeArrayDestroy);
  245.     return _afxOLE.pfnSafeArrayDestroy(psa);
  246. }
  247.  
  248. HRESULT STDAPICALLTYPE AfxThunkSafeArrayDestroyData(SAFEARRAY FAR* psa)
  249. {
  250.     OLEAUTLOAD(SafeArrayDestroyData);
  251.     return _afxOLE.pfnSafeArrayDestroyData(psa);
  252. }
  253.  
  254. HRESULT STDAPICALLTYPE AfxThunkSafeArrayDestroyDescriptor(SAFEARRAY FAR* psa)
  255. {
  256.     OLEAUTLOAD(SafeArrayDestroyDescriptor);
  257.     return _afxOLE.pfnSafeArrayDestroyDescriptor(psa);
  258. }
  259.  
  260. HRESULT STDAPICALLTYPE AfxThunkSafeArrayPtrOfIndex(SAFEARRAY FAR* psa,
  261.     long FAR* rgIndices, void HUGEP* FAR* ppvData)
  262. {
  263.     OLEAUTLOAD(SafeArrayPtrOfIndex);
  264.     return _afxOLE.pfnSafeArrayPtrOfIndex(psa, rgIndices, ppvData);
  265. }
  266.  
  267.  
  268. ///////////////////////////////////////////////////////////////////////////////
  269. // OLE32
  270.  
  271. HRESULT STDAPICALLTYPE AfxThunkReadFmtUserTypeStg(LPSTORAGE pstg, CLIPFORMAT FAR* pcf, LPOLESTR FAR* lplpszUserType)
  272. {
  273.     OLELOAD_M_WLM1(ReadFmtUserTypeStg);
  274.     return _afxOLE.pfnReadFmtUserTypeStg(pstg, pcf, lplpszUserType);
  275. }
  276.  
  277. HRESULT STDAPICALLTYPE AfxThunkReadClassStg(LPSTORAGE pStg, CLSID FAR* pclsid)
  278. {
  279.     OLELOAD_M_DEF(ReadClassStg);
  280.     return _afxOLE.pfnReadClassStg(pStg, pclsid);
  281. }
  282.  
  283. HRESULT STDAPICALLTYPE AfxThunkCreateFileMoniker(LPCOLESTR lpszPathName, LPMONIKER FAR* ppmk)
  284. {
  285.     OLELOAD_M_DEF(CreateFileMoniker);
  286.     return _afxOLE.pfnCreateFileMoniker(lpszPathName, ppmk);
  287. }
  288.  
  289. HRESULT STDAPICALLTYPE AfxThunkStgIsStorageFile(const OLECHAR * pwcsName)
  290. {
  291.     OLELOAD_M_WLM1(StgIsStorageFile);
  292.     return _afxOLE.pfnStgIsStorageFile(pwcsName);
  293. }
  294.  
  295. HRESULT STDAPICALLTYPE AfxThunkStgOpenStorage(const OLECHAR * pwcsName, IStorage *pstgPriority, DWORD grfMode, SNB snbExclude, DWORD reserved, IStorage ** ppstgOpen)
  296. {
  297.     OLELOAD_M_WLM1(StgOpenStorage);
  298.     return _afxOLE.pfnStgOpenStorage(pwcsName, pstgPriority, grfMode, snbExclude, reserved, ppstgOpen);
  299. }
  300.  
  301. HRESULT STDAPICALLTYPE AfxThunkDoDragDrop(LPDATAOBJECT pDataObj, LPDROPSOURCE pDropSource, DWORD dwOKEffects, LPDWORD pdwEffect)
  302. {
  303.     OLELOAD_M_DEF(DoDragDrop);
  304.     return _afxOLE.pfnDoDragDrop(pDataObj, pDropSource, dwOKEffects, pdwEffect);
  305. }
  306.  
  307. HRESULT STDAPICALLTYPE AfxThunkCoLockObjectExternal(LPUNKNOWN pUnk, BOOL fLock, BOOL fLastUnlockReleases)
  308. {
  309.     OLELOAD_M_COM(CoLockObjectExternal);
  310.     return _afxOLE.pfnCoLockObjectExternal(pUnk, fLock, fLastUnlockReleases);
  311. }
  312.  
  313. HRESULT STDAPICALLTYPE AfxThunkRegisterDragDrop(HWND hwnd, LPDROPTARGET pDropTarget)
  314. {
  315.     OLELOAD_M_WLM1(RegisterDragDrop);
  316.     return _afxOLE.pfnRegisterDragDrop(hwnd, pDropTarget);
  317. }
  318.  
  319. HRESULT STDAPICALLTYPE AfxThunkOleRegGetUserType (REFCLSID clsid, DWORD dwFormOfType, LPOLESTR * pszUserType)
  320. {
  321.     OLELOAD_M_DEF(OleRegGetUserType);
  322.     return _afxOLE.pfnOleRegGetUserType(clsid, dwFormOfType, pszUserType);
  323. }
  324.  
  325. HRESULT STDAPICALLTYPE AfxThunkStgCreateDocfile(const OLECHAR * pwcsName, DWORD grfMode, DWORD reserved, IStorage** ppstgOpen)
  326. {
  327.     OLELOAD_M_WLM1(StgCreateDocfile);
  328.     return _afxOLE.pfnStgCreateDocfile(pwcsName, grfMode, reserved, ppstgOpen);
  329. }
  330.  
  331. HRESULT STDAPICALLTYPE AfxThunkRevokeDragDrop(HWND hwnd)
  332. {
  333.     OLELOAD_M_WLM1(RevokeDragDrop);
  334.     return _afxOLE.pfnRevokeDragDrop(hwnd);
  335. }
  336.  
  337. HRESULT STDAPICALLTYPE AfxThunkCoRegisterClassObject(REFCLSID rclsid, LPUNKNOWN pUnk, DWORD dwClsContext, DWORD flags, LPDWORD lpdwRegister)
  338. {
  339.     OLELOAD_M_COM(CoRegisterClassObject);
  340.     return _afxOLE.pfnCoRegisterClassObject(rclsid, pUnk, dwClsContext, flags, lpdwRegister);
  341. }
  342.  
  343. HRESULT STDAPICALLTYPE AfxThunkCoRevokeClassObject(DWORD dwRegister)
  344. {
  345.     OLELOAD_M_COM(CoRevokeClassObject);
  346.     return _afxOLE.pfnCoRevokeClassObject(dwRegister);
  347. }
  348.  
  349. HRESULT STDAPICALLTYPE AfxThunkOleTranslateAccelerator(LPOLEINPLACEFRAME lpFrame, LPOLEINPLACEFRAMEINFO lpFrameInfo, LPMSG lpmsg)
  350. {
  351.     OLELOAD_M_WLM1(OleTranslateAccelerator);
  352.     return _afxOLE.pfnOleTranslateAccelerator(lpFrame, lpFrameInfo, lpmsg);
  353. }
  354.  
  355. BOOL STDAPICALLTYPE AfxThunkIsAccelerator(HACCEL hAccel, INT cAccelEntries, LPMSG lpMsg, WORD* lpwCmd)
  356. {
  357.     OLELOAD_M_WLM1(IsAccelerator);
  358.     return _afxOLE.pfnIsAccelerator(hAccel, cAccelEntries, lpMsg, lpwCmd);
  359. }
  360.  
  361. HOLEMENU STDAPICALLTYPE AfxThunkOleCreateMenuDescriptor(HMENU hmenuCombined, LPOLEMENUGROUPWIDTHS lpMenuWidths)
  362. {
  363.     OLELOAD_M_WLM2(OleCreateMenuDescriptor);
  364.     return _afxOLE.pfnOleCreateMenuDescriptor(hmenuCombined, lpMenuWidths);
  365. }
  366.  
  367. HRESULT STDAPICALLTYPE AfxThunkOleDestroyMenuDescriptor(HOLEMENU holemenu)
  368. {
  369.     OLELOAD_M_WLM2(OleDestroyMenuDescriptor);
  370.     return _afxOLE.pfnOleDestroyMenuDescriptor(holemenu);
  371. }
  372.  
  373. HRESULT STDAPICALLTYPE AfxThunkGetRunningObjectTable(DWORD reserved, LPRUNNINGOBJECTTABLE FAR* pprot)
  374. {
  375.     OLELOAD_M_DEF(GetRunningObjectTable);
  376.     return _afxOLE.pfnGetRunningObjectTable(reserved, pprot);
  377. }
  378.  
  379. HRESULT STDAPICALLTYPE AfxThunkWriteClassStg(LPSTORAGE pStg, REFCLSID rclsid)
  380. {
  381.     OLELOAD_M_DEF(WriteClassStg);
  382.     return _afxOLE.pfnWriteClassStg(pStg, rclsid);
  383. }
  384.  
  385. HRESULT STDAPICALLTYPE AfxThunkOleQueryLinkFromData(LPDATAOBJECT pSrcDataObject)
  386. {
  387.     OLELOAD_M_DEF(OleQueryLinkFromData);
  388.     return _afxOLE.pfnOleQueryLinkFromData(pSrcDataObject);
  389. }
  390.  
  391. HRESULT STDAPICALLTYPE AfxThunkCoRegisterMessageFilter(LPMESSAGEFILTER lpMessageFilter, LPMESSAGEFILTER * lplpMessageFilter)
  392. {
  393.     OLELOAD_M_COM(CoRegisterMessageFilter);
  394.     return _afxOLE.pfnCoRegisterMessageFilter(lpMessageFilter, lplpMessageFilter);
  395. }
  396.  
  397. HRESULT STDAPICALLTYPE AfxThunkCoCreateInstance(REFCLSID rclsid, LPUNKNOWN * pUnkOuter, DWORD dwClsContext, REFIID riid, LPVOID* ppv)
  398. {
  399.     OLELOAD_M_COM(CoCreateInstance);
  400.     return _afxOLE.pfnCoCreateInstance(rclsid, pUnkOuter, dwClsContext, riid, ppv);
  401. }
  402.  
  403. HRESULT STDAPICALLTYPE AfxThunkCreateBindCtx(DWORD reserved, LPBC FAR* ppbc)
  404. {
  405.     OLELOAD_M_DEF(CreateBindCtx);
  406.     return _afxOLE.pfnCreateBindCtx(reserved, ppbc);
  407. }
  408.  
  409. HRESULT STDAPICALLTYPE AfxThunkStringFromCLSID(REFCLSID rclsid, LPOLESTR FAR* lplpsz)
  410. {
  411.     OLELOAD_M_COMI(StringFromCLSID);
  412.     return _afxOLE.pfnStringFromCLSID(rclsid, lplpsz);
  413. }
  414.  
  415. HRESULT STDAPICALLTYPE AfxThunkCoDisconnectObject(LPUNKNOWN pUnk, DWORD dwReserved)
  416. {
  417.     OLELOAD_M_COM(CoDisconnectObject);
  418.     return _afxOLE.pfnCoDisconnectObject(pUnk, dwReserved);
  419. }
  420.  
  421. HRESULT STDAPICALLTYPE AfxThunkOleRegEnumVerbs (REFCLSID clsid, LPENUMOLEVERB FAR* ppenum)
  422. {
  423.     OLELOAD_M_DEF(OleRegEnumVerbs);
  424.     return _afxOLE.pfnOleRegEnumVerbs(clsid, ppenum);
  425. }
  426.  
  427. void STDAPICALLTYPE AfxThunkOleUninitialize(void)
  428. {
  429.     OLELOAD_M_WLM1(OleUninitialize);
  430.     _afxOLE.pfnOleUninitialize();
  431. }
  432.  
  433. HRESULT STDAPICALLTYPE AfxThunkCreateOleAdviseHolder(LPOLEADVISEHOLDER FAR* ppOAHolder)
  434. {
  435.     OLELOAD_M_COMI(CreateOleAdviseHolder);
  436.     return _afxOLE.pfnCreateOleAdviseHolder(ppOAHolder);
  437. }
  438.  
  439. HRESULT STDAPICALLTYPE AfxThunkCreateDataAdviseHolder(LPDATAADVISEHOLDER FAR* ppDAHolder)
  440. {
  441.     OLELOAD_M_WLM1(CreateDataAdviseHolder);
  442.     return _afxOLE.pfnCreateDataAdviseHolder(ppDAHolder);
  443. }
  444.  
  445. HRESULT STDAPICALLTYPE AfxThunkOleGetAutoConvert(REFCLSID clsidOld, LPCLSID pClsidNew)
  446. {
  447.     OLELOAD_M_DEF(OleGetAutoConvert);
  448.     return _afxOLE.pfnOleGetAutoConvert(clsidOld, pClsidNew);
  449. }
  450.  
  451. HRESULT STDAPICALLTYPE AfxThunkCoGetClassObject(REFCLSID rclsid, DWORD dwClsContext, LPVOID pvReserved, REFIID riid, LPVOID* ppv)
  452. {
  453.     OLELOAD_M_COMI(CoGetClassObject);
  454.     return _afxOLE.pfnCoGetClassObject(rclsid, dwClsContext, pvReserved, riid, ppv);
  455. }
  456.  
  457. HRESULT STDAPICALLTYPE AfxThunkOleCreateDefaultHandler(REFCLSID clsid, LPUNKNOWN pUnkOuter, REFIID riid, LPVOID* lplpvObj)
  458. {
  459.     OLELOAD_M_DEF(OleCreateDefaultHandler);
  460.     return _afxOLE.pfnOleCreateDefaultHandler(clsid, pUnkOuter, riid, lplpvObj);
  461. }
  462.  
  463. HRESULT STDAPICALLTYPE AfxThunkReadClassStm(LPSTREAM pStm, CLSID FAR* pclsid)
  464. {
  465.     OLELOAD_M_DEF(ReadClassStm);
  466.     return _afxOLE.pfnReadClassStm(pStm, pclsid);
  467. }
  468.  
  469. HRESULT STDAPICALLTYPE AfxThunkOleLoadFromStream(LPSTREAM pStm, REFIID iidInterface, LPVOID FAR* ppvObj)
  470. {
  471.     OLELOAD_M_DEF(OleLoadFromStream);
  472.     return _afxOLE.pfnOleLoadFromStream(pStm, iidInterface, ppvObj);
  473. }
  474.  
  475. int STDAPICALLTYPE AfxThunkStringFromGUID2(REFGUID rguid, LPOLESTR lpsz, int cbMax)
  476. {
  477.     OLELOAD_M_COMI(StringFromGUID2);
  478.     return _afxOLE.pfnStringFromGUID2(rguid, lpsz, cbMax);
  479. }
  480.  
  481. void STDAPICALLTYPE AfxThunkCoUninitialize(void)
  482. {
  483.     OLELOAD_M_WLM1(CoUninitialize);
  484.     _afxOLE.pfnCoUninitialize();
  485. }
  486.  
  487. HRESULT STDAPICALLTYPE AfxThunkCoInitialize(LPVOID pvReserved)
  488. {
  489.     OLELOAD_M_WLM1(CoInitialize);
  490.     return _afxOLE.pfnCoInitialize(pvReserved);
  491. }
  492.  
  493. HRESULT STDAPICALLTYPE AfxThunkCoInitializeEx(LPVOID pvReserved, DWORD dwCoInit)
  494. {
  495.     OLELOAD_M_WLM1(CoInitializeEx);
  496.     return _afxOLE.pfnCoInitializeEx(pvReserved, dwCoInit);
  497. }
  498.  
  499. void STDAPICALLTYPE AfxThunkCoFreeUnusedLibraries(void)
  500. {
  501.     OLELOAD_M_COMI(CoFreeUnusedLibraries);
  502.     _afxOLE.pfnCoFreeUnusedLibraries();
  503. }
  504.  
  505. HRESULT STDAPICALLTYPE AfxThunkOleCreateFromData(LPDATAOBJECT pSrcDataObj, REFIID riid, DWORD renderopt, LPFORMATETC pFormatEtc, LPOLECLIENTSITE pClientSite, LPSTORAGE pStg, LPVOID* ppvObj)
  506. {
  507.     OLELOAD_M_WLM1(OleCreateFromData);
  508.     return _afxOLE.pfnOleCreateFromData(pSrcDataObj, riid, renderopt, pFormatEtc, pClientSite, pStg, ppvObj);
  509. }
  510.  
  511. HRESULT STDAPICALLTYPE AfxThunkOleSetContainedObject(LPUNKNOWN pUnknown, BOOL fContained)
  512. {
  513.     OLELOAD_M_DEF(OleSetContainedObject);
  514.     return _afxOLE.pfnOleSetContainedObject(pUnknown, fContained);
  515. }
  516.  
  517. HRESULT STDAPICALLTYPE AfxThunkOleLockRunning(LPUNKNOWN pUnknown, BOOL fLock, BOOL fLastUnlockCloses)
  518. {
  519.     OLELOAD_M_DEF(OleLockRunning);
  520.     return _afxOLE.pfnOleLockRunning(pUnknown, fLock, fLastUnlockCloses);
  521. }
  522.  
  523. LPVOID STDAPICALLTYPE AfxThunkCoTaskMemAlloc(ULONG cb)
  524. {
  525.     OLELOAD_M_COMI(CoTaskMemAlloc);
  526.     return _afxOLE.pfnCoTaskMemAlloc(cb);
  527. }
  528.  
  529. LPVOID STDAPICALLTYPE AfxThunkCoTaskMemRealloc(LPVOID pv, ULONG cb)
  530. {
  531.     return NULL;
  532. }
  533.  
  534. HRESULT STDAPICALLTYPE AfxThunkCLSIDFromString(LPOLESTR lpsz, LPCLSID pclsid)
  535. {
  536.     OLELOAD_M_COMI(CLSIDFromString);
  537.     return _afxOLE.pfnCLSIDFromString(lpsz, pclsid);
  538. }
  539.  
  540. HRESULT STDAPICALLTYPE AfxThunkCLSIDFromProgID (LPCOLESTR lpszProgID, LPCLSID lpclsid)
  541. {
  542.     OLELOAD_M_COM(CLSIDFromProgID);
  543.     return _afxOLE.pfnCLSIDFromProgID(lpszProgID, lpclsid);
  544. }
  545.  
  546. HRESULT STDAPICALLTYPE AfxThunkOleIsCurrentClipboard(LPDATAOBJECT pDataObj)
  547. {
  548.     OLELOAD_M_DEF(OleIsCurrentClipboard);
  549.     return _afxOLE.pfnOleIsCurrentClipboard(pDataObj);
  550. }
  551.  
  552. HRESULT STDAPICALLTYPE AfxThunkOleFlushClipboard(void)
  553. {
  554.     OLELOAD_M_DEF(OleFlushClipboard);
  555.     return _afxOLE.pfnOleFlushClipboard();
  556. }
  557.  
  558. HRESULT STDAPICALLTYPE AfxThunkOleSetClipboard(LPDATAOBJECT pDataObj)
  559. {
  560.     OLELOAD_M_DEF(OleSetClipboard);
  561.     return _afxOLE.pfnOleSetClipboard(pDataObj);
  562. }
  563.  
  564. BOOL STDAPICALLTYPE AfxThunkOleIsRunning(LPOLEOBJECT pObject)
  565. {
  566.     OLELOAD_M_DEF(OleIsRunning);
  567.     return _afxOLE.pfnOleIsRunning(pObject);
  568. }
  569.  
  570. HRESULT STDAPICALLTYPE AfxThunkOleRun(LPUNKNOWN pUnknown)
  571. {
  572.     OLELOAD_M_DEF(OleRun);
  573.     return _afxOLE.pfnOleRun(pUnknown);
  574. }
  575.  
  576. HRESULT STDAPICALLTYPE AfxThunkOleGetClipboard(LPDATAOBJECT FAR* ppDataObj)
  577. {
  578.     OLELOAD_M_DEF(OleGetClipboard);
  579.     return _afxOLE.pfnOleGetClipboard(ppDataObj);
  580. }
  581.  
  582. HRESULT STDAPICALLTYPE AfxThunkCoTreatAsClass(REFCLSID clsidOld, REFCLSID clsidNew)
  583. {
  584.     OLELOAD_M_COMI(CoTreatAsClass);
  585.     return _afxOLE.pfnCoTreatAsClass(clsidOld, clsidNew);
  586. }
  587.  
  588. HRESULT STDAPICALLTYPE AfxThunkOleQueryCreateFromData(LPDATAOBJECT pSrcDataObject)
  589. {
  590.     OLELOAD_M_DEF(OleQueryCreateFromData);
  591.     return _afxOLE.pfnOleQueryCreateFromData(pSrcDataObject);
  592. }
  593.  
  594. HRESULT STDAPICALLTYPE AfxThunkOleSetMenuDescriptor (HOLEMENU holemenu, HWND hwndFrame, HWND hwndActiveObject, LPOLEINPLACEFRAME lpFrame, LPOLEINPLACEACTIVEOBJECT lpActiveObj)
  595. {
  596.     OLELOAD_M_WLM2(OleSetMenuDescriptor);
  597.     return _afxOLE.pfnOleSetMenuDescriptor(holemenu, hwndFrame, hwndActiveObject, lpFrame, lpActiveObj);
  598. }
  599.  
  600. HRESULT STDAPICALLTYPE AfxThunkCreateItemMoniker(LPCOLESTR lpszDelim, LPCOLESTR lpszItem, LPMONIKER* ppmk)
  601. {
  602.     OLELOAD_M_DEF(CreateItemMoniker);
  603.     return _afxOLE.pfnCreateItemMoniker(lpszDelim, lpszItem, ppmk);
  604. }
  605.  
  606. HRESULT STDAPICALLTYPE AfxThunkCreateGenericComposite(LPMONIKER pmkFirst, LPMONIKER pmkRest, LPMONIKER* ppmkComposite)
  607. {
  608.     OLELOAD_M_DEF(CreateGenericComposite);
  609.     return _afxOLE.pfnCreateGenericComposite(pmkFirst, pmkRest, ppmkComposite);
  610. }
  611.  
  612. HRESULT STDAPICALLTYPE AfxThunkCreateStreamOnHGlobal(HGLOBAL hGlobal, BOOL fDeleteOnRelease, LPSTREAM* ppstm)
  613. {
  614.     OLELOAD_M_WLM1(CreateStreamOnHGlobal);
  615.     return _afxOLE.pfnCreateStreamOnHGlobal(hGlobal, fDeleteOnRelease, ppstm);
  616. }
  617.  
  618. HRESULT STDAPICALLTYPE AfxThunkOleSaveToStream(LPPERSISTSTREAM pPStm, LPSTREAM pStm)
  619. {
  620.     OLELOAD_M_DEF(OleSaveToStream);
  621.     return _afxOLE.pfnOleSaveToStream(pPStm, pStm);
  622. }
  623.  
  624. HRESULT STDAPICALLTYPE AfxThunkWriteClassStm(LPSTREAM pStm, REFCLSID rclsid)
  625. {
  626.     OLELOAD_M_DEF(WriteClassStm);
  627.     return _afxOLE.pfnWriteClassStm(pStm, rclsid);
  628. }
  629.  
  630. void STDAPICALLTYPE AfxThunkCoTaskMemFree(LPVOID pv)
  631. {
  632.     OLELOAD_M_COMI(CoTaskMemFree);
  633.     _afxOLE.pfnCoTaskMemFree(pv);
  634. }
  635.  
  636. HGLOBAL STDAPICALLTYPE AfxThunkOleGetIconOfClass(REFCLSID rclsid, LPOLESTR lpszLabel, BOOL fUseTypeAsLabel)
  637. {
  638.     OLELOAD_M_WLM1(OleGetIconOfClass);
  639.     return _afxOLE.pfnOleGetIconOfClass(rclsid, lpszLabel, fUseTypeAsLabel);
  640. }
  641.  
  642. void STDAPICALLTYPE AfxThunkReleaseStgMedium(LPSTGMEDIUM lp)
  643. {
  644.     OLELOAD_M_WLM1(ReleaseStgMedium);
  645.     _afxOLE.pfnReleaseStgMedium(lp);
  646. }
  647.  
  648. HRESULT STDAPICALLTYPE AfxThunkGetHGlobalFromILockBytes (LPLOCKBYTES plkbyt, HGLOBAL FAR* phglobal)
  649. {
  650.     OLELOAD_M_WLM1(GetHGlobalFromILockBytes);
  651.     return _afxOLE.pfnGetHGlobalFromILockBytes(plkbyt, phglobal);
  652. }
  653.  
  654. HRESULT STDAPICALLTYPE AfxThunkStgOpenStorageOnILockBytes(LPLOCKBYTES plkbyt, LPSTORAGE pstgPriority, DWORD grfMode, SNB snbExclude, DWORD reserved, LPSTORAGE* ppstgOpen)
  655. {
  656.     OLELOAD_M_DF(StgOpenStorageOnILockBytes);
  657.     return _afxOLE.pfnStgOpenStorageOnILockBytes(plkbyt, pstgPriority, grfMode, snbExclude, reserved, ppstgOpen);
  658. }
  659.  
  660. HRESULT STDAPICALLTYPE AfxThunkCreateILockBytesOnHGlobal(HGLOBAL hGlobal, BOOL fDeleteOnRelease, LPLOCKBYTES* pplkbyt)
  661. {
  662.     OLELOAD_M_WLM1(CreateILockBytesOnHGlobal);
  663.     return _afxOLE.pfnCreateILockBytesOnHGlobal(hGlobal, fDeleteOnRelease, pplkbyt);
  664. }
  665.  
  666. HRESULT STDAPICALLTYPE AfxThunkStgCreateDocfileOnILockBytes(LPLOCKBYTES plkbyt, DWORD grfMode, DWORD reserved, LPSTORAGE* ppstgOpen)
  667. {
  668.     OLELOAD_M_DF(StgCreateDocfileOnILockBytes);
  669.     return _afxOLE.pfnStgCreateDocfileOnILockBytes(plkbyt, grfMode, reserved, ppstgOpen);
  670. }
  671.  
  672. HRESULT STDAPICALLTYPE AfxThunkOleSave(LPPERSISTSTORAGE pPS, LPSTORAGE pStg, BOOL fSameAsLoad)
  673. {
  674.     OLELOAD_M_DEF(OleSave);
  675.     return _afxOLE.pfnOleSave(pPS, pStg, fSameAsLoad);
  676. }
  677.  
  678. HRESULT STDAPICALLTYPE AfxThunkOleLoad(LPSTORAGE pStg, REFIID riid, LPOLECLIENTSITE pClientSite, LPVOID* ppvObj)
  679. {
  680.     OLELOAD_M_DEF(OleLoad);
  681.     return _afxOLE.pfnOleLoad(pStg, riid, pClientSite, ppvObj);
  682. }
  683.  
  684. HRESULT STDAPICALLTYPE AfxThunkOleCreate(REFCLSID rclsid, REFIID riid, DWORD renderopt, LPFORMATETC pFormatEtc, LPOLECLIENTSITE pClientSite, LPSTORAGE pStg, LPVOID* ppvObj)
  685. {
  686.     OLELOAD_M_WLM1(OleCreate);
  687.     return _afxOLE.pfnOleCreate(rclsid, riid, renderopt, pFormatEtc, pClientSite, pStg, ppvObj);
  688. }
  689.  
  690. HRESULT STDAPICALLTYPE AfxThunkOleCreateLinkToFile(LPCOLESTR lpszFileName, REFIID riid, DWORD renderopt, LPFORMATETC lpFormatEtc, LPOLECLIENTSITE pClientSite, LPSTORAGE pStg, LPVOID* ppvObj)
  691. {
  692.     OLELOAD_M_WLM1(OleCreateLinkToFile);
  693.     return _afxOLE.pfnOleCreateLinkToFile(lpszFileName, riid, renderopt, lpFormatEtc, pClientSite, pStg, ppvObj);
  694. }
  695.  
  696. HRESULT STDAPICALLTYPE AfxThunkOleCreateFromFile(REFCLSID rclsid, LPCOLESTR lpszFileName, REFIID riid, DWORD renderopt, LPFORMATETC pFormatEtc, LPOLECLIENTSITE pClientSite, LPSTORAGE pStg, LPVOID* ppvObj)
  697. {
  698.     OLELOAD_M_WLM1(OleCreateFromFile);
  699.     return _afxOLE.pfnOleCreateFromFile(rclsid, lpszFileName, riid, renderopt, pFormatEtc, pClientSite, pStg, ppvObj);
  700. }
  701.  
  702. HRESULT STDAPICALLTYPE AfxThunkOleCreateStaticFromData(LPDATAOBJECT pSrcDataObj, REFIID riid, DWORD renderopt, LPFORMATETC pFormatEtc, LPOLECLIENTSITE pClientSite, LPSTORAGE pStg, LPVOID* ppvObj)
  703. {
  704.     OLELOAD_M_WLM1(OleCreateStaticFromData);
  705.     return _afxOLE.pfnOleCreateStaticFromData(pSrcDataObj, riid, renderopt, pFormatEtc, pClientSite, pStg, ppvObj);
  706. }
  707.  
  708. HRESULT STDAPICALLTYPE AfxThunkOleCreateLinkFromData(LPDATAOBJECT pSrcDataObj, REFIID riid, DWORD renderopt, LPFORMATETC pFormatEtc, LPOLECLIENTSITE pClientSite, LPSTORAGE pStg, LPVOID* ppvObj)
  709. {
  710.     OLELOAD_M_WLM1(OleCreateLinkFromData);
  711.     return _afxOLE.pfnOleCreateLinkFromData(pSrcDataObj, riid, renderopt, pFormatEtc, pClientSite, pStg, ppvObj);
  712. }
  713.  
  714. HRESULT STDAPICALLTYPE AfxThunkSetConvertStg(LPSTORAGE pStg, BOOL fConvert)
  715. {
  716.     OLELOAD_M_DEF(SetConvertStg);
  717.     return _afxOLE.pfnSetConvertStg(pStg, fConvert);
  718. }
  719.  
  720. HANDLE STDAPICALLTYPE AfxThunkOleDuplicateData(HANDLE hSrc, CLIPFORMAT cfFormat, UINT uiFlags)
  721. {
  722.     OLELOAD_M_WLM1(OleDuplicateData);
  723.     return _afxOLE.pfnOleDuplicateData(hSrc, cfFormat, uiFlags);
  724. }
  725.  
  726. HRESULT STDAPICALLTYPE AfxThunkWriteFmtUserTypeStg (LPSTORAGE pstg, CLIPFORMAT cf, LPOLESTR lpszUserType)
  727. {
  728.     OLELOAD_M_WLM1(WriteFmtUserTypeStg);
  729.     return _afxOLE.pfnWriteFmtUserTypeStg(pstg, cf, lpszUserType);
  730. }
  731.  
  732. HRESULT STDAPICALLTYPE AfxThunkOleRegGetMiscStatus(REFCLSID clsid, DWORD dwAspect, DWORD* pdwStatus)
  733. {
  734.     OLELOAD_M_DEF(OleRegGetMiscStatus);
  735.     return _afxOLE.pfnOleRegGetMiscStatus(clsid, dwAspect, pdwStatus);
  736. }
  737.  
  738. HRESULT STDAPICALLTYPE AfxThunkCoGetMalloc(DWORD dwMemContext, LPMALLOC * ppMalloc)
  739. {
  740.     OLELOAD_M_COMI(CoGetMalloc);
  741.     return _afxOLE.pfnCoGetMalloc(dwMemContext, ppMalloc);
  742. }
  743.  
  744. HRESULT STDAPICALLTYPE AfxThunkStgIsStorageILockBytes(LPLOCKBYTES plkbyt)
  745. {
  746.     OLELOAD_M_DF(StgIsStorageILockBytes);
  747.     return _afxOLE.pfnStgIsStorageILockBytes(plkbyt);
  748. }
  749.  
  750. AFX_DATADEF AFX_OLE_CALL _afxOLE =
  751. {
  752.     // OLE32.DLL entry points
  753.     AfxThunkReadFmtUserTypeStg,
  754.     AfxThunkReadClassStg,
  755.     AfxThunkCreateFileMoniker,
  756.     AfxThunkStgIsStorageFile,
  757.     AfxThunkStgOpenStorage,
  758.     AfxThunkDoDragDrop,
  759.     AfxThunkCoLockObjectExternal,
  760.     AfxThunkRegisterDragDrop,
  761.     AfxThunkOleRegGetUserType,
  762.     AfxThunkStgCreateDocfile,
  763.     AfxThunkRevokeDragDrop,
  764.     AfxThunkCoRegisterClassObject,
  765.     AfxThunkCoRevokeClassObject,
  766.     AfxThunkOleTranslateAccelerator,
  767.     AfxThunkIsAccelerator,
  768.     AfxThunkOleCreateMenuDescriptor,
  769.     AfxThunkOleDestroyMenuDescriptor,
  770.     AfxThunkGetRunningObjectTable,
  771.     AfxThunkWriteClassStg,
  772.     AfxThunkOleQueryLinkFromData,
  773.     AfxThunkCoRegisterMessageFilter,
  774.     AfxThunkCoCreateInstance,
  775.     AfxThunkCreateBindCtx,
  776.     AfxThunkStringFromCLSID,
  777.     AfxThunkCoDisconnectObject,
  778.     AfxThunkOleRegEnumVerbs,
  779.     AfxThunkOleUninitialize,
  780.     AfxThunkCreateOleAdviseHolder,
  781.     AfxThunkCreateDataAdviseHolder,
  782.     AfxThunkOleGetAutoConvert,
  783.     AfxThunkCoGetClassObject,
  784.     AfxThunkOleCreateDefaultHandler,
  785. WCE_DEL    AfxThunkCreateDataCache,
  786.     AfxThunkReadClassStm,
  787.     AfxThunkOleLoadFromStream,
  788.     AfxThunkStringFromGUID2,
  789.     AfxThunkCoUninitialize,
  790.     AfxThunkCoInitialize,
  791.     WCE_IF(AfxThunkCoInitializeEx,AfxThunkOleInitialize),
  792.     AfxThunkCoFreeUnusedLibraries,
  793.     AfxThunkOleCreateFromData,
  794.     AfxThunkOleSetContainedObject,
  795.     AfxThunkOleLockRunning,
  796.     AfxThunkCoTaskMemAlloc,
  797. WCE_INS AfxThunkCoTaskMemRealloc,
  798.     AfxThunkCLSIDFromString,
  799.     AfxThunkCLSIDFromProgID,
  800.     AfxThunkOleIsCurrentClipboard,
  801.     AfxThunkOleFlushClipboard,
  802.     AfxThunkOleSetClipboard,
  803.     AfxThunkOleIsRunning,
  804.     AfxThunkOleRun,
  805.     AfxThunkOleGetClipboard,
  806.     AfxThunkCoTreatAsClass,
  807.     AfxThunkOleQueryCreateFromData,
  808.     AfxThunkOleSetMenuDescriptor,
  809.     AfxThunkCreateItemMoniker,
  810.     AfxThunkCreateGenericComposite,
  811.     AfxThunkCreateStreamOnHGlobal,
  812.     AfxThunkOleSaveToStream,
  813.     AfxThunkWriteClassStm,
  814.     AfxThunkCoTaskMemFree,
  815.     AfxThunkOleGetIconOfClass,
  816.     AfxThunkReleaseStgMedium,
  817.     AfxThunkGetHGlobalFromILockBytes,
  818.     AfxThunkStgOpenStorageOnILockBytes,
  819.     AfxThunkCreateILockBytesOnHGlobal,
  820.     AfxThunkStgCreateDocfileOnILockBytes,
  821.     AfxThunkOleSave,
  822.     AfxThunkOleLoad,
  823.     AfxThunkOleCreate,
  824.     AfxThunkOleCreateLinkToFile,
  825.     AfxThunkOleCreateFromFile,
  826.     AfxThunkOleCreateStaticFromData,
  827.     AfxThunkOleCreateLinkFromData,
  828.     AfxThunkSetConvertStg,
  829.     AfxThunkOleDuplicateData,
  830.     AfxThunkWriteFmtUserTypeStg,
  831.     AfxThunkOleRegGetMiscStatus,
  832.     AfxThunkCoGetMalloc,
  833.     AfxThunkStgIsStorageILockBytes,
  834.  
  835.     // OLEAUT32.DLL entry points
  836.     AfxThunkSysFreeString,
  837.     AfxThunkSysAllocStringByteLen,
  838.     AfxThunkVariantCopy,
  839.     AfxThunkVariantClear,
  840.     AfxThunkVariantChangeType,
  841.     AfxThunkSysAllocStringLen,
  842.     AfxThunkSysStringLen,
  843.     AfxThunkSysReAllocStringLen,
  844.     AfxThunkSysAllocString,
  845.     AfxThunkSysStringByteLen,
  846.     AfxThunkVarCyFromStr,
  847.     AfxThunkVarBstrFromCy,
  848.     AfxThunkVarDateFromStr,
  849.     AfxThunkVarBstrFromDate,
  850.     AfxThunkLoadTypeLib,
  851.     AfxThunkLoadRegTypeLib,
  852.     AfxThunkRegisterTypeLib,
  853.     AfxThunkDosDateTimeToVariantTime,
  854.     AfxThunkSafeArrayCreate,
  855.     AfxThunkSafeArrayRedim,
  856.     AfxThunkSafeArrayAccessData,
  857.     AfxThunkSafeArrayUnaccessData,
  858.     AfxThunkSafeArrayGetUBound,
  859.     AfxThunkSafeArrayGetLBound,
  860.     AfxThunkSafeArrayGetElemsize,
  861.     AfxThunkSafeArrayGetDim,
  862.     AfxThunkSafeArrayCopy,
  863.     AfxThunkSafeArrayAllocData,
  864.     AfxThunkSafeArrayAllocDescriptor,
  865.     AfxThunkSafeArrayGetElement,
  866.     AfxThunkSafeArrayPutElement,
  867.     AfxThunkSafeArrayLock,
  868.     AfxThunkSafeArrayUnlock,
  869.     AfxThunkSafeArrayDestroy,
  870.     AfxThunkSafeArrayDestroyData,
  871.     AfxThunkSafeArrayDestroyDescriptor,
  872.     AfxThunkSafeArrayPtrOfIndex,
  873. };
  874.  
  875. #endif // _WIN32_WCE_NO_OLE_THUNKS
  876. #endif // _WIN32_WCE_NO_DELAYLOAD
  877.