ole2.c File Reference

#include <assert.h>
#include <stdlib.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include "windef.h"
#include "winbase.h"
#include "winerror.h"
#include "wingdi.h"
#include "winuser.h"
#include "winnls.h"
#include "winreg.h"
#include "ole2.h"
#include "ole2ver.h"
#include "compobj_private.h"
#include "olestd.h"
#include "wine/list.h"
#include "wine/debug.h"

Include dependency graph for ole2.c:

Go to the source code of this file.

Classes
struct	tagTrackerWindowInfo
struct	tagOleMenuDescriptor
struct	tagOleMenuHookItem
struct	DropTargetWrapper
struct	EnumOLEVERB

Macros
#define	COBJMACROS
#define	NONAMELESSUNION
#define	DRAG_TIMER_ID   1

Typedefs
typedef struct tagTrackerWindowInfo	TrackerWindowInfo
typedef struct tagOleMenuDescriptor	OleMenuDescriptor
typedef struct tagOleMenuHookItem	OleMenuHookItem

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (ole)
	WINE_DECLARE_DEBUG_CHANNEL (accel)
static void	OLEUTL_ReadRegistryDWORDValue (HKEY regKey, DWORD *pdwValue)
static void	OLEMenu_Initialize (void)
static void	OLEMenu_UnInitialize (void)
static BOOL	OLEMenu_InstallHooks (DWORD tid)
static BOOL	OLEMenu_UnInstallHooks (DWORD tid)
static OleMenuHookItem *	OLEMenu_IsHookInstalled (DWORD tid)
static BOOL	OLEMenu_FindMainMenuIndex (HMENU hMainMenu, HMENU hPopupMenu, UINT *pnPos)
static BOOL	OLEMenu_SetIsServerMenu (HMENU hmenu, OleMenuDescriptor *pOleMenuDescriptor)
static LRESULT CALLBACK	OLEMenu_CallWndProc (INT code, WPARAM wParam, LPARAM lParam)
static LRESULT CALLBACK	OLEMenu_GetMsgProc (INT code, WPARAM wParam, LPARAM lParam)
void	OLEClipbrd_UnInitialize (void)
void	OLEClipbrd_Initialize (void)
static void	OLEDD_Initialize (void)
static LRESULT WINAPI	OLEDD_DragTrackerWindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
static void	OLEDD_TrackStateChange (TrackerWindowInfo *trackerInfo)
static DWORD	OLEDD_GetButtonState (void)
DWORD WINAPI	OleBuildVersion (void)
HRESULT WINAPI DECLSPEC_HOTPATCH	OleInitialize (LPVOID reserved)
void WINAPI DECLSPEC_HOTPATCH	OleUninitialize (void)
HRESULT WINAPI	OleInitializeWOW (DWORD x, DWORD y)
static HANDLE	get_droptarget_handle (HWND hwnd)
static BOOL	is_droptarget (HWND hwnd)
static HANDLE	get_droptarget_local_handle (HWND hwnd)
static HRESULT	create_map_from_stream (IStream *stream, HANDLE *map)
static HRESULT	create_stream_from_map (HANDLE map, IStream **stream)
static DropTargetWrapper *	impl_from_IDropTarget (IDropTarget *iface)
static HRESULT WINAPI	DropTargetWrapper_QueryInterface (IDropTarget *iface, REFIID riid, void **ppvObject)
static ULONG WINAPI	DropTargetWrapper_AddRef (IDropTarget *iface)
static ULONG WINAPI	DropTargetWrapper_Release (IDropTarget *iface)
static HRESULT	get_target_from_wrapper (IDropTarget *wrapper, IDropTarget **target)
static HRESULT WINAPI	DropTargetWrapper_DragEnter (IDropTarget *iface, IDataObject *pDataObj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect)
static HRESULT WINAPI	DropTargetWrapper_DragOver (IDropTarget *iface, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect)
static HRESULT WINAPI	DropTargetWrapper_DragLeave (IDropTarget *iface)
static HRESULT WINAPI	DropTargetWrapper_Drop (IDropTarget *iface, IDataObject *pDataObj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect)
static IDropTarget *	WrapDropTarget (HWND hwnd)
static IDropTarget *	get_droptarget_pointer (HWND hwnd)
HRESULT WINAPI	RegisterDragDrop (HWND hwnd, LPDROPTARGET pDropTarget)
HRESULT WINAPI	RevokeDragDrop (HWND hwnd)
HRESULT WINAPI	OleRegGetUserType (REFCLSID clsid, DWORD form, LPOLESTR *usertype)
HRESULT WINAPI	DoDragDrop (IDataObject *pDataObject, IDropSource *pDropSource, DWORD dwOKEffect, DWORD *pdwEffect)
HRESULT WINAPI	OleQueryLinkFromData (IDataObject *pSrcDataObject)
HRESULT WINAPI	OleRegGetMiscStatus (REFCLSID clsid, DWORD dwAspect, DWORD *pdwStatus)
static HRESULT	EnumOLEVERB_Construct (HKEY hkeyVerb, ULONG index, IEnumOLEVERB **ppenum)
static EnumOLEVERB *	impl_from_IEnumOLEVERB (IEnumOLEVERB *iface)
static HRESULT WINAPI	EnumOLEVERB_QueryInterface (IEnumOLEVERB *iface, REFIID riid, void **ppv)
static ULONG WINAPI	EnumOLEVERB_AddRef (IEnumOLEVERB *iface)
static ULONG WINAPI	EnumOLEVERB_Release (IEnumOLEVERB *iface)
static HRESULT WINAPI	EnumOLEVERB_Next (IEnumOLEVERB *iface, ULONG celt, LPOLEVERB rgelt, ULONG *pceltFetched)
static HRESULT WINAPI	EnumOLEVERB_Skip (IEnumOLEVERB *iface, ULONG celt)
static HRESULT WINAPI	EnumOLEVERB_Reset (IEnumOLEVERB *iface)
static HRESULT WINAPI	EnumOLEVERB_Clone (IEnumOLEVERB *iface, IEnumOLEVERB **ppenum)
HRESULT WINAPI	OleRegEnumVerbs (REFCLSID clsid, LPENUMOLEVERB *ppenum)
HRESULT WINAPI	OleSetContainedObject (LPUNKNOWN pUnknown, BOOL fContained)
HRESULT WINAPI DECLSPEC_HOTPATCH	OleRun (LPUNKNOWN pUnknown)
HRESULT WINAPI	OleLoad (LPSTORAGE pStg, REFIID riid, LPOLECLIENTSITE pClientSite, LPVOID *ppvObj)
HRESULT WINAPI	OleSave (LPPERSISTSTORAGE pPS, LPSTORAGE pStg, BOOL fSameAsLoad)
HRESULT WINAPI	OleLockRunning (LPUNKNOWN pUnknown, BOOL fLock, BOOL fLastUnlockCloses)
HOLEMENU WINAPI	OleCreateMenuDescriptor (HMENU hmenuCombined, LPOLEMENUGROUPWIDTHS lpMenuWidths)
HRESULT WINAPI	OleDestroyMenuDescriptor (HOLEMENU hmenuDescriptor)
HRESULT WINAPI	OleSetMenuDescriptor (HOLEMENU hOleMenu, HWND hwndFrame, HWND hwndActiveObject, LPOLEINPLACEFRAME lpFrame, LPOLEINPLACEACTIVEOBJECT lpActiveObject)
BOOL WINAPI	IsAccelerator (HACCEL hAccel, int cAccelEntries, LPMSG lpMsg, WORD *lpwCmd)
void WINAPI	ReleaseStgMedium (STGMEDIUM *pmedium)
static void	drag_enter (TrackerWindowInfo *info, HWND new_target)
static void	drag_end (TrackerWindowInfo *info)
static HRESULT	give_feedback (TrackerWindowInfo *info)
HRESULT WINAPI	OleDraw (IUnknown *pUnk, DWORD dwAspect, HDC hdcDraw, LPCRECT rect)
HRESULT WINAPI	OleTranslateAccelerator (LPOLEINPLACEFRAME lpFrame, LPOLEINPLACEFRAMEINFO lpFrameInfo, LPMSG lpmsg)
HRESULT WINAPI	OleCreate (REFCLSID rclsid, REFIID riid, DWORD renderopt, LPFORMATETC pFormatEtc, LPOLECLIENTSITE pClientSite, LPSTORAGE pStg, LPVOID *ppvObj)
HRESULT WINAPI	OleGetAutoConvert (REFCLSID clsidOld, LPCLSID pClsidNew)
HRESULT WINAPI	OleSetAutoConvert (REFCLSID clsidOld, REFCLSID clsidNew)
HRESULT WINAPI	OleDoAutoConvert (LPSTORAGE pStg, LPCLSID pClsidNew)
BOOL WINAPI	OleIsRunning (LPOLEOBJECT object)
HRESULT WINAPI	OleNoteObjectVisible (LPUNKNOWN pUnknown, BOOL bVisible)
static void	OLE_FreeClipDataArray (ULONG count, CLIPDATA *pClipDataArray)
BSTR WINAPI	PropSysAllocString (LPCOLESTR str)
void WINAPI	PropSysFreeString (LPOLESTR str)
static HRESULT	PROPVARIANT_ValidateType (VARTYPE vt)
HRESULT WINAPI	PropVariantClear (PROPVARIANT *pvar)
HRESULT WINAPI	PropVariantCopy (PROPVARIANT *pvarDest, const PROPVARIANT *pvarSrc)
HRESULT WINAPI	FreePropVariantArray (ULONG cVariants, PROPVARIANT *rgvars)
BOOL WINAPI	DllDebugObjectRPCHook (BOOL b, void *dummy)

Variables
static OleMenuHookItem *	hook_list
static LONG	OLE_moduleLockCount = 0
static const WCHAR	OLEDD_DRAGTRACKERCLASS []
static const WCHAR	prop_olemenuW []
static const WCHAR	prop_oledroptarget []
static const WCHAR	prop_marshalleddroptarget []
static const WCHAR	emptyW [] = { 0 }
static const IDropTargetVtbl	DropTargetWrapperVTbl
static const IEnumOLEVERBVtbl	EnumOLEVERB_VTable

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 32 of file ole2.c.

DRAG_TIMER_ID

#define DRAG_TIMER_ID   1

Definition at line 2148 of file ole2.c.

NONAMELESSUNION

#define NONAMELESSUNION

Definition at line 33 of file ole2.c.

Typedef Documentation

OleMenuDescriptor

typedef struct tagOleMenuDescriptor OleMenuDescriptor

OleMenuHookItem

typedef struct tagOleMenuHookItem OleMenuHookItem

TrackerWindowInfo

typedef struct tagTrackerWindowInfo TrackerWindowInfo

Function Documentation

create_map_from_stream()

static HRESULT create_map_from_stream ( IStream *  stream, HANDLE *  map  )

static

Definition at line 337 of file ole2.c.

{
    HGLOBAL hmem;
    DWORD size;
    HRESULT hr;
    void *data;
 
    hr = GetHGlobalFromStream(stream, &hmem);
    if(FAILED(hr)) return hr;
 
    size = GlobalSize(hmem);
    *map = CreateFileMappingW(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, size, NULL);
    if(!*map) return E_OUTOFMEMORY;
 
    data = MapViewOfFile(*map, FILE_MAP_WRITE, 0, 0, size);
    memcpy(data, GlobalLock(hmem), size);
    GlobalUnlock(hmem);
    UnmapViewOfFile(data);
    return S_OK;
}

Referenced by RegisterDragDrop().

create_stream_from_map()

static HRESULT create_stream_from_map ( HANDLE  map, IStream **  stream  )

static

Definition at line 363 of file ole2.c.

