ole2.h File Reference

#include <winerror.h>
#include <objbase.h>
#include <oleauto.h>
#include <oleidl.h>

Include dependency graph for ole2.h:

Go to the source code of this file.

Classes
struct	_OLESTREAMVTBL
struct	_OLESTREAM

Macros
#define	E_DRAW   VIEW_E_DRAW
#define	DATA_E_FORMATETC   DV_E_FORMATETC
#define	OLEIVERB_PRIMARY   (0L)
#define	OLEIVERB_SHOW   (-1L)
#define	OLEIVERB_OPEN   (-2L)
#define	OLEIVERB_HIDE   (-3L)
#define	OLEIVERB_UIACTIVATE   (-4L)
#define	OLEIVERB_INPLACEACTIVATE   (-5L)
#define	OLEIVERB_DISCARDUNDOSTATE   (-6L)
#define	OLEIVERB_PROPERTIES   (-7L)
#define	EMBDHLP_INPROC_HANDLER   0x00000000
#define	EMBDHLP_INPROC_SERVER   0x00000001
#define	EMBDHLP_CREATENOW   0x00000000
#define	EMBDHLP_DELAYCREATE   0x00010000

Typedefs
typedef struct _OLESTREAM *	LPOLESTREAM
typedef struct _OLESTREAMVTBL	OLESTREAMVTBL
typedef OLESTREAMVTBL *	LPOLESTREAMVTBL
typedef struct _OLESTREAM	OLESTREAM

Functions
HRESULT WINAPI	RegisterDragDrop (HWND, LPDROPTARGET)
HRESULT WINAPI	RevokeDragDrop (HWND)
HRESULT WINAPI	DoDragDrop (LPDATAOBJECT, LPDROPSOURCE, DWORD, DWORD *)
HRESULT WINAPI	OleLoadFromStream (IStream *pStm, REFIID iidInterface, void **ppvObj)
HRESULT WINAPI	OleSaveToStream (IPersistStream *pPStm, IStream *pStm)
HOLEMENU WINAPI	OleCreateMenuDescriptor (HMENU hmenuCombined, LPOLEMENUGROUPWIDTHS lpMenuWidths)
HRESULT WINAPI	OleDestroyMenuDescriptor (HOLEMENU hmenuDescriptor)
HRESULT WINAPI	OleSetMenuDescriptor (HOLEMENU hmenuDescriptor, HWND hwndFrame, HWND hwndActiveObject, LPOLEINPLACEFRAME lpFrame, LPOLEINPLACEACTIVEOBJECT lpActiveObject)
HRESULT WINAPI	WriteClassStg (IStorage *pstg, REFCLSID rclsid)
HRESULT WINAPI	ReadClassStg (IStorage *pstg, CLSID *pclsid)
HRESULT WINAPI	WriteClassStm (IStream *pStm, REFCLSID rclsid)
HRESULT WINAPI	ReadClassStm (IStream *pStm, CLSID *pclsid)
HRESULT WINAPI	OleSave (LPPERSISTSTORAGE pPS, LPSTORAGE pStg, BOOL fSameAsLoad)
HRESULT WINAPI	OleRegGetUserType (REFCLSID clsid, DWORD dwFormOfType, LPOLESTR *pszUserType)
HRESULT WINAPI	OleRegGetMiscStatus (REFCLSID clsid, DWORD dwAspect, DWORD *pdwStatus)
HRESULT WINAPI	OleRegEnumFormatEtc (REFCLSID clsid, DWORD dwDirection, LPENUMFORMATETC *ppenumFormatetc)
HRESULT WINAPI	CreateStreamOnHGlobal (HGLOBAL hGlobal, BOOL fDeleteOnRelease, LPSTREAM *ppstm)
HRESULT WINAPI	GetHGlobalFromStream (LPSTREAM pstm, HGLOBAL *phglobal)
HRESULT WINAPI	OleRegEnumVerbs (REFCLSID clsid, LPENUMOLEVERB *ppenum)
BOOL WINAPI	OleIsRunning (LPOLEOBJECT pObject)
HRESULT WINAPI	OleCreateLinkFromData (LPDATAOBJECT pSrcDataObj, REFIID riid, DWORD renderopt, LPFORMATETC pFormatEtc, LPOLECLIENTSITE pClientSite, LPSTORAGE pStg, LPVOID *ppvObj)
HRESULT WINAPI	OleSetContainedObject (LPUNKNOWN pUnknown, BOOL fContained)
HRESULT WINAPI	OleNoteObjectVisible (LPUNKNOWN pUnknown, BOOL fVisible)
HRESULT WINAPI	OleQueryLinkFromData (IDataObject *pSrcDataObject)
HRESULT WINAPI	OleQueryCreateFromData (LPDATAOBJECT pSrcDataObject)
HRESULT WINAPI	OleRun (LPUNKNOWN pUnknown)
HRESULT WINAPI	OleDraw (LPUNKNOWN pUnknown, DWORD dwAspect, HDC hdcDraw, LPCRECT lprcBounds)
VOID WINAPI	ReleaseStgMedium (LPSTGMEDIUM)
HRESULT WINAPI	OleGetClipboard (IDataObject **ppDataObj)
HRESULT WINAPI	OleIsCurrentClipboard (LPDATAOBJECT)
HRESULT WINAPI	OleSetClipboard (LPDATAOBJECT)
HRESULT WINAPI	OleCreateStaticFromData (LPDATAOBJECT pSrcDataObj, REFIID iid, DWORD renderopt, LPFORMATETC pFormatEtc, LPOLECLIENTSITE pClientSite, LPSTORAGE pStg, LPVOID *ppvObj)
HRESULT WINAPI	ReadFmtUserTypeStg (LPSTORAGE pstg, CLIPFORMAT *pcf, LPOLESTR *lplpszUserType)
HRESULT WINAPI	OleLoad (LPSTORAGE pStg, REFIID riid, LPOLECLIENTSITE pClientSite, LPVOID *ppvObj)
HRESULT WINAPI	GetHGlobalFromILockBytes (LPLOCKBYTES plkbyt, HGLOBAL *phglobal)
HRESULT WINAPI	CreateILockBytesOnHGlobal (HGLOBAL hGlobal, BOOL fDeleteOnRelease, LPLOCKBYTES *pplkbyt)
HRESULT WINAPI	CreateDataAdviseHolder (LPDATAADVISEHOLDER *ppDAHolder)
HGLOBAL WINAPI	OleGetIconOfClass (REFCLSID rclsid, LPOLESTR lpszLabel, BOOL fUseTypeAsLabel)
HGLOBAL WINAPI	OleGetIconOfFile (LPOLESTR lpszPath, BOOL fUseFileAsLabel)
HGLOBAL WINAPI	OleMetafilePictFromIconAndLabel (HICON hIcon, LPOLESTR lpszLabel, LPOLESTR lpszSourceFile, UINT iIconIndex)
HRESULT WINAPI	OleLockRunning (LPUNKNOWN pUnknown, BOOL fLock, BOOL fLastUnlockCloses)
HRESULT WINAPI	OleCreateFromFile (REFCLSID rclsid, LPCOLESTR lpszFileName, REFIID riid, DWORD renderopt, LPFORMATETC lpFormatEtc, LPOLECLIENTSITE pClientSite, LPSTORAGE pStg, LPVOID *ppvObj)
HRESULT WINAPI	OleCreateLink (LPMONIKER pmkLinkSrc, REFIID riid, DWORD renderopt, LPFORMATETC lpFormatEtc, LPOLECLIENTSITE pClientSite, LPSTORAGE pStg, LPVOID *ppvObj)
HRESULT WINAPI	OleCreate (REFCLSID rclsid, REFIID riid, DWORD renderopt, LPFORMATETC pFormatEtc, LPOLECLIENTSITE pClientSite, LPSTORAGE pStg, LPVOID *ppvObj)
HRESULT WINAPI	OleFlushClipboard (void)
HRESULT WINAPI	GetConvertStg (LPSTORAGE pStg)
HRESULT WINAPI	SetConvertStg (LPSTORAGE pStg, BOOL fConvert)
BOOL WINAPI	IsAccelerator (HACCEL hAccel, int cAccelEntries, struct tagMSG *lpMsg, WORD *lpwCmd)
HRESULT WINAPI	OleCreateLinkToFile (LPCOLESTR lpszFileName, REFIID riid, DWORD renderopt, LPFORMATETC lpFormatEtc, LPOLECLIENTSITE pClientSite, LPSTORAGE pStg, LPVOID *ppvObj)
HANDLE WINAPI	OleDuplicateData (HANDLE hSrc, CLIPFORMAT cfFormat, UINT uiFlags)
HRESULT WINAPI	WriteFmtUserTypeStg (LPSTORAGE pstg, CLIPFORMAT cf, LPOLESTR lpszUserType)
HRESULT WINAPI	OleTranslateAccelerator (LPOLEINPLACEFRAME lpFrame, LPOLEINPLACEFRAMEINFO lpFrameInfo, struct tagMSG *lpmsg)
HRESULT WINAPI	OleCreateFromData (LPDATAOBJECT pSrcDataObj, REFIID riid, DWORD renderopt, LPFORMATETC pFormatEtc, LPOLECLIENTSITE pClientSite, LPSTORAGE pStg, LPVOID *ppvObj)
HRESULT WINAPI	OleCreateFromDataEx (LPDATAOBJECT pSrcDataObj, REFIID riid, DWORD dwFlags, DWORD renderopt, ULONG num_formats, DWORD *adv_flags, LPFORMATETC fmts, IAdviseSink *sink, DWORD *conns, LPOLECLIENTSITE pClientSite, LPSTORAGE pStg, LPVOID *ppvObj)
HRESULT WINAPI	OleCreateDefaultHandler (REFCLSID clsid, LPUNKNOWN pUnkOuter, REFIID riid, LPVOID *ppvObj)
HRESULT WINAPI	OleCreateEmbeddingHelper (REFCLSID clsid, LPUNKNOWN pUnkOuter, DWORD flags, IClassFactory *pCF, REFIID riid, LPVOID *ppvObj)
HRESULT WINAPI	CreateOleAdviseHolder (LPOLEADVISEHOLDER *ppOAHolder)
HRESULT WINAPI	OleInitialize (LPVOID pvReserved)
void WINAPI	OleUninitialize (void)
BOOL WINAPI	IsValidInterface (LPUNKNOWN punk)
DWORD WINAPI	OleBuildVersion (VOID)
HRESULT WINAPI	OleConvertOLESTREAMToIStorage (LPOLESTREAM lpolestream, LPSTORAGE pstg, const DVTARGETDEVICE *ptd)
HRESULT WINAPI	OleConvertIStorageToOLESTREAM (LPSTORAGE pstg, LPOLESTREAM lpolestream)
HRESULT WINAPI	OleDoAutoConvert (LPSTORAGE pStg, LPCLSID pClsidNew)
HRESULT WINAPI	OleGetAutoConvert (REFCLSID clsidOld, LPCLSID pClsidNew)
HRESULT WINAPI	OleSetAutoConvert (REFCLSID clsidOld, REFCLSID clsidNew)

