home *** CD-ROM | disk | FTP | other *** search
/ PC Plus SuperCD (UK) 2000 May / PCP163A.iso / Runimage / Cbuilder4 / Include / OLE2.H < prev    next >
Encoding:
C/C++ Source or Header  |  1999-01-26  |  14.8 KB  |  428 lines
  1. //+---------------------------------------------------------------------------
  2. //
  3. //  Microsoft Windows
  4. //  Copyright (C) Microsoft Corporation, 1992-1997.
  5. //
  6. //  File:       OLE2.h
  7. //  Contents:   Main OLE2 header; Defines Linking and Emmebbeding interfaces, and API's.
  8. //              Also includes .h files for the compobj, and oleauto  subcomponents.
  9. //
  10. //----------------------------------------------------------------------------
  11. #if !defined( _OLE2_H_ )
  12. #pragma option push -b -a8 -pc -A- /*P_O_Push_S*/
  13. #define _OLE2_H_
  14.  
  15. #ifndef _MAC
  16. // Set packing to 8
  17. #include <pshpack8.h>
  18.  
  19. // Make 100% sure WIN32 is defined
  20. #ifndef WIN32
  21. #define WIN32    100  // 100 == NT version 1.0
  22. #endif
  23. #else //_MAC
  24. #ifdef _WIN32
  25. #include "macname1.h"
  26. #endif // _WIN32
  27. #endif //_MAC
  28.  
  29.  
  30.  
  31. // SET to remove _export from interface definitions
  32.  
  33.  
  34. #include <winerror.h>
  35.  
  36. #ifdef _MAC
  37. #if !defined(__MACPUB__)
  38. #include <macpub.h>
  39. #endif
  40. #endif //_MAC
  41.  
  42. #include <objbase.h>
  43. #include <oleauto.h>
  44.  
  45. // View OBJECT Error Codes
  46.  
  47. #define E_DRAW                  VIEW_E_DRAW
  48.  
  49. // IDataObject Error Codes
  50. #define DATA_E_FORMATETC        DV_E_FORMATETC
  51.  
  52.  
  53. #ifdef _MAC
  54. /****** Standard Object Definitions *****************************************/
  55.  
  56. //#ifndef __COMPOBJ__
  57. //#include <compobj.h>
  58. //#endif
  59.  
  60.  
  61.  
  62. typedef enum {
  63.     OLE_E_NOEXTENSION    = OLE_E_NOSTORAGE +1,    // no extension at startup
  64.     OLE_E_VERSEXTENSION,                        // extension has wrong version #
  65.     OLE_E_IPBUSY,                                // cannot get inplace resource
  66.     OLE_E_NOT_FRONT_PROCESS,                    // inplace container unexpectedly in background
  67.     OLE_E_WRONG_MENU,                            // holemenu != prev holemenu
  68.     OLE_E_MENU_NOT_PATCHED,                        // menubar is not hashed
  69.     OLE_E_MENUID_NOT_HASHED,                    // id was never hashed
  70.     OLE_E_foo
  71. } inplace_errors;
  72.  
  73.  
  74. // DoDragDropMac()
  75. typedef struct tagDRAG_FLAVORINFO {
  76.     unsigned long    cfFormat;
  77.     unsigned long    FlavorFlags;        // Flavor Flags as specified by the DragManager
  78.     OLEBOOL            fAddData;            // If true, the data is added with the flavor
  79.     long            reserved;            // must be NULL
  80. } DRAG_FLAVORINFO;
  81.  
  82. #endif //_MAC
  83.  
  84.  
  85. // Common stuff gleamed from OLE.2,
  86.  
  87. /* verbs */
  88. #define OLEIVERB_PRIMARY            (0L)
  89. #define OLEIVERB_SHOW               (-1L)
  90. #define OLEIVERB_OPEN               (-2L)
  91. #define OLEIVERB_HIDE               (-3L)
  92. #define OLEIVERB_UIACTIVATE         (-4L)
  93. #define OLEIVERB_INPLACEACTIVATE    (-5L)
  94. #define OLEIVERB_DISCARDUNDOSTATE   (-6L)
  95.  
  96. // for OleCreateEmbeddingHelper flags; roles in low word; options in high word
  97. #define EMBDHLP_INPROC_HANDLER   0x0000L
  98. #define EMBDHLP_INPROC_SERVER    0x0001L
  99. #define EMBDHLP_CREATENOW    0x00000000L
  100. #define EMBDHLP_DELAYCREATE  0x00010000L
  101.  
  102. /* extended create function flags */
  103. #define OLECREATE_LEAVERUNNING    0x00000001
  104.  
  105. /* pull in the MIDL generated header */
  106.  
  107. #include <oleidl.h>
  108.  
  109.  
  110. #ifdef _MAC
  111. typedef struct tagOleMBarRec
  112. {
  113.         long reserved;
  114. } OleMBarRec, *OleMBarPtr, **OleMBarHandle;
  115.  
  116. #define noAxis  3               // indicates no grow or size in any direction
  117. // see mac #defines noConstraint, hAxisOnly, vAxisOnly
  118.  
  119. #endif //_MAC
  120.  
  121.  
  122.  
  123. /****** DV APIs ***********************************************************/
  124.  
  125.  
  126. WINOLEAPI CreateDataAdviseHolder(LPDATAADVISEHOLDER FAR* ppDAHolder);
  127.  
  128.  
  129.  
  130.  
  131.  
  132.  
  133.  
  134. /****** OLE API Prototypes ************************************************/
  135.  
  136. WINOLEAPI_(DWORD) OleBuildVersion( VOID );
  137.  
  138. /* helper functions */
  139. WINOLEAPI ReadClassStg(LPSTORAGE pStg, CLSID FAR* pclsid);
  140. WINOLEAPI WriteClassStg(LPSTORAGE pStg, REFCLSID rclsid);
  141. WINOLEAPI ReadClassStm(LPSTREAM pStm, CLSID FAR* pclsid);
  142. WINOLEAPI WriteClassStm(LPSTREAM pStm, REFCLSID rclsid);
  143. WINOLEAPI WriteFmtUserTypeStg (LPSTORAGE pstg, CLIPFORMAT cf, LPOLESTR lpszUserType);
  144. WINOLEAPI ReadFmtUserTypeStg (LPSTORAGE pstg, CLIPFORMAT FAR* pcf, LPOLESTR FAR* lplpszUserType);
  145.  
  146.  
  147. /* init/term */
  148.  
  149. WINOLEAPI OleInitialize(LPVOID pvReserved);
  150. WINOLEAPI_(void) OleUninitialize(void);
  151.  
  152.  
  153. /* APIs to query whether (Embedded/Linked) object can be created from
  154.    the data object */
  155.  
  156. WINOLEAPI  OleQueryLinkFromData(LPDATAOBJECT pSrcDataObject);
  157. WINOLEAPI  OleQueryCreateFromData(LPDATAOBJECT pSrcDataObject);
  158.  
  159.  
  160. /* Object creation APIs */
  161.  
  162. WINOLEAPI  OleCreate(REFCLSID rclsid, REFIID riid, DWORD renderopt,
  163.                 LPFORMATETC pFormatEtc, LPOLECLIENTSITE pClientSite,
  164.                 LPSTORAGE pStg, LPVOID FAR* ppvObj);
  165.  
  166. WINOLEAPI  OleCreateEx(REFCLSID rclsid, REFIID riid, DWORD dwFlags,
  167.                 DWORD renderopt, ULONG cFormats, DWORD* rgAdvf,
  168.                 LPFORMATETC rgFormatEtc, IAdviseSink FAR* lpAdviseSink,
  169.                 DWORD FAR* rgdwConnection, LPOLECLIENTSITE pClientSite,
  170.                 LPSTORAGE pStg, LPVOID FAR* ppvObj);
  171.  
  172. WINOLEAPI  OleCreateFromData(LPDATAOBJECT pSrcDataObj, REFIID riid,
  173.                 DWORD renderopt, LPFORMATETC pFormatEtc,
  174.                 LPOLECLIENTSITE pClientSite, LPSTORAGE pStg,
  175.                 LPVOID FAR* ppvObj);
  176.  
  177. WINOLEAPI  OleCreateFromDataEx(LPDATAOBJECT pSrcDataObj, REFIID riid,
  178.                 DWORD dwFlags, DWORD renderopt, ULONG cFormats, DWORD* rgAdvf,
  179.                 LPFORMATETC rgFormatEtc, IAdviseSink FAR* lpAdviseSink,
  180.                 DWORD FAR* rgdwConnection, LPOLECLIENTSITE pClientSite,
  181.                 LPSTORAGE pStg, LPVOID FAR* ppvObj);
  182.  
  183. WINOLEAPI  OleCreateLinkFromData(LPDATAOBJECT pSrcDataObj, REFIID riid,
  184.                 DWORD renderopt, LPFORMATETC pFormatEtc,
  185.                 LPOLECLIENTSITE pClientSite, LPSTORAGE pStg,
  186.                 LPVOID FAR* ppvObj);
  187.  
  188. WINOLEAPI  OleCreateLinkFromDataEx(LPDATAOBJECT pSrcDataObj, REFIID riid,
  189.                 DWORD dwFlags, DWORD renderopt, ULONG cFormats, DWORD* rgAdvf,
  190.                 LPFORMATETC rgFormatEtc, IAdviseSink FAR* lpAdviseSink,
  191.                 DWORD FAR* rgdwConnection, LPOLECLIENTSITE pClientSite,
  192.                 LPSTORAGE pStg, LPVOID FAR* ppvObj);
  193.  
  194. WINOLEAPI  OleCreateStaticFromData(LPDATAOBJECT pSrcDataObj, REFIID iid,
  195.                 DWORD renderopt, LPFORMATETC pFormatEtc,
  196.                 LPOLECLIENTSITE pClientSite, LPSTORAGE pStg,
  197.                 LPVOID FAR* ppvObj);
  198.  
  199.  
  200. WINOLEAPI  OleCreateLink(LPMONIKER pmkLinkSrc, REFIID riid,
  201.             DWORD renderopt, LPFORMATETC lpFormatEtc,
  202.             LPOLECLIENTSITE pClientSite, LPSTORAGE pStg, LPVOID FAR* ppvObj);
  203.  
  204. WINOLEAPI  OleCreateLinkEx(LPMONIKER pmkLinkSrc, REFIID riid,
  205.             DWORD dwFlags, DWORD renderopt, ULONG cFormats, DWORD* rgAdvf,
  206.             LPFORMATETC rgFormatEtc, IAdviseSink FAR* lpAdviseSink,
  207.             DWORD FAR* rgdwConnection, LPOLECLIENTSITE pClientSite,
  208.             LPSTORAGE pStg, LPVOID FAR* ppvObj);
  209.  
  210. WINOLEAPI  OleCreateLinkToFile(LPCOLESTR lpszFileName, REFIID riid,
  211.             DWORD renderopt, LPFORMATETC lpFormatEtc,
  212.             LPOLECLIENTSITE pClientSite, LPSTORAGE pStg, LPVOID FAR* ppvObj);
  213.  
  214. WINOLEAPI  OleCreateLinkToFileEx(LPCOLESTR lpszFileName, REFIID riid,
  215.             DWORD dwFlags, DWORD renderopt, ULONG cFormats, DWORD* rgAdvf,
  216.             LPFORMATETC rgFormatEtc, IAdviseSink FAR* lpAdviseSink,
  217.             DWORD FAR* rgdwConnection, LPOLECLIENTSITE pClientSite,
  218.             LPSTORAGE pStg, LPVOID FAR* ppvObj);
  219.  
  220. WINOLEAPI  OleCreateFromFile(REFCLSID rclsid, LPCOLESTR lpszFileName, REFIID riid,
  221.             DWORD renderopt, LPFORMATETC lpFormatEtc,
  222.             LPOLECLIENTSITE pClientSite, LPSTORAGE pStg, LPVOID FAR* ppvObj);
  223.  
  224. WINOLEAPI  OleCreateFromFileEx(REFCLSID rclsid, LPCOLESTR lpszFileName, REFIID riid,
  225.             DWORD dwFlags, DWORD renderopt, ULONG cFormats, DWORD* rgAdvf,
  226.             LPFORMATETC rgFormatEtc, IAdviseSink FAR* lpAdviseSink,
  227.             DWORD FAR* rgdwConnection, LPOLECLIENTSITE pClientSite,
  228.             LPSTORAGE pStg, LPVOID FAR* ppvObj);
  229.  
  230. WINOLEAPI  OleLoad(LPSTORAGE pStg, REFIID riid, LPOLECLIENTSITE pClientSite,
  231.             LPVOID FAR* ppvObj);
  232.  
  233. WINOLEAPI  OleSave(LPPERSISTSTORAGE pPS, LPSTORAGE pStg, BOOL fSameAsLoad);
  234.  
  235. WINOLEAPI  OleLoadFromStream( LPSTREAM pStm, REFIID iidInterface, LPVOID FAR* ppvObj);
  236. WINOLEAPI  OleSaveToStream( LPPERSISTSTREAM pPStm, LPSTREAM pStm );
  237.  
  238.  
  239. WINOLEAPI  OleSetContainedObject(LPUNKNOWN pUnknown, BOOL fContained);
  240. WINOLEAPI  OleNoteObjectVisible(LPUNKNOWN pUnknown, BOOL fVisible);
  241.  
  242.  
  243. /* Drag/Drop APIs */
  244.  
  245. WINOLEAPI  RegisterDragDrop(HWND hwnd, LPDROPTARGET pDropTarget);
  246. WINOLEAPI  RevokeDragDrop(HWND hwnd);
  247. WINOLEAPI  DoDragDrop(LPDATAOBJECT pDataObj, LPDROPSOURCE pDropSource,
  248.             DWORD dwOKEffects, LPDWORD pdwEffect);
  249.  
  250. /* Clipboard APIs */
  251.  
  252. WINOLEAPI  OleSetClipboard(LPDATAOBJECT pDataObj);
  253. WINOLEAPI  OleGetClipboard(LPDATAOBJECT FAR* ppDataObj);
  254. WINOLEAPI  OleFlushClipboard(void);
  255. WINOLEAPI  OleIsCurrentClipboard(LPDATAOBJECT pDataObj);
  256.  
  257.  
  258. /* InPlace Editing APIs */
  259.  
  260. WINOLEAPI_(HOLEMENU)   OleCreateMenuDescriptor (HMENU hmenuCombined,
  261.                                 LPOLEMENUGROUPWIDTHS lpMenuWidths);
  262. WINOLEAPI              OleSetMenuDescriptor (HOLEMENU holemenu, HWND hwndFrame,
  263.                                 HWND hwndActiveObject,
  264.                                 LPOLEINPLACEFRAME lpFrame,
  265.                                 LPOLEINPLACEACTIVEOBJECT lpActiveObj);
  266. WINOLEAPI              OleDestroyMenuDescriptor (HOLEMENU holemenu);
  267.  
  268. WINOLEAPI              OleTranslateAccelerator (LPOLEINPLACEFRAME lpFrame,
  269.                             LPOLEINPLACEFRAMEINFO lpFrameInfo, LPMSG lpmsg);
  270.  
  271.  
  272. /* Helper APIs */
  273. WINOLEAPI_(HANDLE) OleDuplicateData (HANDLE hSrc, CLIPFORMAT cfFormat,
  274.                         UINT uiFlags);
  275.  
  276. WINOLEAPI          OleDraw (LPUNKNOWN pUnknown, DWORD dwAspect, HDC hdcDraw,
  277.                     LPCRECT lprcBounds);
  278.  
  279. WINOLEAPI          OleRun(LPUNKNOWN pUnknown);
  280. WINOLEAPI_(BOOL)   OleIsRunning(LPOLEOBJECT pObject);
  281. WINOLEAPI          OleLockRunning(LPUNKNOWN pUnknown, BOOL fLock, BOOL fLastUnlockCloses);
  282. WINOLEAPI_(void)   ReleaseStgMedium(LPSTGMEDIUM);
  283. WINOLEAPI          CreateOleAdviseHolder(LPOLEADVISEHOLDER FAR* ppOAHolder);
  284.  
  285. WINOLEAPI          OleCreateDefaultHandler(REFCLSID clsid, LPUNKNOWN pUnkOuter,
  286.                     REFIID riid, LPVOID FAR* lplpObj);
  287.  
  288. WINOLEAPI          OleCreateEmbeddingHelper(REFCLSID clsid, LPUNKNOWN pUnkOuter,
  289.                     DWORD flags, LPCLASSFACTORY pCF,
  290.                                         REFIID riid, LPVOID FAR* lplpObj);
  291.  
  292. WINOLEAPI_(BOOL)   IsAccelerator(HACCEL hAccel, int cAccelEntries, LPMSG lpMsg,
  293.                                         WORD FAR* lpwCmd);
  294. /* Icon extraction Helper APIs */
  295.  
  296. WINOLEAPI_(HGLOBAL) OleGetIconOfFile(LPOLESTR lpszPath, BOOL fUseFileAsLabel);
  297.  
  298. WINOLEAPI_(HGLOBAL) OleGetIconOfClass(REFCLSID rclsid,     LPOLESTR lpszLabel,
  299.                                         BOOL fUseTypeAsLabel);
  300.  
  301. WINOLEAPI_(HGLOBAL) OleMetafilePictFromIconAndLabel(HICON hIcon, LPOLESTR lpszLabel,
  302.                                         LPOLESTR lpszSourceFile, UINT iIconIndex);
  303.  
  304.  
  305.  
  306. /* Registration Database Helper APIs */
  307.  
  308. WINOLEAPI                  OleRegGetUserType (REFCLSID clsid, DWORD dwFormOfType,
  309.                                         LPOLESTR FAR* pszUserType);
  310.  
  311. WINOLEAPI                  OleRegGetMiscStatus     (REFCLSID clsid, DWORD dwAspect,
  312.                                         DWORD FAR* pdwStatus);
  313.  
  314. WINOLEAPI                  OleRegEnumFormatEtc     (REFCLSID clsid, DWORD dwDirection,
  315.                                         LPENUMFORMATETC FAR* ppenum);
  316.  
  317. WINOLEAPI                  OleRegEnumVerbs (REFCLSID clsid, LPENUMOLEVERB FAR* ppenum);
  318.  
  319. #ifdef _MAC
  320. /* WlmOLE helper APIs */
  321.  
  322. WINOLEAPI WlmOleCheckoutMacInterface(LPUNKNOWN pUnk, LPVOID* ppv);
  323. WINOLEAPI WlmOleCheckinMacInterface(LPUNKNOWN pUnk);
  324. WINOLEAPI WlmOleWrapMacInterface(LPUNKNOWN pUnk, REFIID riid, LPVOID* ppv);
  325. WINOLEAPI WlmOleUnwrapMacInterface(LPVOID pv);
  326.  
  327. WINOLEAPI WlmOleCheckoutWinInterface(LPVOID pUnk, LPUNKNOWN* ppv);
  328. WINOLEAPI WlmOleCheckinWinInterface(LPVOID pUnk);
  329. WINOLEAPI WlmOleWrapWinInterface(LPVOID pUnk, REFIID riid, LPUNKNOWN* ppv);
  330. WINOLEAPI WlmOleUnwrapWinInterface(LPVOID pv);
  331.  
  332. WINOLEAPI_(void) WlmOleVersion(void);
  333. WINOLEAPI_(void) WlmOleSetInPlaceWindow(HWND hwnd);
  334.  
  335. typedef HRESULT (STDAPICALLTYPE* OLEWRAPPROC) (REFIID riid, LPVOID* ppvWin, LPVOID* ppvMac);
  336. WINOLEAPI WlmOleRegisterUserWrap(OLEWRAPPROC procNew, OLEWRAPPROC* pprocOld);
  337. #endif
  338.  
  339.  
  340. /* OLE 1.0 conversion APIS */
  341.  
  342. /***** OLE 1.0 OLESTREAM declarations *************************************/
  343.  
  344. typedef struct _OLESTREAM FAR*  LPOLESTREAM;
  345.  
  346. typedef struct _OLESTREAMVTBL
  347. {
  348.     DWORD (CALLBACK* Get)(LPOLESTREAM, void FAR*, DWORD);
  349.     DWORD (CALLBACK* Put)(LPOLESTREAM, const void FAR*, DWORD);
  350. } OLESTREAMVTBL;
  351. typedef  OLESTREAMVTBL FAR*  LPOLESTREAMVTBL;
  352.  
  353. typedef struct _OLESTREAM
  354. {
  355.     LPOLESTREAMVTBL lpstbl;
  356. } OLESTREAM;
  357.  
  358.  
  359. WINOLEAPI OleConvertOLESTREAMToIStorage
  360.     (LPOLESTREAM                lpolestream,
  361.     LPSTORAGE                   pstg,
  362.     const DVTARGETDEVICE FAR*   ptd);
  363.  
  364. WINOLEAPI OleConvertIStorageToOLESTREAM
  365.     (LPSTORAGE      pstg,
  366.     LPOLESTREAM     lpolestream);
  367.  
  368.  
  369. /* Storage Utility APIs */
  370. WINOLEAPI GetHGlobalFromILockBytes (LPLOCKBYTES plkbyt, HGLOBAL FAR* phglobal);
  371. WINOLEAPI CreateILockBytesOnHGlobal (HGLOBAL hGlobal, BOOL fDeleteOnRelease,
  372.                                     LPLOCKBYTES FAR* pplkbyt);
  373.  
  374. WINOLEAPI GetHGlobalFromStream (LPSTREAM pstm, HGLOBAL FAR* phglobal);
  375. WINOLEAPI CreateStreamOnHGlobal (HGLOBAL hGlobal, BOOL fDeleteOnRelease,
  376.                                 LPSTREAM FAR* ppstm);
  377.  
  378.  
  379. /* ConvertTo APIS */
  380.  
  381. WINOLEAPI OleDoAutoConvert(LPSTORAGE pStg, LPCLSID pClsidNew);
  382. WINOLEAPI OleGetAutoConvert(REFCLSID clsidOld, LPCLSID pClsidNew);
  383. WINOLEAPI OleSetAutoConvert(REFCLSID clsidOld, REFCLSID clsidNew);
  384. WINOLEAPI GetConvertStg(LPSTORAGE pStg);
  385. WINOLEAPI SetConvertStg(LPSTORAGE pStg, BOOL fConvert);
  386.  
  387.  
  388. WINOLEAPI OleConvertIStorageToOLESTREAMEx
  389.     (LPSTORAGE          pstg,
  390.                                     // Presentation data to OLESTREAM
  391.      CLIPFORMAT         cfFormat,   //      format
  392.      LONG               lWidth,     //      width
  393.      LONG               lHeight,    //      height
  394.      DWORD              dwSize,     //      size in bytes
  395.      LPSTGMEDIUM        pmedium,    //      bits
  396.      LPOLESTREAM        polestm);
  397.  
  398. WINOLEAPI OleConvertOLESTREAMToIStorageEx
  399.     (LPOLESTREAM        polestm,
  400.      LPSTORAGE          pstg,
  401.                                     // Presentation data from OLESTREAM
  402.      CLIPFORMAT FAR*    pcfFormat,  //      format
  403.      LONG FAR*          plwWidth,   //      width
  404.      LONG FAR*          plHeight,   //      height
  405.      DWORD FAR*         pdwSize,    //      size in bytes
  406.      LPSTGMEDIUM        pmedium);   //      bits
  407.  
  408. #ifndef _MAC
  409. #ifndef RC_INVOKED
  410. #include <poppack.h>
  411. #endif // RC_INVOKED
  412.  
  413. #else // _MAC
  414.  
  415. #ifndef __MACAPI__
  416. #include <macapi.h>
  417. #endif
  418.  
  419. #ifdef _WIN32
  420. #include "macname2.h"
  421. #endif // _WIN32
  422.  
  423. #endif // _MAC
  424.  
  425. #pragma option pop /*P_O_Pop*/
  426. #endif     // __OLE2_H__
  427.  
  428.