{
    HRESULT hr = E_OUTOFMEMORY;
    HGLOBAL hmem;
    void *data;
    MEMORY_BASIC_INFORMATION info;
 
    data = MapViewOfFile(map, FILE_MAP_READ, 0, 0, 0);
    if(!data) return hr;
 
    VirtualQuery(data, &info, sizeof(info));
    TRACE("size %d\n", (int)info.RegionSize);
 
    hmem = GlobalAlloc(GMEM_MOVEABLE, info.RegionSize);
    if(hmem)
    {
        memcpy(GlobalLock(hmem), data, info.RegionSize);
        GlobalUnlock(hmem);
        hr = CreateStreamOnHGlobal(hmem, TRUE, stream);
    }
    UnmapViewOfFile(data);
    return hr;
}

Referenced by get_droptarget_pointer(), and RevokeDragDrop().

DllDebugObjectRPCHook()

BOOL WINAPI DllDebugObjectRPCHook	(	BOOL	b,
		void *	dummy
	)

Definition at line 3288 of file ole2.c.

{
  FIXME("stub\n");
  return TRUE;
}

DoDragDrop()

HRESULT WINAPI DoDragDrop	(	IDataObject *	pDataObject,
		IDropSource *	pDropSource,
		DWORD	dwOKEffect,
		DWORD *	pdwEffect
	)

Definition at line 753 of file ole2.c.

{
  static const WCHAR trackerW[] = {'T','r','a','c','k','e','r','W','i','n','d','o','w',0};
  TrackerWindowInfo trackerInfo;
  HWND            hwndTrackWindow;
  MSG             msg;
 
  TRACE("(%p, %p, %08x, %p)\n", pDataObject, pDropSource, dwOKEffect, pdwEffect);
 
  if (!pDataObject || !pDropSource || !pdwEffect)
      return E_INVALIDARG;
 
  /*
   * Setup the drag n drop tracking window.
   */
 
  trackerInfo.dataObject        = pDataObject;
  trackerInfo.dropSource        = pDropSource;
  trackerInfo.dwOKEffect        = dwOKEffect;
  trackerInfo.pdwEffect         = pdwEffect;
  trackerInfo.trackingDone      = FALSE;
  trackerInfo.escPressed        = FALSE;
  trackerInfo.curTargetHWND     = 0;
  trackerInfo.curDragTarget     = 0;
#ifdef __REACTOS__
  trackerInfo.accepterHWND      = NULL;
#endif
 
  hwndTrackWindow = CreateWindowW(OLEDD_DRAGTRACKERCLASS, trackerW,
                                  WS_POPUP, CW_USEDEFAULT, CW_USEDEFAULT,
                                  CW_USEDEFAULT, CW_USEDEFAULT, 0, 0, 0,
                                  &trackerInfo);
 
  if (hwndTrackWindow)
  {
    /*
     * Capture the mouse input
     */
    SetCapture(hwndTrackWindow);
 
    msg.message = 0;
 
    /*
     * Pump messages. All mouse input should go to the capture window.
     */
    while (!trackerInfo.trackingDone && GetMessageW(&msg, 0, 0, 0) )
    {
      trackerInfo.curMousePos.x = msg.pt.x;
      trackerInfo.curMousePos.y = msg.pt.y;
      trackerInfo.dwKeyState = OLEDD_GetButtonState();
        
      if ( (msg.message >= WM_KEYFIRST) &&
       (msg.message <= WM_KEYLAST) )
      {
    /*
     * When keyboard messages are sent to windows on this thread, we
     * want to ignore notify the drop source that the state changed.
     * in the case of the Escape key, we also notify the drop source
     * we give it a special meaning.
     */
    if ( (msg.message==WM_KEYDOWN) &&
         (msg.wParam==VK_ESCAPE) )
    {
      trackerInfo.escPressed = TRUE;
    }
 
    /*
     * Notify the drop source.
     */
        OLEDD_TrackStateChange(&trackerInfo);
      }
      else
      {
    /*
     * Dispatch the messages only when it's not a keyboard message.
     */
    DispatchMessageW(&msg);
      }
    }
 
    /* re-post the quit message to outer message loop */
    if (msg.message == WM_QUIT)
        PostQuitMessage(msg.wParam);
    /*
     * Destroy the temporary window.
     */
    DestroyWindow(hwndTrackWindow);
 
    return trackerInfo.returnValue;
  }
 
  return E_FAIL;
}

Referenced by CDefView::OnNotify(), SHDoDragDrop(), and test_DoDragDrop().

drag_end()

static void drag_end ( TrackerWindowInfo *  info )

static

Definition at line 2319 of file ole2.c.

{
    HRESULT hr;
 
    info->trackingDone = TRUE;
    ReleaseCapture();
 
    if (info->curDragTarget)
    {
        if (info->returnValue == DRAGDROP_S_DROP &&
            *info->pdwEffect != DROPEFFECT_NONE)
        {
            *info->pdwEffect = info->dwOKEffect;
            hr = IDropTarget_Drop( info->curDragTarget, info->dataObject, info->dwKeyState,
                                   info->curMousePos, info->pdwEffect );
            *info->pdwEffect &= info->dwOKEffect;
 
            if (FAILED( hr ))
                info->returnValue = hr;
        }
        else
        {
            IDropTarget_DragLeave( info->curDragTarget );
            *info->pdwEffect = DROPEFFECT_NONE;
        }
        IDropTarget_Release( info->curDragTarget );
        info->curDragTarget = NULL;
    }
#ifdef __REACTOS__
    else if (info->accepterHWND)
    {
        if (info->returnValue == DRAGDROP_S_DROP &&
            *info->pdwEffect != DROPEFFECT_NONE)
        {
            *info->pdwEffect = info->dwOKEffect;
            hr = DefaultDrop(info->accepterHWND, info->dataObject, info->dwKeyState,
                             info->curMousePos, info->pdwEffect);
            *info->pdwEffect &= info->dwOKEffect;
 
            if (FAILED( hr ))
                info->returnValue = hr;
        }
        else
        {
            *info->pdwEffect = DROPEFFECT_NONE;
        }
        info->accepterHWND = NULL;
    }
#endif
    else
        *info->pdwEffect = DROPEFFECT_NONE;
}

Referenced by OLEDD_TrackStateChange().

drag_enter()

static void drag_enter ( TrackerWindowInfo *  info, HWND  new_target  )

static

Definition at line 2260 of file ole2.c.

{
    HRESULT hr;
#ifdef __REACTOS__
    DWORD dwEffect = *info->pdwEffect;
#endif
 
    info->curTargetHWND = new_target;
 
#ifdef __REACTOS__
    info->accepterHWND = NULL;
    while (new_target && !is_droptarget( new_target ))
    {
        if (is_acceptfiles(new_target))
        {
            dwEffect = info->dwOKEffect;
            hr = DefaultDragEnter(new_target, info->dataObject,
                                  info->dwKeyState, info->curMousePos,
                                  &dwEffect);
            dwEffect &= info->dwOKEffect;
 
            if (hr == S_OK)
            {
                info->accepterHWND = new_target;
                info->curDragTarget = NULL;
                *info->pdwEffect = dwEffect;
                return;
            }
        }
        new_target = GetParent( new_target );
    }
#else
    while (new_target && !is_droptarget( new_target ))
        new_target = GetParent( new_target );
#endif
 
    info->curDragTarget = get_droptarget_pointer( new_target );
 
    if (info->curDragTarget)
    {
        *info->pdwEffect = info->dwOKEffect;
        hr = IDropTarget_DragEnter( info->curDragTarget, info->dataObject,
                                    info->dwKeyState, info->curMousePos,
                                    info->pdwEffect );
        *info->pdwEffect &= info->dwOKEffect;
 
        /* failed DragEnter() means invalid target */
        if (hr != S_OK)
        {
            IDropTarget_Release( info->curDragTarget );
            info->curDragTarget = NULL;
            info->curTargetHWND = NULL;
#ifdef __REACTOS__
            info->accepterHWND = NULL;
#endif
        }
    }
}

Referenced by OLEDD_TrackStateChange().

DropTargetWrapper_AddRef()

static ULONG WINAPI DropTargetWrapper_AddRef ( IDropTarget *  iface )

static

Definition at line 421 of file ole2.c.

{
    DropTargetWrapper* This = impl_from_IDropTarget(iface);
    return InterlockedIncrement(&This->refs);
}

DropTargetWrapper_DragEnter()

static HRESULT WINAPI DropTargetWrapper_DragEnter ( IDropTarget *  iface, IDataObject *  pDataObj, DWORD  grfKeyState, POINTL  pt, DWORD *  pdwEffect  )

static

Definition at line 444 of file ole2.c.

{
    IDropTarget *target;
    HRESULT r = get_target_from_wrapper( iface, &target );
 
    if (SUCCEEDED( r ))
    {
        r = IDropTarget_DragEnter( target, pDataObj, grfKeyState, pt, pdwEffect );
        IDropTarget_Release( target );
    }
    return r;
}

DropTargetWrapper_DragLeave()

static HRESULT WINAPI DropTargetWrapper_DragLeave ( IDropTarget *  iface )

static

Definition at line 477 of file ole2.c.

{
    IDropTarget *target;
    HRESULT r = get_target_from_wrapper( iface, &target );
 
    if (SUCCEEDED( r ))
    {
        r = IDropTarget_DragLeave( target );
        IDropTarget_Release( target );
    }
    return r;
}

DropTargetWrapper_DragOver()

static HRESULT WINAPI DropTargetWrapper_DragOver ( IDropTarget *  iface, DWORD  grfKeyState, POINTL  pt, DWORD *  pdwEffect  )

static

Definition at line 461 of file ole2.c.

{
    IDropTarget *target;
    HRESULT r = get_target_from_wrapper( iface, &target );
 
    if (SUCCEEDED( r ))
    {
        r = IDropTarget_DragOver( target, grfKeyState, pt, pdwEffect );
        IDropTarget_Release( target );
    }
    return r;
}

DropTargetWrapper_Drop()

static HRESULT WINAPI DropTargetWrapper_Drop ( IDropTarget *  iface, IDataObject *  pDataObj, DWORD  grfKeyState, POINTL  pt, DWORD *  pdwEffect  )

static

Definition at line 490 of file ole2.c.

{
    IDropTarget *target;
    HRESULT r = get_target_from_wrapper( iface, &target );
 
    if (SUCCEEDED( r ))
    {
        r = IDropTarget_Drop( target, pDataObj, grfKeyState, pt, pdwEffect );
        IDropTarget_Release( target );
    }
    return r;
}

DropTargetWrapper_QueryInterface()

static HRESULT WINAPI DropTargetWrapper_QueryInterface ( IDropTarget *  iface, REFIID  riid, void **  ppvObject  )

static

Definition at line 405 of file ole2.c.

{
    DropTargetWrapper* This = impl_from_IDropTarget(iface);
    if (IsEqualIID(riid, &IID_IUnknown) ||
        IsEqualIID(riid, &IID_IDropTarget))
    {
        IDropTarget_AddRef(&This->IDropTarget_iface);
        *ppvObject = &This->IDropTarget_iface;
        return S_OK;
    }
    *ppvObject = NULL;
    return E_NOINTERFACE;
}

DropTargetWrapper_Release()

static ULONG WINAPI DropTargetWrapper_Release ( IDropTarget *  iface )

static

Definition at line 427 of file ole2.c.

{
    DropTargetWrapper* This = impl_from_IDropTarget(iface);
    ULONG refs = InterlockedDecrement(&This->refs);
    if (!refs) HeapFree(GetProcessHeap(), 0, This);
    return refs;
}

EnumOLEVERB_AddRef()

static ULONG WINAPI EnumOLEVERB_AddRef ( IEnumOLEVERB *  iface )

static

Definition at line 938 of file ole2.c.

{
    EnumOLEVERB *This = impl_from_IEnumOLEVERB(iface);
    TRACE("()\n");
    return InterlockedIncrement(&This->ref);
}

EnumOLEVERB_Clone()

static HRESULT WINAPI EnumOLEVERB_Clone ( IEnumOLEVERB *  iface, IEnumOLEVERB **  ppenum  )

static

Definition at line 1070 of file ole2.c.