Macro Definition Documentation

DATA_E_FORMATETC

#define DATA_E_FORMATETC   DV_E_FORMATETC

Definition at line 36 of file ole2.h.

E_DRAW

#define E_DRAW   VIEW_E_DRAW

Definition at line 35 of file ole2.h.

EMBDHLP_CREATENOW

#define EMBDHLP_CREATENOW   0x00000000

Definition at line 49 of file ole2.h.

EMBDHLP_DELAYCREATE

#define EMBDHLP_DELAYCREATE   0x00010000

Definition at line 50 of file ole2.h.

EMBDHLP_INPROC_HANDLER

#define EMBDHLP_INPROC_HANDLER   0x00000000

Definition at line 47 of file ole2.h.

EMBDHLP_INPROC_SERVER

#define EMBDHLP_INPROC_SERVER   0x00000001

Definition at line 48 of file ole2.h.

OLEIVERB_DISCARDUNDOSTATE

#define OLEIVERB_DISCARDUNDOSTATE   (-6L)

Definition at line 44 of file ole2.h.

OLEIVERB_HIDE

#define OLEIVERB_HIDE   (-3L)

Definition at line 41 of file ole2.h.

OLEIVERB_INPLACEACTIVATE

#define OLEIVERB_INPLACEACTIVATE   (-5L)

Definition at line 43 of file ole2.h.

OLEIVERB_OPEN

#define OLEIVERB_OPEN   (-2L)

Definition at line 40 of file ole2.h.

OLEIVERB_PRIMARY

#define OLEIVERB_PRIMARY   (0L)

Definition at line 38 of file ole2.h.

OLEIVERB_PROPERTIES

#define OLEIVERB_PROPERTIES   (-7L)

Definition at line 45 of file ole2.h.

OLEIVERB_SHOW

#define OLEIVERB_SHOW   (-1L)

Definition at line 39 of file ole2.h.

OLEIVERB_UIACTIVATE

#define OLEIVERB_UIACTIVATE   (-4L)

Definition at line 42 of file ole2.h.

Typedef Documentation

LPOLESTREAM

typedef struct _OLESTREAM* LPOLESTREAM

Definition at line 149 of file ole2.h.

LPOLESTREAMVTBL

typedef OLESTREAMVTBL* LPOLESTREAMVTBL

Definition at line 154 of file ole2.h.

OLESTREAM

typedef struct _OLESTREAM OLESTREAM

OLESTREAMVTBL

typedef struct _OLESTREAMVTBL OLESTREAMVTBL

Function Documentation

CreateDataAdviseHolder()

HRESULT WINAPI CreateDataAdviseHolder

(

LPDATAADVISEHOLDER *

ppDAHolder

)

CreateILockBytesOnHGlobal()

HRESULT WINAPI CreateILockBytesOnHGlobal	(	HGLOBAL	hGlobal,
		BOOL	fDeleteOnRelease,
		LPLOCKBYTES *	pplkbyt
	)

CreateOleAdviseHolder()

HRESULT WINAPI CreateOleAdviseHolder

(

LPOLEADVISEHOLDER *

ppOAHolder

)

CreateStreamOnHGlobal()

HRESULT WINAPI CreateStreamOnHGlobal	(	HGLOBAL	hGlobal,
		BOOL	fDeleteOnRelease,
		LPSTREAM *	ppstm
	)

DoDragDrop()

HRESULT WINAPI DoDragDrop	(	LPDATAOBJECT	,
		LPDROPSOURCE	,
		DWORD	,
		DWORD *
	)

GetConvertStg()

HRESULT WINAPI GetConvertStg

(

LPSTORAGE

pStg

)

GetHGlobalFromILockBytes()

HRESULT WINAPI GetHGlobalFromILockBytes	(	LPLOCKBYTES	plkbyt,
		HGLOBAL *	phglobal
	)

GetHGlobalFromStream()

HRESULT WINAPI GetHGlobalFromStream	(	LPSTREAM	pstm,
		HGLOBAL *	phglobal
	)

IsAccelerator()

BOOL WINAPI IsAccelerator	(	HACCEL	hAccel,
		int	cAccelEntries,
		struct tagMSG *	lpMsg,
		WORD *	lpwCmd
	)

IsValidInterface()

BOOL WINAPI IsValidInterface

(

LPUNKNOWN

punk

)

Definition at line 172 of file ole32_main.c.

{
    return !(IsBadReadPtr(punk,4) ||
                 IsBadReadPtr(punk->lpVtbl,4) ||
                 IsBadReadPtr(punk->lpVtbl->QueryInterface,9) ||
                 IsBadCodePtr((FARPROC)punk->lpVtbl->QueryInterface));
}

Referenced by MkParseDisplayName().

OleBuildVersion()

DWORD WINAPI OleBuildVersion

(

VOID

)

Definition at line 153 of file ole2.c.

{
    TRACE("Returning version %d, build %d.\n", rmm, rup);
    return (rmm<<16)+rup;
}

OleConvertIStorageToOLESTREAM()

HRESULT WINAPI OleConvertIStorageToOLESTREAM	(	LPSTORAGE	pstg,
		LPOLESTREAM	lpolestream
	)

Definition at line 10301 of file storage32.c.

{
    int i;
    HRESULT hRes = S_OK;
    IStream *pStream;
    OLECONVERT_OLESTREAM_DATA pOleStreamData[2];
 
    TRACE("%p %p\n", pstg, pOleStream);
 
    memset(pOleStreamData, 0, sizeof(pOleStreamData));
 
    if(pstg == NULL || pOleStream == NULL)
    {
        hRes = E_INVALIDARG;
    }
    if(hRes == S_OK)
    {
        /* Get the ProgID */
        pOleStreamData[0].dwOleTypeNameLength = OLESTREAM_MAX_STR_LEN;
        hRes = OLECONVERT_GetOLE10ProgID(pstg, pOleStreamData[0].strOleTypeName, &(pOleStreamData[0].dwOleTypeNameLength));
    }
    if(hRes == S_OK)
    {
        /* Was it originally Ole10 */
        hRes = IStorage_OpenStream(pstg, L"\1Ole10Native", 0, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &pStream);
        if(hRes == S_OK)
        {
            IStream_Release(pStream);
            /* Get Presentation Data for Ole10Native */
            OLECONVERT_GetOle10PresData(pstg, pOleStreamData);
        }
        else
        {
            /* Get Presentation Data (OLE20) */
            OLECONVERT_GetOle20PresData(pstg, pOleStreamData);
        }
 
        /* Save OLESTREAM */
        hRes = OLECONVERT_SaveOLE10(&(pOleStreamData[0]), pOleStream);
        if(hRes == S_OK)
        {
            hRes = OLECONVERT_SaveOLE10(&(pOleStreamData[1]), pOleStream);
        }
 
    }
 
    /* Free allocated memory */
    for(i=0; i < 2; i++)
    {
        HeapFree(GetProcessHeap(),0,pOleStreamData[i].pData);
    }
 
    return hRes;
}

OleConvertOLESTREAMToIStorage()

HRESULT WINAPI OleConvertOLESTREAMToIStorage	(	LPOLESTREAM	lpolestream,
		LPSTORAGE	pstg,
		const DVTARGETDEVICE *	ptd
	)

Definition at line 10210 of file storage32.c.

{
    int i;
    HRESULT hRes=S_OK;
    OLECONVERT_OLESTREAM_DATA pOleStreamData[2];
 
    TRACE("%p %p %p\n", pOleStream, pstg, ptd);
 
    memset(pOleStreamData, 0, sizeof(pOleStreamData));
 
    if(ptd != NULL)
    {
        FIXME("DVTARGETDEVICE is not NULL, unhandled parameter\n");
    }
 
    if(pstg == NULL || pOleStream == NULL)
    {
        hRes = E_INVALIDARG;
    }
 
    if(hRes == S_OK)
    {
        /* Load the OLESTREAM to Memory */
        hRes = OLECONVERT_LoadOLE10(pOleStream, &pOleStreamData[0], TRUE);
    }
 
    if(hRes == S_OK)
    {
        /* Load the OLESTREAM to Memory (part 2)*/
        hRes = OLECONVERT_LoadOLE10(pOleStream, &pOleStreamData[1], FALSE);
    }
 
    if(hRes == S_OK)
    {
 
        if(pOleStreamData[0].dwDataLength > sizeof(STORAGE_magic))
        {
            /* Do we have the IStorage Data in the OLESTREAM */
            if(memcmp(pOleStreamData[0].pData, STORAGE_magic, sizeof(STORAGE_magic)) ==0)
            {
                OLECONVERT_GetOLE20FromOLE10(pstg, pOleStreamData[0].pData, pOleStreamData[0].dwDataLength);
                OLECONVERT_CreateOlePresStream(pstg, pOleStreamData[1].dwMetaFileWidth, pOleStreamData[1].dwMetaFileHeight, pOleStreamData[1].pData, pOleStreamData[1].dwDataLength);
            }
            else
            {
                /* It must be an original OLE 1.0 source */
                OLECONVERT_CreateOle10NativeStream(pstg, pOleStreamData[0].pData, pOleStreamData[0].dwDataLength);
            }
        }
        else
        {
            /* It must be an original OLE 1.0 source */
            OLECONVERT_CreateOle10NativeStream(pstg, pOleStreamData[0].pData, pOleStreamData[0].dwDataLength);
        }
 
        /* Create CompObj Stream if necessary */
        hRes = OLECONVERT_CreateCompObjStream(pstg, pOleStreamData[0].strOleTypeName);
        if(hRes == S_OK)
        {
            /*Create the Ole Stream if necessary */
            STORAGE_CreateOleStream(pstg, 0);
        }
    }
 
 
    /* Free allocated memory */
    for(i=0; i < 2; i++)
    {
        HeapFree(GetProcessHeap(),0,pOleStreamData[i].pData);
        HeapFree(GetProcessHeap(),0,pOleStreamData[i].pstrOleObjFileName);
        pOleStreamData[i].pstrOleObjFileName = NULL;
    }
    return hRes;
}

