home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / vc98 / mfc / include / afxdisp.h < prev    next >
C/C++ Source or Header  |  1998-06-16  |  50KB  |  1,430 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. #ifndef __AFXDISP_H__
  12. #define __AFXDISP_H__
  13.  
  14. #ifdef _AFX_NO_OLE_SUPPORT
  15.     #error OLE classes not supported in this library variant.
  16. #endif
  17.  
  18. #ifndef __AFXWIN_H__
  19.     #include <afxwin.h>
  20. #endif
  21.  
  22. // include necessary OLE headers
  23. #ifndef _OBJBASE_H_
  24.     #include <objbase.h>
  25. #endif
  26. #ifndef _OLEAUTO_H_
  27.     #include <oleauto.h>
  28. #endif
  29. #ifndef _OLECTL_H_
  30.     #include <olectl.h>
  31. #endif
  32. #ifndef __ocidl_h__
  33.     #include <ocidl.h>
  34. #endif
  35.  
  36. // Shell interface support
  37. #ifndef _SHLOBJ_H_
  38.     #include <shlobj.h>
  39. #endif
  40.  
  41. #ifdef _AFX_MINREBUILD
  42. #pragma component(minrebuild, off)
  43. #endif
  44. #ifndef _AFX_FULLTYPEINFO
  45. #pragma component(mintypeinfo, on)
  46. #endif
  47.  
  48. #ifndef _AFX_NOFORCE_LIBS
  49.  
  50. /////////////////////////////////////////////////////////////////////////////
  51. // Win32 libraries
  52.  
  53. #ifdef _AFXDLL
  54.     #if defined(_DEBUG) && !defined(_AFX_MONOLITHIC)
  55.         #ifndef _UNICODE
  56.             #pragma comment(lib, "mfco42d.lib")
  57.         #else
  58.             #pragma comment(lib, "mfco42ud.lib")
  59.         #endif
  60.     #endif
  61. #endif
  62.  
  63. #pragma comment(lib, "oledlg.lib")
  64. #pragma comment(lib, "ole32.lib")
  65. #pragma comment(lib, "olepro32.lib")
  66. #pragma comment(lib, "oleaut32.lib")
  67. #pragma comment(lib, "uuid.lib")
  68. #pragma comment(lib, "urlmon.lib")
  69.  
  70. #endif //!_AFX_NOFORCE_LIBS
  71.  
  72. /////////////////////////////////////////////////////////////////////////////
  73.  
  74. #ifdef _AFX_PACKING
  75. #pragma pack(push, _AFX_PACKING)
  76. #endif
  77.  
  78. /////////////////////////////////////////////////////////////////////////////
  79. // AFXDISP - MFC IDispatch & ClassFactory support
  80.  
  81. // Classes declared in this file
  82.  
  83. //CException
  84.     class COleException;            // caught by client or server
  85.     class COleDispatchException;    // special exception for IDispatch calls
  86.  
  87. //CCmdTarget
  88.     class COleObjectFactory;        // glue for IClassFactory -> runtime class
  89.         class COleTemplateServer;   // server documents using CDocTemplate
  90.  
  91. class COleDispatchDriver;           // helper class to call IDispatch
  92.  
  93. class COleVariant;          // OLE VARIANT wrapper
  94. class COleCurrency;         // Based on OLE CY
  95. class COleDateTime;         // Based on OLE DATE
  96. class COleDateTimeSpan;     // Based on a double
  97. class COleSafeArray;        // Based on OLE VARIANT
  98. /////////////////////////////////////////////////////////////////////////////
  99.  
  100. // AFXDLL support
  101. #undef AFX_DATA
  102. #define AFX_DATA AFX_OLE_DATA
  103.  
  104. /////////////////////////////////////////////////////////////////////////////
  105. // OLE COM (Component Object Model) implementation infrastructure
  106. //      - data driven QueryInterface
  107. //      - standard implementation of aggregate AddRef and Release
  108. // (see CCmdTarget in AFXWIN.H for more information)
  109.  
  110. #define METHOD_PROLOGUE(theClass, localClass) \
  111.     theClass* pThis = \
  112.         ((theClass*)((BYTE*)this - offsetof(theClass, m_x##localClass))); \
  113.     AFX_MANAGE_STATE(pThis->m_pModuleState) \
  114.     pThis; // avoid warning from compiler \
  115.  
  116. #define METHOD_PROLOGUE_(theClass, localClass) \
  117.     theClass* pThis = \
  118.         ((theClass*)((BYTE*)this - offsetof(theClass, m_x##localClass))); \
  119.     pThis; // avoid warning from compiler \
  120.  
  121. #ifndef _AFX_NO_NESTED_DERIVATION
  122. #define METHOD_PROLOGUE_EX(theClass, localClass) \
  123.     theClass* pThis = ((theClass*)((BYTE*)this - m_nOffset)); \
  124.     AFX_MANAGE_STATE(pThis->m_pModuleState) \
  125.     pThis; // avoid warning from compiler \
  126.  
  127. #define METHOD_PROLOGUE_EX_(theClass, localClass) \
  128.     theClass* pThis = ((theClass*)((BYTE*)this - m_nOffset)); \
  129.     pThis; // avoid warning from compiler \
  130.  
  131. #else
  132. #define METHOD_PROLOGUE_EX(theClass, localClass) \
  133.     METHOD_PROLOGUE(theClass, localClass) \
  134.  
  135. #define METHOD_PROLOGUE_EX_(theClass, localClass) \
  136.     METHOD_PROLOGUE_(theClass, localClass) \
  137.  
  138. #endif
  139.  
  140. // Provided only for compatibility with CDK 1.x
  141. #define METHOD_MANAGE_STATE(theClass, localClass) \
  142.     METHOD_PROLOGUE_EX(theClass, localClass) \
  143.  
  144. #define BEGIN_INTERFACE_PART(localClass, baseClass) \
  145.     class X##localClass : public baseClass \
  146.     { \
  147.     public: \
  148.         STDMETHOD_(ULONG, AddRef)(); \
  149.         STDMETHOD_(ULONG, Release)(); \
  150.         STDMETHOD(QueryInterface)(REFIID iid, LPVOID* ppvObj); \
  151.  
  152. #ifndef _AFX_NO_NESTED_DERIVATION
  153. #define BEGIN_INTERFACE_PART_DERIVE(localClass, baseClass) \
  154.     class X##localClass : public baseClass \
  155.     { \
  156.     public: \
  157.  
  158. #else
  159. #define BEGIN_INTERFACE_PART_DERIVE(localClass, baseClass) \
  160.     BEGIN_INTERFACE_PART(localClass, baseClass) \
  161.  
  162. #endif
  163.  
  164. #ifndef _AFX_NO_NESTED_DERIVATION
  165. #define INIT_INTERFACE_PART(theClass, localClass) \
  166.         size_t m_nOffset; \
  167.         INIT_INTERFACE_PART_DERIVE(theClass, localClass) \
  168.  
  169. #define INIT_INTERFACE_PART_DERIVE(theClass, localClass) \
  170.         X##localClass() \
  171.             { m_nOffset = offsetof(theClass, m_x##localClass); } \
  172.  
  173. #else
  174. #define INIT_INTERFACE_PART(theClass, localClass)
  175. #define INIT_INTERFACE_PART_DERIVE(theClass, localClass)
  176.  
  177. #endif
  178.  
  179. // Note: Inserts the rest of OLE functionality between these two macros,
  180. //  depending upon the interface that is being implemented.  It is not
  181. //  necessary to include AddRef, Release, and QueryInterface since those
  182. //  member functions are declared by the macro.
  183.  
  184. #define END_INTERFACE_PART(localClass) \
  185.     } m_x##localClass; \
  186.     friend class X##localClass; \
  187.  
  188. struct CInterfacePlaceHolder
  189. {
  190.     DWORD m_vtbl;   // filled in with USE_INTERFACE_PART
  191.     CInterfacePlaceHolder() { m_vtbl = 0; }
  192. };
  193.  
  194. #define END_INTERFACE_PART_OPTIONAL(localClass) \
  195.     }; \
  196.     CInterfacePlaceHolder m_x##localClass; \
  197.     friend class X##localClass; \
  198.  
  199. #ifdef _AFXDLL
  200. #define END_INTERFACE_PART_STATIC END_INTERFACE_PART
  201. #else
  202. #define END_INTERFACE_PART_STATIC END_INTERFACE_PART
  203. #endif
  204.  
  205. #define USE_INTERFACE_PART(localClass) \
  206.     m_x##localClass.m_vtbl = *(DWORD*)&X##localClass(); \
  207.  
  208. #ifdef _AFXDLL
  209. #define BEGIN_INTERFACE_MAP(theClass, theBase) \
  210.     const AFX_INTERFACEMAP* PASCAL theClass::_GetBaseInterfaceMap() \
  211.         { return &theBase::interfaceMap; } \
  212.     const AFX_INTERFACEMAP* theClass::GetInterfaceMap() const \
  213.         { return &theClass::interfaceMap; } \
  214.     AFX_COMDAT const AFX_DATADEF AFX_INTERFACEMAP theClass::interfaceMap = \
  215.         { &theClass::_GetBaseInterfaceMap, &theClass::_interfaceEntries[0], }; \
  216.     AFX_COMDAT const AFX_DATADEF AFX_INTERFACEMAP_ENTRY theClass::_interfaceEntries[] = \
  217.     { \
  218.  
  219. #else
  220. #define BEGIN_INTERFACE_MAP(theClass, theBase) \
  221.     const AFX_INTERFACEMAP* theClass::GetInterfaceMap() const \
  222.         { return &theClass::interfaceMap; } \
  223.     AFX_COMDAT const AFX_DATADEF AFX_INTERFACEMAP theClass::interfaceMap = \
  224.         { &theBase::interfaceMap, &theClass::_interfaceEntries[0], }; \
  225.     AFX_COMDAT const AFX_DATADEF AFX_INTERFACEMAP_ENTRY theClass::_interfaceEntries[] = \
  226.     { \
  227.  
  228. #endif
  229.  
  230. #define INTERFACE_PART(theClass, iid, localClass) \
  231.         { &iid, offsetof(theClass, m_x##localClass) }, \
  232.  
  233. #define INTERFACE_AGGREGATE(theClass, theAggr) \
  234.         { NULL, offsetof(theClass, theAggr) }, \
  235.  
  236. #define END_INTERFACE_MAP() \
  237.         { NULL, (size_t)-1 } \
  238.     }; \
  239.  
  240. /////////////////////////////////////////////////////////////////////////////
  241. // COleException - unexpected or rare OLE error returned
  242.  
  243. class COleException : public CException
  244. {
  245.     DECLARE_DYNAMIC(COleException)
  246.  
  247. public:
  248.     SCODE m_sc;
  249.     static SCODE PASCAL Process(const CException* pAnyException);
  250.  
  251. // Implementation (use AfxThrowOleException to create)
  252. public:
  253.     COleException();
  254.     virtual ~COleException();
  255.  
  256.     virtual BOOL GetErrorMessage(LPTSTR lpszError, UINT nMaxError,
  257.         PUINT pnHelpContext = NULL);
  258. };
  259.  
  260. void AFXAPI AfxThrowOleException(SCODE sc);
  261. void AFXAPI AfxCheckError(SCODE sc);
  262.  
  263. /////////////////////////////////////////////////////////////////////////////
  264. // IDispatch specific exception
  265.  
  266. class COleDispatchException : public CException
  267. {
  268.     DECLARE_DYNAMIC(COleDispatchException)
  269.  
  270. public:
  271. // Attributes
  272.     WORD m_wCode;   // error code (specific to IDispatch implementation)
  273.     CString m_strDescription;   // human readable description of the error
  274.     DWORD m_dwHelpContext;      // help context for error
  275.  
  276.     // usually empty in application which creates it (eg. servers)
  277.     CString m_strHelpFile;      // help file to use with m_dwHelpContext
  278.     CString m_strSource;        // source of the error (name of server)
  279.  
  280. // Implementation
  281. public:
  282.     COleDispatchException(LPCTSTR lpszDescription, UINT nHelpID, WORD wCode);
  283.     virtual ~COleDispatchException();
  284.     static void PASCAL Process(
  285.         EXCEPINFO* pInfo, const CException* pAnyException);
  286.  
  287.     virtual BOOL GetErrorMessage(LPTSTR lpszError, UINT nMaxError,
  288.         PUINT pnHelpContext = NULL);
  289.  
  290.     SCODE m_scError;            // SCODE describing the error
  291. };
  292.  
  293. void AFXAPI AfxThrowOleDispatchException(WORD wCode, LPCTSTR lpszDescription,
  294.     UINT nHelpID = 0);
  295. void AFXAPI AfxThrowOleDispatchException(WORD wCode, UINT nDescriptionID,
  296.     UINT nHelpID = (UINT)-1);
  297.  
  298. /////////////////////////////////////////////////////////////////////////////
  299. // Macros for CCmdTarget IDispatchable classes
  300.  
  301. #ifdef _AFXDLL
  302. #define BEGIN_DISPATCH_MAP(theClass, baseClass) \
  303.     const AFX_DISPMAP* PASCAL theClass::_GetBaseDispatchMap() \
  304.         { return &baseClass::dispatchMap; } \
  305.     const AFX_DISPMAP* theClass::GetDispatchMap() const \
  306.         { return &theClass::dispatchMap; } \
  307.     AFX_COMDAT const AFX_DISPMAP theClass::dispatchMap = \
  308.         { &theClass::_GetBaseDispatchMap, &theClass::_dispatchEntries[0], \
  309.             &theClass::_dispatchEntryCount, &theClass::_dwStockPropMask }; \
  310.     AFX_COMDAT UINT theClass::_dispatchEntryCount = (UINT)-1; \
  311.     AFX_COMDAT DWORD theClass::_dwStockPropMask = (DWORD)-1; \
  312.     AFX_COMDAT const AFX_DISPMAP_ENTRY theClass::_dispatchEntries[] = \
  313.     { \
  314.  
  315. #else
  316. #define BEGIN_DISPATCH_MAP(theClass, baseClass) \
  317.     const AFX_DISPMAP* theClass::GetDispatchMap() const \
  318.         { return &theClass::dispatchMap; } \
  319.     AFX_COMDAT const AFX_DISPMAP theClass::dispatchMap = \
  320.         { &baseClass::dispatchMap, &theClass::_dispatchEntries[0], \
  321.             &theClass::_dispatchEntryCount, &theClass::_dwStockPropMask }; \
  322.     AFX_COMDAT UINT theClass::_dispatchEntryCount = (UINT)-1; \
  323.     AFX_COMDAT DWORD theClass::_dwStockPropMask = (DWORD)-1; \
  324.     AFX_COMDAT const AFX_DISPMAP_ENTRY theClass::_dispatchEntries[] = \
  325.     { \
  326.  
  327. #endif
  328.  
  329. #define END_DISPATCH_MAP() \
  330.     { VTS_NONE, DISPID_UNKNOWN, VTS_NONE, VT_VOID, \
  331.         (AFX_PMSG)NULL, (AFX_PMSG)NULL, (size_t)-1, afxDispCustom } }; \
  332.  
  333. // parameter types: by value VTs
  334. #define VTS_I2              "\x02"      // a 'short'
  335. #define VTS_I4              "\x03"      // a 'long'
  336. #define VTS_R4              "\x04"      // a 'float'
  337. #define VTS_R8              "\x05"      // a 'double'
  338. #define VTS_CY              "\x06"      // a 'CY' or 'CY*'
  339. #define VTS_DATE            "\x07"      // a 'DATE'
  340. #define VTS_WBSTR           "\x08"      // an 'LPCOLESTR'
  341. #define VTS_DISPATCH        "\x09"      // an 'IDispatch*'
  342. #define VTS_SCODE           "\x0A"      // an 'SCODE'
  343. #define VTS_BOOL            "\x0B"      // a 'BOOL'
  344. #define VTS_VARIANT         "\x0C"      // a 'const VARIANT&' or 'VARIANT*'
  345. #define VTS_UNKNOWN         "\x0D"      // an 'IUnknown*'
  346. #if defined(_UNICODE) || defined(OLE2ANSI)
  347.     #define VTS_BSTR            VTS_WBSTR// an 'LPCOLESTR'
  348.     #define VT_BSTRT            VT_BSTR
  349. #else
  350.     #define VTS_BSTR            "\x0E"  // an 'LPCSTR'
  351.     #define VT_BSTRA            14
  352.     #define VT_BSTRT            VT_BSTRA
  353. #endif
  354. #define VTS_UI1             "\x0F"      // a 'BYTE'
  355.  
  356. // parameter types: by reference VTs
  357. #define VTS_PI2             "\x42"      // a 'short*'
  358. #define VTS_PI4             "\x43"      // a 'long*'
  359. #define VTS_PR4             "\x44"      // a 'float*'
  360. #define VTS_PR8             "\x45"      // a 'double*'
  361. #define VTS_PCY             "\x46"      // a 'CY*'
  362. #define VTS_PDATE           "\x47"      // a 'DATE*'
  363. #define VTS_PBSTR           "\x48"      // a 'BSTR*'
  364. #define VTS_PDISPATCH       "\x49"      // an 'IDispatch**'
  365. #define VTS_PSCODE          "\x4A"      // an 'SCODE*'
  366. #define VTS_PBOOL           "\x4B"      // a 'VARIANT_BOOL*'
  367. #define VTS_PVARIANT        "\x4C"      // a 'VARIANT*'
  368. #define VTS_PUNKNOWN        "\x4D"      // an 'IUnknown**'
  369. #define VTS_PUI1            "\x4F"      // a 'BYTE*'
  370.  
  371. // special VT_ and VTS_ values
  372. #define VTS_NONE            NULL        // used for members with 0 params
  373. #define VT_MFCVALUE         0xFFF       // special value for DISPID_VALUE
  374. #define VT_MFCBYREF         0x40        // indicates VT_BYREF type
  375. #define VT_MFCMARKER        0xFF        // delimits named parameters (INTERNAL USE)
  376.  
  377. // variant handling (use V_BSTRT when you have ANSI BSTRs, as in DAO)
  378. #ifndef _UNICODE
  379.     #define V_BSTRT(b)  (LPSTR)V_BSTR(b)
  380. #else
  381.     #define V_BSTRT(b)  V_BSTR(b)
  382. #endif
  383.  
  384. /////////////////////////////////////////////////////////////////////////////
  385. // OLE control parameter types
  386.  
  387. #define VTS_COLOR           VTS_I4      // OLE_COLOR
  388. #define VTS_XPOS_PIXELS     VTS_I4      // OLE_XPOS_PIXELS
  389. #define VTS_YPOS_PIXELS     VTS_I4      // OLE_YPOS_PIXELS
  390. #define VTS_XSIZE_PIXELS    VTS_I4      // OLE_XSIZE_PIXELS
  391. #define VTS_YSIZE_PIXELS    VTS_I4      // OLE_YSIZE_PIXELS
  392. #define VTS_XPOS_HIMETRIC   VTS_I4      // OLE_XPOS_HIMETRIC
  393. #define VTS_YPOS_HIMETRIC   VTS_I4      // OLE_YPOS_HIMETRIC
  394. #define VTS_XSIZE_HIMETRIC  VTS_I4      // OLE_XSIZE_HIMETRIC
  395. #define VTS_YSIZE_HIMETRIC  VTS_I4      // OLE_YSIZE_HIMETRIC
  396. #define VTS_TRISTATE        VTS_I2      // OLE_TRISTATE
  397. #define VTS_OPTEXCLUSIVE    VTS_BOOL    // OLE_OPTEXCLUSIVE
  398.  
  399. #define VTS_PCOLOR          VTS_PI4     // OLE_COLOR*
  400. #define VTS_PXPOS_PIXELS    VTS_PI4     // OLE_XPOS_PIXELS*
  401. #define VTS_PYPOS_PIXELS    VTS_PI4     // OLE_YPOS_PIXELS*
  402. #define VTS_PXSIZE_PIXELS   VTS_PI4     // OLE_XSIZE_PIXELS*
  403. #define VTS_PYSIZE_PIXELS   VTS_PI4     // OLE_YSIZE_PIXELS*
  404. #define VTS_PXPOS_HIMETRIC  VTS_PI4     // OLE_XPOS_HIMETRIC*
  405. #define VTS_PYPOS_HIMETRIC  VTS_PI4     // OLE_YPOS_HIMETRIC*
  406. #define VTS_PXSIZE_HIMETRIC VTS_PI4     // OLE_XSIZE_HIMETRIC*
  407. #define VTS_PYSIZE_HIMETRIC VTS_PI4     // OLE_YSIZE_HIMETRIC*
  408. #define VTS_PTRISTATE       VTS_PI2     // OLE_TRISTATE*
  409. #define VTS_POPTEXCLUSIVE   VTS_PBOOL   // OLE_OPTEXCLUSIVE*
  410.  
  411. #define VTS_FONT            VTS_DISPATCH    // IFontDispatch*
  412. #define VTS_PICTURE         VTS_DISPATCH    // IPictureDispatch*
  413.  
  414. #define VTS_HANDLE          VTS_I4      // OLE_HANDLE
  415. #define VTS_PHANDLE         VTS_PI4     // OLE_HANDLE*
  416.  
  417. // these DISP_ macros cause the framework to generate the DISPID
  418. #define DISP_FUNCTION(theClass, szExternalName, pfnMember, vtRetVal, vtsParams) \
  419.     { _T(szExternalName), DISPID_UNKNOWN, vtsParams, vtRetVal, \
  420.         (AFX_PMSG)(void (theClass::*)(void))&pfnMember, (AFX_PMSG)0, 0, \
  421.         afxDispCustom }, \
  422.  
  423. #define DISP_PROPERTY(theClass, szExternalName, memberName, vtPropType) \
  424.     { _T(szExternalName), DISPID_UNKNOWN, NULL, vtPropType, (AFX_PMSG)0, (AFX_PMSG)0, \
  425.         offsetof(theClass, memberName), afxDispCustom }, \
  426.  
  427. #define DISP_PROPERTY_NOTIFY(theClass, szExternalName, memberName, pfnAfterSet, vtPropType) \
  428.     { _T(szExternalName), DISPID_UNKNOWN, NULL, vtPropType, (AFX_PMSG)0, \
  429.         (AFX_PMSG)(void (theClass::*)(void))&pfnAfterSet, \
  430.         offsetof(theClass, memberName), afxDispCustom }, \
  431.  
  432. #define DISP_PROPERTY_EX(theClass, szExternalName, pfnGet, pfnSet, vtPropType) \
  433.     { _T(szExternalName), DISPID_UNKNOWN, NULL, vtPropType, \
  434.         (AFX_PMSG)(void (theClass::*)(void))&pfnGet, \
  435.         (AFX_PMSG)(void (theClass::*)(void))&pfnSet, 0, afxDispCustom }, \
  436.  
  437. #define DISP_PROPERTY_PARAM(theClass, szExternalName, pfnGet, pfnSet, vtPropType, vtsParams) \
  438.     { _T(szExternalName), DISPID_UNKNOWN, vtsParams, vtPropType, \
  439.         (AFX_PMSG)(void (theClass::*)(void))&pfnGet, \
  440.         (AFX_PMSG)(void (theClass::*)(void))&pfnSet, 0, afxDispCustom }, \
  441.  
  442. // these DISP_ macros allow the app to determine the DISPID
  443. #define DISP_FUNCTION_ID(theClass, szExternalName, dispid, pfnMember, vtRetVal, vtsParams) \
  444.     { _T(szExternalName), dispid, vtsParams, vtRetVal, \
  445.         (AFX_PMSG)(void (theClass::*)(void))&pfnMember, (AFX_PMSG)0, 0, \
  446.         afxDispCustom }, \
  447.  
  448. #define DISP_PROPERTY_ID(theClass, szExternalName, dispid, memberName, vtPropType) \
  449.     { _T(szExternalName), dispid, NULL, vtPropType, (AFX_PMSG)0, (AFX_PMSG)0, \
  450.         offsetof(theClass, memberName), afxDispCustom }, \
  451.  
  452. #define DISP_PROPERTY_NOTIFY_ID(theClass, szExternalName, dispid, memberName, pfnAfterSet, vtPropType) \
  453.     { _T(szExternalName), dispid, NULL, vtPropType, (AFX_PMSG)0, \
  454.         (AFX_PMSG)(void (theClass::*)(void))&pfnAfterSet, \
  455.         offsetof(theClass, memberName), afxDispCustom }, \
  456.  
  457. #define DISP_PROPERTY_EX_ID(theClass, szExternalName, dispid, pfnGet, pfnSet, vtPropType) \
  458.     { _T(szExternalName), dispid, NULL, vtPropType, \
  459.         (AFX_PMSG)(void (theClass::*)(void))&pfnGet, \
  460.         (AFX_PMSG)(void (theClass::*)(void))&pfnSet, 0, afxDispCustom }, \
  461.  
  462. #define DISP_PROPERTY_PARAM_ID(theClass, szExternalName, dispid, pfnGet, pfnSet, vtPropType, vtsParams) \
  463.     { _T(szExternalName), dispid, vtsParams, vtPropType, \
  464.         (AFX_PMSG)(void (theClass::*)(void))&pfnGet, \
  465.         (AFX_PMSG)(void (theClass::*)(void))&pfnSet, 0, afxDispCustom }, \
  466.  
  467. // the DISP_DEFVALUE is a special case macro that creates an alias for DISPID_VALUE
  468. #define DISP_DEFVALUE(theClass, szExternalName) \
  469.     { _T(szExternalName), DISPID_UNKNOWN, NULL, VT_MFCVALUE, \
  470.         (AFX_PMSG)0, (AFX_PMSG)0, 0, afxDispCustom }, \
  471.  
  472. #define DISP_DEFVALUE_ID(theClass, dispid) \
  473.     { NULL, dispid, NULL, VT_MFCVALUE, (AFX_PMSG)0, (AFX_PMSG)0, 0, \
  474.         afxDispCustom }, \
  475.  
  476. /////////////////////////////////////////////////////////////////////////////
  477. // Macros for creating "creatable" automation classes.
  478.  
  479. #define DECLARE_OLECREATE(class_name) \
  480. public: \
  481.     static AFX_DATA COleObjectFactory factory; \
  482.     static AFX_DATA const GUID guid; \
  483.  
  484. #define IMPLEMENT_OLECREATE(class_name, external_name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
  485.     AFX_DATADEF COleObjectFactory class_name::factory(class_name::guid, \
  486.         RUNTIME_CLASS(class_name), FALSE, _T(external_name)); \
  487.     AFX_COMDAT const AFX_DATADEF GUID class_name::guid = \
  488.         { l, w1, w2, { b1, b2, b3, b4, b5, b6, b7, b8 } }; \
  489.  
  490. /////////////////////////////////////////////////////////////////////////////
  491. // Helper class for driving IDispatch
  492.  
  493. class COleDispatchDriver
  494. {
  495. // Constructors
  496. public:
  497.     COleDispatchDriver();
  498.     COleDispatchDriver(LPDISPATCH lpDispatch, BOOL bAutoRelease = TRUE);
  499.     COleDispatchDriver(const COleDispatchDriver& dispatchSrc);
  500.  
  501. // Attributes
  502.     LPDISPATCH m_lpDispatch;
  503.     BOOL m_bAutoRelease;
  504.  
  505. // Operations
  506.     BOOL CreateDispatch(REFCLSID clsid, COleException* pError = NULL);
  507.     BOOL CreateDispatch(LPCTSTR lpszProgID, COleException* pError = NULL);
  508.  
  509.     void AttachDispatch(LPDISPATCH lpDispatch, BOOL bAutoRelease = TRUE);
  510.     LPDISPATCH DetachDispatch();
  511.         // detach and get ownership of m_lpDispatch
  512.     void ReleaseDispatch();
  513.  
  514.     // helpers for IDispatch::Invoke
  515.     void AFX_CDECL InvokeHelper(DISPID dwDispID, WORD wFlags,
  516.         VARTYPE vtRet, void* pvRet, const BYTE* pbParamInfo, ...);
  517.     void AFX_CDECL SetProperty(DISPID dwDispID, VARTYPE vtProp, ...);
  518.     void GetProperty(DISPID dwDispID, VARTYPE vtProp, void* pvProp) const;
  519.  
  520.     // special operators
  521.     operator LPDISPATCH();
  522.     const COleDispatchDriver& operator=(const COleDispatchDriver& dispatchSrc);
  523.  
  524. // Implementation
  525. public:
  526.     ~COleDispatchDriver();
  527.     void InvokeHelperV(DISPID dwDispID, WORD wFlags, VARTYPE vtRet,
  528.         void* pvRet, const BYTE* pbParamInfo, va_list argList);
  529. };
  530.  
  531. /////////////////////////////////////////////////////////////////////////////
  532. // Class Factory implementation (binds OLE class factory -> runtime class)
  533. //  (all specific class factories derive from this class factory)
  534.  
  535. class COleObjectFactory : public CCmdTarget
  536. {
  537.     DECLARE_DYNAMIC(COleObjectFactory)
  538.  
  539. // Construction
  540. public:
  541.     COleObjectFactory(REFCLSID clsid, CRuntimeClass* pRuntimeClass,
  542.         BOOL bMultiInstance, LPCTSTR lpszProgID);
  543.  
  544. // Attributes
  545.     virtual BOOL IsRegistered() const;
  546.     REFCLSID GetClassID() const;
  547.  
  548. // Operations
  549.     virtual BOOL Register();
  550.     BOOL Unregister();
  551.     void Revoke();
  552.     void UpdateRegistry(LPCTSTR lpszProgID = NULL);
  553.         // default uses m_lpszProgID if not NULL
  554.     BOOL IsLicenseValid();
  555.  
  556.     static BOOL PASCAL UnregisterAll();
  557.     static BOOL PASCAL RegisterAll();
  558.     static void PASCAL RevokeAll();
  559.     static BOOL PASCAL UpdateRegistryAll(BOOL bRegister = TRUE);
  560.  
  561. // Overridables
  562. protected:
  563.     virtual CCmdTarget* OnCreateObject();
  564.     virtual BOOL UpdateRegistry(BOOL bRegister);
  565.     virtual BOOL VerifyUserLicense();
  566.     virtual BOOL GetLicenseKey(DWORD dwReserved, BSTR* pbstrKey);
  567.     virtual BOOL VerifyLicenseKey(BSTR bstrKey);
  568.  
  569. // Implementation
  570. public:
  571.     virtual ~COleObjectFactory();
  572. #ifdef _DEBUG
  573.     void AssertValid() const;
  574.     void Dump(CDumpContext& dc) const;
  575. #endif
  576.  
  577. public:
  578.     COleObjectFactory* m_pNextFactory;  // list of factories maintained
  579.  
  580. protected:
  581.     DWORD m_dwRegister;             // registry identifier
  582.     CLSID m_clsid;                  // registered class ID
  583.     CRuntimeClass* m_pRuntimeClass; // runtime class of CCmdTarget derivative
  584.     BOOL m_bMultiInstance;          // multiple instance?
  585.     LPCTSTR m_lpszProgID;           // human readable class ID
  586.     BYTE m_bLicenseChecked;
  587.     BYTE m_bLicenseValid;
  588.     BYTE m_bRegistered;             // is currently registered w/ system
  589.     BYTE m_bOAT;                          // used by COleTemplateServer to
  590.                                               // remember application type for unregistry
  591.  
  592. // Interface Maps
  593. public:
  594.     BEGIN_INTERFACE_PART(ClassFactory, IClassFactory2)
  595.         INIT_INTERFACE_PART(COleObjectFactory, ClassFactory)
  596.         STDMETHOD(CreateInstance)(LPUNKNOWN, REFIID, LPVOID*);
  597.         STDMETHOD(LockServer)(BOOL);
  598.         STDMETHOD(GetLicInfo)(LPLICINFO);
  599.         STDMETHOD(RequestLicKey)(DWORD, BSTR*);
  600.         STDMETHOD(CreateInstanceLic)(LPUNKNOWN, LPUNKNOWN, REFIID, BSTR,
  601.             LPVOID*);
  602.     END_INTERFACE_PART(ClassFactory)
  603.  
  604.     DECLARE_INTERFACE_MAP()
  605.  
  606.     friend SCODE AFXAPI AfxDllGetClassObject(REFCLSID, REFIID, LPVOID*);
  607.     friend SCODE STDAPICALLTYPE DllGetClassObject(REFCLSID, REFIID, LPVOID*);
  608. };
  609.  
  610. // Define COleObjectFactoryEx for compatibility with old CDK
  611. #define COleObjectFactoryEx COleObjectFactory
  612.  
  613. //////////////////////////////////////////////////////////////////////////////
  614. // COleTemplateServer - COleObjectFactory using CDocTemplates
  615.  
  616. // This enumeration is used in AfxOleRegisterServerClass to pick the
  617. //  correct registration entries given the application type.
  618. enum OLE_APPTYPE
  619. {
  620.     OAT_UNKNOWN = -1,                // no type decided yet
  621.     OAT_INPLACE_SERVER = 0,     // server has full server user-interface
  622.     OAT_SERVER = 1,             // server supports only embedding
  623.     OAT_CONTAINER = 2,          // container supports links to embeddings
  624.     OAT_DISPATCH_OBJECT = 3,    // IDispatch capable object
  625.     OAT_DOC_OBJECT_SERVER = 4,  // sever supports DocObject embedding
  626.     OAT_DOC_OBJECT_CONTAINER =5,// container supports DocObject clients
  627. };
  628.  
  629. class COleTemplateServer : public COleObjectFactory
  630. {
  631. // Constructors
  632. public:
  633.     COleTemplateServer();
  634.  
  635. // Operations
  636.     void ConnectTemplate(REFCLSID clsid, CDocTemplate* pDocTemplate,
  637.         BOOL bMultiInstance);
  638.         // set doc template after creating it in InitInstance
  639.     void UpdateRegistry(OLE_APPTYPE nAppType = OAT_INPLACE_SERVER,
  640.         LPCTSTR* rglpszRegister = NULL, LPCTSTR* rglpszOverwrite = NULL);
  641.         // may want to UpdateRegistry if not run with /Embedded
  642.     BOOL Register();
  643.     BOOL Unregister();
  644.  
  645. // Implementation
  646. protected:
  647.     virtual BOOL OnCmdMsg(UINT nID, int nCode, void* pExtra,
  648.             AFX_CMDHANDLERINFO* pHandlerInfo);
  649.     virtual CCmdTarget* OnCreateObject();
  650.     CDocTemplate* m_pDocTemplate;
  651.  
  652. private:
  653.     void UpdateRegistry(LPCTSTR lpszProgID);
  654.         // hide base class version of UpdateRegistry
  655. };
  656.  
  657. /////////////////////////////////////////////////////////////////////////////
  658. // System registry helpers
  659.  
  660. // Helper to register server in case of no .REG file loaded
  661. BOOL AFXAPI AfxOleRegisterServerClass(
  662.     REFCLSID clsid, LPCTSTR lpszClassName,
  663.     LPCTSTR lpszShortTypeName, LPCTSTR lpszLongTypeName,
  664.     OLE_APPTYPE nAppType = OAT_SERVER,
  665.     LPCTSTR* rglpszRegister = NULL, LPCTSTR* rglpszOverwrite = NULL,
  666.     int nIconIndex = 0, LPCTSTR lpszLocalFilterName = NULL);
  667. BOOL AFXAPI AfxOleRegisterServerClass(
  668.     REFCLSID clsid, LPCTSTR lpszClassName,
  669.     LPCTSTR lpszShortTypeName, LPCTSTR lpszLongTypeName,
  670.     OLE_APPTYPE nAppType,
  671.     LPCTSTR* rglpszRegister, LPCTSTR* rglpszOverwrite,
  672.     int nIconIndex, LPCTSTR lpszLocalFilterName, LPCTSTR lpszLocalFilterExt);
  673.  
  674. BOOL AFXAPI AfxOleUnregisterServerClass(
  675.     REFCLSID clsid, LPCTSTR lpszClassName, LPCTSTR lpszShortTypeName,
  676.     LPCTSTR lpszLongTypeName, OLE_APPTYPE nAppType = OAT_SERVER,
  677.     LPCTSTR* rglpszRegister = NULL, LPCTSTR* rglpszOverwrite = NULL);
  678.  
  679. // AfxOleRegisterHelper is a worker function used by
  680. //  AfxOleRegisterServerClass (available for advanced registry work)
  681. BOOL AFXAPI AfxOleRegisterHelper(LPCTSTR const* rglpszRegister,
  682.     LPCTSTR const* rglpszSymbols, int nSymbols, BOOL bReplace,
  683.     HKEY hKeyRoot = ((HKEY)0x80000000)); // HKEY_CLASSES_ROOT
  684.  
  685. BOOL AFXAPI AfxOleUnregisterHelper(LPCTSTR const* rglpszRegister,
  686.     LPCTSTR const* rglpszSymbols, int nSymbols,
  687.     HKEY hKeyRoot = ((HKEY)0x80000000)); // HKEY_CLASSES_ROOT
  688.  
  689. /////////////////////////////////////////////////////////////////////////////
  690. // Connection maps
  691.  
  692. #define BEGIN_CONNECTION_PART(theClass, localClass) \
  693.     class X##localClass : public CConnectionPoint \
  694.     { \
  695.     public: \
  696.         X##localClass() \
  697.             { m_nOffset = offsetof(theClass, m_x##localClass); }
  698.  
  699. #define CONNECTION_IID(iid) \
  700.         REFIID GetIID() { return iid; }
  701.  
  702. #define END_CONNECTION_PART(localClass) \
  703.     } m_x##localClass; \
  704.     friend class X##localClass;
  705.  
  706. #ifdef _AFXDLL
  707. #define BEGIN_CONNECTION_MAP(theClass, theBase) \
  708.     const AFX_CONNECTIONMAP* PASCAL theClass::_GetBaseConnectionMap() \
  709.         { return &theBase::connectionMap; } \
  710.     const AFX_CONNECTIONMAP* theClass::GetConnectionMap() const \
  711.         { return &theClass::connectionMap; } \
  712.     AFX_COMDAT const AFX_DATADEF AFX_CONNECTIONMAP theClass::connectionMap = \
  713.         { &theClass::_GetBaseConnectionMap, &theClass::_connectionEntries[0], }; \
  714.     AFX_COMDAT const AFX_DATADEF AFX_CONNECTIONMAP_ENTRY theClass::_connectionEntries[] = \
  715.     { \
  716.  
  717. #else
  718. #define BEGIN_CONNECTION_MAP(theClass, theBase) \
  719.     const AFX_CONNECTIONMAP* theClass::GetConnectionMap() const \
  720.         { return &theClass::connectionMap; } \
  721.     AFX_COMDAT const AFX_DATADEF AFX_CONNECTIONMAP theClass::connectionMap = \
  722.         { &(theBase::connectionMap), &theClass::_connectionEntries[0], }; \
  723.     AFX_COMDAT const AFX_DATADEF AFX_CONNECTIONMAP_ENTRY theClass::_connectionEntries[] = \
  724.     { \
  725.  
  726. #endif
  727.  
  728. #define CONNECTION_PART(theClass, iid, localClass) \
  729.         { &iid, offsetof(theClass, m_x##localClass) }, \
  730.  
  731. #define END_CONNECTION_MAP() \
  732.         { NULL, (size_t)-1 } \
  733.     }; \
  734.  
  735. /////////////////////////////////////////////////////////////////////////////
  736. // CConnectionPoint
  737.  
  738. #ifdef _AFXDLL
  739. class CConnectionPoint : public CCmdTarget
  740. #else
  741. class AFX_NOVTABLE CConnectionPoint : public CCmdTarget
  742. #endif
  743. {
  744. // Constructors
  745. public:
  746.     CConnectionPoint();
  747.  
  748. // Operations
  749.     POSITION GetStartPosition() const;
  750.     LPUNKNOWN GetNextConnection(POSITION& pos) const;
  751.     const CPtrArray* GetConnections();  // obsolete
  752.  
  753. // Overridables
  754.     virtual LPCONNECTIONPOINTCONTAINER GetContainer();
  755.     virtual REFIID GetIID() = 0;
  756.     virtual void OnAdvise(BOOL bAdvise);
  757.     virtual int GetMaxConnections();
  758.     virtual LPUNKNOWN QuerySinkInterface(LPUNKNOWN pUnkSink);
  759.  
  760. // Implementation
  761.     ~CConnectionPoint();
  762.     void CreateConnectionArray();
  763.     int GetConnectionCount();
  764.  
  765. protected:
  766.     size_t m_nOffset;
  767.     LPUNKNOWN m_pUnkFirstConnection;
  768.     CPtrArray* m_pConnections;
  769.  
  770. // Interface Maps
  771. public:
  772.     BEGIN_INTERFACE_PART(ConnPt, IConnectionPoint)
  773.         INIT_INTERFACE_PART(CConnectionPoint, ConnPt)
  774.         STDMETHOD(GetConnectionInterface)(IID* pIID);
  775.         STDMETHOD(GetConnectionPointContainer)(
  776.             IConnectionPointContainer** ppCPC);
  777.         STDMETHOD(Advise)(LPUNKNOWN pUnkSink, DWORD* pdwCookie);
  778.         STDMETHOD(Unadvise)(DWORD dwCookie);
  779.         STDMETHOD(EnumConnections)(LPENUMCONNECTIONS* ppEnum);
  780.     END_INTERFACE_PART(ConnPt)
  781. };
  782.  
  783. /////////////////////////////////////////////////////////////////////////////
  784. // EventSink Maps
  785.  
  786. #ifndef _AFX_NO_OCC_SUPPORT
  787.  
  788. #ifdef _AFXDLL
  789. #define BEGIN_EVENTSINK_MAP(theClass, baseClass) \
  790.     const AFX_EVENTSINKMAP* PASCAL theClass::_GetBaseEventSinkMap() \
  791.         { return &baseClass::eventsinkMap; } \
  792.     const AFX_EVENTSINKMAP* theClass::GetEventSinkMap() const \
  793.         { return &theClass::eventsinkMap; } \
  794.     const AFX_EVENTSINKMAP theClass::eventsinkMap = \
  795.         { &theClass::_GetBaseEventSinkMap, &theClass::_eventsinkEntries[0], \
  796.             &theClass::_eventsinkEntryCount }; \
  797.     UINT theClass::_eventsinkEntryCount = (UINT)-1; \
  798.     const AFX_EVENTSINKMAP_ENTRY theClass::_eventsinkEntries[] = \
  799.     { \
  800.  
  801. #else
  802. #define BEGIN_EVENTSINK_MAP(theClass, baseClass) \
  803.     const AFX_EVENTSINKMAP* theClass::GetEventSinkMap() const \
  804.         { return &theClass::eventsinkMap; } \
  805.     const AFX_EVENTSINKMAP theClass::eventsinkMap = \
  806.         { &baseClass::eventsinkMap, &theClass::_eventsinkEntries[0], \
  807.             &theClass::_eventsinkEntryCount }; \
  808.     UINT theClass::_eventsinkEntryCount = (UINT)-1; \
  809.     const AFX_EVENTSINKMAP_ENTRY theClass::_eventsinkEntries[] = \
  810.     { \
  811.  
  812. #endif
  813.  
  814. #define END_EVENTSINK_MAP() \
  815.     { VTS_NONE, DISPID_UNKNOWN, VTS_NONE, VT_VOID, \
  816.         (AFX_PMSG)NULL, (AFX_PMSG)NULL, (size_t)-1, afxDispCustom, \
  817.         (UINT)-1, 0 } }; \
  818.  
  819. #define ON_EVENT(theClass, id, dispid, pfnHandler, vtsParams) \
  820.     { _T(""), dispid, vtsParams, VT_BOOL, \
  821.         (AFX_PMSG)(void (theClass::*)(void))&pfnHandler, (AFX_PMSG)0, 0, \
  822.         afxDispCustom, id, (UINT)-1 }, \
  823.  
  824. #define ON_EVENT_RANGE(theClass, idFirst, idLast, dispid, pfnHandler, vtsParams) \
  825.     { _T(""), dispid, vtsParams, VT_BOOL, \
  826.         (AFX_PMSG)(void (theClass::*)(void))&pfnHandler, (AFX_PMSG)0, 0, \
  827.         afxDispCustom, idFirst, idLast }, \
  828.  
  829. #define ON_PROPNOTIFY(theClass, id, dispid, pfnRequest, pfnChanged) \
  830.     { _T(""), dispid, VTS_NONE, VT_VOID, \
  831.         (AFX_PMSG)(BOOL (CCmdTarget::*)(BOOL*))&pfnRequest, \
  832.         (AFX_PMSG)(BOOL (CCmdTarget::*)(void))&pfnChanged, \
  833.         1, afxDispCustom, id, (UINT)-1 }, \
  834.  
  835. #define ON_PROPNOTIFY_RANGE(theClass, idFirst, idLast, dispid, pfnRequest, pfnChanged) \
  836.     { _T(""), dispid, VTS_NONE, VT_VOID, \
  837.         (AFX_PMSG)(BOOL (CCmdTarget::*)(UINT, BOOL*))&pfnRequest, \
  838.         (AFX_PMSG)(BOOL (CCmdTarget::*)(UINT))&pfnChanged, \
  839.         1, afxDispCustom, idFirst, idLast }, \
  840.  
  841. #define ON_DSCNOTIFY(theClass, id, pfnNotify) \
  842.     { _T(""), DISPID_UNKNOWN, VTS_NONE, VT_VOID, \
  843.         (AFX_PMSG)(BOOL (CCmdTarget::*)(DSCSTATE, DSCREASON, BOOL*))&pfnNotify, (AFX_PMSG)0, \
  844.         1, afxDispCustom, id, (UINT)-1 }, \
  845.  
  846. #define ON_DSCNOTIFY_RANGE(theClass, idFirst, idLast, pfnNotify) \
  847.     { _T(""), DISPID_UNKNOWN, VTS_NONE, VT_VOID, \
  848.         (AFX_PMSG)(BOOL (CCmdTarget::*)(UINT, DSCSTATE, DSCREASON, BOOL*))&pfnNotify, (AFX_PMSG)0, \
  849.         1, afxDispCustom, idFirst, idLast }, \
  850.  
  851. #define ON_EVENT_REFLECT(theClass, dispid, pfnHandler, vtsParams) \
  852.     { _T(""), dispid, vtsParams, VT_BOOL, \
  853.         (AFX_PMSG)(void (theClass::*)(void))&pfnHandler, (AFX_PMSG)0, 0, \
  854.         afxDispCustom, (UINT)-1, (UINT)-1 }, \
  855.  
  856. #define ON_PROPNOTIFY_REFLECT(theClass, dispid, pfnRequest, pfnChanged) \
  857.     { _T(""), dispid, VTS_NONE, VT_VOID, \
  858.         (AFX_PMSG)(BOOL (CCmdTarget::*)(BOOL*))&pfnRequest, \
  859.         (AFX_PMSG)(BOOL (CCmdTarget::*)(void))&pfnChanged, \
  860.         1, afxDispCustom, (UINT)-1, (UINT)-1 }, \
  861.  
  862. #endif // !_AFX_NO_OCC_SUPPORT
  863.  
  864. /////////////////////////////////////////////////////////////////////////////
  865. // Macros for type library information
  866.  
  867. CTypeLibCache* AFXAPI AfxGetTypeLibCache(const GUID* pTypeLibID);
  868.  
  869. #define DECLARE_OLETYPELIB(class_name) \
  870.     protected: \
  871.         virtual UINT GetTypeInfoCount(); \
  872.         virtual HRESULT GetTypeLib(LCID, LPTYPELIB*); \
  873.         virtual CTypeLibCache* GetTypeLibCache(); \
  874.  
  875. #define IMPLEMENT_OLETYPELIB(class_name, tlid, wVerMajor, wVerMinor) \
  876.     UINT class_name::GetTypeInfoCount() \
  877.         { return 1; } \
  878.     HRESULT class_name::GetTypeLib(LCID lcid, LPTYPELIB* ppTypeLib) \
  879.         { return ::LoadRegTypeLib(tlid, wVerMajor, wVerMinor, lcid, ppTypeLib); } \
  880.     CTypeLibCache* class_name::GetTypeLibCache() \
  881.         { AFX_MANAGE_STATE(m_pModuleState); return AfxGetTypeLibCache(&tlid); } \
  882.  
  883. /////////////////////////////////////////////////////////////////////////////
  884. // Init & Term helpers
  885.  
  886. BOOL AFXAPI AfxOleInit();
  887. void AFXAPI AfxOleTerm(BOOL bJustRevoke = FALSE);
  888. void AFXAPI AfxOleTermOrFreeLib(BOOL bTerm = TRUE, BOOL bJustRevoke = FALSE);
  889.  
  890. /////////////////////////////////////////////////////////////////////////////
  891. // Memory management helpers (for OLE task allocator memory)
  892.  
  893. #define AfxAllocTaskMem(nSize) CoTaskMemAlloc(nSize)
  894. #define AfxFreeTaskMem(p) CoTaskMemFree(p)
  895.  
  896. LPWSTR AFXAPI AfxAllocTaskWideString(LPCWSTR lpszString);
  897. LPWSTR AFXAPI AfxAllocTaskWideString(LPCSTR lpszString);
  898. LPSTR AFXAPI AfxAllocTaskAnsiString(LPCWSTR lpszString);
  899. LPSTR AFXAPI AfxAllocTaskAnsiString(LPCSTR lpszString);
  900.  
  901. #ifdef _UNICODE
  902.     #define AfxAllocTaskString(x) AfxAllocTaskWideString(x)
  903. #else
  904.     #define AfxAllocTaskString(x) AfxAllocTaskAnsiString(x)
  905. #endif
  906.  
  907. #ifdef OLE2ANSI
  908.     #define AfxAllocTaskOleString(x) AfxAllocTaskAnsiString(x)
  909. #else
  910.     #define AfxAllocTaskOleString(x) AfxAllocTaskWideString(x)
  911. #endif
  912.  
  913. HRESULT AFXAPI AfxGetClassIDFromString(LPCTSTR lpsz, LPCLSID lpClsID);
  914.  
  915. /////////////////////////////////////////////////////////////////////////////
  916. // Special in-proc server APIs
  917.  
  918. SCODE AFXAPI AfxDllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID* ppv);
  919. SCODE AFXAPI AfxDllCanUnloadNow(void);
  920.  
  921. /////////////////////////////////////////////////////////////////////////////
  922. // COleVariant class helpers
  923.  
  924. #define AFX_OLE_TRUE (-1)
  925. #define AFX_OLE_FALSE 0
  926.  
  927. class CLongBinary;  // forward reference (see afxdb_.h)
  928.  
  929. /////////////////////////////////////////////////////////////////////////////
  930. // COleVariant class - wraps VARIANT types
  931.  
  932. typedef const VARIANT* LPCVARIANT;
  933.  
  934. class COleVariant : public tagVARIANT
  935. {
  936. // Constructors
  937. public:
  938.     COleVariant();
  939.  
  940.     COleVariant(const VARIANT& varSrc);
  941.     COleVariant(LPCVARIANT pSrc);
  942.     COleVariant(const COleVariant& varSrc);
  943.  
  944.     COleVariant(LPCTSTR lpszSrc);
  945.     COleVariant(LPCTSTR lpszSrc, VARTYPE vtSrc); // used to set to ANSI string
  946.     COleVariant(CString& strSrc);
  947.  
  948.     COleVariant(BYTE nSrc);
  949.     COleVariant(short nSrc, VARTYPE vtSrc = VT_I2);
  950.     COleVariant(long lSrc, VARTYPE vtSrc = VT_I4);
  951.     COleVariant(const COleCurrency& curSrc);
  952.  
  953.     COleVariant(float fltSrc);
  954.     COleVariant(double dblSrc);
  955.     COleVariant(const COleDateTime& timeSrc);
  956.  
  957.     COleVariant(const CByteArray& arrSrc);
  958.     COleVariant(const CLongBinary& lbSrc);
  959.  
  960.     COleVariant(LPCITEMIDLIST pidl);
  961.  
  962. // Operations
  963. public:
  964.     void Clear();
  965.     void ChangeType(VARTYPE vartype, LPVARIANT pSrc = NULL);
  966.     void Attach(VARIANT& varSrc);
  967.     VARIANT Detach();
  968.  
  969.     BOOL operator==(const VARIANT& varSrc) const;
  970.     BOOL operator==(LPCVARIANT pSrc) const;
  971.  
  972.     const COleVariant& operator=(const VARIANT& varSrc);
  973.     const COleVariant& operator=(LPCVARIANT pSrc);
  974.     const COleVariant& operator=(const COleVariant& varSrc);
  975.  
  976.     const COleVariant& operator=(const LPCTSTR lpszSrc);
  977.     const COleVariant& operator=(const CString& strSrc);
  978.  
  979.     const COleVariant& operator=(BYTE nSrc);
  980.     const COleVariant& operator=(short nSrc);
  981.     const COleVariant& operator=(long lSrc);
  982.     const COleVariant& operator=(const COleCurrency& curSrc);
  983.  
  984.     const COleVariant& operator=(float fltSrc);
  985.     const COleVariant& operator=(double dblSrc);
  986.     const COleVariant& operator=(const COleDateTime& dateSrc);
  987.  
  988.     const COleVariant& operator=(const CByteArray& arrSrc);
  989.     const COleVariant& operator=(const CLongBinary& lbSrc);
  990.  
  991.     void SetString(LPCTSTR lpszSrc, VARTYPE vtSrc); // used to set ANSI string
  992.  
  993.     operator LPVARIANT();
  994.     operator LPCVARIANT() const;
  995.  
  996. // Implementation
  997. public:
  998.     ~COleVariant();
  999.     void _ClearCompat();
  1000. };
  1001.  
  1002. // COleVariant diagnostics and serialization
  1003. #ifdef _DEBUG
  1004. CDumpContext& AFXAPI operator<<(CDumpContext& dc, COleVariant varSrc);
  1005. #endif
  1006. CArchive& AFXAPI operator<<(CArchive& ar, COleVariant varSrc);
  1007. CArchive& AFXAPI operator>>(CArchive& ar, COleVariant& varSrc);
  1008.  
  1009. // Helper for initializing VARIANT structures
  1010. void AFXAPI AfxVariantInit(LPVARIANT pVar);
  1011.  
  1012. /////////////////////////////////////////////////////////////////////////////
  1013. // COleCurrency class
  1014.  
  1015. class COleCurrency
  1016. {
  1017. // Constructors
  1018. public:
  1019.     COleCurrency();
  1020.  
  1021.     COleCurrency(CURRENCY cySrc);
  1022.     COleCurrency(const COleCurrency& curSrc);
  1023.     COleCurrency(const VARIANT& varSrc);
  1024.     COleCurrency(long nUnits, long nFractionalUnits);
  1025.  
  1026. // Attributes
  1027. public:
  1028.     enum CurrencyStatus
  1029.     {
  1030.         valid = 0,
  1031.         invalid = 1,    // Invalid currency (overflow, div 0, etc.)
  1032.         null = 2,       // Literally has no value
  1033.     };
  1034.  
  1035.     CURRENCY m_cur;
  1036.     CurrencyStatus m_status;
  1037.  
  1038.     void SetStatus(CurrencyStatus status);
  1039.     CurrencyStatus GetStatus() const;
  1040.  
  1041. // Operations
  1042. public:
  1043.     const COleCurrency& operator=(CURRENCY cySrc);
  1044.     const COleCurrency& operator=(const COleCurrency& curSrc);
  1045.     const COleCurrency& operator=(const VARIANT& varSrc);
  1046.  
  1047.     BOOL operator==(const COleCurrency& cur) const;
  1048.     BOOL operator!=(const COleCurrency& cur) const;
  1049.     BOOL operator<(const COleCurrency& cur) const;
  1050.     BOOL operator>(const COleCurrency& cur) const;
  1051.     BOOL operator<=(const COleCurrency& cur) const;
  1052.     BOOL operator>=(const COleCurrency& cur) const;
  1053.  
  1054.     // Currency math
  1055.     COleCurrency operator+(const COleCurrency& cur) const;
  1056.     COleCurrency operator-(const COleCurrency& cur) const;
  1057.     const COleCurrency& operator+=(const COleCurrency& cur);
  1058.     const COleCurrency& operator-=(const COleCurrency& cur);
  1059.     COleCurrency operator-() const;
  1060.  
  1061.     COleCurrency operator*(long nOperand) const;
  1062.     COleCurrency operator/(long nOperand) const;
  1063.     const COleCurrency& operator*=(long nOperand);
  1064.     const COleCurrency& operator/=(long nOperand);
  1065.  
  1066.     operator CURRENCY() const;
  1067.  
  1068.     // Currency definition
  1069.     void SetCurrency(long nUnits, long nFractionalUnits);
  1070.     BOOL ParseCurrency(LPCTSTR lpszCurrency, DWORD dwFlags = 0,
  1071.         LCID = LANG_USER_DEFAULT);
  1072.  
  1073.     // formatting
  1074.     CString Format(DWORD dwFlags = 0, LCID lcid = LANG_USER_DEFAULT) const;
  1075. };
  1076.  
  1077. // COleCurrency diagnostics and serialization
  1078. #ifdef _DEBUG
  1079. CDumpContext& AFXAPI operator<<(CDumpContext& dc, COleCurrency curSrc);
  1080. #endif
  1081. CArchive& AFXAPI operator<<(CArchive& ar, COleCurrency curSrc);
  1082. CArchive& AFXAPI operator>>(CArchive& ar, COleCurrency& curSrc);
  1083.  
  1084. /////////////////////////////////////////////////////////////////////////////
  1085. // COleDateTime class helpers
  1086.  
  1087. #define AFX_OLE_DATETIME_ERROR (-1)
  1088. #define AFX_OLE_DATETIME_HALFSECOND (1.0 / (2.0 * (60.0 * 60.0 * 24.0)))
  1089.  
  1090. /////////////////////////////////////////////////////////////////////////////
  1091. // COleDateTime class
  1092.  
  1093. class COleDateTime
  1094. {
  1095. // Constructors
  1096. public:
  1097.     static COleDateTime PASCAL GetCurrentTime();
  1098.  
  1099.     COleDateTime();
  1100.  
  1101.     COleDateTime(const COleDateTime& dateSrc);
  1102.     COleDateTime(const VARIANT& varSrc);
  1103.     COleDateTime(DATE dtSrc);
  1104.  
  1105.     COleDateTime(time_t timeSrc);
  1106.     COleDateTime(const SYSTEMTIME& systimeSrc);
  1107.     COleDateTime(const FILETIME& filetimeSrc);
  1108.  
  1109.     COleDateTime(int nYear, int nMonth, int nDay,
  1110.         int nHour, int nMin, int nSec);
  1111.     COleDateTime(WORD wDosDate, WORD wDosTime);
  1112.  
  1113. // Attributes
  1114. public:
  1115.     enum DateTimeStatus
  1116.     {
  1117.         valid = 0,
  1118.         invalid = 1,    // Invalid date (out of range, etc.)
  1119.         null = 2,       // Literally has no value
  1120.     };
  1121.  
  1122.     DATE m_dt;
  1123.     DateTimeStatus m_status;
  1124.  
  1125.     void SetStatus(DateTimeStatus status);
  1126.     DateTimeStatus GetStatus() const;
  1127.  
  1128.     BOOL GetAsSystemTime(SYSTEMTIME& sysTime) const;
  1129.  
  1130.     int GetYear() const;
  1131.     int GetMonth() const;       // month of year (1 = Jan)
  1132.     int GetDay() const;         // day of month (0-31)
  1133.     int GetHour() const;        // hour in day (0-23)
  1134.     int GetMinute() const;      // minute in hour (0-59)
  1135.     int GetSecond() const;      // second in minute (0-59)
  1136.     int GetDayOfWeek() const;   // 1=Sun, 2=Mon, ..., 7=Sat
  1137.     int GetDayOfYear() const;   // days since start of year, Jan 1 = 1
  1138.  
  1139. // Operations
  1140. public:
  1141.     const COleDateTime& operator=(const COleDateTime& dateSrc);
  1142.     const COleDateTime& operator=(const VARIANT& varSrc);
  1143.     const COleDateTime& operator=(DATE dtSrc);
  1144.  
  1145.     const COleDateTime& operator=(const time_t& timeSrc);
  1146.     const COleDateTime& operator=(const SYSTEMTIME& systimeSrc);
  1147.     const COleDateTime& operator=(const FILETIME& filetimeSrc);
  1148.  
  1149.     BOOL operator==(const COleDateTime& date) const;
  1150.     BOOL operator!=(const COleDateTime& date) const;
  1151.     BOOL operator<(const COleDateTime& date) const;
  1152.     BOOL operator>(const COleDateTime& date) const;
  1153.     BOOL operator<=(const COleDateTime& date) const;
  1154.     BOOL operator>=(const COleDateTime& date) const;
  1155.  
  1156.     // DateTime math
  1157.     COleDateTime operator+(const COleDateTimeSpan& dateSpan) const;
  1158.     COleDateTime operator-(const COleDateTimeSpan& dateSpan) const;
  1159.     const COleDateTime& operator+=(const COleDateTimeSpan dateSpan);
  1160.     const COleDateTime& operator-=(const COleDateTimeSpan dateSpan);
  1161.  
  1162.     // DateTimeSpan math
  1163.     COleDateTimeSpan operator-(const COleDateTime& date) const;
  1164.  
  1165.     operator DATE() const;
  1166.  
  1167.     int SetDateTime(int nYear, int nMonth, int nDay,
  1168.         int nHour, int nMin, int nSec);
  1169.     int SetDate(int nYear, int nMonth, int nDay);
  1170.     int SetTime(int nHour, int nMin, int nSec);
  1171.     BOOL ParseDateTime(LPCTSTR lpszDate, DWORD dwFlags = 0,
  1172.         LCID lcid = LANG_USER_DEFAULT);
  1173.  
  1174.     // formatting
  1175.     CString Format(DWORD dwFlags = 0, LCID lcid = LANG_USER_DEFAULT) const;
  1176.     CString Format(LPCTSTR lpszFormat) const;
  1177.     CString Format(UINT nFormatID) const;
  1178.  
  1179. // Implementation
  1180. protected:
  1181.     void CheckRange();
  1182.     friend COleDateTimeSpan;
  1183. };
  1184.  
  1185. // COleDateTime diagnostics and serialization
  1186. #ifdef _DEBUG
  1187. CDumpContext& AFXAPI operator<<(CDumpContext& dc, COleDateTime dateSrc);
  1188. #endif
  1189. CArchive& AFXAPI operator<<(CArchive& ar, COleDateTime dateSrc);
  1190. CArchive& AFXAPI operator>>(CArchive& ar, COleDateTime& dateSrc);
  1191.  
  1192. /////////////////////////////////////////////////////////////////////////////
  1193. // COleDateTimeSpan class
  1194. class COleDateTimeSpan
  1195. {
  1196. // Constructors
  1197. public:
  1198.     COleDateTimeSpan();
  1199.  
  1200.     COleDateTimeSpan(double dblSpanSrc);
  1201.     COleDateTimeSpan(const COleDateTimeSpan& dateSpanSrc);
  1202.     COleDateTimeSpan(long lDays, int nHours, int nMins, int nSecs);
  1203.  
  1204. // Attributes
  1205. public:
  1206.     enum DateTimeSpanStatus
  1207.     {
  1208.         valid = 0,
  1209.         invalid = 1,    // Invalid span (out of range, etc.)
  1210.         null = 2,       // Literally has no value
  1211.     };
  1212.  
  1213.     double m_span;
  1214.     DateTimeSpanStatus m_status;
  1215.  
  1216.     void SetStatus(DateTimeSpanStatus status);
  1217.     DateTimeSpanStatus GetStatus() const;
  1218.  
  1219.     double GetTotalDays() const;    // span in days (about -3.65e6 to 3.65e6)
  1220.     double GetTotalHours() const;   // span in hours (about -8.77e7 to 8.77e6)
  1221.     double GetTotalMinutes() const; // span in minutes (about -5.26e9 to 5.26e9)
  1222.     double GetTotalSeconds() const; // span in seconds (about -3.16e11 to 3.16e11)
  1223.  
  1224.     long GetDays() const;       // component days in span
  1225.     long GetHours() const;      // component hours in span (-23 to 23)
  1226.     long GetMinutes() const;    // component minutes in span (-59 to 59)
  1227.     long GetSeconds() const;    // component seconds in span (-59 to 59)
  1228.  
  1229. // Operations
  1230. public:
  1231.     const COleDateTimeSpan& operator=(double dblSpanSrc);
  1232.     const COleDateTimeSpan& operator=(const COleDateTimeSpan& dateSpanSrc);
  1233.  
  1234.     BOOL operator==(const COleDateTimeSpan& dateSpan) const;
  1235.     BOOL operator!=(const COleDateTimeSpan& dateSpan) const;
  1236.     BOOL operator<(const COleDateTimeSpan& dateSpan) const;
  1237.     BOOL operator>(const COleDateTimeSpan& dateSpan) const;
  1238.     BOOL operator<=(const COleDateTimeSpan& dateSpan) const;
  1239.     BOOL operator>=(const COleDateTimeSpan& dateSpan) const;
  1240.  
  1241.     // DateTimeSpan math
  1242.     COleDateTimeSpan operator+(const COleDateTimeSpan& dateSpan) const;
  1243.     COleDateTimeSpan operator-(const COleDateTimeSpan& dateSpan) const;
  1244.     const COleDateTimeSpan& operator+=(const COleDateTimeSpan dateSpan);
  1245.     const COleDateTimeSpan& operator-=(const COleDateTimeSpan dateSpan);
  1246.     COleDateTimeSpan operator-() const;
  1247.  
  1248.     operator double() const;
  1249.  
  1250.     void SetDateTimeSpan(long lDays, int nHours, int nMins, int nSecs);
  1251.  
  1252.     // formatting
  1253.     CString Format(LPCTSTR pFormat) const;
  1254.     CString Format(UINT nID) const;
  1255.  
  1256. // Implementation
  1257. public:
  1258.     void CheckRange();
  1259.     friend COleDateTime;
  1260. };
  1261.  
  1262. // COleDateTimeSpan diagnostics and serialization
  1263. #ifdef _DEBUG
  1264. CDumpContext& AFXAPI operator<<(CDumpContext& dc,COleDateTimeSpan dateSpanSrc);
  1265. #endif
  1266. CArchive& AFXAPI operator<<(CArchive& ar, COleDateTimeSpan dateSpanSrc);
  1267. CArchive& AFXAPI operator>>(CArchive& ar, COleDateTimeSpan& dateSpanSrc);
  1268.  
  1269. /////////////////////////////////////////////////////////////////////////////
  1270. // Helper for initializing COleSafeArray
  1271. void AFXAPI AfxSafeArrayInit(COleSafeArray* psa);
  1272.  
  1273. /////////////////////////////////////////////////////////////////////////////
  1274. // CSafeArray class
  1275.  
  1276. typedef const SAFEARRAY* LPCSAFEARRAY;
  1277.  
  1278. class COleSafeArray : public tagVARIANT
  1279. {
  1280. //Constructors
  1281. public:
  1282.     COleSafeArray();
  1283.     COleSafeArray(const SAFEARRAY& saSrc, VARTYPE vtSrc);
  1284.     COleSafeArray(LPCSAFEARRAY pSrc, VARTYPE vtSrc);
  1285.     COleSafeArray(const COleSafeArray& saSrc);
  1286.     COleSafeArray(const VARIANT& varSrc);
  1287.     COleSafeArray(LPCVARIANT pSrc);
  1288.     COleSafeArray(const COleVariant& varSrc);
  1289.  
  1290. // Operations
  1291. public:
  1292.     void Clear();
  1293.     void Attach(VARIANT& varSrc);
  1294.     VARIANT Detach();
  1295.  
  1296.     COleSafeArray& operator=(const COleSafeArray& saSrc);
  1297.     COleSafeArray& operator=(const VARIANT& varSrc);
  1298.     COleSafeArray& operator=(LPCVARIANT pSrc);
  1299.     COleSafeArray& operator=(const COleVariant& varSrc);
  1300.  
  1301.     BOOL operator==(const SAFEARRAY& saSrc) const;
  1302.     BOOL operator==(LPCSAFEARRAY pSrc) const;
  1303.     BOOL operator==(const COleSafeArray& saSrc) const;
  1304.     BOOL operator==(const VARIANT& varSrc) const;
  1305.     BOOL operator==(LPCVARIANT pSrc) const;
  1306.     BOOL operator==(const COleVariant& varSrc) const;
  1307.  
  1308.     operator LPVARIANT();
  1309.     operator LPCVARIANT() const;
  1310.  
  1311.     // One dim array helpers
  1312.     void CreateOneDim(VARTYPE vtSrc, DWORD dwElements,
  1313.         const void* pvSrcData = NULL, long nLBound = 0);
  1314.     DWORD GetOneDimSize();
  1315.     void ResizeOneDim(DWORD dwElements);
  1316.  
  1317.     // Multi dim array helpers
  1318.     void Create(VARTYPE vtSrc, DWORD dwDims, DWORD* rgElements);
  1319.  
  1320.     // SafeArray wrapper classes
  1321.     void Create(VARTYPE vtSrc, DWORD dwDims, SAFEARRAYBOUND* rgsabounds);
  1322.     void AccessData(void** ppvData);
  1323.     void UnaccessData();
  1324.     void AllocData();
  1325.     void AllocDescriptor(DWORD dwDims);
  1326.     void Copy(LPSAFEARRAY* ppsa);
  1327.     void GetLBound(DWORD dwDim, long* pLBound);
  1328.     void GetUBound(DWORD dwDim, long* pUBound);
  1329.     void GetElement(long* rgIndices, void* pvData);
  1330.     void PtrOfIndex(long* rgIndices, void** ppvData);
  1331.     void PutElement(long* rgIndices, void* pvData);
  1332.     void Redim(SAFEARRAYBOUND* psaboundNew);
  1333.     void Lock();
  1334.     void Unlock();
  1335.     DWORD GetDim();
  1336.     DWORD GetElemSize();
  1337.     void Destroy();
  1338.     void DestroyData();
  1339.     void DestroyDescriptor();
  1340.  
  1341. //Implementation
  1342. public:
  1343.     ~COleSafeArray();
  1344.  
  1345.     // Cache info to make element access (operator []) faster
  1346.     DWORD m_dwElementSize;
  1347.     DWORD m_dwDims;
  1348. };
  1349.  
  1350. // COleSafeArray diagnostics and serialization
  1351. #ifdef _DEBUG
  1352. CDumpContext& AFXAPI operator<<(CDumpContext& dc, COleSafeArray& saSrc);
  1353. #endif
  1354.  
  1355. /////////////////////////////////////////////////////////////////////////////
  1356. // DDX_ functions for OLE controls on dialogs
  1357.  
  1358. #ifndef _AFX_NO_OCC_SUPPORT
  1359.  
  1360. void AFXAPI DDX_OCText(CDataExchange* pDX, int nIDC, DISPID dispid,
  1361.     CString& value);
  1362. void AFXAPI DDX_OCTextRO(CDataExchange* pDX, int nIDC, DISPID dispid,
  1363.     CString& value);
  1364. void AFXAPI DDX_OCBool(CDataExchange* pDX, int nIDC, DISPID dispid,
  1365.     BOOL& value);
  1366. void AFXAPI DDX_OCBoolRO(CDataExchange* pDX, int nIDC, DISPID dispid,
  1367.     BOOL& value);
  1368. void AFXAPI DDX_OCInt(CDataExchange* pDX, int nIDC, DISPID dispid,
  1369.     int &value);
  1370. void AFXAPI DDX_OCIntRO(CDataExchange* pDX, int nIDC, DISPID dispid,
  1371.     int &value);
  1372. void AFXAPI DDX_OCInt(CDataExchange* pDX, int nIDC, DISPID dispid,
  1373.     long &value);
  1374. void AFXAPI DDX_OCIntRO(CDataExchange* pDX, int nIDC, DISPID dispid,
  1375.     long &value);
  1376. void AFXAPI DDX_OCShort(CDataExchange* pDX, int nIDC, DISPID dispid,
  1377.     short& value);
  1378. void AFXAPI DDX_OCShortRO(CDataExchange* pDX, int nIDC, DISPID dispid,
  1379.     short& value);
  1380. void AFXAPI DDX_OCColor(CDataExchange* pDX, int nIDC, DISPID dispid,
  1381.     OLE_COLOR& value);
  1382. void AFXAPI DDX_OCColorRO(CDataExchange* pDX, int nIDC, DISPID dispid,
  1383.     OLE_COLOR& value);
  1384. void AFXAPI DDX_OCFloat(CDataExchange* pDX, int nIDC, DISPID dispid,
  1385.     float& value);
  1386. void AFXAPI DDX_OCFloatRO(CDataExchange* pDX, int nIDC, DISPID dispid,
  1387.     float& value);
  1388. void AFXAPI DDX_OCFloat(CDataExchange* pDX, int nIDC, DISPID dispid,
  1389.     double& value);
  1390. void AFXAPI DDX_OCFloatRO(CDataExchange* pDX, int nIDC, DISPID dispid,
  1391.     double& value);
  1392.  
  1393. #endif // !_AFX_NO_OCC_SUPPORT
  1394.  
  1395. /////////////////////////////////////////////////////////////////////////////
  1396. // Function to enable containment of OLE controls
  1397.  
  1398. #ifndef _AFX_NO_OCC_SUPPORT
  1399. void AFX_CDECL AfxEnableControlContainer(COccManager* pOccManager=NULL);
  1400. #else
  1401. #define AfxEnableControlContainer()
  1402. #endif
  1403.  
  1404. /////////////////////////////////////////////////////////////////////////////
  1405. // Inline function declarations
  1406.  
  1407. #ifdef _AFX_PACKING
  1408. #pragma pack(pop)
  1409. #endif
  1410.  
  1411. #ifdef _AFX_ENABLE_INLINES
  1412. #define _AFXDISP_INLINE AFX_INLINE
  1413. #include <afxole.inl>
  1414. #undef _AFXDISP_INLINE
  1415. #endif
  1416.  
  1417. #undef AFX_DATA
  1418. #define AFX_DATA
  1419.  
  1420. #ifdef _AFX_MINREBUILD
  1421. #pragma component(minrebuild, on)
  1422. #endif
  1423. #ifndef _AFX_FULLTYPEINFO
  1424. #pragma component(mintypeinfo, off)
  1425. #endif
  1426.  
  1427. #endif //__AFXDISP_H__
  1428.  
  1429. /////////////////////////////////////////////////////////////////////////////
  1430.