{
    EnumOLEVERB *This = impl_from_IEnumOLEVERB(iface);
    HKEY hkeyVerb;
    TRACE("(%p)\n", ppenum);
    if (!DuplicateHandle(GetCurrentProcess(), This->hkeyVerb, GetCurrentProcess(), (HANDLE *)&hkeyVerb, 0, FALSE, DUPLICATE_SAME_ACCESS))
        return HRESULT_FROM_WIN32(GetLastError());
    return EnumOLEVERB_Construct(hkeyVerb, This->index, ppenum);
}

EnumOLEVERB_Construct()

static HRESULT EnumOLEVERB_Construct ( HKEY  hkeyVerb, ULONG  index, IEnumOLEVERB **  ppenum  )

static

Definition at line 1093 of file ole2.c.

{
    EnumOLEVERB *This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
    if (!This)
    {
        RegCloseKey(hkeyVerb);
        return E_OUTOFMEMORY;
    }
    This->IEnumOLEVERB_iface.lpVtbl = &EnumOLEVERB_VTable;
    This->ref = 1;
    This->index = index;
    This->hkeyVerb = hkeyVerb;
    *ppenum = &This->IEnumOLEVERB_iface;
    return S_OK;
}

Referenced by EnumOLEVERB_Clone(), and OleRegEnumVerbs().

EnumOLEVERB_Next()

static HRESULT WINAPI EnumOLEVERB_Next ( IEnumOLEVERB *  iface, ULONG  celt, LPOLEVERB  rgelt, ULONG *  pceltFetched  )

static

Definition at line 960 of file ole2.c.

{
    EnumOLEVERB *This = impl_from_IEnumOLEVERB(iface);
    HRESULT hr = S_OK;
 
    TRACE("(%d, %p, %p)\n", celt, rgelt, pceltFetched);
 
    if (pceltFetched)
        *pceltFetched = 0;
 
    for (; celt; celt--, rgelt++)
    {
        WCHAR wszSubKey[20];
        LONG cbData;
        LPWSTR pwszOLEVERB;
        LPWSTR pwszMenuFlags;
        LPWSTR pwszAttribs;
        LONG res = RegEnumKeyW(This->hkeyVerb, This->index, wszSubKey, ARRAY_SIZE(wszSubKey));
        if (res == ERROR_NO_MORE_ITEMS)
        {
            hr = S_FALSE;
            break;
        }
        else if (res != ERROR_SUCCESS)
        {
            ERR("RegEnumKeyW failed with error %d\n", res);
            hr = REGDB_E_READREGDB;
            break;
        }
        res = RegQueryValueW(This->hkeyVerb, wszSubKey, NULL, &cbData);
        if (res != ERROR_SUCCESS)
        {
            ERR("RegQueryValueW failed with error %d\n", res);
            hr = REGDB_E_READREGDB;
            break;
        }
        pwszOLEVERB = CoTaskMemAlloc(cbData);
        if (!pwszOLEVERB)
        {
            hr = E_OUTOFMEMORY;
            break;
        }
        res = RegQueryValueW(This->hkeyVerb, wszSubKey, pwszOLEVERB, &cbData);
        if (res != ERROR_SUCCESS)
        {
            ERR("RegQueryValueW failed with error %d\n", res);
            hr = REGDB_E_READREGDB;
            CoTaskMemFree(pwszOLEVERB);
            break;
        }
 
        TRACE("verb string: %s\n", debugstr_w(pwszOLEVERB));
        pwszMenuFlags = wcschr(pwszOLEVERB, ',');
        if (!pwszMenuFlags)
        {
            hr = OLEOBJ_E_INVALIDVERB;
            CoTaskMemFree(pwszOLEVERB);
            break;
        }
        /* nul terminate the name string and advance to first character */
        *pwszMenuFlags = '\0';
        pwszMenuFlags++;
        pwszAttribs = wcschr(pwszMenuFlags, ',');
        if (!pwszAttribs)
        {
            hr = OLEOBJ_E_INVALIDVERB;
            CoTaskMemFree(pwszOLEVERB);
            break;
        }
        /* nul terminate the menu string and advance to first character */
        *pwszAttribs = '\0';
        pwszAttribs++;
 
        /* fill out structure for this verb */
        rgelt->lVerb = wcstol(wszSubKey, NULL, 10);
        rgelt->lpszVerbName = pwszOLEVERB; /* user should free */
        rgelt->fuFlags = wcstol(pwszMenuFlags, NULL, 10);
        rgelt->grfAttribs = wcstol(pwszAttribs, NULL, 10);
 
        if (pceltFetched)
            (*pceltFetched)++;
        This->index++;
    }
    return hr;
}

EnumOLEVERB_QueryInterface()

static HRESULT WINAPI EnumOLEVERB_QueryInterface ( IEnumOLEVERB *  iface, REFIID  riid, void **  ppv  )

static

Definition at line 924 of file ole2.c.

{
    TRACE("(%s, %p)\n", debugstr_guid(riid), ppv);
    if (IsEqualIID(riid, &IID_IUnknown) ||
        IsEqualIID(riid, &IID_IEnumOLEVERB))
    {
        IEnumOLEVERB_AddRef(iface);
        *ppv = iface;
        return S_OK;
    }
    return E_NOINTERFACE;
}

EnumOLEVERB_Release()

static ULONG WINAPI EnumOLEVERB_Release ( IEnumOLEVERB *  iface )

static

Definition at line 946 of file ole2.c.

{
    EnumOLEVERB *This = impl_from_IEnumOLEVERB(iface);
    LONG refs = InterlockedDecrement(&This->ref);
    TRACE("()\n");
    if (!refs)
    {
        RegCloseKey(This->hkeyVerb);
        HeapFree(GetProcessHeap(), 0, This);
    }
    return refs;
}

EnumOLEVERB_Reset()

static HRESULT WINAPI EnumOLEVERB_Reset ( IEnumOLEVERB *  iface )

static

Definition at line 1059 of file ole2.c.

{
    EnumOLEVERB *This = impl_from_IEnumOLEVERB(iface);
 
    TRACE("()\n");
 
    This->index = 0;
    return S_OK;
}

EnumOLEVERB_Skip()

static HRESULT WINAPI EnumOLEVERB_Skip ( IEnumOLEVERB *  iface, ULONG  celt  )

static

Definition at line 1048 of file ole2.c.

{
    EnumOLEVERB *This = impl_from_IEnumOLEVERB(iface);
 
    TRACE("(%d)\n", celt);
 
    This->index += celt;
    return S_OK;
}

FreePropVariantArray()

HRESULT WINAPI FreePropVariantArray	(	ULONG	cVariants,
		PROPVARIANT *	rgvars
	)

Definition at line 3267 of file ole2.c.

{
    ULONG i;
 
    TRACE("(%u, %p)\n", cVariants, rgvars);
 
    if (!rgvars)
        return E_INVALIDARG;
 
    for(i = 0; i < cVariants; i++)
        PropVariantClear(&rgvars[i]);
 
    return S_OK;
}

Referenced by PropVariantClear().

get_droptarget_handle()

static HANDLE get_droptarget_handle ( HWND  hwnd )

inlinestatic

Definition at line 281 of file ole2.c.

{
    return GetPropW(hwnd, prop_marshalleddroptarget);
}

Referenced by get_droptarget_local_handle(), is_droptarget(), and RevokeDragDrop().

get_droptarget_local_handle()

static HANDLE get_droptarget_local_handle ( HWND  hwnd )

static

Definition at line 308 of file ole2.c.

{
    HANDLE handle, local_handle = 0;
 
    handle = get_droptarget_handle(hwnd);
 
    if(handle)
    {
        DWORD pid;
        HANDLE process;
 
        GetWindowThreadProcessId(hwnd, &pid);
        process = OpenProcess(PROCESS_DUP_HANDLE, FALSE, pid);
        if(process)
        {
            DuplicateHandle(process, handle, GetCurrentProcess(), &local_handle, 0, FALSE, DUPLICATE_SAME_ACCESS);
            CloseHandle(process);
        }
    }
    return local_handle;
}

Referenced by get_droptarget_pointer().

get_droptarget_pointer()

static IDropTarget * get_droptarget_pointer ( HWND  hwnd )

static

Definition at line 536 of file ole2.c.

{
    IDropTarget *droptarget = NULL;
    HANDLE map;
    IStream *stream;
 
    map = get_droptarget_local_handle(hwnd);
    if(!map) return NULL;
 
    if(SUCCEEDED(create_stream_from_map(map, &stream)))
    {
        CoUnmarshalInterface(stream, &IID_IDropTarget, (void**)&droptarget);
        IStream_Release(stream);
    }
    CloseHandle(map);
    return droptarget;
}

Referenced by drag_enter().

get_target_from_wrapper()

static HRESULT get_target_from_wrapper ( IDropTarget *  wrapper, IDropTarget **  target  )

inlinestatic

Definition at line 435 of file ole2.c.

{
    DropTargetWrapper* This = impl_from_IDropTarget( wrapper );
    *target = GetPropW( This->hwnd, prop_oledroptarget );
    if (!*target) return DRAGDROP_E_NOTREGISTERED;
    IDropTarget_AddRef( *target );
    return S_OK;
}

Referenced by DropTargetWrapper_DragEnter(), DropTargetWrapper_DragLeave(), DropTargetWrapper_DragOver(), and DropTargetWrapper_Drop().

give_feedback()

static HRESULT give_feedback ( TrackerWindowInfo *  info )

static

Definition at line 2372 of file ole2.c.

{
    HRESULT hr;
    int res;
    HCURSOR cur;
 
#ifdef __REACTOS__
    if (info->curDragTarget == NULL && info->accepterHWND == NULL)
        *info->pdwEffect = DROPEFFECT_NONE;
#else
    if (info->curDragTarget == NULL)
        *info->pdwEffect = DROPEFFECT_NONE;
#endif
 
    hr = IDropSource_GiveFeedback( info->dropSource, *info->pdwEffect );
 
    if (hr == DRAGDROP_S_USEDEFAULTCURSORS)
    {
        if (*info->pdwEffect & DROPEFFECT_MOVE)
            res = CURSOR_MOVE;
        else if (*info->pdwEffect & DROPEFFECT_COPY)
            res = CURSOR_COPY;
        else if (*info->pdwEffect & DROPEFFECT_LINK)
            res = CURSOR_LINK;
        else
            res = CURSOR_NODROP;
 
        cur = LoadCursorW( hProxyDll, MAKEINTRESOURCEW( res ) );
        SetCursor( cur );
    }
 
    return hr;
}

Referenced by OLEDD_TrackStateChange().

impl_from_IDropTarget()

static DropTargetWrapper * impl_from_IDropTarget ( IDropTarget *  iface )

inlinestatic

Definition at line 400 of file ole2.c.

{
    return CONTAINING_RECORD(iface, DropTargetWrapper, IDropTarget_iface);
}

Referenced by DropTargetWrapper_AddRef(), DropTargetWrapper_QueryInterface(), DropTargetWrapper_Release(), and get_target_from_wrapper().

impl_from_IEnumOLEVERB()

static EnumOLEVERB * impl_from_IEnumOLEVERB ( IEnumOLEVERB *  iface )

inlinestatic

Definition at line 919 of file ole2.c.

{
    return CONTAINING_RECORD(iface, EnumOLEVERB, IEnumOLEVERB_iface);
}

Referenced by EnumOLEVERB_AddRef(), EnumOLEVERB_Clone(), EnumOLEVERB_Next(), EnumOLEVERB_Release(), EnumOLEVERB_Reset(), and EnumOLEVERB_Skip().

is_droptarget()

static BOOL is_droptarget ( HWND  hwnd )

inlinestatic

Definition at line 291 of file ole2.c.

{
    return get_droptarget_handle(hwnd) != 0;
}

Referenced by drag_enter(), and RegisterDragDrop().

IsAccelerator()

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

Definition at line 1949 of file ole2.c.