OleCreate()

HRESULT WINAPI OleCreate	(	REFCLSID	rclsid,
		REFIID	riid,
		DWORD	renderopt,
		LPFORMATETC	pFormatEtc,
		LPOLECLIENTSITE	pClientSite,
		LPSTORAGE	pStg,
		LPVOID *	ppvObj
	)

Definition at line 2596 of file ole2.c.

{
    HRESULT hres;
    IUnknown * pUnk = NULL;
    IOleObject *pOleObject = NULL;
 
    TRACE("%s, %s, %ld, %p, %p, %p, %p.\n", debugstr_guid(rclsid),
        debugstr_guid(riid), renderopt, pFormatEtc, pClientSite, pStg, ppvObj);
 
    hres = CoCreateInstance(rclsid, 0, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER, riid, (LPVOID*)&pUnk);
 
    if (SUCCEEDED(hres))
        hres = IStorage_SetClass(pStg, rclsid);
 
    if (pClientSite && SUCCEEDED(hres))
    {
        hres = IUnknown_QueryInterface(pUnk, &IID_IOleObject, (LPVOID*)&pOleObject);
        if (SUCCEEDED(hres))
        {
            DWORD dwStatus;
            IOleObject_GetMiscStatus(pOleObject, DVASPECT_CONTENT, &dwStatus);
        }
    }
 
    if (SUCCEEDED(hres))
    {
        IPersistStorage * pPS;
        if (SUCCEEDED((hres = IUnknown_QueryInterface(pUnk, &IID_IPersistStorage, (LPVOID*)&pPS))))
        {
            TRACE("trying to set stg %p\n", pStg);
            hres = IPersistStorage_InitNew(pPS, pStg);
            TRACE("-- result %#lx\n", hres);
            IPersistStorage_Release(pPS);
        }
    }
 
    if (pClientSite && SUCCEEDED(hres))
    {
        TRACE("trying to set clientsite %p\n", pClientSite);
        hres = IOleObject_SetClientSite(pOleObject, pClientSite);
        TRACE("-- result %#lx\n", hres);
    }
 
    if (pOleObject)
        IOleObject_Release(pOleObject);
 
    if (((renderopt == OLERENDER_DRAW) || (renderopt == OLERENDER_FORMAT)) &&
        SUCCEEDED(hres))
    {
        hres = OleRun(pUnk);
        if (SUCCEEDED(hres))
        {
            IOleCache *pOleCache;
 
            if (SUCCEEDED(IUnknown_QueryInterface(pUnk, &IID_IOleCache, (void **)&pOleCache)))
            {
                DWORD dwConnection;
                if (renderopt == OLERENDER_DRAW && !pFormatEtc) {
                    FORMATETC pfe;
                    pfe.cfFormat = 0;
                    pfe.ptd = NULL;
                    pfe.dwAspect = DVASPECT_CONTENT;
                    pfe.lindex = -1;
                    pfe.tymed = TYMED_NULL;
                    hres = IOleCache_Cache(pOleCache, &pfe, ADVF_PRIMEFIRST, &dwConnection);
                }
                else
                    hres = IOleCache_Cache(pOleCache, pFormatEtc, ADVF_PRIMEFIRST, &dwConnection);
                IOleCache_Release(pOleCache);
            }
        }
    }
 
    if (FAILED(hres) && pUnk)
    {
        IUnknown_Release(pUnk);
        pUnk = NULL;
    }
 
    *ppvObj = pUnk;
 
    TRACE("-- %p\n", pUnk);
    return hres;
}

Referenced by InitWebBrowser(), test_OleCreate(), and UIINSERTOBJECTDLG_OnOpen().

OleCreateDefaultHandler()

HRESULT WINAPI OleCreateDefaultHandler	(	REFCLSID	clsid,
		LPUNKNOWN	pUnkOuter,
		REFIID	riid,
		LPVOID *	ppvObj
	)

Definition at line 2281 of file defaulthandler.c.

{
    TRACE("(%s, %p, %s, %p)\n", debugstr_guid(clsid), pUnkOuter,debugstr_guid(riid), ppvObj);
    return OleCreateEmbeddingHelper(clsid, pUnkOuter, EMBDHLP_INPROC_HANDLER | EMBDHLP_CREATENOW,
                                    NULL, riid, ppvObj);
}

Referenced by add_icon_to_control(), HandlerCF_CreateInstance(), insert_static_object(), OleCreateStaticFromData(), OleLoad(), test_default_handler(), test_default_handler_run(), and test_olestream().

OleCreateEmbeddingHelper()

HRESULT WINAPI OleCreateEmbeddingHelper	(	REFCLSID	clsid,
		LPUNKNOWN	pUnkOuter,
		DWORD	flags,
		IClassFactory *	pCF,
		REFIID	riid,
		LPVOID *	ppvObj
	)

Definition at line 2228 of file defaulthandler.c.

{
  DefaultHandler* newHandler = NULL;
  HRESULT         hr         = S_OK;
 
  TRACE("%s, %p, %#lx, %p, %s, %p.\n", debugstr_guid(clsid), pUnkOuter, flags, pCF, debugstr_guid(riid), ppvObj);
 
  if (!ppvObj)
    return E_POINTER;
 
  *ppvObj = NULL;
 
  /*
   * If This handler is constructed for aggregation, make sure
   * the caller is requesting the IUnknown interface.
   * This is necessary because it's the only time the non-delegating
   * IUnknown pointer can be returned to the outside.
   */
  if (pUnkOuter && !IsEqualIID(&IID_IUnknown, riid))
    return CLASS_E_NOAGGREGATION;
 
  /*
   * Try to construct a new instance of the class.
   */
  newHandler = DefaultHandler_Construct(clsid, pUnkOuter, flags, pCF);
 
  if (!newHandler)
    return E_OUTOFMEMORY;
 
  /*
   * Make sure it supports the interface required by the caller.
   */
  hr = IUnknown_QueryInterface(&newHandler->IUnknown_iface, riid, ppvObj);
 
  /*
   * Release the reference obtained in the constructor. If
   * the QueryInterface was unsuccessful, it will free the class.
   */
  IUnknown_Release(&newHandler->IUnknown_iface);
 
  return hr;
}

Referenced by OleCreateDefaultHandler(), and test_default_handler().

OleCreateFromData()

HRESULT WINAPI OleCreateFromData	(	LPDATAOBJECT	pSrcDataObj,
		REFIID	riid,
		DWORD	renderopt,
		LPFORMATETC	pFormatEtc,
		LPOLECLIENTSITE	pClientSite,
		LPSTORAGE	pStg,
		LPVOID *	ppvObj
	)

OleCreateFromDataEx()

HRESULT WINAPI OleCreateFromDataEx	(	LPDATAOBJECT	pSrcDataObj,
		REFIID	riid,
		DWORD	dwFlags,
		DWORD	renderopt,
		ULONG	num_formats,
		DWORD *	adv_flags,
		LPFORMATETC	fmts,
		IAdviseSink *	sink,
		DWORD *	conns,
		LPOLECLIENTSITE	pClientSite,
		LPSTORAGE	pStg,
		LPVOID *	ppvObj
	)

OleCreateFromFile()

HRESULT WINAPI OleCreateFromFile	(	REFCLSID	rclsid,
		LPCOLESTR	lpszFileName,
		REFIID	riid,
		DWORD	renderopt,
		LPFORMATETC	lpFormatEtc,
		LPOLECLIENTSITE	pClientSite,
		LPSTORAGE	pStg,
		LPVOID *	ppvObj
	)

OleCreateLink()

HRESULT WINAPI OleCreateLink	(	LPMONIKER	pmkLinkSrc,
		REFIID	riid,
		DWORD	renderopt,
		LPFORMATETC	lpFormatEtc,
		LPOLECLIENTSITE	pClientSite,
		LPSTORAGE	pStg,
		LPVOID *	ppvObj
	)

Definition at line 47 of file ole2stubs.c.

{
  FIXME("(not shown), stub!\n");
  return E_NOTIMPL;
}

OleCreateLinkFromData()

HRESULT WINAPI OleCreateLinkFromData	(	LPDATAOBJECT	pSrcDataObj,
		REFIID	riid,
		DWORD	renderopt,
		LPFORMATETC	pFormatEtc,
		LPOLECLIENTSITE	pClientSite,
		LPSTORAGE	pStg,
		LPVOID *	ppvObj
	)

OleCreateLinkToFile()

HRESULT WINAPI OleCreateLinkToFile	(	LPCOLESTR	lpszFileName,
		REFIID	riid,
		DWORD	renderopt,
		LPFORMATETC	lpFormatEtc,
		LPOLECLIENTSITE	pClientSite,
		LPSTORAGE	pStg,
		LPVOID *	ppvObj
	)

Definition at line 36 of file ole2stubs.c.

{
    FIXME("%p, %p, %ld, %p, %p, %p, %p stub!\n",lpszFileName, riid, renderopt, lpFormatEtc, pClientSite, pStg, ppvObj);
    return E_NOTIMPL;
}

OleCreateMenuDescriptor()

HOLEMENU WINAPI OleCreateMenuDescriptor	(	HMENU	hmenuCombined,
		LPOLEMENUGROUPWIDTHS	lpMenuWidths
	)

Definition at line 1793 of file ole2.c.

{
  HOLEMENU hOleMenu;
  OleMenuDescriptor *pOleMenuDescriptor;
  int i;
 
  if ( !hmenuCombined || !lpMenuWidths )
    return 0;
 
  /* Create an OLE menu descriptor */
  if ( !(hOleMenu = GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT,
                                sizeof(OleMenuDescriptor) ) ) )
  return 0;
 
  pOleMenuDescriptor = GlobalLock( hOleMenu );
  if ( !pOleMenuDescriptor )
    return 0;
 
  /* Initialize menu group widths and hmenu */
  for ( i = 0; i < 6; i++ )
    pOleMenuDescriptor->mgw.width[i] = lpMenuWidths->width[i];
 
  pOleMenuDescriptor->hmenuCombined = hmenuCombined;
  pOleMenuDescriptor->bIsServerItem = FALSE;
  GlobalUnlock( hOleMenu );
 
  return hOleMenu;
}

OleCreateStaticFromData()

HRESULT WINAPI OleCreateStaticFromData	(	LPDATAOBJECT	pSrcDataObj,
		REFIID	iid,
		DWORD	renderopt,
		LPFORMATETC	pFormatEtc,
		LPOLECLIENTSITE	pClientSite,
		LPSTORAGE	pStg,
		LPVOID *	ppvObj
	)

OleDestroyMenuDescriptor()

HRESULT WINAPI OleDestroyMenuDescriptor

(

HOLEMENU

hmenuDescriptor

)

Definition at line 1828 of file ole2.c.

{
    if ( hmenuDescriptor )
        GlobalFree( hmenuDescriptor );
    return S_OK;
}

OleDoAutoConvert()

HRESULT WINAPI OleDoAutoConvert	(	LPSTORAGE	pStg,
		LPCLSID	pClsidNew
	)

Definition at line 2743 of file ole2.c.

{
    WCHAR *user_type_old, *user_type_new;
    CLIPFORMAT cf;
    STATSTG stat;
    CLSID clsid;
    HRESULT hr;
 
    TRACE("(%p, %p)\n", pStg, pClsidNew);
 
    *pClsidNew = CLSID_NULL;
    if(!pStg)
        return E_INVALIDARG;
    hr = IStorage_Stat(pStg, &stat, STATFLAG_NONAME);
    if(FAILED(hr))
        return hr;
 
    *pClsidNew = stat.clsid;
    hr = OleGetAutoConvert(&stat.clsid, &clsid);
    if(FAILED(hr))
        return hr;
 
    hr = IStorage_SetClass(pStg, &clsid);
    if(FAILED(hr))
        return hr;
 
    hr = ReadFmtUserTypeStg(pStg, &cf, &user_type_old);
    if(FAILED(hr)) {
        cf = 0;
        user_type_new = NULL;
    }
 
    hr = OleRegGetUserType(&clsid, USERCLASSTYPE_FULL, &user_type_new);
    if(FAILED(hr))
        user_type_new = NULL;
 
    hr = WriteFmtUserTypeStg(pStg, cf, user_type_new);
    CoTaskMemFree(user_type_new);
    if(FAILED(hr))
    {
        CoTaskMemFree(user_type_old);
        IStorage_SetClass(pStg, &stat.clsid);
        return hr;
    }
 
    hr = SetConvertStg(pStg, TRUE);
    if(FAILED(hr))
    {
        WriteFmtUserTypeStg(pStg, cf, user_type_old);
        IStorage_SetClass(pStg, &stat.clsid);
    }
    else
        *pClsidNew = clsid;
    CoTaskMemFree(user_type_old);
    return hr;
}

Referenced by test_OleDoAutoConvert().

OleDraw()

HRESULT WINAPI OleDraw	(	LPUNKNOWN	pUnknown,
		DWORD	dwAspect,
		HDC	hdcDraw,
		LPCRECT	lprcBounds
	)

OleDuplicateData()

HANDLE WINAPI OleDuplicateData	(	HANDLE	hSrc,
		CLIPFORMAT	cfFormat,
		UINT	uiFlags
	)

Definition at line 3219 of file ole2.c.

{
    HANDLE hDst = NULL;
 
    TRACE("(%p,%x,%x)\n", hSrc, cfFormat, uiFlags);
 
    if (!uiFlags) uiFlags = GMEM_MOVEABLE;
 
    switch (cfFormat)
    {
    case CF_ENHMETAFILE:
        hDst = CopyEnhMetaFileW(hSrc, NULL);
        break;
    case CF_METAFILEPICT:
        hDst = CopyMetaFileW(hSrc, NULL);
        break;
    case CF_PALETTE:
        {
            LOGPALETTE * logpalette;
            UINT nEntries = GetPaletteEntries(hSrc, 0, 0, NULL);
            if (!nEntries) return NULL;
            logpalette = HeapAlloc(GetProcessHeap(), 0,
                FIELD_OFFSET(LOGPALETTE, palPalEntry[nEntries]));
            if (!logpalette) return NULL;
            if (!GetPaletteEntries(hSrc, 0, nEntries, logpalette->palPalEntry))
            {
                HeapFree(GetProcessHeap(), 0, logpalette);
                return NULL;
            }
            logpalette->palVersion = 0x300;
            logpalette->palNumEntries = (WORD)nEntries;
 
            hDst = CreatePalette(logpalette);
 
            HeapFree(GetProcessHeap(), 0, logpalette);
            break;
        }
    case CF_BITMAP:
        {
            LONG size;
            BITMAP bm;
            if (!GetObjectW(hSrc, sizeof(bm), &bm))
                return NULL;
            size = GetBitmapBits(hSrc, 0, NULL);
            if (!size) return NULL;
            bm.bmBits = HeapAlloc(GetProcessHeap(), 0, size);
            if (!bm.bmBits) return NULL;
            if (GetBitmapBits(hSrc, size, bm.bmBits))
                hDst = CreateBitmapIndirect(&bm);
            HeapFree(GetProcessHeap(), 0, bm.bmBits);
            break;
        }
    default:
        {
            SIZE_T size = GlobalSize(hSrc);
            LPVOID pvSrc = NULL;
            LPVOID pvDst = NULL;
 
            /* allocate space for object */
            if (!size) return NULL;
            hDst = GlobalAlloc(uiFlags, size);
            if (!hDst) return NULL;
 
            /* lock pointers */
            pvSrc = GlobalLock(hSrc);
            if (!pvSrc)
            {
                GlobalFree(hDst);
                return NULL;
            }
            pvDst = GlobalLock(hDst);
            if (!pvDst)
            {
                GlobalUnlock(hSrc);
                GlobalFree(hDst);
                return NULL;
            }
            /* copy data */
            memcpy(pvDst, pvSrc, size);
 
            /* cleanup */
            GlobalUnlock(hDst);
            GlobalUnlock(hSrc);
        }
    }
 
    TRACE("returning %p\n", hDst);
    return hDst;
}

Referenced by copy_stg_medium(), and IDataObjectImpl::CopyMedium().

OleFlushClipboard()

HRESULT WINAPI OleFlushClipboard

(

void

)

Definition at line 2290 of file clipboard.c.

{
  struct oletls *info = COM_CurrentInfo();
  HRESULT hr;
  ole_clipbrd *clipbrd;
  HWND wnd;
 
  TRACE("()\n");
 
  if(FAILED(hr = get_ole_clipbrd(&clipbrd))) return hr;
 
  if(!info->ole_inits)
    return E_FAIL;
 
  if(FAILED(hr = get_clipbrd_window(clipbrd, &wnd))) return hr;
 
  /*
   * Already flushed or no source DataObject? Nothing to do.
   */
  if (!clipbrd->src_data) return S_OK;
 
  if (!OpenClipboard(wnd)) return CLIPBRD_E_CANT_OPEN;
 
  SendMessageW(wnd, WM_RENDERALLFORMATS, 0, 0);
 
  hr = set_dataobject_format(NULL);
 
  expose_marshalled_dataobject(clipbrd, NULL);
  set_src_dataobject(clipbrd, NULL);
 
  if ( !CloseClipboard() ) hr = CLIPBRD_E_CANT_CLOSE;
 
  return hr;
}

Referenced by fnTextSrv_TxSetText(), CShellBrowser::OnDestroy(), SHFlushClipboard(), START_TEST(), test_consumer_refs(), test_flushed_getdata(), test_get_clipboard_uninitialized(), test_set_clipboard(), and test_set_clipboard_DRAWCLIPBOARD().

OleGetAutoConvert()

HRESULT WINAPI OleGetAutoConvert	(	REFCLSID	clsidOld,
		LPCLSID	pClsidNew
	)

Definition at line 2691 of file ole2.c.

{
    HKEY hkey = NULL;
    WCHAR buf[CHARS_IN_GUID];
    LONG len;
    HRESULT res = S_OK;
 
    res = COM_OpenKeyForCLSID(clsidOld, L"AutoConvertTo", KEY_READ, &hkey);
    if (FAILED(res))
        goto done;
 
    len = sizeof(buf);
    if (RegQueryValueW(hkey, NULL, buf, &len))
    {
        res = REGDB_E_KEYMISSING;
        goto done;
    }
    res = CLSIDFromString(buf, pClsidNew);
done:
    if (hkey) RegCloseKey(hkey);
    return res;
}

Referenced by OleDoAutoConvert(), and test_OleDoAutoConvert().

OleGetClipboard()

HRESULT WINAPI OleGetClipboard

(

IDataObject **

ppDataObj

)

Definition at line 2246 of file clipboard.c.

{
    HRESULT hr;
    ole_clipbrd *clipbrd;
    DWORD seq_no;
 
    TRACE("(%p)\n", obj);
 
    if(!obj) return E_INVALIDARG;
    *obj = NULL;
 
    if(FAILED(hr = get_ole_clipbrd(&clipbrd))) return hr;
 
    seq_no = GetClipboardSequenceNumber();
    EnterCriticalSection(&latest_snapshot_cs);
    if(clipbrd->latest_snapshot && clipbrd->latest_snapshot->seq_no != seq_no)
        clipbrd->latest_snapshot = NULL;
 
    if(!clipbrd->latest_snapshot)
    {
        clipbrd->latest_snapshot = snapshot_construct(seq_no);
        if(!clipbrd->latest_snapshot)
        {
            LeaveCriticalSection(&latest_snapshot_cs);
            return E_OUTOFMEMORY;
        }
    }
 
    *obj = &clipbrd->latest_snapshot->IDataObject_iface;
    IDataObject_AddRef(*obj);
    LeaveCriticalSection(&latest_snapshot_cs);
 
    return S_OK;
}

Referenced by CDefViewBckgrndMenu::_bCanPaste(), CDefaultContextMenu::DoPaste(), CFontExt::GetUIObjectOf(), HasClipboardData(), CFontBackgroundMenu::InvokeCommand(), OleUIPasteSpecialW(), paste_special(), test_complex_get_clipboard(), test_consumer_refs(), test_enum_fmtetc(), test_flushed_getdata(), test_get_clipboard(), test_get_clipboard_locked(), test_get_clipboard_uninitialized(), test_getdatahere(), test_multithreaded_clipboard(), and test_nonole_clipboard().