{
    LPACCEL lpAccelTbl;
    int i;
 
    if(!lpMsg) return FALSE;
    if (!hAccel)
    {
    WARN_(accel)("NULL accel handle\n");
    return FALSE;
    }
    if((lpMsg->message != WM_KEYDOWN &&
    lpMsg->message != WM_SYSKEYDOWN &&
    lpMsg->message != WM_SYSCHAR &&
    lpMsg->message != WM_CHAR)) return FALSE;
    lpAccelTbl = HeapAlloc(GetProcessHeap(), 0, cAccelEntries * sizeof(ACCEL));
    if (NULL == lpAccelTbl)
    {
    return FALSE;
    }
    if (CopyAcceleratorTableW(hAccel, lpAccelTbl, cAccelEntries) != cAccelEntries)
    {
    WARN_(accel)("CopyAcceleratorTableW failed\n");
    HeapFree(GetProcessHeap(), 0, lpAccelTbl);
    return FALSE;
    }
 
    TRACE_(accel)("hAccel=%p, cAccelEntries=%d,"
        "msg->hwnd=%p, msg->message=%04x, wParam=%08lx, lParam=%08lx\n",
        hAccel, cAccelEntries,
        lpMsg->hwnd, lpMsg->message, lpMsg->wParam, lpMsg->lParam);
    for(i = 0; i < cAccelEntries; i++)
    {
    if(lpAccelTbl[i].key != lpMsg->wParam)
        continue;
 
    if(lpMsg->message == WM_CHAR)
    {
        if(!(lpAccelTbl[i].fVirt & FALT) && !(lpAccelTbl[i].fVirt & FVIRTKEY))
        {
        TRACE_(accel)("found accel for WM_CHAR: ('%c')\n", LOWORD(lpMsg->wParam) & 0xff);
        goto found;
        }
    }
    else
    {
        if(lpAccelTbl[i].fVirt & FVIRTKEY)
        {
        INT mask = 0;
        TRACE_(accel)("found accel for virt_key %04lx (scan %04x)\n",
                lpMsg->wParam, HIWORD(lpMsg->lParam) & 0xff);
        if(GetKeyState(VK_SHIFT) & 0x8000) mask |= FSHIFT;
        if(GetKeyState(VK_CONTROL) & 0x8000) mask |= FCONTROL;
        if(GetKeyState(VK_MENU) & 0x8000) mask |= FALT;
        if(mask == (lpAccelTbl[i].fVirt & (FSHIFT | FCONTROL | FALT))) goto found;
        TRACE_(accel)("incorrect SHIFT/CTRL/ALT-state\n");
        }
        else
        {
        if(!(lpMsg->lParam & 0x01000000))  /* no special_key */
        {
            if((lpAccelTbl[i].fVirt & FALT) && (lpMsg->lParam & 0x20000000))
            {                              /* ^^ ALT pressed */
            TRACE_(accel)("found accel for Alt-%c\n", LOWORD(lpMsg->wParam) & 0xff);
            goto found;
            }
        }
        }
    }
    }
 
    WARN_(accel)("couldn't translate accelerator key\n");
    HeapFree(GetProcessHeap(), 0, lpAccelTbl);
    return FALSE;
 
found:
    if(lpwCmd) *lpwCmd = lpAccelTbl[i].cmd;
    HeapFree(GetProcessHeap(), 0, lpAccelTbl);
    return TRUE;
}

Referenced by OleTranslateAccelerator().

OLE_FreeClipDataArray()

static void OLE_FreeClipDataArray ( ULONG  count, CLIPDATA *  pClipDataArray  )

static

Definition at line 2852 of file ole2.c.

{
    ULONG i;
    for (i = 0; i < count; i++)
        CoTaskMemFree(pClipDataArray[i].pClipData);
}

Referenced by PropVariantClear().

OleBuildVersion()

DWORD WINAPI OleBuildVersion

(

void

)

Definition at line 160 of file ole2.c.

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

OLEClipbrd_Initialize()

void OLEClipbrd_Initialize

(

void

)

Definition at line 1781 of file clipboard.c.

{
    register_clipboard_formats();
 
    if ( !theOleClipboard )
    {
        ole_clipbrd* clipbrd;
        HGLOBAL h;
 
        TRACE("()\n");
 
        clipbrd = HeapAlloc( GetProcessHeap(), 0, sizeof(*clipbrd) );
        if (!clipbrd) return;
 
        clipbrd->latest_snapshot = NULL;
        clipbrd->window = NULL;
        clipbrd->src_data = NULL;
        clipbrd->cached_enum = NULL;
 
        h = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE, 0);
        if(!h)
        {
            HeapFree(GetProcessHeap(), 0, clipbrd);
            return;
        }
 
        if(FAILED(CreateStreamOnHGlobal(h, TRUE, &clipbrd->marshal_data)))
        {
            GlobalFree(h);
            HeapFree(GetProcessHeap(), 0, clipbrd);
            return;
        }
 
        theOleClipboard = clipbrd;
    }
}

Referenced by OleInitialize().

OLEClipbrd_UnInitialize()

void OLEClipbrd_UnInitialize

(

void

)

Definition at line 2027 of file clipboard.c.

{
    ole_clipbrd *clipbrd = theOleClipboard;
 
    TRACE("()\n");
 
    if ( clipbrd )
    {
        static const WCHAR ole32W[] = {'o','l','e','3','2',0};
        HINSTANCE hinst = GetModuleHandleW(ole32W);
 
        /* OleUninitialize() does not release the reference to the dataobject, so
           take an additional reference here.  This reference is then leaked. */
        if (clipbrd->src_data)
        {
            IDataObject_AddRef(clipbrd->src_data);
            set_src_dataobject(clipbrd, NULL);
        }
 
        if ( clipbrd->window )
        {
            DestroyWindow(clipbrd->window);
            UnregisterClassW( clipbrd_wndclass, hinst );
        }
 
        IStream_Release(clipbrd->marshal_data);
        HeapFree(GetProcessHeap(), 0, clipbrd);
        theOleClipboard = NULL;
    }
}

Referenced by OleUninitialize().

OleCreate()

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

Definition at line 2609 of file ole2.c.