OleGetIconOfClass()

HGLOBAL WINAPI OleGetIconOfClass	(	REFCLSID	rclsid,
		LPOLESTR	lpszLabel,
		BOOL	fUseTypeAsLabel
	)

Definition at line 57 of file ole2stubs.c.

{
  FIXME("(%p,%p,%x), stub!\n", rclsid, lpszLabel, fUseTypeAsLabel);
  return NULL;
}

OleGetIconOfFile()

HGLOBAL WINAPI OleGetIconOfFile	(	LPOLESTR	lpszPath,
		BOOL	fUseFileAsLabel
	)

Definition at line 66 of file ole2stubs.c.

{
    FIXME("(%s, %d), stub!\n", debugstr_w(path), use_file_as_label);
    return NULL;
}

OleInitialize()

HRESULT WINAPI OleInitialize

(

LPVOID

pvReserved

)

Definition at line 162 of file ole2.c.

{
  HRESULT hr;
 
  TRACE("(%p)\n", reserved);
 
  /*
   * The first duty of the OleInitialize is to initialize the COM libraries.
   */
  hr = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
 
  /*
   * If the CoInitializeEx call failed, the OLE libraries can't be
   * initialized.
   */
  if (FAILED(hr))
    return hr;
 
  if (!COM_CurrentInfo()->ole_inits)
    hr = S_OK;
  else
    hr = S_FALSE;
 
  /*
   * Then, it has to initialize the OLE specific modules.
   * This includes:
   *     Clipboard
   *     Drag and Drop
   *     Object linking and Embedding
   *     In-place activation
   */
  if (!COM_CurrentInfo()->ole_inits++ &&
      InterlockedIncrement(&OLE_moduleLockCount) == 1)
  {
    /*
     * Initialize the libraries.
     */
    TRACE("() - Initializing the OLE libraries\n");
 
    /*
     * Drag and Drop
     */
    OLEDD_Initialize();
 
    /*
     * OLE shared menu
     */
    OLEMenu_Initialize();
  }
 
  return hr;
}

Referenced by _tWinMain(), adv_install(), AtlAxWinInit(), AVIFileInit(), BrowserThreadProc(), CreateHelpViewer(), CDesktopThread::DesktopThreadProc(), display_cpl_sheets(), do_enum(), FileOpenDlgProc95(), hook_proc(), ImageView_Main(), init_explorerbrowser(), ME_MakeEditor(), OleInit::OleInit(), SHRegisterDragDrop(), START_TEST(), StartWithDesktop(), test_CoCreateInstance(), test_CoInitializeEx(), test_consumer_refs(), test_DoDragDrop(), test_flushed_getdata(), test_get_clipboard_locked(), test_getdatahere(), test_multithreaded_clipboard(), test_nonole_clipboard(), test_ole_init_wndproc(), test_ole_initialization(), test_OleCreateFontIndirect(), test_OleInitialize_InitCounting(), test_Register_Revoke(), test_set_clipboard(), test_set_clipboard_DRAWCLIPBOARD(), test_TreatAsClass(), CHardErrorThread::ThreadProc(), wmain(), and wWinMain().

OleIsCurrentClipboard()

HRESULT WINAPI OleIsCurrentClipboard

(

LPDATAOBJECT

)

OleIsRunning()

BOOL WINAPI OleIsRunning

(

LPOLEOBJECT

pObject

)

Definition at line 2803 of file ole2.c.

{
    IRunnableObject *pRunnable;
    HRESULT hr;
    BOOL running;
 
    TRACE("(%p)\n", object);
 
    if (!object) return FALSE;
 
    hr = IOleObject_QueryInterface(object, &IID_IRunnableObject, (void **)&pRunnable);
    if (FAILED(hr))
        return TRUE;
    running = IRunnableObject_IsRunning(pRunnable);
    IRunnableObject_Release(pRunnable);
    return running;
}

Referenced by test_runnable().

OleLoad()

HRESULT WINAPI OleLoad	(	LPSTORAGE	pStg,
		REFIID	riid,
		LPOLECLIENTSITE	pClientSite,
		LPVOID *	ppvObj
	)

Definition at line 1205 of file ole2.c.

{
  IPersistStorage* persistStorage = NULL;
  IUnknown*        pUnk;
  IOleObject*      pOleObject      = NULL;
  STATSTG          storageInfo;
  HRESULT          hres;
 
  TRACE("(%p, %s, %p, %p)\n", pStg, debugstr_guid(riid), pClientSite, ppvObj);
 
  *ppvObj = NULL;
 
  /*
   * TODO, Conversion ... OleDoAutoConvert
   */
 
  /*
   * Get the class ID for the object.
   */
  hres = IStorage_Stat(pStg, &storageInfo, STATFLAG_NONAME);
  if (FAILED(hres))
    return hres;
 
  /*
   * Now, try and create the handler for the object
   */
  hres = CoCreateInstance(&storageInfo.clsid,
              NULL,
              CLSCTX_INPROC_HANDLER|CLSCTX_INPROC_SERVER,
              riid,
              (void**)&pUnk);
 
  /*
   * If that fails, as it will most times, load the default
   * OLE handler.
   */
  if (FAILED(hres))
  {
    hres = OleCreateDefaultHandler(&storageInfo.clsid,
                   NULL,
                   riid,
                   (void**)&pUnk);
  }
 
  /*
   * If we couldn't find a handler... this is bad. Abort the whole thing.
   */
  if (FAILED(hres))
    return hres;
 
  if (pClientSite)
  {
    hres = IUnknown_QueryInterface(pUnk, &IID_IOleObject, (void **)&pOleObject);
    if (SUCCEEDED(hres))
    {
        DWORD dwStatus;
        hres = IOleObject_GetMiscStatus(pOleObject, DVASPECT_CONTENT, &dwStatus);
    }
  }
 
  /*
   * Initialize the object with its IPersistStorage interface.
   */
  hres = IUnknown_QueryInterface(pUnk, &IID_IPersistStorage, (void**)&persistStorage);
  if (SUCCEEDED(hres))
  {
    hres = IPersistStorage_Load(persistStorage, pStg);
 
    IPersistStorage_Release(persistStorage);
    persistStorage = NULL;
  }
 
  if (SUCCEEDED(hres) && pClientSite)
    /*
     * Inform the new object of its client site.
     */
    hres = IOleObject_SetClientSite(pOleObject, pClientSite);
 
  /*
   * Cleanup interfaces used internally
   */
  if (pOleObject)
    IOleObject_Release(pOleObject);
 
  if (SUCCEEDED(hres))
  {
    IOleLink *pOleLink;
    HRESULT hres1;
    hres1 = IUnknown_QueryInterface(pUnk, &IID_IOleLink, (void **)&pOleLink);
    if (SUCCEEDED(hres1))
    {
      FIXME("handle OLE link\n");
      IOleLink_Release(pOleLink);
    }
  }
 
  if (FAILED(hres))
  {
    IUnknown_Release(pUnk);
    pUnk = NULL;
  }
 
  *ppvObj = pUnk;
 
  return hres;
}

Referenced by OleCreateFromDataEx(), OleCreateFromFileEx(), and test_OleLoad().

OleLoadFromStream()

HRESULT WINAPI OleLoadFromStream	(	IStream *	pStm,
		REFIID	iidInterface,
		void **	ppvObj
	)

Definition at line 9001 of file storage32.c.

{
    CLSID   clsid;
    HRESULT res;
    LPPERSISTSTREAM xstm;
 
    TRACE("(%p,%s,%p)\n",pStm,debugstr_guid(iidInterface),ppvObj);
 
    res=ReadClassStm(pStm,&clsid);
    if (FAILED(res))
    return res;
    res=CoCreateInstance(&clsid,NULL,CLSCTX_INPROC_SERVER,iidInterface,ppvObj);
    if (FAILED(res))
    return res;
    res=IUnknown_QueryInterface((IUnknown*)*ppvObj,&IID_IPersistStream,(LPVOID*)&xstm);
    if (FAILED(res)) {
    IUnknown_Release((IUnknown*)*ppvObj);
    return res;
    }
    res=IPersistStream_Load(xstm,pStm);
    IPersistStream_Release(xstm);
    /* FIXME: all refcounts ok at this point? I think they should be:
     *      pStm    : unchanged
     *      ppvObj  : 1
     *      xstm    : 0 (released)
     */
    return res;
}

Referenced by CompositeMonikerImpl_Load(), HlinkClone(), IPersistStream_fnLoad(), and CTrayBandSite::OnLoad().

OleLockRunning()

HRESULT WINAPI OleLockRunning	(	LPUNKNOWN	pUnknown,
		BOOL	fLock,
		BOOL	fLastUnlockCloses
	)

Definition at line 1358 of file ole2.c.

{
  IRunnableObject* runnable = NULL;
  HRESULT          hres;
 
  TRACE("(%p,%x,%x)\n", pUnknown, fLock, fLastUnlockCloses);
 
  hres = IUnknown_QueryInterface(pUnknown,
                 &IID_IRunnableObject,
                 (void**)&runnable);
 
  if (SUCCEEDED(hres))
  {
    hres = IRunnableObject_LockRunning(runnable, fLock, fLastUnlockCloses);
 
    IRunnableObject_Release(runnable);
 
    return hres;
  }
 
  return S_OK;
}

Referenced by test_OleLockRunning().

OleMetafilePictFromIconAndLabel()

HGLOBAL WINAPI OleMetafilePictFromIconAndLabel	(	HICON	hIcon,
		LPOLESTR	lpszLabel,
		LPOLESTR	lpszSourceFile,
		UINT	iIconIndex
	)

Definition at line 40 of file ole32_main.c.

{
    METAFILEPICT mfp;
    HDC hdc;
    HGLOBAL hmem = NULL;
    LPVOID mfdata;
    static const char szIconOnly[] = "IconOnly";
    SIZE text_size = { 0, 0 };
    INT width;
    INT icon_width;
    INT icon_height;
    INT label_offset;
    HDC hdcScreen;
    LOGFONTW lf;
    HFONT font;
 
    TRACE("%p %p %s %d\n", hIcon, lpszLabel, debugstr_w(lpszSourceFile), iIconIndex);
 
    if( !hIcon )
        return NULL;
 
    if (!SystemParametersInfoW(SPI_GETICONTITLELOGFONT, sizeof(lf), &lf, 0))
        return NULL;
 
    font = CreateFontIndirectW(&lf);
    if (!font)
        return NULL;
 
    hdc = CreateMetaFileW(NULL);
    if( !hdc )
    {
        DeleteObject(font);
        return NULL;
    }
 
    SelectObject(hdc, font);
 
    ExtEscape(hdc, MFCOMMENT, sizeof(szIconOnly), szIconOnly, 0, NULL);
 
    icon_width = GetSystemMetrics(SM_CXICON);
    icon_height = GetSystemMetrics(SM_CYICON);
    /* FIXME: should we give the label a bit of padding here? */
    label_offset = icon_height;
    if (lpszLabel)
    {
        HFONT screen_old_font;
        /* metafile DCs don't support GetTextExtentPoint32, so size the font
         * using the desktop window DC */
        hdcScreen = GetDC(NULL);
        screen_old_font = SelectObject(hdcScreen, font);
        GetTextExtentPoint32W(hdcScreen, lpszLabel, lstrlenW(lpszLabel), &text_size);
        SelectObject(hdcScreen, screen_old_font);
        ReleaseDC(NULL, hdcScreen);
 
        width = 3 * icon_width;
    }
    else
        width = icon_width;
 
    SetMapMode(hdc, MM_ANISOTROPIC);
    SetWindowOrgEx(hdc, 0, 0, NULL);
    SetWindowExtEx(hdc, width, label_offset + text_size.cy, NULL);
 
    /* draw the icon centered */
    DrawIcon(hdc, (width-icon_width) / 2, 0, hIcon);
    if(lpszLabel)
        /* draw the label centered too, if provided */
        TextOutW(hdc, (width-text_size.cx) / 2, label_offset, lpszLabel, lstrlenW(lpszLabel));
 
    if (lpszSourceFile)
    {
        char szIconIndex[10];
        int path_length = WideCharToMultiByte(CP_ACP,0,lpszSourceFile,-1,NULL,0,NULL,NULL);
        if (path_length > 1)
        {
            char * szPath = CoTaskMemAlloc(path_length * sizeof(CHAR));
            if (szPath)
            {
                WideCharToMultiByte(CP_ACP,0,lpszSourceFile,-1,szPath,path_length,NULL,NULL);
                ExtEscape(hdc, MFCOMMENT, path_length, szPath, 0, NULL);
                CoTaskMemFree(szPath);
            }
        }
        snprintf(szIconIndex, 10, "%u", iIconIndex);
        ExtEscape(hdc, MFCOMMENT, strlen(szIconIndex)+1, szIconIndex, 0, NULL);
    }
 
    mfp.mm = MM_ANISOTROPIC;
    hdcScreen = GetDC(NULL);
    mfp.xExt = MulDiv(width, HIMETRIC_INCHES, GetDeviceCaps(hdcScreen, LOGPIXELSX));
    mfp.yExt = MulDiv(label_offset + text_size.cy, HIMETRIC_INCHES, GetDeviceCaps(hdcScreen, LOGPIXELSY));
    ReleaseDC(NULL, hdcScreen);
    mfp.hMF = CloseMetaFile(hdc);
    DeleteObject(font);
    if( !mfp.hMF )
        return NULL;
 
    hmem = GlobalAlloc( GMEM_MOVEABLE, sizeof(mfp) );
    if( !hmem )
    {
        DeleteMetaFile(mfp.hMF);
        return NULL;
    }
 
    mfdata = GlobalLock( hmem );
    if( !mfdata )
    {
        GlobalFree( hmem );
        DeleteMetaFile(mfp.hMF);
        return NULL;
    }
 
    memcpy(mfdata,&mfp,sizeof(mfp));
    GlobalUnlock( hmem );
 
    TRACE("returning %p\n",hmem);
 
    return hmem;
}

Referenced by test_data_cache().

OleNoteObjectVisible()

HRESULT WINAPI OleNoteObjectVisible	(	LPUNKNOWN	pUnknown,
		BOOL	fVisible
	)

Definition at line 2824 of file ole2.c.

{
    TRACE("(%p, %s)\n", pUnknown, bVisible ? "TRUE" : "FALSE");
    return CoLockObjectExternal(pUnknown, bVisible, TRUE);
}

OleQueryCreateFromData()

HRESULT WINAPI OleQueryCreateFromData

(

LPDATAOBJECT

pSrcDataObject

)

OleQueryLinkFromData()

HRESULT WINAPI OleQueryLinkFromData

(

IDataObject *

pSrcDataObject

)

Definition at line 838 of file ole2.c.

{
  FIXME("(%p),stub!\n", pSrcDataObject);
  return S_FALSE;
}

OleRegEnumFormatEtc()

HRESULT WINAPI OleRegEnumFormatEtc	(	REFCLSID	clsid,
		DWORD	dwDirection,
		LPENUMFORMATETC *	ppenumFormatetc
	)

Definition at line 75 of file ole2stubs.c.

{
    FIXME("%p, %ld, %p stub!\n", clsid, dwDirection, ppenumFormatetc);
 
    return E_NOTIMPL;
}

Referenced by DefaultHandler_EnumFormatEtc().

OleRegEnumVerbs()

HRESULT WINAPI OleRegEnumVerbs	(	REFCLSID	clsid,
		LPENUMOLEVERB *	ppenum
	)

Definition at line 1107 of file ole2.c.

{
    LONG res;
    HKEY hkeyVerb;
    DWORD dwSubKeys;
 
    TRACE("(%s, %p)\n", debugstr_guid(clsid), ppenum);
 
    res = COM_OpenKeyForCLSID(clsid, L"Verb", KEY_READ, &hkeyVerb);
    if (FAILED(res))
    {
        if (res == REGDB_E_CLASSNOTREG)
            ERR("CLSID %s not registered\n", debugstr_guid(clsid));
        else if (res == REGDB_E_KEYMISSING)
            ERR("no Verbs key for class %s\n", debugstr_guid(clsid));
        else
            ERR("failed to open Verbs key for CLSID %s with error %ld\n",
                debugstr_guid(clsid), res);
        return res;
    }
 
    res = RegQueryInfoKeyW(hkeyVerb, NULL, NULL, NULL, &dwSubKeys, NULL,
                          NULL, NULL, NULL, NULL, NULL, NULL);
    if (res != ERROR_SUCCESS)
    {
        ERR("failed to get subkey count with error %ld\n", GetLastError());
        return REGDB_E_READREGDB;
    }
 
    if (!dwSubKeys)
    {
        WARN("class %s has no verbs\n", debugstr_guid(clsid));
        RegCloseKey(hkeyVerb);
        return OLEOBJ_E_NOVERBS;
    }
 
    return EnumOLEVERB_Construct(hkeyVerb, 0, ppenum);
}

Referenced by DefaultHandler_EnumVerbs(), and SEALED_::IOleObject::EnumVerbs().

OleRegGetMiscStatus()

HRESULT WINAPI OleRegGetMiscStatus	(	REFCLSID	clsid,
		DWORD	dwAspect,
		DWORD *	pdwStatus
	)

Definition at line 848 of file ole2.c.

{
  WCHAR   keyName[16];
  HKEY    miscStatusKey;
  HKEY    aspectKey;
  LONG    result;
  HRESULT hr;
 
  TRACE("%s, %ld, %p.\n", debugstr_guid(clsid), dwAspect, pdwStatus);
 
  if (!pdwStatus) return E_INVALIDARG;
 
  *pdwStatus = 0;
 
  if (actctx_get_miscstatus(clsid, dwAspect, pdwStatus)) return S_OK;
 
  hr = COM_OpenKeyForCLSID(clsid, L"MiscStatus", KEY_READ, &miscStatusKey);
  if (FAILED(hr))
    /* missing key is not a failure */
    return hr == REGDB_E_KEYMISSING ? S_OK : hr;
 
  OLEUTL_ReadRegistryDWORDValue(miscStatusKey, pdwStatus);
 
  /*
   * Open the key specific to the requested aspect.
   */
  swprintf(keyName, ARRAY_SIZE(keyName), L"%d", dwAspect);
 
  result = open_classes_key(miscStatusKey, keyName, KEY_READ, &aspectKey);
  if (result == ERROR_SUCCESS)
  {
    OLEUTL_ReadRegistryDWORDValue(aspectKey, pdwStatus);
    RegCloseKey(aspectKey);
  }
 
  RegCloseKey(miscStatusKey);
  return S_OK;
}

Referenced by DefaultHandler_GetMiscStatus(), SEALED_::IOleObject::GetMiscStatus(), and test_OleRegGetMiscStatus().

OleRegGetUserType()

HRESULT WINAPI OleRegGetUserType	(	REFCLSID	clsid,
		DWORD	dwFormOfType,
		LPOLESTR *	pszUserType
	)

Definition at line 668 of file ole2.c.

{
  DWORD valuetype, valuelen;
  WCHAR auxkeynameW[16];
  HKEY    usertypekey;
  HRESULT hres;
  LONG    ret;
 
  TRACE("%s, %lu, %p.\n", debugstr_guid(clsid), form, usertype);
 
  if (!usertype)
    return E_INVALIDARG;
 
  *usertype = NULL;
 
  /* Return immediately if it's not registered. */
  hres = COM_OpenKeyForCLSID(clsid, NULL, KEY_READ, &usertypekey);
  if (FAILED(hres))
    return hres;
 
  valuelen = 0;
 
  /* Try additional types if requested. If they don't exist fall back to USERCLASSTYPE_FULL. */
  if (form != USERCLASSTYPE_FULL)
  {
    HKEY auxkey;
 
    swprintf(auxkeynameW, ARRAY_SIZE(auxkeynameW), L"AuxUserType\\%d", form);
    if (COM_OpenKeyForCLSID(clsid, auxkeynameW, KEY_READ, &auxkey) == S_OK)
    {
      if (!RegQueryValueExW(auxkey, L"", NULL, &valuetype, NULL, &valuelen) && valuelen)
      {
        RegCloseKey(usertypekey);
        usertypekey = auxkey;
      }
      else
        RegCloseKey(auxkey);
    }
  }
 
  valuelen = 0;
  if (RegQueryValueExW(usertypekey, L"", NULL, &valuetype, NULL, &valuelen))
  {
    RegCloseKey(usertypekey);
    return REGDB_E_READREGDB;
  }
 
  *usertype = CoTaskMemAlloc(valuelen);
  if (!*usertype)
  {
    RegCloseKey(usertypekey);
    return E_OUTOFMEMORY;
  }
 
  ret = RegQueryValueExW(usertypekey, L"", NULL, &valuetype, (BYTE *)*usertype, &valuelen);
  RegCloseKey(usertypekey);
  if (ret != ERROR_SUCCESS)
  {
    CoTaskMemFree(*usertype);
    *usertype = NULL;
    return REGDB_E_READREGDB;
  }
 
  return S_OK;
}