{
    HRESULT hres;
    IUnknown * pUnk = NULL;
    IOleObject *pOleObject = NULL;
 
    TRACE("(%s, %s, %d, %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 0x%08x\n", hres);
            IPersistStorage_Release(pPS);
        }
    }
 
    if (pClientSite && SUCCEEDED(hres))
    {
        TRACE("trying to set clientsite %p\n", pClientSite);
        hres = IOleObject_SetClientSite(pOleObject, pClientSite);
        TRACE("-- result 0x%08x\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().

OleCreateMenuDescriptor()

HOLEMENU WINAPI OleCreateMenuDescriptor	(	HMENU	hmenuCombined,
		LPOLEMENUGROUPWIDTHS	lpMenuWidths
	)

Definition at line 1812 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;
}

OLEDD_DragTrackerWindowProc()

static LRESULT WINAPI OLEDD_DragTrackerWindowProc ( HWND  hwnd, UINT  uMsg, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 2150 of file ole2.c.

{
  switch (uMsg)
  {
    case WM_CREATE:
    {
      LPCREATESTRUCTA createStruct = (LPCREATESTRUCTA)lParam;
 
      SetWindowLongPtrW(hwnd, 0, (LONG_PTR)createStruct->lpCreateParams);
      SetTimer(hwnd, DRAG_TIMER_ID, 50, NULL);
 
      break;
    }
    case WM_TIMER:
    case WM_MOUSEMOVE:
    case WM_LBUTTONUP:
    case WM_MBUTTONUP:
    case WM_RBUTTONUP:
    case WM_LBUTTONDOWN:
    case WM_MBUTTONDOWN:
    case WM_RBUTTONDOWN:
    {
      TrackerWindowInfo *trackerInfo = (TrackerWindowInfo*)GetWindowLongPtrA(hwnd, 0);
      if (trackerInfo->trackingDone) break;
      OLEDD_TrackStateChange(trackerInfo);
      break;
    }
    case WM_DESTROY:
    {
      KillTimer(hwnd, DRAG_TIMER_ID);
      break;
    }
  }
 
  /*
   * This is a window proc after all. Let's call the default.
   */
  return DefWindowProcW (hwnd, uMsg, wParam, lParam);
}

Referenced by OLEDD_Initialize().

OLEDD_GetButtonState()

static DWORD OLEDD_GetButtonState ( void  )

static

Definition at line 2484 of file ole2.c.

{
  BYTE  keyboardState[256];
  DWORD keyMask = 0;
 
  GetKeyboardState(keyboardState);
 
  if ( (keyboardState[VK_SHIFT] & 0x80) !=0)
    keyMask |= MK_SHIFT;
 
  if ( (keyboardState[VK_CONTROL] & 0x80) !=0)
    keyMask |= MK_CONTROL;
 
  if ( (keyboardState[VK_MENU] & 0x80) !=0)
    keyMask |= MK_ALT;
 
  if ( (keyboardState[VK_LBUTTON] & 0x80) !=0)
    keyMask |= MK_LBUTTON;
 
  if ( (keyboardState[VK_RBUTTON] & 0x80) !=0)
    keyMask |= MK_RBUTTON;
 
  if ( (keyboardState[VK_MBUTTON] & 0x80) !=0)
    keyMask |= MK_MBUTTON;
 
  return keyMask;
}

Referenced by DoDragDrop().

OLEDD_Initialize()

static void OLEDD_Initialize ( void  )

static

Definition at line 2123 of file ole2.c.

{
    WNDCLASSW wndClass;
 
    ZeroMemory (&wndClass, sizeof(WNDCLASSW));
    wndClass.style         = CS_GLOBALCLASS;
    wndClass.lpfnWndProc   = OLEDD_DragTrackerWindowProc;
    wndClass.cbClsExtra    = 0;
    wndClass.cbWndExtra    = sizeof(TrackerWindowInfo*);
    wndClass.hCursor       = 0;
    wndClass.hbrBackground = 0;
    wndClass.lpszClassName = OLEDD_DRAGTRACKERCLASS;
 
    RegisterClassW (&wndClass);
}

Referenced by OleInitialize().

OLEDD_TrackStateChange()

static void OLEDD_TrackStateChange ( TrackerWindowInfo *  trackerInfo )

static

Definition at line 2416 of file ole2.c.

{
  HWND   hwndNewTarget = 0;
  POINT pt;
 
  /*
   * Get the handle of the window under the mouse
   */
  pt.x = trackerInfo->curMousePos.x;
  pt.y = trackerInfo->curMousePos.y;
  hwndNewTarget = WindowFromPoint(pt);
 
  trackerInfo->returnValue = IDropSource_QueryContinueDrag(trackerInfo->dropSource,
                                                           trackerInfo->escPressed,
                                                           trackerInfo->dwKeyState);
 
  if (trackerInfo->curTargetHWND != hwndNewTarget &&
      (trackerInfo->returnValue == S_OK ||
       trackerInfo->returnValue == DRAGDROP_S_DROP))
  {
    if (trackerInfo->curDragTarget)
    {
      IDropTarget_DragLeave(trackerInfo->curDragTarget);
      IDropTarget_Release(trackerInfo->curDragTarget);
      trackerInfo->curDragTarget = NULL;
      trackerInfo->curTargetHWND = NULL;
    }
#ifdef __REACTOS__
    trackerInfo->accepterHWND = NULL;
#endif
 
    if (hwndNewTarget)
      drag_enter( trackerInfo, hwndNewTarget );
 
    give_feedback( trackerInfo );
 
  }
 
  if (trackerInfo->returnValue == S_OK)
  {
    if (trackerInfo->curDragTarget)
    {
      *trackerInfo->pdwEffect = trackerInfo->dwOKEffect;
      IDropTarget_DragOver(trackerInfo->curDragTarget,
                           trackerInfo->dwKeyState,
                           trackerInfo->curMousePos,
                           trackerInfo->pdwEffect);
      *trackerInfo->pdwEffect &= trackerInfo->dwOKEffect;
    }
#ifdef __REACTOS__
    else if (trackerInfo->accepterHWND)
    {
      *trackerInfo->pdwEffect = trackerInfo->dwOKEffect;
    }
#endif
    give_feedback( trackerInfo );
  }
  else
    drag_end( trackerInfo );
}

Referenced by DoDragDrop(), and OLEDD_DragTrackerWindowProc().

OleDestroyMenuDescriptor()

HRESULT WINAPI OleDestroyMenuDescriptor

(

HOLEMENU

hmenuDescriptor

)

Definition at line 1847 of file ole2.c.

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

OleDoAutoConvert()

HRESULT WINAPI OleDoAutoConvert	(	LPSTORAGE	pStg,
		LPCLSID	pClsidNew
	)

Definition at line 2758 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	(	IUnknown *	pUnk,
		DWORD	dwAspect,
		HDC	hdcDraw,
		LPCRECT	rect
	)

Definition at line 2565 of file ole2.c.

{
  HRESULT hres;
  IViewObject *viewobject;
 
  if (!pUnk) return E_INVALIDARG;
 
  hres = IUnknown_QueryInterface(pUnk,
                 &IID_IViewObject,
                 (void**)&viewobject);
  if (SUCCEEDED(hres))
  {
    hres = IViewObject_Draw(viewobject, dwAspect, -1, 0, 0, 0, hdcDraw, (RECTL*)rect, 0, 0, 0);
    IViewObject_Release(viewobject);
    return hres;
  }
  else
    return DV_E_NOIVIEWOBJECT;
}

Referenced by test_OleDraw(), and test_OleLoad().

OleGetAutoConvert()

HRESULT WINAPI OleGetAutoConvert	(	REFCLSID	clsidOld,
		LPCLSID	pClsidNew
	)

Definition at line 2704 of file ole2.c.

{
    static const WCHAR wszAutoConvertTo[] = {'A','u','t','o','C','o','n','v','e','r','t','T','o',0};
    HKEY hkey = NULL;
    WCHAR buf[CHARS_IN_GUID];
    LONG len;
    HRESULT res = S_OK;
 
    res = COM_OpenKeyForCLSID(clsidOld, wszAutoConvertTo, 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().

OleInitialize()

HRESULT WINAPI DECLSPEC_HOTPATCH OleInitialize

(

LPVOID

reserved

)

Definition at line 169 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");
 
    /*
     * OLE Clipboard
     */
    OLEClipbrd_Initialize();
 
    /*
     * 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(), 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(), and wWinMain().

OleInitializeWOW()

HRESULT WINAPI OleInitializeWOW	(	DWORD	x,
		DWORD	y
	)

Definition at line 269 of file ole2.c.

                                                  {
        FIXME("(0x%08x, 0x%08x),stub!\n",x, y);
        return 0;
}

OleIsRunning()

BOOL WINAPI OleIsRunning

(

LPOLEOBJECT

object

)

Definition at line 2818 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 1224 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().

OleLockRunning()

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

Definition at line 1377 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().

OLEMenu_CallWndProc()

static LRESULT CALLBACK OLEMenu_CallWndProc ( INT  code, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 1628 of file ole2.c.

{
  LPCWPSTRUCT pMsg;
  HOLEMENU hOleMenu = 0;
  OleMenuDescriptor *pOleMenuDescriptor = NULL;
  OleMenuHookItem *pHookItem = NULL;
  WORD fuFlags;
 
  TRACE("%i, %04lx, %08lx\n", code, wParam, lParam );
 
  /* Check if we're being asked to process the message */
  if ( HC_ACTION != code )
    goto NEXTHOOK;
 
  /* Retrieve the current message being dispatched from lParam */
  pMsg = (LPCWPSTRUCT)lParam;
 
  /* Check if the message is destined for a window we are interested in:
   * If the window has an OLEMenu property we may need to dispatch
   * the menu message to its active objects window instead. */
 
  hOleMenu = GetPropW( pMsg->hwnd, prop_olemenuW );
  if ( !hOleMenu )
    goto NEXTHOOK;
 
  /* Get the menu descriptor */
  pOleMenuDescriptor = GlobalLock( hOleMenu );
  if ( !pOleMenuDescriptor ) /* Bad descriptor! */
    goto NEXTHOOK;
 
  /* Process menu messages */
  switch( pMsg->message )
  {
    case WM_INITMENU:
    {
      /* Reset the menu descriptor state */
      pOleMenuDescriptor->bIsServerItem = FALSE;
 
      /* Send this message to the server as well */
      SendMessageW( pOleMenuDescriptor->hwndActiveObject,
                  pMsg->message, pMsg->wParam, pMsg->lParam );
      goto NEXTHOOK;
    }
 
    case WM_INITMENUPOPUP:
    {
      /* Save the state for whether this is a server owned menu */
      OLEMenu_SetIsServerMenu( (HMENU)pMsg->wParam, pOleMenuDescriptor );
      break;
    }
 
    case WM_MENUSELECT:
    {
      fuFlags = HIWORD(pMsg->wParam);  /* Get flags */
      if ( fuFlags & MF_SYSMENU )
         goto NEXTHOOK;
 
      /* Save the state for whether this is a server owned popup menu */
      else if ( fuFlags & MF_POPUP )
        OLEMenu_SetIsServerMenu( (HMENU)pMsg->lParam, pOleMenuDescriptor );
 
      break;
    }
 
    case WM_DRAWITEM:
    {
      LPDRAWITEMSTRUCT lpdis = (LPDRAWITEMSTRUCT) pMsg->lParam;
      if ( pMsg->wParam != 0 || lpdis->CtlType != ODT_MENU )
        goto NEXTHOOK;  /* Not a menu message */
 
      break;
    }
 
    default:
      goto NEXTHOOK;
  }
 
  /* If the message was for the server dispatch it accordingly */
  if ( pOleMenuDescriptor->bIsServerItem )
  {
    SendMessageW( pOleMenuDescriptor->hwndActiveObject,
                  pMsg->message, pMsg->wParam, pMsg->lParam );
  }
 
NEXTHOOK:
  if ( pOleMenuDescriptor )
    GlobalUnlock( hOleMenu );
 
  /* Lookup the hook item for the current thread */
  if ( !( pHookItem = OLEMenu_IsHookInstalled( GetCurrentThreadId() ) ) )
  {
    /* This should never fail!! */
    WARN("could not retrieve hHook for current thread!\n" );
    return 0;
  }
 
  /* Pass on the message to the next hooker */
  return CallNextHookEx( pHookItem->CallWndProc_hHook, code, wParam, lParam );
}

Referenced by OLEMenu_InstallHooks().

OLEMenu_FindMainMenuIndex()

static BOOL OLEMenu_FindMainMenuIndex ( HMENU  hMainMenu, HMENU  hPopupMenu, UINT *  pnPos  )

static

Definition at line 1546 of file ole2.c.

{
  INT i, nItems;
 
  nItems = GetMenuItemCount( hMainMenu );
 
  for (i = 0; i < nItems; i++)
  {
    HMENU hsubmenu;
 
    /*  Is the current item a submenu? */
    if ( (hsubmenu = GetSubMenu(hMainMenu, i)) )
    {
      /* If the handle is the same we're done */
      if ( hsubmenu == hPopupMenu )
      {
        if (pnPos)
          *pnPos = i;
        return TRUE;
      }
      /* Recursively search without updating pnPos */
      else if ( OLEMenu_FindMainMenuIndex( hsubmenu, hPopupMenu, NULL ) )
      {
        if (pnPos)
          *pnPos = i;
        return TRUE;
      }
    }
  }
 
  return FALSE;
}

Referenced by OLEMenu_FindMainMenuIndex(), and OLEMenu_SetIsServerMenu().

OLEMenu_GetMsgProc()

static LRESULT CALLBACK OLEMenu_GetMsgProc ( INT  code, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 1733 of file ole2.c.

{
  LPMSG pMsg;
  HOLEMENU hOleMenu = 0;
  OleMenuDescriptor *pOleMenuDescriptor = NULL;
  OleMenuHookItem *pHookItem = NULL;
  WORD wCode;
 
  TRACE("%i, %04lx, %08lx\n", code, wParam, lParam );
 
  /* Check if we're being asked to process a  messages */
  if ( HC_ACTION != code )
    goto NEXTHOOK;
 
  /* Retrieve the current message being dispatched from lParam */
  pMsg = (LPMSG)lParam;
 
  /* Check if the message is destined for a window we are interested in:
   * If the window has an OLEMenu property we may need to dispatch
   * the menu message to its active objects window instead. */
 
  hOleMenu = GetPropW( pMsg->hwnd, prop_olemenuW );
  if ( !hOleMenu )
    goto NEXTHOOK;
 
  /* Process menu messages */
  switch( pMsg->message )
  {
    case WM_COMMAND:
    {
      wCode = HIWORD(pMsg->wParam);  /* Get notification code */
      if ( wCode )
        goto NEXTHOOK;  /* Not a menu message */
      break;
    }
    default:
      goto NEXTHOOK;
  }
 
  /* Get the menu descriptor */
  pOleMenuDescriptor = GlobalLock( hOleMenu );
  if ( !pOleMenuDescriptor ) /* Bad descriptor! */
    goto NEXTHOOK;
 
  /* If the message was for the server dispatch it accordingly */
  if ( pOleMenuDescriptor->bIsServerItem )
  {
    /* Change the hWnd in the message to the active objects hWnd.
     * The message loop which reads this message will automatically
     * dispatch it to the embedded objects window. */
    pMsg->hwnd = pOleMenuDescriptor->hwndActiveObject;
  }
 
NEXTHOOK:
  if ( pOleMenuDescriptor )
    GlobalUnlock( hOleMenu );
 
  /* Lookup the hook item for the current thread */
  if ( !( pHookItem = OLEMenu_IsHookInstalled( GetCurrentThreadId() ) ) )
  {
    /* This should never fail!! */
    WARN("could not retrieve hHook for current thread!\n" );
    return FALSE;
  }
 
  /* Pass on the message to the next hooker */
  return CallNextHookEx( pHookItem->GetMsg_hHook, code, wParam, lParam );
}

Referenced by OLEMenu_InstallHooks().

OLEMenu_Initialize()

static void OLEMenu_Initialize ( void  )

static

Definition at line 1411 of file ole2.c.

{
}

Referenced by OleInitialize().

OLEMenu_InstallHooks()

static BOOL OLEMenu_InstallHooks ( DWORD  tid )

static

Definition at line 1431 of file ole2.c.

{
  OleMenuHookItem *pHookItem;
 
  /* Create an entry for the hook table */
  if ( !(pHookItem = HeapAlloc(GetProcessHeap(), 0,
                               sizeof(OleMenuHookItem)) ) )
    return FALSE;
 
  pHookItem->tid = tid;
  pHookItem->hHeap = GetProcessHeap();
  pHookItem->CallWndProc_hHook = NULL;
 
  /* Install a thread scope message hook for WH_GETMESSAGE */
  pHookItem->GetMsg_hHook = SetWindowsHookExW( WH_GETMESSAGE, OLEMenu_GetMsgProc,
                                               0, GetCurrentThreadId() );
  if ( !pHookItem->GetMsg_hHook )
    goto CLEANUP;
 
  /* Install a thread scope message hook for WH_CALLWNDPROC */
  pHookItem->CallWndProc_hHook = SetWindowsHookExW( WH_CALLWNDPROC, OLEMenu_CallWndProc,
                                                    0, GetCurrentThreadId() );
  if ( !pHookItem->CallWndProc_hHook )
    goto CLEANUP;
 
  /* Insert the hook table entry */
  pHookItem->next = hook_list;
  hook_list = pHookItem;
 
  return TRUE;
 
CLEANUP:
  /* Unhook any hooks */
  if ( pHookItem->GetMsg_hHook )
    UnhookWindowsHookEx( pHookItem->GetMsg_hHook );
  if ( pHookItem->CallWndProc_hHook )
    UnhookWindowsHookEx( pHookItem->CallWndProc_hHook );
  /* Release the hook table entry */
  HeapFree(pHookItem->hHeap, 0, pHookItem );
 
  return FALSE;
}

Referenced by OleSetMenuDescriptor().

OLEMenu_IsHookInstalled()

static OleMenuHookItem * OLEMenu_IsHookInstalled ( DWORD  tid )

static

Definition at line 1523 of file ole2.c.

{
  OleMenuHookItem *pHookItem;
 
  /* Do a simple linear search for an entry whose tid matches ours.
   * We really need a map but efficiency is not a concern here. */
  for (pHookItem = hook_list; pHookItem; pHookItem = pHookItem->next)
  {
    if ( tid == pHookItem->tid )
      return pHookItem;
  }
 
  return NULL;
}

Referenced by OLEMenu_CallWndProc(), OLEMenu_GetMsgProc(), and OleSetMenuDescriptor().

OLEMenu_SetIsServerMenu()

static BOOL OLEMenu_SetIsServerMenu ( HMENU  hmenu, OleMenuDescriptor *  pOleMenuDescriptor  )

static

Definition at line 1589 of file ole2.c.

{
  UINT nPos = 0, nWidth, i;
 
  pOleMenuDescriptor->bIsServerItem = FALSE;
 
  /* Don't bother searching if the popup is the combined menu itself */
  if ( hmenu == pOleMenuDescriptor->hmenuCombined )
    return FALSE;
 
  /* Find the menu item index in the shared OLE menu that this item belongs to */
  if ( !OLEMenu_FindMainMenuIndex( pOleMenuDescriptor->hmenuCombined, hmenu,  &nPos ) )
    return FALSE;
 
  /* The group widths array has counts for the number of elements
   * in the groups File, Edit, Container, Object, Window, Help.
   * The Edit, Object & Help groups belong to the server object
   * and the other three belong to the container.
   * Loop through the group widths and locate the group we are a member of.
   */
  for ( i = 0, nWidth = 0; i < 6; i++ )
  {
    nWidth += pOleMenuDescriptor->mgw.width[i];
    if ( nPos < nWidth )
    {
      /* Odd elements are server menu widths */
      pOleMenuDescriptor->bIsServerItem = i%2;
      break;
    }
  }
 
  return pOleMenuDescriptor->bIsServerItem;
}

Referenced by OLEMenu_CallWndProc().

OLEMenu_UnInitialize()

static void OLEMenu_UnInitialize ( void  )

static

Definition at line 1420 of file ole2.c.

{
}

Referenced by OleUninitialize().

OLEMenu_UnInstallHooks()

static BOOL OLEMenu_UnInstallHooks ( DWORD  tid )

static

Definition at line 1481 of file ole2.c.

{
  OleMenuHookItem *pHookItem = NULL;
  OleMenuHookItem **ppHook = &hook_list;
 
  while (*ppHook)
  {
      if ((*ppHook)->tid == tid)
      {
          pHookItem = *ppHook;
          *ppHook = pHookItem->next;
          break;
      }
      ppHook = &(*ppHook)->next;
  }
  if (!pHookItem) return FALSE;
 
  /* Uninstall the hooks installed for this thread */
  if ( !UnhookWindowsHookEx( pHookItem->GetMsg_hHook ) )
    goto CLEANUP;
  if ( !UnhookWindowsHookEx( pHookItem->CallWndProc_hHook ) )
    goto CLEANUP;
 
  /* Release the hook table entry */
  HeapFree(pHookItem->hHeap, 0, pHookItem );
 
  return TRUE;
 
CLEANUP:
  /* Release the hook table entry */
  HeapFree(pHookItem->hHeap, 0, pHookItem );
 
  return FALSE;
}

Referenced by OleSetMenuDescriptor().

OleNoteObjectVisible()

HRESULT WINAPI OleNoteObjectVisible	(	LPUNKNOWN	pUnknown,
		BOOL	bVisible
	)

Definition at line 2839 of file ole2.c.

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

OleQueryLinkFromData()

HRESULT WINAPI OleQueryLinkFromData

(

IDataObject *

pSrcDataObject

)

Definition at line 854 of file ole2.c.

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

OleRegEnumVerbs()

HRESULT WINAPI OleRegEnumVerbs	(	REFCLSID	clsid,
		LPENUMOLEVERB *	ppenum
	)

Definition at line 1125 of file ole2.c.

{
    LONG res;
    HKEY hkeyVerb;
    DWORD dwSubKeys;
    static const WCHAR wszVerb[] = {'V','e','r','b',0};
 
    TRACE("(%s, %p)\n", debugstr_guid(clsid), ppenum);
 
    res = COM_OpenKeyForCLSID(clsid, wszVerb, 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 %d\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 %d\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 864 of file ole2.c.

{
  static const WCHAR miscstatusW[] = {'M','i','s','c','S','t','a','t','u','s',0};
  static const WCHAR dfmtW[] = {'%','d',0};
  WCHAR   keyName[16];
  HKEY    miscStatusKey;
  HKEY    aspectKey;
  LONG    result;
  HRESULT hr;
 
  TRACE("(%s, %d, %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, miscstatusW, 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, dfmtW, 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	form,
		LPOLESTR *	usertype
	)

Definition at line 678 of file ole2.c.

{
  static const WCHAR auxusertypeW[] = {'A','u','x','U','s','e','r','T','y','p','e','\\','%','d',0};
  DWORD valuetype, valuelen;
  WCHAR auxkeynameW[16];
  HKEY    usertypekey;
  HRESULT hres;
  LONG    ret;
 
  TRACE("(%s, %u, %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, auxusertypeW, form);
    if (COM_OpenKeyForCLSID(clsid, auxkeynameW, KEY_READ, &auxkey) == S_OK)
    {
      if (!RegQueryValueExW(auxkey, emptyW, NULL, &valuetype, NULL, &valuelen) && valuelen)
      {
        RegCloseKey(usertypekey);
        usertypekey = auxkey;
      }
      else
        RegCloseKey(auxkey);
    }
  }
 
  valuelen = 0;
  if (RegQueryValueExW(usertypekey, emptyW, NULL, &valuetype, NULL, &valuelen))
  {
    RegCloseKey(usertypekey);
    return REGDB_E_READREGDB;
  }
 
  *usertype = CoTaskMemAlloc(valuelen);
  if (!*usertype)
  {
    RegCloseKey(usertypekey);
    return E_OUTOFMEMORY;
  }
 
  ret = RegQueryValueExW(usertypekey,
              emptyW,
              NULL,
              &valuetype,
              (LPBYTE)*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 DECLSPEC_HOTPATCH OleRun

(

LPUNKNOWN

pUnknown

)

Definition at line 1205 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 1338 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;
}

OleSetAutoConvert()

HRESULT WINAPI OleSetAutoConvert	(	REFCLSID	clsidOld,
		REFCLSID	clsidNew
	)

Definition at line 2731 of file ole2.c.

{
    static const WCHAR wszAutoConvertTo[] = {'A','u','t','o','C','o','n','v','e','r','t','T','o',0};
    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, wszAutoConvertTo, 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().

OleSetContainedObject()

HRESULT WINAPI OleSetContainedObject	(	LPUNKNOWN	pUnknown,
		BOOL	fContained
	)

Definition at line 1168 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	hOleMenu,
		HWND	hwndFrame,
		HWND	hwndActiveObject,
		LPOLEINPLACEFRAME	lpFrame,
		LPOLEINPLACEACTIVEOBJECT	lpActiveObject
	)

Definition at line 1875 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,
		LPMSG	lpmsg
	)

Definition at line 2592 of file ole2.c.

{
    WORD wID;
 
    TRACE("(%p,%p,%p)\n", lpFrame, lpFrameInfo, lpmsg);
 
    if (IsAccelerator(lpFrameInfo->haccel,lpFrameInfo->cAccelEntries,lpmsg,&wID))
        return IOleInPlaceFrame_TranslateAccelerator(lpFrame,lpmsg,wID);
 
    return S_FALSE;
}

OleUninitialize()

void WINAPI DECLSPEC_HOTPATCH OleUninitialize

(

void

)

Definition at line 230 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
     */
    OLEClipbrd_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(), 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(), and OleInit::~OleInit().

OLEUTL_ReadRegistryDWORDValue()

static void OLEUTL_ReadRegistryDWORDValue ( HKEY  regKey, DWORD *  pdwValue  )

static

Definition at line 2526 of file ole2.c.

{
  WCHAR buffer[20];
  DWORD cbData = sizeof(buffer);
  DWORD dwKeyType;
  LONG  lres;
 
  lres = RegQueryValueExW(regKey,
              emptyW,
              NULL,
              &dwKeyType,
              (LPBYTE)buffer,
              &cbData);
 
  if (lres==ERROR_SUCCESS)
  {
    switch (dwKeyType)
    {
      case REG_DWORD:
    *pdwValue = *(DWORD*)buffer;
    break;
      case REG_EXPAND_SZ:
      case REG_MULTI_SZ:
      case REG_SZ:
    *pdwValue = wcstoul(buffer, NULL, 10);
    break;
    }
  }
}

Referenced by OleRegGetMiscStatus().

PropSysAllocString()

BSTR WINAPI PropSysAllocString

(

LPCOLESTR

str

)

Definition at line 2864 of file ole2.c.

{
    return SysAllocString(str);
}

Referenced by PropVariantCopy().

PropSysFreeString()

void WINAPI PropSysFreeString

(

LPOLESTR

str

)

Definition at line 2874 of file ole2.c.

{
    SysFreeString(str);
}

Referenced by PropVariantClear().

PROPVARIANT_ValidateType()

static HRESULT PROPVARIANT_ValidateType ( VARTYPE  vt )

inlinestatic

Definition at line 2882 of file ole2.c.

{
    switch (vt)
    {
    case VT_EMPTY:
    case VT_NULL:
    case VT_I1:
    case VT_I2:
    case VT_I4:
    case VT_I8:
    case VT_R4:
    case VT_R8:
    case VT_CY:
    case VT_DATE:
    case VT_BSTR:
    case VT_ERROR:
    case VT_BOOL:
    case VT_DECIMAL:
    case VT_UI1:
    case VT_UI2:
    case VT_UI4:
    case VT_UI8:
    case VT_INT:
    case VT_UINT:
    case VT_LPSTR:
    case VT_LPWSTR:
    case VT_FILETIME:
    case VT_BLOB:
    case VT_DISPATCH:
    case VT_UNKNOWN:
    case VT_STREAM:
    case VT_STORAGE:
    case VT_STREAMED_OBJECT:
    case VT_STORED_OBJECT:
    case VT_BLOB_OBJECT:
    case VT_CF:
    case VT_CLSID:
    case VT_I1|VT_VECTOR:
    case VT_I2|VT_VECTOR:
    case VT_I4|VT_VECTOR:
    case VT_I8|VT_VECTOR:
    case VT_R4|VT_VECTOR:
    case VT_R8|VT_VECTOR:
    case VT_CY|VT_VECTOR:
    case VT_DATE|VT_VECTOR:
    case VT_BSTR|VT_VECTOR:
    case VT_ERROR|VT_VECTOR:
    case VT_BOOL|VT_VECTOR:
    case VT_VARIANT|VT_VECTOR:
    case VT_UI1|VT_VECTOR:
    case VT_UI2|VT_VECTOR:
    case VT_UI4|VT_VECTOR:
    case VT_UI8|VT_VECTOR:
    case VT_LPSTR|VT_VECTOR:
    case VT_LPWSTR|VT_VECTOR:
    case VT_FILETIME|VT_VECTOR:
    case VT_CF|VT_VECTOR:
    case VT_CLSID|VT_VECTOR:
    case VT_ARRAY|VT_I1:
    case VT_ARRAY|VT_UI1:
    case VT_ARRAY|VT_I2:
    case VT_ARRAY|VT_UI2:
    case VT_ARRAY|VT_I4:
    case VT_ARRAY|VT_UI4:
    case VT_ARRAY|VT_INT:
    case VT_ARRAY|VT_UINT:
    case VT_ARRAY|VT_R4:
    case VT_ARRAY|VT_R8:
    case VT_ARRAY|VT_CY:
    case VT_ARRAY|VT_DATE:
    case VT_ARRAY|VT_BSTR:
    case VT_ARRAY|VT_BOOL:
    case VT_ARRAY|VT_DECIMAL:
    case VT_ARRAY|VT_DISPATCH:
    case VT_ARRAY|VT_UNKNOWN:
    case VT_ARRAY|VT_ERROR:
    case VT_ARRAY|VT_VARIANT:
        return S_OK;
    }
    WARN("Bad type %d\n", vt);
    return STG_E_INVALIDPARAMETER;
}

Referenced by PropVariantClear(), and PropVariantCopy().

PropVariantClear()

HRESULT WINAPI PropVariantClear

(

PROPVARIANT *

pvar

)

Definition at line 2968 of file ole2.c.

{
    HRESULT hr;
 
    TRACE("(%p)\n", pvar);
 
    if (!pvar)
        return S_OK;
 
    hr = PROPVARIANT_ValidateType(pvar->vt);
    if (FAILED(hr))
    {
        memset(pvar, 0, sizeof(*pvar));
        return hr;
    }
 
    switch(pvar->vt)
    {
    case VT_EMPTY:
    case VT_NULL:
    case VT_I1:
    case VT_I2:
    case VT_I4:
    case VT_I8:
    case VT_R4:
    case VT_R8:
    case VT_CY:
    case VT_DATE:
    case VT_ERROR:
    case VT_BOOL:
    case VT_DECIMAL:
    case VT_UI1:
    case VT_UI2:
    case VT_UI4:
    case VT_UI8:
    case VT_INT:
    case VT_UINT:
    case VT_FILETIME:
        break;
    case VT_DISPATCH:
    case VT_UNKNOWN:
    case VT_STREAM:
    case VT_STREAMED_OBJECT:
    case VT_STORAGE:
    case VT_STORED_OBJECT:
        if (pvar->u.pStream)
            IStream_Release(pvar->u.pStream);
        break;
    case VT_CLSID:
    case VT_LPSTR:
    case VT_LPWSTR:
        /* pick an arbitrary typed pointer - we don't care about the type
         * as we are just freeing it */
        CoTaskMemFree(pvar->u.puuid);
        break;
    case VT_BLOB:
    case VT_BLOB_OBJECT:
        CoTaskMemFree(pvar->u.blob.pBlobData);
        break;
    case VT_BSTR:
        PropSysFreeString(pvar->u.bstrVal);
        break;
    case VT_CF:
        if (pvar->u.pclipdata)
        {
            OLE_FreeClipDataArray(1, pvar->u.pclipdata);
            CoTaskMemFree(pvar->u.pclipdata);
        }
        break;
    default:
        if (pvar->vt & VT_VECTOR)
        {
            ULONG i;
 
            switch (pvar->vt & ~VT_VECTOR)
            {
            case VT_VARIANT:
                FreePropVariantArray(pvar->u.capropvar.cElems, pvar->u.capropvar.pElems);
                break;
            case VT_CF:
                OLE_FreeClipDataArray(pvar->u.caclipdata.cElems, pvar->u.caclipdata.pElems);
                break;
            case VT_BSTR:
                for (i = 0; i < pvar->u.cabstr.cElems; i++)
                    PropSysFreeString(pvar->u.cabstr.pElems[i]);
                break;
            case VT_LPSTR:
                for (i = 0; i < pvar->u.calpstr.cElems; i++)
                    CoTaskMemFree(pvar->u.calpstr.pElems[i]);
                break;
            case VT_LPWSTR:
                for (i = 0; i < pvar->u.calpwstr.cElems; i++)
                    CoTaskMemFree(pvar->u.calpwstr.pElems[i]);
                break;
            }
            if (pvar->vt & ~VT_VECTOR)
            {
                /* pick an arbitrary VT_VECTOR structure - they all have the same
                 * memory layout */
                CoTaskMemFree(pvar->u.capropvar.pElems);
            }
        }
        else if (pvar->vt & VT_ARRAY)
            hr = SafeArrayDestroy(pvar->u.parray);
        else
        {
            WARN("Invalid/unsupported type %d\n", pvar->vt);
            hr = STG_E_INVALIDPARAMETER;
        }
    }
 
    memset(pvar, 0, sizeof(*pvar));
    return hr;
}

Referenced by check_tiff_format(), compare_metadata(), destroy_format(), free_header(), FreePropVariantArray(), GdipGetAllPropertyItems(), GdipGetPropertyItem(), GdipGetPropertyItemSize(), GdipGetPropertySize(), get_bool_property(), get_next_reader(), get_property(), get_token(), get_ulong_by_index(), MetadataHandler_FreeItems(), MimeBody_GetProp(), MMDevice_Create(), MMDevice_GetPropValue(), mqr_GetMetadataByName(), on_mime_message_available(), PersistFile_Save(), png_metadata_reader(), PropertyStorage_PropertyDestroy(), PropertyStorage_ReadFromStream(), PropertyStorage_StorePropWithId(), PropertyStore_SetValue(), PropertyStore_SetValueAndState(), PropVariantCompareEx(), set_driver_prop_value(), test_BodyDeleteProp(), test_convert(), test_copy(), test_CreateMessage(), test_deviceinterface(), test_first_device(), test_InitPropVariantFromBuffer(), test_InitPropVariantFromCLSID(), test_intconversions(), test_MessageGetPropInfo(), test_MessageOptions(), test_MessageSetProp(), test_metadata_APE(), test_metadata_cHRM(), test_metadata_gAMA(), test_metadata_gif(), test_metadata_GIF_comment(), test_metadata_IFD(), test_metadata_tEXt(), test_metadata_unknown(), test_propertystore(), test_propertytovariant(), test_PropVariantChangeType_LPWSTR(), test_PropVariantToBuffer(), test_PropVariantToDouble(), test_PropVariantToGUID(), test_PropVariantToString(), test_PropVariantToStringAlloc(), test_queryreader(), test_validtypes(), testCodepage(), and testPropsHelper().

PropVariantCopy()

HRESULT WINAPI PropVariantCopy	(	PROPVARIANT *	pvarDest,
		const PROPVARIANT *	pvarSrc
	)

Definition at line 3086 of file ole2.c.

{
    ULONG len;
    HRESULT hr;
 
    TRACE("(%p, %p vt %04x)\n", pvarDest, pvarSrc, pvarSrc->vt);
 
    hr = PROPVARIANT_ValidateType(pvarSrc->vt);
    if (FAILED(hr))
        return DISP_E_BADVARTYPE;
 
    /* this will deal with most cases */
    *pvarDest = *pvarSrc;
 
    switch(pvarSrc->vt)
    {
    case VT_EMPTY:
    case VT_NULL:
    case VT_I1:
    case VT_UI1:
    case VT_I2:
    case VT_UI2:
    case VT_BOOL:
    case VT_DECIMAL:
    case VT_I4:
    case VT_UI4:
    case VT_R4:
    case VT_ERROR:
    case VT_I8:
    case VT_UI8:
    case VT_INT:
    case VT_UINT:
    case VT_R8:
    case VT_CY:
    case VT_DATE:
    case VT_FILETIME:
        break;
    case VT_DISPATCH:
    case VT_UNKNOWN:
    case VT_STREAM:
    case VT_STREAMED_OBJECT:
    case VT_STORAGE:
    case VT_STORED_OBJECT:
        if (pvarDest->u.pStream)
            IStream_AddRef(pvarDest->u.pStream);
        break;
    case VT_CLSID:
        pvarDest->u.puuid = CoTaskMemAlloc(sizeof(CLSID));
        *pvarDest->u.puuid = *pvarSrc->u.puuid;
        break;
    case VT_LPSTR:
        if (pvarSrc->u.pszVal)
        {
            len = strlen(pvarSrc->u.pszVal);
            pvarDest->u.pszVal = CoTaskMemAlloc((len+1)*sizeof(CHAR));
            CopyMemory(pvarDest->u.pszVal, pvarSrc->u.pszVal, (len+1)*sizeof(CHAR));
        }
        break;
    case VT_LPWSTR:
        if (pvarSrc->u.pwszVal)
        {
            len = lstrlenW(pvarSrc->u.pwszVal);
            pvarDest->u.pwszVal = CoTaskMemAlloc((len+1)*sizeof(WCHAR));
            CopyMemory(pvarDest->u.pwszVal, pvarSrc->u.pwszVal, (len+1)*sizeof(WCHAR));
        }
        break;
    case VT_BLOB:
    case VT_BLOB_OBJECT:
        if (pvarSrc->u.blob.pBlobData)
        {
            len = pvarSrc->u.blob.cbSize;
            pvarDest->u.blob.pBlobData = CoTaskMemAlloc(len);
            CopyMemory(pvarDest->u.blob.pBlobData, pvarSrc->u.blob.pBlobData, len);
        }
        break;
    case VT_BSTR:
        pvarDest->u.bstrVal = PropSysAllocString(pvarSrc->u.bstrVal);
        break;
    case VT_CF:
        if (pvarSrc->u.pclipdata)
        {
            len = pvarSrc->u.pclipdata->cbSize - sizeof(pvarSrc->u.pclipdata->ulClipFmt);
            pvarDest->u.pclipdata = CoTaskMemAlloc(sizeof (CLIPDATA));
            pvarDest->u.pclipdata->cbSize = pvarSrc->u.pclipdata->cbSize;
            pvarDest->u.pclipdata->ulClipFmt = pvarSrc->u.pclipdata->ulClipFmt;
            pvarDest->u.pclipdata->pClipData = CoTaskMemAlloc(len);
            CopyMemory(pvarDest->u.pclipdata->pClipData, pvarSrc->u.pclipdata->pClipData, len);
        }
        break;
    default:
        if (pvarSrc->vt & VT_VECTOR)
        {
            int elemSize;
            ULONG i;
 
            switch(pvarSrc->vt & ~VT_VECTOR)
            {
            case VT_I1:       elemSize = sizeof(pvarSrc->u.cVal); break;
            case VT_UI1:      elemSize = sizeof(pvarSrc->u.bVal); break;
            case VT_I2:       elemSize = sizeof(pvarSrc->u.iVal); break;
            case VT_UI2:      elemSize = sizeof(pvarSrc->u.uiVal); break;
            case VT_BOOL:     elemSize = sizeof(pvarSrc->u.boolVal); break;
            case VT_I4:       elemSize = sizeof(pvarSrc->u.lVal); break;
            case VT_UI4:      elemSize = sizeof(pvarSrc->u.ulVal); break;
            case VT_R4:       elemSize = sizeof(pvarSrc->u.fltVal); break;
            case VT_R8:       elemSize = sizeof(pvarSrc->u.dblVal); break;
            case VT_ERROR:    elemSize = sizeof(pvarSrc->u.scode); break;
            case VT_I8:       elemSize = sizeof(pvarSrc->u.hVal); break;
            case VT_UI8:      elemSize = sizeof(pvarSrc->u.uhVal); break;
            case VT_CY:       elemSize = sizeof(pvarSrc->u.cyVal); break;
            case VT_DATE:     elemSize = sizeof(pvarSrc->u.date); break;
            case VT_FILETIME: elemSize = sizeof(pvarSrc->u.filetime); break;
            case VT_CLSID:    elemSize = sizeof(*pvarSrc->u.puuid); break;
            case VT_CF:       elemSize = sizeof(*pvarSrc->u.pclipdata); break;
            case VT_BSTR:     elemSize = sizeof(pvarSrc->u.bstrVal); break;
            case VT_LPSTR:    elemSize = sizeof(pvarSrc->u.pszVal); break;
            case VT_LPWSTR:   elemSize = sizeof(pvarSrc->u.pwszVal); break;
            case VT_VARIANT:  elemSize = sizeof(*pvarSrc->u.pvarVal); break;
 
            default:
                FIXME("Invalid element type: %ul\n", pvarSrc->vt & ~VT_VECTOR);
                return E_INVALIDARG;
            }
            len = pvarSrc->u.capropvar.cElems;
            pvarDest->u.capropvar.pElems = len ? CoTaskMemAlloc(len * elemSize) : NULL;
            if (pvarSrc->vt == (VT_VECTOR | VT_VARIANT))
            {
                for (i = 0; i < len; i++)
                    PropVariantCopy(&pvarDest->u.capropvar.pElems[i], &pvarSrc->u.capropvar.pElems[i]);
            }
            else if (pvarSrc->vt == (VT_VECTOR | VT_CF))
            {
                FIXME("Copy clipformats\n");
            }
            else if (pvarSrc->vt == (VT_VECTOR | VT_BSTR))
            {
                for (i = 0; i < len; i++)
                    pvarDest->u.cabstr.pElems[i] = PropSysAllocString(pvarSrc->u.cabstr.pElems[i]);
            }
            else if (pvarSrc->vt == (VT_VECTOR | VT_LPSTR))
            {
                size_t strLen;
                for (i = 0; i < len; i++)
                {
                    strLen = lstrlenA(pvarSrc->u.calpstr.pElems[i]) + 1;
                    pvarDest->u.calpstr.pElems[i] = CoTaskMemAlloc(strLen);
                    memcpy(pvarDest->u.calpstr.pElems[i],
                     pvarSrc->u.calpstr.pElems[i], strLen);
                }
            }
            else if (pvarSrc->vt == (VT_VECTOR | VT_LPWSTR))
            {
                size_t strLen;
                for (i = 0; i < len; i++)
                {
                    strLen = (lstrlenW(pvarSrc->u.calpwstr.pElems[i]) + 1) *
                     sizeof(WCHAR);
                    pvarDest->u.calpstr.pElems[i] = CoTaskMemAlloc(strLen);
                    memcpy(pvarDest->u.calpstr.pElems[i],
                     pvarSrc->u.calpstr.pElems[i], strLen);
                }
            }
            else
                CopyMemory(pvarDest->u.capropvar.pElems, pvarSrc->u.capropvar.pElems, len * elemSize);
        }
        else if (pvarSrc->vt & VT_ARRAY)
        {
            pvarDest->u.uhVal.QuadPart = 0;
            return SafeArrayCopy(pvarSrc->u.parray, &pvarDest->u.parray);
        }
        else
            WARN("Invalid/unsupported type %d\n", pvarSrc->vt);
    }
 
    return S_OK;
}

Referenced by IPropertyStorage_fnWriteMultiple(), MetadataHandler_GetValue(), MetadataHandler_GetValueByIndex(), MetadataHandlerEnum_Next(), MimeBody_SetProp(), PropertyStorage_PropVariantCopy(), PropertyStore_GetValue(), PropertyStore_GetValueAndState(), PropertyStore_SetValue(), PropertyStore_SetValueAndState(), PropVariantChangeType(), PropVariantCopy(), test_copy(), and test_validtypes().

RegisterDragDrop()

HRESULT WINAPI RegisterDragDrop	(	HWND	hwnd,
		LPDROPTARGET	pDropTarget
	)

Definition at line 557 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

(

STGMEDIUM *

pmedium

)

Definition at line 2033 of file ole2.c.

{
  switch (pmedium->tymed)
  {
    case TYMED_HGLOBAL:
    {
      if ( (pmedium->pUnkForRelease==0) &&
       (pmedium->u.hGlobal!=0) )
    GlobalFree(pmedium->u.hGlobal);
      break;
    }
    case TYMED_FILE:
    {
      if (pmedium->u.lpszFileName!=0)
      {
    if (pmedium->pUnkForRelease==0)
    {
      DeleteFileW(pmedium->u.lpszFileName);
    }
 
    CoTaskMemFree(pmedium->u.lpszFileName);
      }
      break;
    }
    case TYMED_ISTREAM:
    {
      if (pmedium->u.pstm!=0)
      {
    IStream_Release(pmedium->u.pstm);
      }
      break;
    }
    case TYMED_ISTORAGE:
    {
      if (pmedium->u.pstg!=0)
      {
    IStorage_Release(pmedium->u.pstg);
      }
      break;
    }
    case TYMED_GDI:
    {
      if ( (pmedium->pUnkForRelease==0) &&
       (pmedium->u.hBitmap!=0) )
    DeleteObject(pmedium->u.hBitmap);
      break;
    }
    case TYMED_MFPICT:
    {
      if ( (pmedium->pUnkForRelease==0) &&
       (pmedium->u.hMetaFilePict!=0) )
      {
    LPMETAFILEPICT pMP = GlobalLock(pmedium->u.hMetaFilePict);
    DeleteMetaFile(pMP->hMF);
    GlobalUnlock(pmedium->u.hMetaFilePict);
    GlobalFree(pmedium->u.hMetaFilePict);
      }
      break;
    }
    case TYMED_ENHMF:
    {
      if ( (pmedium->pUnkForRelease==0) &&
       (pmedium->u.hEnhMetaFile!=0) )
      {
    DeleteEnhMetaFile(pmedium->u.hEnhMetaFile);
      }
      break;
    }
    case TYMED_NULL:
    default:
      break;
  }
  pmedium->tymed=TYMED_NULL;
 
  /*
   * After cleaning up, the unknown is released
   */
  if (pmedium->pUnkForRelease!=0)
  {
    IUnknown_Release(pmedium->pUnkForRelease);
    pmedium->pUnkForRelease = 0;
  }
}

Referenced by CDefViewBckgrndMenu::_bCanPaste(), CRecyclerDropTarget::_DoDeleteDataObject(), CFSDropTarget::_DoDrop(), CopyBindInfo(), DataCache_UpdateCache(), DataCacheEntry_Destroy(), DataCacheEntry_DiscardData(), DataCacheEntry_SetData(), CFSDropTarget::DragEnter(), CSendToZip::Drop(), CExeDropHandler::Drop(), IDropTargetImpl::Drop(), get_data_from_bitmap(), get_data_from_enhmetafile(), get_data_from_global(), get_data_from_metafilepict(), get_data_from_storage(), get_data_from_stream(), IBindStatusCallback_OnDataAvailable_Stub(), CVfdShExt::Initialize(), CDrvDefExt::Initialize(), BtrfsContextMenu::Initialize(), BtrfsPropSheet::Initialize(), BtrfsVolPropSheet::Initialize(), CShellLink::Initialize(), CFileDefExt::Initialize(), CZipFolder::Initialize(), CLayerUIPropPage::Initialize(), InvokeObjectPickerDialog(), InvokeRemoteRegistryPickerDialog(), load_emf(), ME_DrawOLE(), ME_GetOLEObjectSize(), ok_attributes_(), OleCreateFromFileEx(), OleCreateStaticFromData(), paste_emf(), paste_rtf(), paste_text(), QueryDeskCplExtInterface(), QueryDeskCplString(), ReleaseBindInfo(), render_embed_source_hack(), CIDLDataObj::SetData(), snapshot_GetDataHere(), STGMEDIUM_UserFree(), stream_out_graphics(), test_complex_get_clipboard(), test_consumer_refs(), test_CopyStgMedium(), test_data_cache(), test_data_cache_cache(), test_data_cache_dib_contents_stream(), test_data_cache_save_data(), test_DataObject(), test_DataObject_FirstFile(), test_DataObject_FirstFolder(), test_EnumObjects_Files(), test_EnumObjects_Folders(), test_flushed_getdata(), test_get_clipboard(), test_getdatahere(), test_nonole_clipboard(), test_OleCreateStaticFromData(), TestDefaultFormat(), TestSetAndGetExtraFormat(), BtrfsContextMenu::~BtrfsContextMenu(), BtrfsPropSheet::~BtrfsPropSheet(), BtrfsVolPropSheet::~BtrfsVolPropSheet(), CIDLDataObj::~CIDLDataObj(), IDataObjectImpl::~IDataObjectImpl(), and PIDList::~PIDList().

RevokeDragDrop()

HRESULT WINAPI RevokeDragDrop

(

HWND

hwnd

)

Definition at line 639 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().

WINE_DECLARE_DEBUG_CHANNEL()

WINE_DECLARE_DEBUG_CHANNEL

(

accel

)

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

ole

)

WrapDropTarget()

static IDropTarget * WrapDropTarget ( HWND  hwnd )

static

Definition at line 518 of file ole2.c.

{
    DropTargetWrapper* This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
 
    if (This)
    {
        This->IDropTarget_iface.lpVtbl = &DropTargetWrapperVTbl;
        This->hwnd = hwnd;
        This->refs = 1;
    }
    return &This->IDropTarget_iface;
}

Referenced by RegisterDragDrop().

Variable Documentation

DropTargetWrapperVTbl

const IDropTargetVtbl DropTargetWrapperVTbl

static

Initial value:

=
{
    DropTargetWrapper_QueryInterface,
    DropTargetWrapper_AddRef,
    DropTargetWrapper_Release,
    DropTargetWrapper_DragEnter,
    DropTargetWrapper_DragOver,
    DropTargetWrapper_DragLeave,
    DropTargetWrapper_Drop
}

Definition at line 507 of file ole2.c.

Referenced by WrapDropTarget().

emptyW

const WCHAR emptyW[] = { 0 }

static

Definition at line 123 of file ole2.c.

Referenced by OleRegGetUserType(), and OLEUTL_ReadRegistryDWORDValue().

EnumOLEVERB_VTable

const IEnumOLEVERBVtbl EnumOLEVERB_VTable

static

Initial value:

=
{
    EnumOLEVERB_QueryInterface,
    EnumOLEVERB_AddRef,
    EnumOLEVERB_Release,
    EnumOLEVERB_Next,
    EnumOLEVERB_Skip,
    EnumOLEVERB_Reset,
    EnumOLEVERB_Clone
}

Definition at line 1082 of file ole2.c.

Referenced by EnumOLEVERB_Construct().

hook_list

OleMenuHookItem* hook_list

static

Definition at line 95 of file ole2.c.

Referenced by common_set_report_hook(), OLEMenu_InstallHooks(), OLEMenu_IsHookInstalled(), and OLEMenu_UnInstallHooks().

OLE_moduleLockCount

LONG OLE_moduleLockCount = 0

static

Definition at line 101 of file ole2.c.

Referenced by OleInitialize(), and OleUninitialize().

OLEDD_DRAGTRACKERCLASS

const WCHAR OLEDD_DRAGTRACKERCLASS[]

static

Initial value:

=
  {'W','i','n','e','D','r','a','g','D','r','o','p','T','r','a','c','k','e','r','3','2',0}

Definition at line 106 of file ole2.c.

Referenced by DoDragDrop(), and OLEDD_Initialize().

prop_marshalleddroptarget

const WCHAR prop_marshalleddroptarget[]

static

Initial value:

=
  {'W','i','n','e','M','a','r','s','h','a','l','l','e','d','D','r','o','p','T','a','r','g','e','t',0}

Definition at line 120 of file ole2.c.

Referenced by get_droptarget_handle(), RegisterDragDrop(), and RevokeDragDrop().

prop_oledroptarget

const WCHAR prop_oledroptarget[]

static

Initial value:

=
  {'O','l','e','D','r','o','p','T','a','r','g','e','t','I','n','t','e','r','f','a','c','e',0}

Definition at line 116 of file ole2.c.

Referenced by get_target_from_wrapper(), RegisterDragDrop(), and RevokeDragDrop().

prop_olemenuW

const WCHAR prop_olemenuW[]

static

Initial value:

=
  {'P','R','O','P','_','O','L','E','M','e','n','u','D','e','s','c','r','i','p','t','o','r',0}

Definition at line 112 of file ole2.c.

Referenced by OLEMenu_CallWndProc(), OLEMenu_GetMsgProc(), and OleSetMenuDescriptor().