Referenced by DefaultHandler_GetUserType(), get_descriptors(), SEALED_::IOleObject::GetUserType(), OleDoAutoConvert(), OleObject_GetUserType(), and test_OleRegGetUserType().

OleRun()

HRESULT WINAPI OleRun

(

LPUNKNOWN

pUnknown

)

Definition at line 1186 of file ole2.c.

{
    IRunnableObject *runable;
    HRESULT hres;
 
    TRACE("(%p)\n", pUnknown);
 
    hres = IUnknown_QueryInterface(pUnknown, &IID_IRunnableObject, (void**)&runable);
    if (FAILED(hres))
        return S_OK; /* Appears to return no error. */
 
    hres = IRunnableObject_Run(runable, NULL);
    IRunnableObject_Release(runable);
    return hres;
}

Referenced by OleCreate(), START_TEST(), and test_OleRun().

OleSave()

HRESULT WINAPI OleSave	(	LPPERSISTSTORAGE	pPS,
		LPSTORAGE	pStg,
		BOOL	fSameAsLoad
	)

Definition at line 1319 of file ole2.c.

{
  HRESULT hres;
  CLSID   objectClass;
 
  TRACE("(%p,%p,%x)\n", pPS, pStg, fSameAsLoad);
 
  /*
   * First, we transfer the class ID (if available)
   */
  hres = IPersistStorage_GetClassID(pPS, &objectClass);
 
  if (SUCCEEDED(hres))
  {
    WriteClassStg(pStg, &objectClass);
  }
 
  /*
   * Then, we ask the object to save itself to the
   * storage. If it is successful, we commit the storage.
   */
  hres = IPersistStorage_Save(pPS, pStg, fSameAsLoad);
 
  if (SUCCEEDED(hres))
  {
    IStorage_Commit(pStg,
            STGC_DEFAULT);
  }
 
  return hres;
}

OleSaveToStream()

HRESULT WINAPI OleSaveToStream	(	IPersistStream *	pPStm,
		IStream *	pStm
	)

Definition at line 9036 of file storage32.c.

{
 
    CLSID clsid;
    HRESULT res;
 
    TRACE("(%p,%p)\n",pPStm,pStm);
 
    res=IPersistStream_GetClassID(pPStm,&clsid);
 
    if (SUCCEEDED(res)){
 
        res=WriteClassStm(pStm,&clsid);
 
        if (SUCCEEDED(res))
 
            res=IPersistStream_Save(pPStm,pStm,TRUE);
    }
 
    TRACE("Finished Save\n");
    return res;
}

Referenced by composite_save_components(), HlinkClone(), and IPersistStream_fnSave().

OleSetAutoConvert()

HRESULT WINAPI OleSetAutoConvert	(	REFCLSID	clsidOld,
		REFCLSID	clsidNew
	)

Definition at line 2717 of file ole2.c.

{
    HKEY hkey = NULL;
    WCHAR szClsidNew[CHARS_IN_GUID];
    HRESULT res = S_OK;
 
    TRACE("(%s,%s)\n", debugstr_guid(clsidOld), debugstr_guid(clsidNew));
    
    res = COM_OpenKeyForCLSID(clsidOld, NULL, KEY_READ | KEY_WRITE, &hkey);
    if (FAILED(res))
        goto done;
    StringFromGUID2(clsidNew, szClsidNew, CHARS_IN_GUID);
    if (RegSetValueW(hkey, L"AutoConvertTo", REG_SZ, szClsidNew, (lstrlenW(szClsidNew)+1) * sizeof(WCHAR)))
    {
        res = REGDB_E_WRITEREGDB;
    goto done;
    }
 
done:
    if (hkey) RegCloseKey(hkey);
    return res;
}

Referenced by test_OleDoAutoConvert().

OleSetClipboard()

HRESULT WINAPI OleSetClipboard

(

LPDATAOBJECT

)

OleSetContainedObject()

HRESULT WINAPI OleSetContainedObject	(	LPUNKNOWN	pUnknown,
		BOOL	fContained
	)

Definition at line 1149 of file ole2.c.

{
  IRunnableObject* runnable = NULL;
  HRESULT          hres;
 
  TRACE("(%p,%x)\n", pUnknown, fContained);
 
  hres = IUnknown_QueryInterface(pUnknown,
                 &IID_IRunnableObject,
                 (void**)&runnable);
 
  if (SUCCEEDED(hres))
  {
    hres = IRunnableObject_SetContainedObject(runnable, fContained);
 
    IRunnableObject_Release(runnable);
 
    return hres;
  }
 
  return S_OK;
}

Referenced by InitWebBrowser().

OleSetMenuDescriptor()

HRESULT WINAPI OleSetMenuDescriptor	(	HOLEMENU	hmenuDescriptor,
		HWND	hwndFrame,
		HWND	hwndActiveObject,
		LPOLEINPLACEFRAME	lpFrame,
		LPOLEINPLACEACTIVEOBJECT	lpActiveObject
	)

Definition at line 1856 of file ole2.c.

{
    OleMenuDescriptor *pOleMenuDescriptor = NULL;
 
    /* Check args */
    if ( !hwndFrame || (hOleMenu && !hwndActiveObject) )
        return E_INVALIDARG;
 
    if ( lpFrame || lpActiveObject )
    {
        FIXME("(%p, %p, %p, %p, %p), Context sensitive help filtering not implemented!\n",
        hOleMenu,
        hwndFrame,
        hwndActiveObject,
        lpFrame,
        lpActiveObject);
    }
 
    /* Set up a message hook to intercept the containers frame window messages.
     * The message filter is responsible for dispatching menu messages from the
     * shared menu which are intended for the object.
     */
 
    if ( hOleMenu )  /* Want to install dispatching code */
    {
        /* If OLEMenu hooks are already installed for this thread, fail
         * Note: This effectively means that OleSetMenuDescriptor cannot
         * be called twice in succession on the same frame window
         * without first calling it with a null hOleMenu to uninstall
         */
        if ( OLEMenu_IsHookInstalled( GetCurrentThreadId() ) )
            return E_FAIL;
 
        /* Get the menu descriptor */
        pOleMenuDescriptor = GlobalLock( hOleMenu );
        if ( !pOleMenuDescriptor )
            return E_UNEXPECTED;
 
        /* Update the menu descriptor */
        pOleMenuDescriptor->hwndFrame = hwndFrame;
        pOleMenuDescriptor->hwndActiveObject = hwndActiveObject;
 
        GlobalUnlock( hOleMenu );
        pOleMenuDescriptor = NULL;
 
        /* Add a menu descriptor windows property to the frame window */
        SetPropW( hwndFrame, prop_olemenuW, hOleMenu );
 
        /* Install thread scope message hooks for WH_GETMESSAGE and WH_CALLWNDPROC */
        if ( !OLEMenu_InstallHooks( GetCurrentThreadId() ) )
            return E_FAIL;
    }
    else  /* Want to uninstall dispatching code */
    {
        /* Uninstall the hooks */
        if ( !OLEMenu_UnInstallHooks( GetCurrentThreadId() ) )
            return E_FAIL;
 
        /* Remove the menu descriptor property from the frame window */
        RemovePropW( hwndFrame, prop_olemenuW );
    }
 
    return S_OK;
}

Referenced by test_ole_menu().

OleTranslateAccelerator()

HRESULT WINAPI OleTranslateAccelerator	(	LPOLEINPLACEFRAME	lpFrame,
		LPOLEINPLACEFRAMEINFO	lpFrameInfo,
		struct tagMSG *	lpmsg
	)

OleUninitialize()

void WINAPI OleUninitialize

(

void

)

Definition at line 218 of file ole2.c.

{
  TRACE("()\n");
 
  if (COM_CurrentInfo()->ole_inits == 0)
  {
    WARN("ole_inits is already 0\n");
    return ;
  }
  /*
   * If we hit the bottom of the lock stack, free the libraries.
   */
  if (!--COM_CurrentInfo()->ole_inits && !InterlockedDecrement(&OLE_moduleLockCount))
  {
    /*
     * Actually free the libraries.
     */
    TRACE("() - Freeing the last reference count\n");
 
    /*
     * OLE Clipboard
     */
    clipbrd_uninitialize();
 
    /*
     * OLE shared menu
     */
    OLEMenu_UnInitialize();
  }
 
  /*
   * Then, uninitialize the COM libraries.
   */
  CoUninitialize();
}

Referenced by _tWinMain(), adv_install(), BrowserThreadProc(), CDesktopThread::DesktopThreadProc(), display_cpl_sheets(), do_enum(), GetFileName95(), hook_proc(), ImageView_Main(), ME_DestroyEditor(), ReleaseHelpViewer(), CHardErrorThread::s_HardErrorThreadProc(), START_TEST(), StartWithDesktop(), test_CoCreateInstance(), test_CoInitializeEx(), test_consumer_refs(), test_DoDragDrop(), test_flushed_getdata(), test_get_clipboard_locked(), test_getdatahere(), test_multithreaded_clipboard(), test_nonole_clipboard(), test_ole_init_wndproc(), test_ole_initialization(), test_OleCreateFontIndirect(), test_OleInitialize_InitCounting(), test_Register_Revoke(), test_set_clipboard(), test_set_clipboard_DRAWCLIPBOARD(), test_TreatAsClass(), wmain(), and OleInit::~OleInit().

ReadClassStg()

HRESULT WINAPI ReadClassStg	(	IStorage *	pstg,
		CLSID *	pclsid
	)

Definition at line 72 of file storage32.c.

{
    STATSTG pstatstg;
    HRESULT hRes;
 
    TRACE("(%p, %p)\n", pstg, pclsid);
 
    if (!pstg || !pclsid)
        return E_INVALIDARG;
 
   /*
    * read a STATSTG structure (contains the clsid) from the storage
    */
    hRes = IStorage_Stat(pstg, &pstatstg, STATFLAG_NONAME);
 
    if (SUCCEEDED(hRes))
        *pclsid = pstatstg.clsid;
 
    return hRes;
}

Referenced by DataCache_InitNew(), DataCache_Load(), GetClassFile(), render_embed_source_hack(), and test_writeclassstg().

ReadClassStm()

HRESULT WINAPI ReadClassStm	(	IStream *	pStm,
		CLSID *	pclsid
	)

Definition at line 109 of file storage32.c.

{
    ULONG nbByte;
    HRESULT res;
 
    TRACE("(%p,%p)\n", pStm, pclsid);
 
    if (!pStm || !pclsid)
        return E_INVALIDARG;
 
    /* clear the output args */
    *pclsid = CLSID_NULL;
 
    res = IStream_Read(pStm, pclsid, sizeof(CLSID), &nbByte);
 
    if (FAILED(res))
        return res;
 
    if (nbByte != sizeof(CLSID))
        return STG_E_READFAULT;
    else
        return S_OK;
}

Referenced by OleLoadFromStream(), ReadFmtUserTypeStg(), and test_ReadClassStm().

ReadFmtUserTypeStg()

HRESULT WINAPI ReadFmtUserTypeStg	(	LPSTORAGE	pstg,
		CLIPFORMAT *	pcf,
		LPOLESTR *	lplpszUserType
	)

Definition at line 9269 of file storage32.c.

{
    HRESULT r;
    IStream *stm = 0;
    unsigned char unknown1[12];
    unsigned char unknown2[16];
    DWORD count;
    LPWSTR szProgIDName = NULL, szCLSIDName = NULL, szOleTypeName = NULL;
    CLSID clsid;
 
    TRACE("(%p,%p,%p)\n", pstg, pcf, lplpszUserType);
 
    r = IStorage_OpenStream( pstg, L"\1CompObj", NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm );
    if( FAILED ( r ) )
    {
        WARN("Failed to open stream r = %#lx\n", r);
        return r;
    }
 
    /* read the various parts of the structure */
    r = IStream_Read( stm, unknown1, sizeof(unknown1), &count );
    if( FAILED( r ) || ( count != sizeof(unknown1) ) )
        goto end;
    r = ReadClassStm( stm, &clsid );
    if( FAILED( r ) )
        goto end;
 
    r = STREAM_ReadString( stm, &szCLSIDName );
    if( FAILED( r ) )
        goto end;
 
    r = STREAM_ReadString( stm, &szOleTypeName );
    if( FAILED( r ) )
        goto end;
 
    r = STREAM_ReadString( stm, &szProgIDName );
    if( FAILED( r ) )
        goto end;
 
    r = IStream_Read( stm, unknown2, sizeof(unknown2), &count );
    if( FAILED( r ) || ( count != sizeof(unknown2) ) )
        goto end;
 
    /* ok, success... now we just need to store what we found */
    if( pcf )
        *pcf = RegisterClipboardFormatW( szOleTypeName );
 
    if( lplpszUserType )
    {
        *lplpszUserType = szCLSIDName;
        szCLSIDName = NULL;
    }
 
end:
    CoTaskMemFree( szCLSIDName );
    CoTaskMemFree( szOleTypeName );
    CoTaskMemFree( szProgIDName );
    IStream_Release( stm );
 
    return r;
}

Referenced by OleDoAutoConvert().

RegisterDragDrop()

HRESULT WINAPI RegisterDragDrop	(	HWND	hwnd,
		LPDROPTARGET	pDropTarget
	)

Definition at line 547 of file ole2.c.

{
  DWORD pid = 0;
  HRESULT hr;
  IStream *stream;
  HANDLE map;
  IDropTarget *wrapper;
 
  TRACE("(%p,%p)\n", hwnd, pDropTarget);
 
  if (!COM_CurrentApt())
  {
    ERR("COM not initialized\n");
    return E_OUTOFMEMORY;
  }
 
  if (!pDropTarget)
    return E_INVALIDARG;
 
  if (!IsWindow(hwnd))
  {
    ERR("invalid hwnd %p\n", hwnd);
    return DRAGDROP_E_INVALIDHWND;
  }
 
  /* block register for other processes windows */
  GetWindowThreadProcessId(hwnd, &pid);
  if (pid != GetCurrentProcessId())
  {
    FIXME("register for another process windows is disabled\n");
    return DRAGDROP_E_INVALIDHWND;
  }
 
  /* check if the window is already registered */
  if (is_droptarget(hwnd))
    return DRAGDROP_E_ALREADYREGISTERED;
 
  /*
   * Marshal the drop target pointer into a shared memory map and
   * store the map's handle in a Wine specific window prop.  We also
   * store the drop target pointer itself in the
   * "OleDropTargetInterface" prop for compatibility with Windows.
   */
 
  hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
  if(FAILED(hr)) return hr;
 
  /* IDropTarget::QueryInterface() shouldn't be called, some (broken) apps depend on this. */
  wrapper = WrapDropTarget( hwnd );
  if(!wrapper)
  {
    IStream_Release(stream);
    return E_OUTOFMEMORY;
  }
  hr = CoMarshalInterface(stream, &IID_IDropTarget, (IUnknown*)wrapper, MSHCTX_LOCAL, NULL, MSHLFLAGS_TABLESTRONG);
  IDropTarget_Release(wrapper);
 
  if(SUCCEEDED(hr))
  {
    hr = create_map_from_stream(stream, &map);
    if(SUCCEEDED(hr))
    {
      IDropTarget_AddRef(pDropTarget);
      SetPropW(hwnd, prop_oledroptarget, pDropTarget);
      SetPropW(hwnd, prop_marshalleddroptarget, map);
    }
    else
    {
      LARGE_INTEGER zero;
      zero.QuadPart = 0;
      IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL);
      CoReleaseMarshalData(stream);
    }
  }
  IStream_Release(stream);
 
  return hr;
}

Referenced by DesktopShellView::InitDragDrop(), ShellBrowser::InitDragDrop(), CDefView::OnCreate(), SHRegisterDragDrop(), test_DoDragDrop(), and test_Register_Revoke().

ReleaseStgMedium()

VOID WINAPI ReleaseStgMedium

(

LPSTGMEDIUM

)

RevokeDragDrop()

HRESULT WINAPI RevokeDragDrop

(

HWND

hwnd

)

Definition at line 629 of file ole2.c.

{
  HANDLE map;
  IStream *stream;
  IDropTarget *drop_target;
  HRESULT hr;
 
  TRACE("(%p)\n", hwnd);
 
  if (!IsWindow(hwnd))
  {
    ERR("invalid hwnd %p\n", hwnd);
    return DRAGDROP_E_INVALIDHWND;
  }
 
  /* no registration data */
  if (!(map = get_droptarget_handle(hwnd)))
    return DRAGDROP_E_NOTREGISTERED;
 
  drop_target = GetPropW(hwnd, prop_oledroptarget);
  if(drop_target) IDropTarget_Release(drop_target);
 
  RemovePropW(hwnd, prop_oledroptarget);
  RemovePropW(hwnd, prop_marshalleddroptarget);
 
  hr = create_stream_from_map(map, &stream);
  if(SUCCEEDED(hr))
  {
      CoReleaseMarshalData(stream);
      IStream_Release(stream);
  }
  CloseHandle(map);
 
  return hr;
}

Referenced by CDefView::OnDestroy(), SHRevokeDragDrop(), test_Register_Revoke(), and DesktopShellView::~DesktopShellView().

SetConvertStg()

HRESULT WINAPI SetConvertStg	(	LPSTORAGE	pStg,
		BOOL	fConvert
	)

WriteClassStg()

HRESULT WINAPI WriteClassStg	(	IStorage *	pstg,
		REFCLSID	rclsid
	)

Definition at line 58 of file storage32.c.

{
    if (!pStg)
        return E_INVALIDARG;
 
    if (!rclsid)
        return STG_E_INVALIDPOINTER;
 
    return IStorage_SetClass(pStg, rclsid);
}

Referenced by OleCreateStaticFromData(), OleSave(), test_hglobal_storage_stat(), test_overwrite(), test_storage_refcount(), test_streamenum(), test_transacted_shared(), and test_writeclassstg().

WriteClassStm()

HRESULT WINAPI WriteClassStm	(	IStream *	pStm,
		REFCLSID	rclsid
	)

Definition at line 96 of file storage32.c.

{
    TRACE("(%p,%p)\n", pStm, rclsid);
 
    if (!pStm || !rclsid)
        return E_INVALIDARG;
 
    return IStream_Write(pStm, rclsid, sizeof(CLSID), NULL);
}

Referenced by OLECONVERT_CreateCompObjStream(), OleSaveToStream(), STORAGE_WriteCompObj(), and test_ReadClassStm().

WriteFmtUserTypeStg()

HRESULT WINAPI WriteFmtUserTypeStg	(	LPSTORAGE	pstg,
		CLIPFORMAT	cf,
		LPOLESTR	lpszUserType
	)

Definition at line 9226 of file storage32.c.

{
    STATSTG stat;
    HRESULT r;
    WCHAR szwClipName[0x40];
    CLSID clsid;
    LPWSTR wstrProgID = NULL;
    DWORD n;
 
    TRACE("(%p,%x,%s)\n",pstg,cf,debugstr_w(lpszUserType));
 
    /* get the clipboard format name */
    if( cf )
    {
        n = GetClipboardFormatNameW(cf, szwClipName, ARRAY_SIZE(szwClipName));
        szwClipName[n]=0;
    }
 
    TRACE("Clipboard name is %s\n", debugstr_w(szwClipName));
 
    r = IStorage_Stat(pstg, &stat, STATFLAG_NONAME);
    if(SUCCEEDED(r))
        clsid = stat.clsid;
    else
        clsid = CLSID_NULL;
 
    ProgIDFromCLSID(&clsid, &wstrProgID);
 
    TRACE("progid is %s\n",debugstr_w(wstrProgID));
 
    r = STORAGE_WriteCompObj( pstg, &clsid, lpszUserType,
            cf ? szwClipName : NULL, wstrProgID );
 
    CoTaskMemFree(wstrProgID);
 
    return r;
}

Referenced by OleCreateStaticFromData(), OleDoAutoConvert(), test_fmtusertypestg(), and test_OleDoAutoConvert().