git.oblomov.eu Git - wine/blob - dlls/ole32/ole2.c

   1 /*
   2  *      OLE2 library
   3  *
   4  * Copyright 1995 Martin von Loewis
   5  * Copyright 1999 Francis Beaudet
   6  * Copyright 1999 Noel Borthwick
   7  * Copyright 1999, 2000 Marcus Meissner
   8  * Copyright 2005 Juan Lang
   9  *
  10  * This library is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * This library is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with this library; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  23  */
  24
  25 #include "config.h"
  26
  27 #include <assert.h>
  28 #include <stdlib.h>
  29 #include <stdarg.h>
  30 #include <stdio.h>
  31 #include <string.h>
  32
  33 #define COBJMACROS
  34 #define NONAMELESSUNION
  35 #define NONAMELESSSTRUCT
  36
  37 #include "windef.h"
  38 #include "winbase.h"
  39 #include "winerror.h"
  40 #include "wingdi.h"
  41 #include "winuser.h"
  42 #include "winnls.h"
  43 #include "winreg.h"
  44 #include "ole2.h"
  45 #include "ole2ver.h"
  46
  47 #include "wine/unicode.h"
  48 #include "compobj_private.h"
  49 #include "wine/list.h"
  50
  51 #include "wine/debug.h"
  52
  53 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  54 WINE_DECLARE_DEBUG_CHANNEL(accel);
  55
  56 /******************************************************************************
  57  * These are static/global variables and internal data structures that the
  58  * OLE module uses to maintain it's state.
  59  */
  60 typedef struct tagTrackerWindowInfo
  61 {
  62   IDataObject* dataObject;
  63   IDropSource* dropSource;
  64   DWORD        dwOKEffect;
  65   DWORD*       pdwEffect;
  66   BOOL       trackingDone;
  67   HRESULT      returnValue;
  68
  69   BOOL       escPressed;
  70   HWND       curTargetHWND;     /* window the mouse is hovering over */
  71   HWND       curDragTargetHWND; /* might be a ancestor of curTargetHWND */
  72   IDropTarget* curDragTarget;
  73   POINTL     curMousePos;       /* current position of the mouse in screen coordinates */
  74   DWORD      dwKeyState;        /* current state of the shift and ctrl keys and the mouse buttons */
  75 } TrackerWindowInfo;
  76
  77 typedef struct tagOleMenuDescriptor  /* OleMenuDescriptor */
  78 {
  79   HWND               hwndFrame;         /* The containers frame window */
  80   HWND               hwndActiveObject;  /* The active objects window */
  81   OLEMENUGROUPWIDTHS mgw;               /* OLE menu group widths for the shared menu */
  82   HMENU              hmenuCombined;     /* The combined menu */
  83   BOOL               bIsServerItem;     /* True if the currently open popup belongs to the server */
  84 } OleMenuDescriptor;
  85
  86 typedef struct tagOleMenuHookItem   /* OleMenu hook item in per thread hook list */
  87 {
  88   DWORD tid;                /* Thread Id  */
  89   HANDLE hHeap;             /* Heap this is allocated from */
  90   HHOOK GetMsg_hHook;       /* message hook for WH_GETMESSAGE */
  91   HHOOK CallWndProc_hHook;  /* message hook for WH_CALLWNDPROC */
  92   struct tagOleMenuHookItem *next;
  93 } OleMenuHookItem;
  94
  95 static OleMenuHookItem *hook_list;
  96
  97 /*
  98  * This is the lock count on the OLE library. It is controlled by the
  99  * OLEInitialize/OLEUninitialize methods.
 100  */
 101 static LONG OLE_moduleLockCount = 0;
 102
 103 /*
 104  * Name of our registered window class.
 105  */
 106 static const WCHAR OLEDD_DRAGTRACKERCLASS[] =
 107   {'W','i','n','e','D','r','a','g','D','r','o','p','T','r','a','c','k','e','r','3','2',0};
 108
 109 /*
 110  * Name of menu descriptor property.
 111  */
 112 static const WCHAR prop_olemenuW[] =
 113   {'P','R','O','P','_','O','L','E','M','e','n','u','D','e','s','c','r','i','p','t','o','r',0};
 114
 115 /* property to store IDropTarget pointer */
 116 static const WCHAR prop_oledroptarget[] =
 117   {'O','l','e','D','r','o','p','T','a','r','g','e','t','I','n','t','e','r','f','a','c','e',0};
 118
 119 /* property to store Marshalled IDropTarget pointer */
 120 static const WCHAR prop_marshalleddroptarget[] =
 121   {'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};
 122
 123 static const WCHAR clsidfmtW[] =
 124   {'C','L','S','I','D','\\','{','%','0','8','x','-','%','0','4','x','-','%','0','4','x','-',
 125    '%','0','2','x','%','0','2','x','-','%','0','2','x','%','0','2','x','%','0','2','x','%','0','2','x',
 126     '%','0','2','x','%','0','2','x','}','\\',0};
 127
 128 static const WCHAR emptyW[] = { 0 };
 129
 130 /******************************************************************************
 131  * These are the prototypes of miscellaneous utility methods
 132  */
 133 static void OLEUTL_ReadRegistryDWORDValue(HKEY regKey, DWORD* pdwValue);
 134
 135 /******************************************************************************
 136  * These are the prototypes of the utility methods used to manage a shared menu
 137  */
 138 static void OLEMenu_Initialize(void);
 139 static void OLEMenu_UnInitialize(void);
 140 static BOOL OLEMenu_InstallHooks( DWORD tid );
 141 static BOOL OLEMenu_UnInstallHooks( DWORD tid );
 142 static OleMenuHookItem * OLEMenu_IsHookInstalled( DWORD tid );
 143 static BOOL OLEMenu_FindMainMenuIndex( HMENU hMainMenu, HMENU hPopupMenu, UINT *pnPos );
 144 static BOOL OLEMenu_SetIsServerMenu( HMENU hmenu, OleMenuDescriptor *pOleMenuDescriptor );
 145 static LRESULT CALLBACK OLEMenu_CallWndProc(INT code, WPARAM wParam, LPARAM lParam);
 146 static LRESULT CALLBACK OLEMenu_GetMsgProc(INT code, WPARAM wParam, LPARAM lParam);
 147
 148 /******************************************************************************
 149  * These are the prototypes of the OLE Clipboard initialization methods (in clipboard.c)
 150  */
 151 extern void OLEClipbrd_UnInitialize(void);
 152 extern void OLEClipbrd_Initialize(void);
 153
 154 /******************************************************************************
 155  * These are the prototypes of the utility methods used for OLE Drag n Drop
 156  */
 157 static void OLEDD_Initialize(void);
 158 static LRESULT WINAPI  OLEDD_DragTrackerWindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
 159 static void OLEDD_TrackMouseMove(TrackerWindowInfo* trackerInfo);
 160 static void OLEDD_TrackStateChange(TrackerWindowInfo* trackerInfo);
 161 static DWORD OLEDD_GetButtonState(void);
 162
 163 /******************************************************************************
 164  *              OleBuildVersion [OLE32.@]
 165  */
 166 DWORD WINAPI OleBuildVersion(void)
 167 {
 168     TRACE("Returning version %d, build %d.\n", rmm, rup);
 169     return (rmm<<16)+rup;
 170 }
 171
 172 /***********************************************************************
 173  *           OleInitialize       (OLE32.@)
 174  */
 175 HRESULT WINAPI OleInitialize(LPVOID reserved)
 176 {
 177   HRESULT hr;
 178
 179   TRACE("(%p)\n", reserved);
 180
 181   /*
 182    * The first duty of the OleInitialize is to initialize the COM libraries.
 183    */
 184   hr = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
 185
 186   /*
 187    * If the CoInitializeEx call failed, the OLE libraries can't be
 188    * initialized.
 189    */
 190   if (FAILED(hr))
 191     return hr;
 192
 193   if (!COM_CurrentInfo()->ole_inits)
 194     hr = S_OK;
 195
 196   /*
 197    * Then, it has to initialize the OLE specific modules.
 198    * This includes:
 199    *     Clipboard
 200    *     Drag and Drop
 201    *     Object linking and Embedding
 202    *     In-place activation
 203    */
 204   if (!COM_CurrentInfo()->ole_inits++ &&
 205       InterlockedIncrement(&OLE_moduleLockCount) == 1)
 206   {
 207     /*
 208      * Initialize the libraries.
 209      */
 210     TRACE("() - Initializing the OLE libraries\n");
 211
 212     /*
 213      * OLE Clipboard
 214      */
 215     OLEClipbrd_Initialize();
 216
 217     /*
 218      * Drag and Drop
 219      */
 220     OLEDD_Initialize();
 221
 222     /*
 223      * OLE shared menu
 224      */
 225     OLEMenu_Initialize();
 226   }
 227
 228   return hr;
 229 }
 230
 231 /******************************************************************************
 232  *              OleUninitialize [OLE32.@]
 233  */
 234 void WINAPI OleUninitialize(void)
 235 {
 236   TRACE("()\n");
 237
 238   /*
 239    * If we hit the bottom of the lock stack, free the libraries.
 240    */
 241   if (!--COM_CurrentInfo()->ole_inits && !InterlockedDecrement(&OLE_moduleLockCount))
 242   {
 243     /*
 244      * Actually free the libraries.
 245      */
 246     TRACE("() - Freeing the last reference count\n");
 247
 248     /*
 249      * OLE Clipboard
 250      */
 251     OLEClipbrd_UnInitialize();
 252
 253     /*
 254      * OLE shared menu
 255      */
 256     OLEMenu_UnInitialize();
 257   }
 258
 259   /*
 260    * Then, uninitialize the COM libraries.
 261    */
 262   CoUninitialize();
 263 }
 264
 265 /******************************************************************************
 266  *              OleInitializeWOW        [OLE32.@]
 267  */
 268 HRESULT WINAPI OleInitializeWOW(DWORD x, DWORD y) {
 269         FIXME("(0x%08x, 0x%08x),stub!\n",x, y);
 270         return 0;
 271 }
 272
 273 /*************************************************************
 274  *           get_droptarget_handle
 275  *
 276  * Retrieve a handle to the map containing the marshalled IDropTarget.
 277  * This handle belongs to the process that called RegisterDragDrop.
 278  * See get_droptarget_local_handle().
 279  */
 280 static inline HANDLE get_droptarget_handle(HWND hwnd)
 281 {
 282     return GetPropW(hwnd, prop_marshalleddroptarget);
 283 }
 284
 285 /*************************************************************
 286  *           is_droptarget
 287  *
 288  * Is the window a droptarget.
 289  */
 290 static inline BOOL is_droptarget(HWND hwnd)
 291 {
 292     return get_droptarget_handle(hwnd) ? TRUE : FALSE;
 293 }
 294
 295 /*************************************************************
 296  *           get_droptarget_local_handle
 297  *
 298  * Retrieve a handle to the map containing the marshalled IDropTarget.
 299  * The handle should be closed when finished with.
 300  */
 301 static HANDLE get_droptarget_local_handle(HWND hwnd)
 302 {
 303     HANDLE handle, local_handle = 0;
 304
 305     handle = get_droptarget_handle(hwnd);
 306
 307     if(handle)
 308     {
 309         DWORD pid;
 310         HANDLE process;
 311
 312         GetWindowThreadProcessId(hwnd, &pid);
 313         process = OpenProcess(PROCESS_DUP_HANDLE, FALSE, pid);
 314         if(process)
 315         {
 316             DuplicateHandle(process, handle, GetCurrentProcess(), &local_handle, 0, FALSE, DUPLICATE_SAME_ACCESS);
 317             CloseHandle(process);
 318         }
 319     }
 320     return local_handle;
 321 }
 322
 323 /***********************************************************************
 324  *     create_map_from_stream
 325  *
 326  * Helper for RegisterDragDrop.  Creates a file mapping object
 327  * with the contents of the provided stream.  The stream must
 328  * be a global memory backed stream.
 329  */
 330 static HRESULT create_map_from_stream(IStream *stream, HANDLE *map)
 331 {
 332     HGLOBAL hmem;
 333     DWORD size;
 334     HRESULT hr;
 335     void *data;
 336
 337     hr = GetHGlobalFromStream(stream, &hmem);
 338     if(FAILED(hr)) return hr;
 339
 340     size = GlobalSize(hmem);
 341     *map = CreateFileMappingW(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, size, NULL);
 342     if(!*map) return E_OUTOFMEMORY;
 343
 344     data = MapViewOfFile(*map, FILE_MAP_WRITE, 0, 0, size);
 345     memcpy(data, GlobalLock(hmem), size);
 346     GlobalUnlock(hmem);
 347     UnmapViewOfFile(data);
 348     return S_OK;
 349 }
 350
 351 /***********************************************************************
 352  *     create_stream_from_map
 353  *
 354  * Creates a stream from the provided map.
 355  */
 356 static HRESULT create_stream_from_map(HANDLE map, IStream **stream)
 357 {
 358     HRESULT hr = E_OUTOFMEMORY;
 359     HGLOBAL hmem;
 360     void *data;
 361     MEMORY_BASIC_INFORMATION info;
 362
 363     data = MapViewOfFile(map, FILE_MAP_READ, 0, 0, 0);
 364     if(!data) return hr;
 365
 366     VirtualQuery(data, &info, sizeof(info));
 367     TRACE("size %d\n", (int)info.RegionSize);
 368
 369     hmem = GlobalAlloc(GMEM_MOVEABLE, info.RegionSize);
 370     if(hmem)
 371     {
 372         memcpy(GlobalLock(hmem), data, info.RegionSize);
 373         GlobalUnlock(hmem);
 374         hr = CreateStreamOnHGlobal(hmem, TRUE, stream);
 375     }
 376     UnmapViewOfFile(data);
 377     return hr;
 378 }
 379
 380 /***********************************************************************
 381  *     get_droptarget_pointer
 382  *
 383  * Retrieves the marshalled IDropTarget from the window.
 384  */
 385 static IDropTarget* get_droptarget_pointer(HWND hwnd)
 386 {
 387     IDropTarget *droptarget = NULL;
 388     HANDLE map;
 389     IStream *stream;
 390
 391     map = get_droptarget_local_handle(hwnd);
 392     if(!map) return NULL;
 393
 394     if(SUCCEEDED(create_stream_from_map(map, &stream)))
 395     {
 396         CoUnmarshalInterface(stream, &IID_IDropTarget, (void**)&droptarget);
 397         IStream_Release(stream);
 398     }
 399     CloseHandle(map);
 400     return droptarget;
 401 }
 402
 403 /***********************************************************************
 404  *           RegisterDragDrop (OLE32.@)
 405  */
 406 HRESULT WINAPI RegisterDragDrop(HWND hwnd, LPDROPTARGET pDropTarget)
 407 {
 408   DWORD pid = 0;
 409   HRESULT hr;
 410   IStream *stream;
 411   HANDLE map;
 412
 413   TRACE("(%p,%p)\n", hwnd, pDropTarget);
 414
 415   if (!COM_CurrentApt())
 416   {
 417     ERR("COM not initialized\n");
 418     return E_OUTOFMEMORY;
 419   }
 420
 421   if (!pDropTarget)
 422     return E_INVALIDARG;
 423
 424   if (!IsWindow(hwnd))
 425   {
 426     ERR("invalid hwnd %p\n", hwnd);
 427     return DRAGDROP_E_INVALIDHWND;
 428   }
 429
 430   /* block register for other processes windows */
 431   GetWindowThreadProcessId(hwnd, &pid);
 432   if (pid != GetCurrentProcessId())
 433   {
 434     FIXME("register for another process windows is disabled\n");
 435     return DRAGDROP_E_INVALIDHWND;
 436   }
 437
 438   /* check if the window is already registered */
 439   if (is_droptarget(hwnd))
 440     return DRAGDROP_E_ALREADYREGISTERED;
 441
 442   /*
 443    * Marshal the drop target pointer into a shared memory map and
 444    * store the map's handle in a Wine specific window prop.  We also
 445    * store the drop target pointer itself in the
 446    * "OleDropTargetInterface" prop for compatibility with Windows.
 447    */
 448
 449   hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
 450   if(FAILED(hr)) return hr;
 451
 452   hr = CoMarshalInterface(stream, &IID_IDropTarget, (IUnknown*)pDropTarget, MSHCTX_LOCAL, NULL, MSHLFLAGS_TABLESTRONG);
 453   if(SUCCEEDED(hr))
 454   {
 455     hr = create_map_from_stream(stream, &map);
 456     if(SUCCEEDED(hr))
 457     {
 458       IDropTarget_AddRef(pDropTarget);
 459       SetPropW(hwnd, prop_oledroptarget, pDropTarget);
 460       SetPropW(hwnd, prop_marshalleddroptarget, map);
 461     }
 462     else
 463     {
 464       LARGE_INTEGER zero;
 465       zero.QuadPart = 0;
 466       IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL);
 467       CoReleaseMarshalData(stream);
 468     }
 469   }
 470   IStream_Release(stream);
 471
 472   return hr;
 473 }
 474
 475 /***********************************************************************
 476  *           RevokeDragDrop (OLE32.@)
 477  */
 478 HRESULT WINAPI RevokeDragDrop(HWND hwnd)
 479 {
 480   HANDLE map;
 481   IStream *stream;
 482   IDropTarget *drop_target;
 483   HRESULT hr;
 484
 485   TRACE("(%p)\n", hwnd);
 486
 487   if (!IsWindow(hwnd))
 488   {
 489     ERR("invalid hwnd %p\n", hwnd);
 490     return DRAGDROP_E_INVALIDHWND;
 491   }
 492
 493   /* no registration data */
 494   if (!(map = get_droptarget_handle(hwnd)))
 495     return DRAGDROP_E_NOTREGISTERED;
 496
 497   drop_target = GetPropW(hwnd, prop_oledroptarget);
 498   if(drop_target) IDropTarget_Release(drop_target);
 499
 500   RemovePropW(hwnd, prop_oledroptarget);
 501   RemovePropW(hwnd, prop_marshalleddroptarget);
 502
 503   hr = create_stream_from_map(map, &stream);
 504   if(SUCCEEDED(hr))
 505   {
 506       CoReleaseMarshalData(stream);
 507       IStream_Release(stream);
 508   }
 509   CloseHandle(map);
 510
 511   return hr;
 512 }
 513
 514 /***********************************************************************
 515  *           OleRegGetUserType (OLE32.@)
 516  *
 517  * This implementation of OleRegGetUserType ignores the dwFormOfType
 518  * parameter and always returns the full name of the object. This is
 519  * not too bad since this is the case for many objects because of the
 520  * way they are registered.
 521  */
 522 HRESULT WINAPI OleRegGetUserType(
 523         REFCLSID clsid,
 524         DWORD dwFormOfType,
 525         LPOLESTR* pszUserType)
 526 {
 527   WCHAR   keyName[60];
 528   DWORD   dwKeyType;
 529   DWORD   cbData;
 530   HKEY    clsidKey;
 531   LONG    hres;
 532
 533   /*
 534    * Initialize the out parameter.
 535    */
 536   *pszUserType = NULL;
 537
 538   /*
 539    * Build the key name we're looking for
 540    */
 541   sprintfW( keyName, clsidfmtW,
 542             clsid->Data1, clsid->Data2, clsid->Data3,
 543             clsid->Data4[0], clsid->Data4[1], clsid->Data4[2], clsid->Data4[3],
 544             clsid->Data4[4], clsid->Data4[5], clsid->Data4[6], clsid->Data4[7] );
 545
 546   TRACE("(%s, %d, %p)\n", debugstr_w(keyName), dwFormOfType, pszUserType);
 547
 548   /*
 549    * Open the class id Key
 550    */
 551   hres = RegOpenKeyW(HKEY_CLASSES_ROOT,
 552                      keyName,
 553                      &clsidKey);
 554
 555   if (hres != ERROR_SUCCESS)
 556     return REGDB_E_CLASSNOTREG;
 557
 558   /*
 559    * Retrieve the size of the name string.
 560    */
 561   cbData = 0;
 562
 563   hres = RegQueryValueExW(clsidKey,
 564                           emptyW,
 565                           NULL,
 566                           &dwKeyType,
 567                           NULL,
 568                           &cbData);
 569
 570   if (hres!=ERROR_SUCCESS)
 571   {
 572     RegCloseKey(clsidKey);
 573     return REGDB_E_READREGDB;
 574   }
 575
 576   /*
 577    * Allocate a buffer for the registry value.
 578    */
 579   *pszUserType = CoTaskMemAlloc(cbData);
 580
 581   if (*pszUserType==NULL)
 582   {
 583     RegCloseKey(clsidKey);
 584     return E_OUTOFMEMORY;
 585   }
 586
 587   hres = RegQueryValueExW(clsidKey,
 588                           emptyW,
 589                           NULL,
 590                           &dwKeyType,
 591                           (LPBYTE) *pszUserType,
 592                           &cbData);
 593
 594   RegCloseKey(clsidKey);
 595
 596   if (hres != ERROR_SUCCESS)
 597   {
 598     CoTaskMemFree(*pszUserType);
 599     *pszUserType = NULL;
 600
 601     return REGDB_E_READREGDB;
 602   }
 603
 604   return S_OK;
 605 }
 606
 607 /***********************************************************************
 608  * DoDragDrop [OLE32.@]
 609  */
 610 HRESULT WINAPI DoDragDrop (
 611   IDataObject *pDataObject,  /* [in] ptr to the data obj           */
 612   IDropSource* pDropSource,  /* [in] ptr to the source obj         */
 613   DWORD       dwOKEffect,    /* [in] effects allowed by the source */
 614   DWORD       *pdwEffect)    /* [out] ptr to effects of the source */
 615 {
 616   static const WCHAR trackerW[] = {'T','r','a','c','k','e','r','W','i','n','d','o','w',0};
 617   TrackerWindowInfo trackerInfo;
 618   HWND            hwndTrackWindow;
 619   MSG             msg;
 620
 621   TRACE("(%p, %p, %d, %p)\n", pDataObject, pDropSource, dwOKEffect, pdwEffect);
 622
 623   if (!pDataObject || !pDropSource || !pdwEffect)
 624       return E_INVALIDARG;
 625
 626   /*
 627    * Setup the drag n drop tracking window.
 628    */
 629
 630   trackerInfo.dataObject        = pDataObject;
 631   trackerInfo.dropSource        = pDropSource;
 632   trackerInfo.dwOKEffect        = dwOKEffect;
 633   trackerInfo.pdwEffect         = pdwEffect;
 634   trackerInfo.trackingDone      = FALSE;
 635   trackerInfo.escPressed        = FALSE;
 636   trackerInfo.curDragTargetHWND = 0;
 637   trackerInfo.curTargetHWND     = 0;
 638   trackerInfo.curDragTarget     = 0;
 639
 640   hwndTrackWindow = CreateWindowW(OLEDD_DRAGTRACKERCLASS, trackerW,
 641                                   WS_POPUP, CW_USEDEFAULT, CW_USEDEFAULT,
 642                                   CW_USEDEFAULT, CW_USEDEFAULT, 0, 0, 0,
 643                                   &trackerInfo);
 644
 645   if (hwndTrackWindow)
 646   {
 647     /*
 648      * Capture the mouse input
 649      */
 650     SetCapture(hwndTrackWindow);
 651
 652     msg.message = 0;
 653
 654     /*
 655      * Pump messages. All mouse input should go to the capture window.
 656      */
 657     while (!trackerInfo.trackingDone && GetMessageW(&msg, 0, 0, 0) )
 658     {
 659       trackerInfo.curMousePos.x = msg.pt.x;
 660       trackerInfo.curMousePos.y = msg.pt.y;
 661       trackerInfo.dwKeyState = OLEDD_GetButtonState();
 662
 663       if ( (msg.message >= WM_KEYFIRST) &&
 664            (msg.message <= WM_KEYLAST) )
 665       {
 666         /*
 667          * When keyboard messages are sent to windows on this thread, we
 668          * want to ignore notify the drop source that the state changed.
 669          * in the case of the Escape key, we also notify the drop source
 670          * we give it a special meaning.
 671          */
 672         if ( (msg.message==WM_KEYDOWN) &&
 673              (msg.wParam==VK_ESCAPE) )
 674         {
 675           trackerInfo.escPressed = TRUE;
 676         }
 677
 678         /*
 679          * Notify the drop source.
 680          */
 681         OLEDD_TrackStateChange(&trackerInfo);
 682       }
 683       else
 684       {
 685         /*
 686          * Dispatch the messages only when it's not a keyboard message.
 687          */
 688         DispatchMessageW(&msg);
 689       }
 690     }
 691
 692     /* re-post the quit message to outer message loop */
 693     if (msg.message == WM_QUIT)
 694         PostQuitMessage(msg.wParam);
 695     /*
 696      * Destroy the temporary window.
 697      */
 698     DestroyWindow(hwndTrackWindow);
 699
 700     return trackerInfo.returnValue;
 701   }
 702
 703   return E_FAIL;
 704 }
 705
 706 /***********************************************************************
 707  * OleQueryLinkFromData [OLE32.@]
 708  */
 709 HRESULT WINAPI OleQueryLinkFromData(
 710   IDataObject* pSrcDataObject)
 711 {
 712   FIXME("(%p),stub!\n", pSrcDataObject);
 713   return S_FALSE;
 714 }
 715
 716 /***********************************************************************
 717  * OleRegGetMiscStatus [OLE32.@]
 718  */
 719 HRESULT WINAPI OleRegGetMiscStatus(
 720   REFCLSID clsid,
 721   DWORD    dwAspect,
 722   DWORD*   pdwStatus)
 723 {
 724   static const WCHAR miscstatusW[] = {'M','i','s','c','S','t','a','t','u','s',0};
 725   static const WCHAR dfmtW[] = {'%','d',0};
 726   WCHAR   keyName[60];
 727   HKEY    clsidKey;
 728   HKEY    miscStatusKey;
 729   HKEY    aspectKey;
 730   LONG    result;
 731
 732   /*
 733    * Initialize the out parameter.
 734    */
 735   *pdwStatus = 0;
 736
 737   /*
 738    * Build the key name we're looking for
 739    */
 740   sprintfW( keyName, clsidfmtW,
 741             clsid->Data1, clsid->Data2, clsid->Data3,
 742             clsid->Data4[0], clsid->Data4[1], clsid->Data4[2], clsid->Data4[3],
 743             clsid->Data4[4], clsid->Data4[5], clsid->Data4[6], clsid->Data4[7] );
 744
 745   TRACE("(%s, %d, %p)\n", debugstr_w(keyName), dwAspect, pdwStatus);
 746
 747   /*
 748    * Open the class id Key
 749    */
 750   result = RegOpenKeyW(HKEY_CLASSES_ROOT,
 751                        keyName,
 752                        &clsidKey);
 753
 754   if (result != ERROR_SUCCESS)
 755     return REGDB_E_CLASSNOTREG;
 756
 757   /*
 758    * Get the MiscStatus
 759    */
 760   result = RegOpenKeyW(clsidKey,
 761                        miscstatusW,
 762                        &miscStatusKey);
 763
 764
 765   if (result != ERROR_SUCCESS)
 766   {
 767     RegCloseKey(clsidKey);
 768     return REGDB_E_READREGDB;
 769   }
 770
 771   /*
 772    * Read the default value
 773    */
 774   OLEUTL_ReadRegistryDWORDValue(miscStatusKey, pdwStatus);
 775
 776   /*
 777    * Open the key specific to the requested aspect.
 778    */
 779   sprintfW(keyName, dfmtW, dwAspect);
 780
 781   result = RegOpenKeyW(miscStatusKey,
 782                        keyName,
 783                        &aspectKey);
 784
 785   if (result == ERROR_SUCCESS)
 786   {
 787     OLEUTL_ReadRegistryDWORDValue(aspectKey, pdwStatus);
 788     RegCloseKey(aspectKey);
 789   }
 790
 791   /*
 792    * Cleanup
 793    */
 794   RegCloseKey(miscStatusKey);
 795   RegCloseKey(clsidKey);
 796
 797   return S_OK;
 798 }
 799
 800 static HRESULT EnumOLEVERB_Construct(HKEY hkeyVerb, ULONG index, IEnumOLEVERB **ppenum);
 801
 802 typedef struct
 803 {
 804     const IEnumOLEVERBVtbl *lpvtbl;
 805     LONG ref;
 806
 807     HKEY hkeyVerb;
 808     ULONG index;
 809 } EnumOLEVERB;
 810
 811 static HRESULT WINAPI EnumOLEVERB_QueryInterface(
 812     IEnumOLEVERB *iface, REFIID riid, void **ppv)
 813 {
 814     TRACE("(%s, %p)\n", debugstr_guid(riid), ppv);
 815     if (IsEqualIID(riid, &IID_IUnknown) ||
 816         IsEqualIID(riid, &IID_IEnumOLEVERB))
 817     {
 818         IUnknown_AddRef(iface);
 819         *ppv = iface;
 820         return S_OK;
 821     }
 822     return E_NOINTERFACE;
 823 }
 824
 825 static ULONG WINAPI EnumOLEVERB_AddRef(
 826     IEnumOLEVERB *iface)
 827 {
 828     EnumOLEVERB *This = (EnumOLEVERB *)iface;
 829     TRACE("()\n");
 830     return InterlockedIncrement(&This->ref);
 831 }
 832
 833 static ULONG WINAPI EnumOLEVERB_Release(
 834     IEnumOLEVERB *iface)
 835 {
 836     EnumOLEVERB *This = (EnumOLEVERB *)iface;
 837     LONG refs = InterlockedDecrement(&This->ref);
 838     TRACE("()\n");
 839     if (!refs)
 840     {
 841         RegCloseKey(This->hkeyVerb);
 842         HeapFree(GetProcessHeap(), 0, This);
 843     }
 844     return refs;
 845 }
 846
 847 static HRESULT WINAPI EnumOLEVERB_Next(
 848     IEnumOLEVERB *iface, ULONG celt, LPOLEVERB rgelt,
 849     ULONG *pceltFetched)
 850 {
 851     EnumOLEVERB *This = (EnumOLEVERB *)iface;
 852     HRESULT hr = S_OK;
 853
 854     TRACE("(%d, %p, %p)\n", celt, rgelt, pceltFetched);
 855
 856     if (pceltFetched)
 857         *pceltFetched = 0;
 858
 859     for (; celt; celt--, rgelt++)
 860     {
 861         WCHAR wszSubKey[20];
 862         LONG cbData;
 863         LPWSTR pwszOLEVERB;
 864         LPWSTR pwszMenuFlags;
 865         LPWSTR pwszAttribs;
 866         LONG res = RegEnumKeyW(This->hkeyVerb, This->index, wszSubKey, sizeof(wszSubKey)/sizeof(wszSubKey[0]));
 867         if (res == ERROR_NO_MORE_ITEMS)
 868         {
 869             hr = S_FALSE;
 870             break;
 871         }
 872         else if (res != ERROR_SUCCESS)
 873         {
 874             ERR("RegEnumKeyW failed with error %d\n", res);
 875             hr = REGDB_E_READREGDB;
 876             break;
 877         }
 878         res = RegQueryValueW(This->hkeyVerb, wszSubKey, NULL, &cbData);
 879         if (res != ERROR_SUCCESS)
 880         {
 881             ERR("RegQueryValueW failed with error %d\n", res);
 882             hr = REGDB_E_READREGDB;
 883             break;
 884         }
 885         pwszOLEVERB = CoTaskMemAlloc(cbData);
 886         if (!pwszOLEVERB)
 887         {
 888             hr = E_OUTOFMEMORY;
 889             break;
 890         }
 891         res = RegQueryValueW(This->hkeyVerb, wszSubKey, pwszOLEVERB, &cbData);
 892         if (res != ERROR_SUCCESS)
 893         {
 894             ERR("RegQueryValueW failed with error %d\n", res);
 895             hr = REGDB_E_READREGDB;
 896             CoTaskMemFree(pwszOLEVERB);
 897             break;
 898         }
 899
 900         TRACE("verb string: %s\n", debugstr_w(pwszOLEVERB));
 901         pwszMenuFlags = strchrW(pwszOLEVERB, ',');
 902         if (!pwszMenuFlags)
 903         {
 904             hr = OLEOBJ_E_INVALIDVERB;
 905             CoTaskMemFree(pwszOLEVERB);
 906             break;
 907         }
 908         /* nul terminate the name string and advance to first character */
 909         *pwszMenuFlags = '\0';
 910         pwszMenuFlags++;
 911         pwszAttribs = strchrW(pwszMenuFlags, ',');
 912         if (!pwszAttribs)
 913         {
 914             hr = OLEOBJ_E_INVALIDVERB;
 915             CoTaskMemFree(pwszOLEVERB);
 916             break;
 917         }
 918         /* nul terminate the menu string and advance to first character */
 919         *pwszAttribs = '\0';
 920         pwszAttribs++;
 921
 922         /* fill out structure for this verb */
 923         rgelt->lVerb = atolW(wszSubKey);
 924         rgelt->lpszVerbName = pwszOLEVERB; /* user should free */
 925         rgelt->fuFlags = atolW(pwszMenuFlags);
 926         rgelt->grfAttribs = atolW(pwszAttribs);
 927
 928         if (pceltFetched)
 929             (*pceltFetched)++;
 930         This->index++;
 931     }
 932     return hr;
 933 }
 934
 935 static HRESULT WINAPI EnumOLEVERB_Skip(
 936     IEnumOLEVERB *iface, ULONG celt)
 937 {
 938     EnumOLEVERB *This = (EnumOLEVERB *)iface;
 939
 940     TRACE("(%d)\n", celt);
 941
 942     This->index += celt;
 943     return S_OK;
 944 }
 945
 946 static HRESULT WINAPI EnumOLEVERB_Reset(
 947     IEnumOLEVERB *iface)
 948 {
 949     EnumOLEVERB *This = (EnumOLEVERB *)iface;
 950
 951     TRACE("()\n");
 952
 953     This->index = 0;
 954     return S_OK;
 955 }
 956
 957 static HRESULT WINAPI EnumOLEVERB_Clone(
 958     IEnumOLEVERB *iface,
 959     IEnumOLEVERB **ppenum)
 960 {
 961     EnumOLEVERB *This = (EnumOLEVERB *)iface;
 962     HKEY hkeyVerb;
 963     TRACE("(%p)\n", ppenum);
 964     if (!DuplicateHandle(GetCurrentProcess(), This->hkeyVerb, GetCurrentProcess(), (HANDLE *)&hkeyVerb, 0, FALSE, DUPLICATE_SAME_ACCESS))
 965         return HRESULT_FROM_WIN32(GetLastError());
 966     return EnumOLEVERB_Construct(hkeyVerb, This->index, ppenum);
 967 }
 968
 969 static const IEnumOLEVERBVtbl EnumOLEVERB_VTable =
 970 {
 971     EnumOLEVERB_QueryInterface,
 972     EnumOLEVERB_AddRef,
 973     EnumOLEVERB_Release,
 974     EnumOLEVERB_Next,
 975     EnumOLEVERB_Skip,
 976     EnumOLEVERB_Reset,
 977     EnumOLEVERB_Clone
 978 };
 979
 980 static HRESULT EnumOLEVERB_Construct(HKEY hkeyVerb, ULONG index, IEnumOLEVERB **ppenum)
 981 {
 982     EnumOLEVERB *This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
 983     if (!This)
 984     {
 985         RegCloseKey(hkeyVerb);
 986         return E_OUTOFMEMORY;
 987     }
 988     This->lpvtbl = &EnumOLEVERB_VTable;
 989     This->ref = 1;
 990     This->index = index;
 991     This->hkeyVerb = hkeyVerb;
 992     *ppenum = (IEnumOLEVERB *)&This->lpvtbl;
 993     return S_OK;
 994 }
 995
 996 /***********************************************************************
 997  *           OleRegEnumVerbs    [OLE32.@]
 998  *
 999  * Enumerates verbs associated with a class stored in the registry.
1000  *
1001  * PARAMS
1002  *  clsid  [I] Class ID to enumerate the verbs for.
1003  *  ppenum [O] Enumerator.
1004  *
1005  * RETURNS
1006  *  S_OK: Success.
1007  *  REGDB_E_CLASSNOTREG: The specified class does not have a key in the registry.
1008  *  REGDB_E_READREGDB: The class key could not be opened for some other reason.
1009  *  OLE_E_REGDB_KEY: The Verb subkey for the class is not present.
1010  *  OLEOBJ_E_NOVERBS: The Verb subkey for the class is empty.
1011  */
1012 HRESULT WINAPI OleRegEnumVerbs (REFCLSID clsid, LPENUMOLEVERB* ppenum)
1013 {
1014     LONG res;
1015     HKEY hkeyVerb;
1016     DWORD dwSubKeys;
1017     static const WCHAR wszVerb[] = {'V','e','r','b',0};
1018
1019     TRACE("(%s, %p)\n", debugstr_guid(clsid), ppenum);
1020
1021     res = COM_OpenKeyForCLSID(clsid, wszVerb, KEY_READ, &hkeyVerb);
1022     if (FAILED(res))
1023     {
1024         if (res == REGDB_E_CLASSNOTREG)
1025             ERR("CLSID %s not registered\n", debugstr_guid(clsid));
1026         else if (res == REGDB_E_KEYMISSING)
1027             ERR("no Verbs key for class %s\n", debugstr_guid(clsid));
1028         else
1029             ERR("failed to open Verbs key for CLSID %s with error %d\n",
1030                 debugstr_guid(clsid), res);
1031         return res;
1032     }
1033
1034     res = RegQueryInfoKeyW(hkeyVerb, NULL, NULL, NULL, &dwSubKeys, NULL,
1035                           NULL, NULL, NULL, NULL, NULL, NULL);
1036     if (res != ERROR_SUCCESS)
1037     {
1038         ERR("failed to get subkey count with error %d\n", GetLastError());
1039         return REGDB_E_READREGDB;
1040     }
1041
1042     if (!dwSubKeys)
1043     {
1044         WARN("class %s has no verbs\n", debugstr_guid(clsid));
1045         RegCloseKey(hkeyVerb);
1046         return OLEOBJ_E_NOVERBS;
1047     }
1048
1049     return EnumOLEVERB_Construct(hkeyVerb, 0, ppenum);
1050 }
1051
1052 /******************************************************************************
1053  *              OleSetContainedObject        [OLE32.@]
1054  */
1055 HRESULT WINAPI OleSetContainedObject(
1056   LPUNKNOWN pUnknown,
1057   BOOL      fContained)
1058 {
1059   IRunnableObject* runnable = NULL;
1060   HRESULT          hres;
1061
1062   TRACE("(%p,%x)\n", pUnknown, fContained);
1063
1064   hres = IUnknown_QueryInterface(pUnknown,
1065                                  &IID_IRunnableObject,
1066                                  (void**)&runnable);
1067
1068   if (SUCCEEDED(hres))
1069   {
1070     hres = IRunnableObject_SetContainedObject(runnable, fContained);
1071
1072     IRunnableObject_Release(runnable);
1073
1074     return hres;
1075   }
1076
1077   return S_OK;
1078 }
1079
1080 /******************************************************************************
1081  *              OleRun        [OLE32.@]
1082  *
1083  * Set the OLE object to the running state.
1084  *
1085  * PARAMS
1086  *  pUnknown [I] OLE object to run.
1087  *
1088  * RETURNS
1089  *  Success: S_OK.
1090  *  Failure: Any HRESULT code.
1091  */
1092 HRESULT WINAPI OleRun(LPUNKNOWN pUnknown)
1093 {
1094     IRunnableObject *runable;
1095     HRESULT hres;
1096
1097     TRACE("(%p)\n", pUnknown);
1098
1099     hres = IUnknown_QueryInterface(pUnknown, &IID_IRunnableObject, (void**)&runable);
1100     if (FAILED(hres))
1101         return S_OK; /* Appears to return no error. */
1102
1103     hres = IRunnableObject_Run(runable, NULL);
1104     IRunnableObject_Release(runable);
1105     return hres;
1106 }
1107
1108 /******************************************************************************
1109  *              OleLoad        [OLE32.@]
1110  */
1111 HRESULT WINAPI OleLoad(
1112   LPSTORAGE       pStg,
1113   REFIID          riid,
1114   LPOLECLIENTSITE pClientSite,
1115   LPVOID*         ppvObj)
1116 {
1117   IPersistStorage* persistStorage = NULL;
1118   IUnknown*        pUnk;
1119   IOleObject*      pOleObject      = NULL;
1120   STATSTG          storageInfo;
1121   HRESULT          hres;
1122
1123   TRACE("(%p, %s, %p, %p)\n", pStg, debugstr_guid(riid), pClientSite, ppvObj);
1124
1125   *ppvObj = NULL;
1126
1127   /*
1128    * TODO, Conversion ... OleDoAutoConvert
1129    */
1130
1131   /*
1132    * Get the class ID for the object.
1133    */
1134   hres = IStorage_Stat(pStg, &storageInfo, STATFLAG_NONAME);
1135
1136   /*
1137    * Now, try and create the handler for the object
1138    */
1139   hres = CoCreateInstance(&storageInfo.clsid,
1140                           NULL,
1141                           CLSCTX_INPROC_HANDLER|CLSCTX_INPROC_SERVER,
1142                           riid,
1143                           (void**)&pUnk);
1144
1145   /*
1146    * If that fails, as it will most times, load the default
1147    * OLE handler.
1148    */
1149   if (FAILED(hres))
1150   {
1151     hres = OleCreateDefaultHandler(&storageInfo.clsid,
1152                                    NULL,
1153                                    riid,
1154                                    (void**)&pUnk);
1155   }
1156
1157   /*
1158    * If we couldn't find a handler... this is bad. Abort the whole thing.
1159    */
1160   if (FAILED(hres))
1161     return hres;
1162
1163   if (pClientSite)
1164   {
1165     hres = IUnknown_QueryInterface(pUnk, &IID_IOleObject, (void **)&pOleObject);
1166     if (SUCCEEDED(hres))
1167     {
1168         DWORD dwStatus;
1169         hres = IOleObject_GetMiscStatus(pOleObject, DVASPECT_CONTENT, &dwStatus);
1170     }
1171   }
1172
1173   if (SUCCEEDED(hres))
1174     /*
1175      * Initialize the object with it's IPersistStorage interface.
1176      */
1177     hres = IOleObject_QueryInterface(pUnk,
1178                                      &IID_IPersistStorage,
1179                                      (void**)&persistStorage);
1180
1181   if (SUCCEEDED(hres))
1182   {
1183     hres = IPersistStorage_Load(persistStorage, pStg);
1184
1185     IPersistStorage_Release(persistStorage);
1186     persistStorage = NULL;
1187   }
1188
1189   if (SUCCEEDED(hres) && pClientSite)
1190     /*
1191      * Inform the new object of it's client site.
1192      */
1193     hres = IOleObject_SetClientSite(pOleObject, pClientSite);
1194
1195   /*
1196    * Cleanup interfaces used internally
1197    */
1198   if (pOleObject)
1199     IOleObject_Release(pOleObject);
1200
1201   if (SUCCEEDED(hres))
1202   {
1203     IOleLink *pOleLink;
1204     HRESULT hres1;
1205     hres1 = IUnknown_QueryInterface(pUnk, &IID_IOleLink, (void **)&pOleLink);
1206     if (SUCCEEDED(hres1))
1207     {
1208       FIXME("handle OLE link\n");
1209       IOleLink_Release(pOleLink);
1210     }
1211   }
1212
1213   if (FAILED(hres))
1214   {
1215     IUnknown_Release(pUnk);
1216     pUnk = NULL;
1217   }
1218
1219   *ppvObj = pUnk;
1220
1221   return hres;
1222 }
1223
1224 /***********************************************************************
1225  *           OleSave     [OLE32.@]
1226  */
1227 HRESULT WINAPI OleSave(
1228   LPPERSISTSTORAGE pPS,
1229   LPSTORAGE        pStg,
1230   BOOL             fSameAsLoad)
1231 {
1232   HRESULT hres;
1233   CLSID   objectClass;
1234
1235   TRACE("(%p,%p,%x)\n", pPS, pStg, fSameAsLoad);
1236
1237   /*
1238    * First, we transfer the class ID (if available)
1239    */
1240   hres = IPersistStorage_GetClassID(pPS, &objectClass);
1241
1242   if (SUCCEEDED(hres))
1243   {
1244     WriteClassStg(pStg, &objectClass);
1245   }
1246
1247   /*
1248    * Then, we ask the object to save itself to the
1249    * storage. If it is successful, we commit the storage.
1250    */
1251   hres = IPersistStorage_Save(pPS, pStg, fSameAsLoad);
1252
1253   if (SUCCEEDED(hres))
1254   {
1255     IStorage_Commit(pStg,
1256                     STGC_DEFAULT);
1257   }
1258
1259   return hres;
1260 }
1261
1262
1263 /******************************************************************************
1264  *              OleLockRunning        [OLE32.@]
1265  */
1266 HRESULT WINAPI OleLockRunning(LPUNKNOWN pUnknown, BOOL fLock, BOOL fLastUnlockCloses)
1267 {
1268   IRunnableObject* runnable = NULL;
1269   HRESULT          hres;
1270
1271   TRACE("(%p,%x,%x)\n", pUnknown, fLock, fLastUnlockCloses);
1272
1273   hres = IUnknown_QueryInterface(pUnknown,
1274                                  &IID_IRunnableObject,
1275                                  (void**)&runnable);
1276
1277   if (SUCCEEDED(hres))
1278   {
1279     hres = IRunnableObject_LockRunning(runnable, fLock, fLastUnlockCloses);
1280
1281     IRunnableObject_Release(runnable);
1282
1283     return hres;
1284   }
1285
1286   return S_OK;
1287 }
1288
1289
1290 /**************************************************************************
1291  * Internal methods to manage the shared OLE menu in response to the
1292  * OLE***MenuDescriptor API
1293  */
1294
1295 /***
1296  * OLEMenu_Initialize()
1297  *
1298  * Initializes the OLEMENU data structures.
1299  */
1300 static void OLEMenu_Initialize(void)
1301 {
1302 }
1303
1304 /***
1305  * OLEMenu_UnInitialize()
1306  *
1307  * Releases the OLEMENU data structures.
1308  */
1309 static void OLEMenu_UnInitialize(void)
1310 {
1311 }
1312
1313 /*************************************************************************
1314  * OLEMenu_InstallHooks
1315  * Install thread scope message hooks for WH_GETMESSAGE and WH_CALLWNDPROC
1316  *
1317  * RETURNS: TRUE if message hooks were successfully installed
1318  *          FALSE on failure
1319  */
1320 static BOOL OLEMenu_InstallHooks( DWORD tid )
1321 {
1322   OleMenuHookItem *pHookItem;
1323
1324   /* Create an entry for the hook table */
1325   if ( !(pHookItem = HeapAlloc(GetProcessHeap(), 0,
1326                                sizeof(OleMenuHookItem)) ) )
1327     return FALSE;
1328
1329   pHookItem->tid = tid;
1330   pHookItem->hHeap = GetProcessHeap();
1331   pHookItem->CallWndProc_hHook = NULL;
1332
1333   /* Install a thread scope message hook for WH_GETMESSAGE */
1334   pHookItem->GetMsg_hHook = SetWindowsHookExW( WH_GETMESSAGE, OLEMenu_GetMsgProc,
1335                                                0, GetCurrentThreadId() );
1336   if ( !pHookItem->GetMsg_hHook )
1337     goto CLEANUP;
1338
1339   /* Install a thread scope message hook for WH_CALLWNDPROC */
1340   pHookItem->CallWndProc_hHook = SetWindowsHookExW( WH_CALLWNDPROC, OLEMenu_CallWndProc,
1341                                                     0, GetCurrentThreadId() );
1342   if ( !pHookItem->CallWndProc_hHook )
1343     goto CLEANUP;
1344
1345   /* Insert the hook table entry */
1346   pHookItem->next = hook_list;
1347   hook_list = pHookItem;
1348
1349   return TRUE;
1350
1351 CLEANUP:
1352   /* Unhook any hooks */
1353   if ( pHookItem->GetMsg_hHook )
1354     UnhookWindowsHookEx( pHookItem->GetMsg_hHook );
1355   if ( pHookItem->CallWndProc_hHook )
1356     UnhookWindowsHookEx( pHookItem->CallWndProc_hHook );
1357   /* Release the hook table entry */
1358   HeapFree(pHookItem->hHeap, 0, pHookItem );
1359
1360   return FALSE;
1361 }
1362
1363 /*************************************************************************
1364  * OLEMenu_UnInstallHooks
1365  * UnInstall thread scope message hooks for WH_GETMESSAGE and WH_CALLWNDPROC
1366  *
1367  * RETURNS: TRUE if message hooks were successfully installed
1368  *          FALSE on failure
1369  */
1370 static BOOL OLEMenu_UnInstallHooks( DWORD tid )
1371 {
1372   OleMenuHookItem *pHookItem = NULL;
1373   OleMenuHookItem **ppHook = &hook_list;
1374
1375   while (*ppHook)
1376   {
1377       if ((*ppHook)->tid == tid)
1378       {
1379           pHookItem = *ppHook;
1380           *ppHook = pHookItem->next;
1381           break;
1382       }
1383       ppHook = &(*ppHook)->next;
1384   }
1385   if (!pHookItem) return FALSE;
1386
1387   /* Uninstall the hooks installed for this thread */
1388   if ( !UnhookWindowsHookEx( pHookItem->GetMsg_hHook ) )
1389     goto CLEANUP;
1390   if ( !UnhookWindowsHookEx( pHookItem->CallWndProc_hHook ) )
1391     goto CLEANUP;
1392
1393   /* Release the hook table entry */
1394   HeapFree(pHookItem->hHeap, 0, pHookItem );
1395
1396   return TRUE;
1397
1398 CLEANUP:
1399   /* Release the hook table entry */
1400   HeapFree(pHookItem->hHeap, 0, pHookItem );
1401
1402   return FALSE;
1403 }
1404
1405 /*************************************************************************
1406  * OLEMenu_IsHookInstalled
1407  * Tests if OLEMenu hooks have been installed for a thread
1408  *
1409  * RETURNS: The pointer and index of the hook table entry for the tid
1410  *          NULL and -1 for the index if no hooks were installed for this thread
1411  */
1412 static OleMenuHookItem * OLEMenu_IsHookInstalled( DWORD tid )
1413 {
1414   OleMenuHookItem *pHookItem;
1415
1416   /* Do a simple linear search for an entry whose tid matches ours.
1417    * We really need a map but efficiency is not a concern here. */
1418   for (pHookItem = hook_list; pHookItem; pHookItem = pHookItem->next)
1419   {
1420     if ( tid == pHookItem->tid )
1421       return pHookItem;
1422   }
1423
1424   return NULL;
1425 }
1426
1427 /***********************************************************************
1428  *           OLEMenu_FindMainMenuIndex
1429  *
1430  * Used by OLEMenu API to find the top level group a menu item belongs to.
1431  * On success pnPos contains the index of the item in the top level menu group
1432  *
1433  * RETURNS: TRUE if the ID was found, FALSE on failure
1434  */
1435 static BOOL OLEMenu_FindMainMenuIndex( HMENU hMainMenu, HMENU hPopupMenu, UINT *pnPos )
1436 {
1437   INT i, nItems;
1438
1439   nItems = GetMenuItemCount( hMainMenu );
1440
1441   for (i = 0; i < nItems; i++)
1442   {
1443     HMENU hsubmenu;
1444
1445     /*  Is the current item a submenu? */
1446     if ( (hsubmenu = GetSubMenu(hMainMenu, i)) )
1447     {
1448       /* If the handle is the same we're done */
1449       if ( hsubmenu == hPopupMenu )
1450       {
1451         if (pnPos)
1452           *pnPos = i;
1453         return TRUE;
1454       }
1455       /* Recursively search without updating pnPos */
1456       else if ( OLEMenu_FindMainMenuIndex( hsubmenu, hPopupMenu, NULL ) )
1457       {
1458         if (pnPos)
1459           *pnPos = i;
1460         return TRUE;
1461       }
1462     }
1463   }
1464
1465   return FALSE;
1466 }
1467
1468 /***********************************************************************
1469  *           OLEMenu_SetIsServerMenu
1470  *
1471  * Checks whether a popup menu belongs to a shared menu group which is
1472  * owned by the server, and sets the menu descriptor state accordingly.
1473  * All menu messages from these groups should be routed to the server.
1474  *
1475  * RETURNS: TRUE if the popup menu is part of a server owned group
1476  *          FALSE if the popup menu is part of a container owned group
1477  */
1478 static BOOL OLEMenu_SetIsServerMenu( HMENU hmenu, OleMenuDescriptor *pOleMenuDescriptor )
1479 {
1480   UINT nPos = 0, nWidth, i;
1481
1482   pOleMenuDescriptor->bIsServerItem = FALSE;
1483
1484   /* Don't bother searching if the popup is the combined menu itself */
1485   if ( hmenu == pOleMenuDescriptor->hmenuCombined )
1486     return FALSE;
1487
1488   /* Find the menu item index in the shared OLE menu that this item belongs to */
1489   if ( !OLEMenu_FindMainMenuIndex( pOleMenuDescriptor->hmenuCombined, hmenu,  &nPos ) )
1490     return FALSE;
1491
1492   /* The group widths array has counts for the number of elements
1493    * in the groups File, Edit, Container, Object, Window, Help.
1494    * The Edit, Object & Help groups belong to the server object
1495    * and the other three belong to the container.
1496    * Loop through the group widths and locate the group we are a member of.
1497    */
1498   for ( i = 0, nWidth = 0; i < 6; i++ )
1499   {
1500     nWidth += pOleMenuDescriptor->mgw.width[i];
1501     if ( nPos < nWidth )
1502     {
1503       /* Odd elements are server menu widths */
1504       pOleMenuDescriptor->bIsServerItem = (i%2) ? TRUE : FALSE;
1505       break;
1506     }
1507   }
1508
1509   return pOleMenuDescriptor->bIsServerItem;
1510 }
1511
1512 /*************************************************************************
1513  * OLEMenu_CallWndProc
1514  * Thread scope WH_CALLWNDPROC hook proc filter function (callback)
1515  * This is invoked from a message hook installed in OleSetMenuDescriptor.
1516  */
1517 static LRESULT CALLBACK OLEMenu_CallWndProc(INT code, WPARAM wParam, LPARAM lParam)
1518 {
1519   LPCWPSTRUCT pMsg;
1520   HOLEMENU hOleMenu = 0;
1521   OleMenuDescriptor *pOleMenuDescriptor = NULL;
1522   OleMenuHookItem *pHookItem = NULL;
1523   WORD fuFlags;
1524
1525   TRACE("%i, %04lx, %08lx\n", code, wParam, lParam );
1526
1527   /* Check if we're being asked to process the message */
1528   if ( HC_ACTION != code )
1529     goto NEXTHOOK;
1530
1531   /* Retrieve the current message being dispatched from lParam */
1532   pMsg = (LPCWPSTRUCT)lParam;
1533
1534   /* Check if the message is destined for a window we are interested in:
1535    * If the window has an OLEMenu property we may need to dispatch
1536    * the menu message to its active objects window instead. */
1537
1538   hOleMenu = GetPropW( pMsg->hwnd, prop_olemenuW );
1539   if ( !hOleMenu )
1540     goto NEXTHOOK;
1541
1542   /* Get the menu descriptor */
1543   pOleMenuDescriptor = GlobalLock( hOleMenu );
1544   if ( !pOleMenuDescriptor ) /* Bad descriptor! */
1545     goto NEXTHOOK;
1546
1547   /* Process menu messages */
1548   switch( pMsg->message )
1549   {
1550     case WM_INITMENU:
1551     {
1552       /* Reset the menu descriptor state */
1553       pOleMenuDescriptor->bIsServerItem = FALSE;
1554
1555       /* Send this message to the server as well */
1556       SendMessageW( pOleMenuDescriptor->hwndActiveObject,
1557                   pMsg->message, pMsg->wParam, pMsg->lParam );
1558       goto NEXTHOOK;
1559     }
1560
1561     case WM_INITMENUPOPUP:
1562     {
1563       /* Save the state for whether this is a server owned menu */
1564       OLEMenu_SetIsServerMenu( (HMENU)pMsg->wParam, pOleMenuDescriptor );
1565       break;
1566     }
1567
1568     case WM_MENUSELECT:
1569     {
1570       fuFlags = HIWORD(pMsg->wParam);  /* Get flags */
1571       if ( fuFlags & MF_SYSMENU )
1572          goto NEXTHOOK;
1573
1574       /* Save the state for whether this is a server owned popup menu */
1575       else if ( fuFlags & MF_POPUP )
1576         OLEMenu_SetIsServerMenu( (HMENU)pMsg->lParam, pOleMenuDescriptor );
1577
1578       break;
1579     }
1580
1581     case WM_DRAWITEM:
1582     {
1583       LPDRAWITEMSTRUCT lpdis = (LPDRAWITEMSTRUCT) pMsg->lParam;
1584       if ( pMsg->wParam != 0 || lpdis->CtlType != ODT_MENU )
1585         goto NEXTHOOK;  /* Not a menu message */
1586
1587       break;
1588     }
1589
1590     default:
1591       goto NEXTHOOK;
1592   }
1593
1594   /* If the message was for the server dispatch it accordingly */
1595   if ( pOleMenuDescriptor->bIsServerItem )
1596   {
1597     SendMessageW( pOleMenuDescriptor->hwndActiveObject,
1598                   pMsg->message, pMsg->wParam, pMsg->lParam );
1599   }
1600
1601 NEXTHOOK:
1602   if ( pOleMenuDescriptor )
1603     GlobalUnlock( hOleMenu );
1604
1605   /* Lookup the hook item for the current thread */
1606   if ( !( pHookItem = OLEMenu_IsHookInstalled( GetCurrentThreadId() ) ) )
1607   {
1608     /* This should never fail!! */
1609     WARN("could not retrieve hHook for current thread!\n" );
1610     return 0;
1611   }
1612
1613   /* Pass on the message to the next hooker */
1614   return CallNextHookEx( pHookItem->CallWndProc_hHook, code, wParam, lParam );
1615 }
1616
1617 /*************************************************************************
1618  * OLEMenu_GetMsgProc
1619  * Thread scope WH_GETMESSAGE hook proc filter function (callback)
1620  * This is invoked from a message hook installed in OleSetMenuDescriptor.
1621  */
1622 static LRESULT CALLBACK OLEMenu_GetMsgProc(INT code, WPARAM wParam, LPARAM lParam)
1623 {
1624   LPMSG pMsg;
1625   HOLEMENU hOleMenu = 0;
1626   OleMenuDescriptor *pOleMenuDescriptor = NULL;
1627   OleMenuHookItem *pHookItem = NULL;
1628   WORD wCode;
1629
1630   TRACE("%i, %04lx, %08lx\n", code, wParam, lParam );
1631
1632   /* Check if we're being asked to process a  messages */
1633   if ( HC_ACTION != code )
1634     goto NEXTHOOK;
1635
1636   /* Retrieve the current message being dispatched from lParam */
1637   pMsg = (LPMSG)lParam;
1638
1639   /* Check if the message is destined for a window we are interested in:
1640    * If the window has an OLEMenu property we may need to dispatch
1641    * the menu message to its active objects window instead. */
1642
1643   hOleMenu = GetPropW( pMsg->hwnd, prop_olemenuW );
1644   if ( !hOleMenu )
1645     goto NEXTHOOK;
1646
1647   /* Process menu messages */
1648   switch( pMsg->message )
1649   {
1650     case WM_COMMAND:
1651     {
1652       wCode = HIWORD(pMsg->wParam);  /* Get notification code */
1653       if ( wCode )
1654         goto NEXTHOOK;  /* Not a menu message */
1655       break;
1656     }
1657     default:
1658       goto NEXTHOOK;
1659   }
1660
1661   /* Get the menu descriptor */
1662   pOleMenuDescriptor = GlobalLock( hOleMenu );
1663   if ( !pOleMenuDescriptor ) /* Bad descriptor! */
1664     goto NEXTHOOK;
1665
1666   /* If the message was for the server dispatch it accordingly */
1667   if ( pOleMenuDescriptor->bIsServerItem )
1668   {
1669     /* Change the hWnd in the message to the active objects hWnd.
1670      * The message loop which reads this message will automatically
1671      * dispatch it to the embedded objects window. */
1672     pMsg->hwnd = pOleMenuDescriptor->hwndActiveObject;
1673   }
1674
1675 NEXTHOOK:
1676   if ( pOleMenuDescriptor )
1677     GlobalUnlock( hOleMenu );
1678
1679   /* Lookup the hook item for the current thread */
1680   if ( !( pHookItem = OLEMenu_IsHookInstalled( GetCurrentThreadId() ) ) )
1681   {
1682     /* This should never fail!! */
1683     WARN("could not retrieve hHook for current thread!\n" );
1684     return FALSE;
1685   }
1686
1687   /* Pass on the message to the next hooker */
1688   return CallNextHookEx( pHookItem->GetMsg_hHook, code, wParam, lParam );
1689 }
1690
1691 /***********************************************************************
1692  * OleCreateMenuDescriptor [OLE32.@]
1693  * Creates an OLE menu descriptor for OLE to use when dispatching
1694  * menu messages and commands.
1695  *
1696  * PARAMS:
1697  *    hmenuCombined  -  Handle to the objects combined menu
1698  *    lpMenuWidths   -  Pointer to array of 6 LONG's indicating menus per group
1699  *
1700  */
1701 HOLEMENU WINAPI OleCreateMenuDescriptor(
1702   HMENU                hmenuCombined,
1703   LPOLEMENUGROUPWIDTHS lpMenuWidths)
1704 {
1705   HOLEMENU hOleMenu;
1706   OleMenuDescriptor *pOleMenuDescriptor;
1707   int i;
1708
1709   if ( !hmenuCombined || !lpMenuWidths )
1710     return 0;
1711
1712   /* Create an OLE menu descriptor */
1713   if ( !(hOleMenu = GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT,
1714                                 sizeof(OleMenuDescriptor) ) ) )
1715   return 0;
1716
1717   pOleMenuDescriptor = GlobalLock( hOleMenu );
1718   if ( !pOleMenuDescriptor )
1719     return 0;
1720
1721   /* Initialize menu group widths and hmenu */
1722   for ( i = 0; i < 6; i++ )
1723     pOleMenuDescriptor->mgw.width[i] = lpMenuWidths->width[i];
1724
1725   pOleMenuDescriptor->hmenuCombined = hmenuCombined;
1726   pOleMenuDescriptor->bIsServerItem = FALSE;
1727   GlobalUnlock( hOleMenu );
1728
1729   return hOleMenu;
1730 }
1731
1732 /***********************************************************************
1733  * OleDestroyMenuDescriptor [OLE32.@]
1734  * Destroy the shared menu descriptor
1735  */
1736 HRESULT WINAPI OleDestroyMenuDescriptor(
1737   HOLEMENU hmenuDescriptor)
1738 {
1739   if ( hmenuDescriptor )
1740     GlobalFree( hmenuDescriptor );
1741         return S_OK;
1742 }
1743
1744 /***********************************************************************
1745  * OleSetMenuDescriptor [OLE32.@]
1746  * Installs or removes OLE dispatching code for the containers frame window.
1747  *
1748  * PARAMS
1749  *     hOleMenu         Handle to composite menu descriptor
1750  *     hwndFrame        Handle to containers frame window
1751  *     hwndActiveObject Handle to objects in-place activation window
1752  *     lpFrame          Pointer to IOleInPlaceFrame on containers window
1753  *     lpActiveObject   Pointer to IOleInPlaceActiveObject on active in-place object
1754  *
1755  * RETURNS
1756  *      S_OK                               - menu installed correctly
1757  *      E_FAIL, E_INVALIDARG, E_UNEXPECTED - failure
1758  *
1759  * FIXME
1760  *      The lpFrame and lpActiveObject parameters are currently ignored
1761  *      OLE should install context sensitive help F1 filtering for the app when
1762  *      these are non null.
1763  */
1764 HRESULT WINAPI OleSetMenuDescriptor(
1765   HOLEMENU               hOleMenu,
1766   HWND                   hwndFrame,
1767   HWND                   hwndActiveObject,
1768   LPOLEINPLACEFRAME        lpFrame,
1769   LPOLEINPLACEACTIVEOBJECT lpActiveObject)
1770 {
1771   OleMenuDescriptor *pOleMenuDescriptor = NULL;
1772
1773   /* Check args */
1774   if ( !hwndFrame || (hOleMenu && !hwndActiveObject) )
1775     return E_INVALIDARG;
1776
1777   if ( lpFrame || lpActiveObject )
1778   {
1779      FIXME("(%p, %p, %p, %p, %p), Context sensitive help filtering not implemented!\n",
1780         hOleMenu,
1781         hwndFrame,
1782         hwndActiveObject,
1783         lpFrame,
1784         lpActiveObject);
1785   }
1786
1787   /* Set up a message hook to intercept the containers frame window messages.
1788    * The message filter is responsible for dispatching menu messages from the
1789    * shared menu which are intended for the object.
1790    */
1791
1792   if ( hOleMenu )  /* Want to install dispatching code */
1793   {
1794     /* If OLEMenu hooks are already installed for this thread, fail
1795      * Note: This effectively means that OleSetMenuDescriptor cannot
1796      * be called twice in succession on the same frame window
1797      * without first calling it with a null hOleMenu to uninstall */
1798     if ( OLEMenu_IsHookInstalled( GetCurrentThreadId() ) )
1799   return E_FAIL;
1800
1801     /* Get the menu descriptor */
1802     pOleMenuDescriptor = GlobalLock( hOleMenu );
1803     if ( !pOleMenuDescriptor )
1804       return E_UNEXPECTED;
1805
1806     /* Update the menu descriptor */
1807     pOleMenuDescriptor->hwndFrame = hwndFrame;
1808     pOleMenuDescriptor->hwndActiveObject = hwndActiveObject;
1809
1810     GlobalUnlock( hOleMenu );
1811     pOleMenuDescriptor = NULL;
1812
1813     /* Add a menu descriptor windows property to the frame window */
1814     SetPropW( hwndFrame, prop_olemenuW, hOleMenu );
1815
1816     /* Install thread scope message hooks for WH_GETMESSAGE and WH_CALLWNDPROC */
1817     if ( !OLEMenu_InstallHooks( GetCurrentThreadId() ) )
1818       return E_FAIL;
1819   }
1820   else  /* Want to uninstall dispatching code */
1821   {
1822     /* Uninstall the hooks */
1823     if ( !OLEMenu_UnInstallHooks( GetCurrentThreadId() ) )
1824       return E_FAIL;
1825
1826     /* Remove the menu descriptor property from the frame window */
1827     RemovePropW( hwndFrame, prop_olemenuW );
1828   }
1829
1830   return S_OK;
1831 }
1832
1833 /******************************************************************************
1834  *              IsAccelerator        [OLE32.@]
1835  * Mostly copied from controls/menu.c TranslateAccelerator implementation
1836  */
1837 BOOL WINAPI IsAccelerator(HACCEL hAccel, int cAccelEntries, LPMSG lpMsg, WORD* lpwCmd)
1838 {
1839     LPACCEL lpAccelTbl;
1840     int i;
1841
1842     if(!lpMsg) return FALSE;
1843     if (!hAccel)
1844     {
1845         WARN_(accel)("NULL accel handle\n");
1846         return FALSE;
1847     }
1848     if((lpMsg->message != WM_KEYDOWN &&
1849         lpMsg->message != WM_SYSKEYDOWN &&
1850         lpMsg->message != WM_SYSCHAR &&
1851         lpMsg->message != WM_CHAR)) return FALSE;
1852     lpAccelTbl = HeapAlloc(GetProcessHeap(), 0, cAccelEntries * sizeof(ACCEL));
1853     if (NULL == lpAccelTbl)
1854     {
1855         return FALSE;
1856     }
1857     if (CopyAcceleratorTableW(hAccel, lpAccelTbl, cAccelEntries) != cAccelEntries)
1858     {
1859         WARN_(accel)("CopyAcceleratorTableW failed\n");
1860         HeapFree(GetProcessHeap(), 0, lpAccelTbl);
1861         return FALSE;
1862     }
1863
1864     TRACE_(accel)("hAccel=%p, cAccelEntries=%d,"
1865                 "msg->hwnd=%p, msg->message=%04x, wParam=%08lx, lParam=%08lx\n",
1866                 hAccel, cAccelEntries,
1867                 lpMsg->hwnd, lpMsg->message, lpMsg->wParam, lpMsg->lParam);
1868     for(i = 0; i < cAccelEntries; i++)
1869     {
1870         if(lpAccelTbl[i].key != lpMsg->wParam)
1871             continue;
1872
1873         if(lpMsg->message == WM_CHAR)
1874         {
1875             if(!(lpAccelTbl[i].fVirt & FALT) && !(lpAccelTbl[i].fVirt & FVIRTKEY))
1876             {
1877                 TRACE_(accel)("found accel for WM_CHAR: ('%c')\n", LOWORD(lpMsg->wParam) & 0xff);
1878                 goto found;
1879             }
1880         }
1881         else
1882         {
1883             if(lpAccelTbl[i].fVirt & FVIRTKEY)
1884             {
1885                 INT mask = 0;
1886                 TRACE_(accel)("found accel for virt_key %04lx (scan %04x)\n",
1887                                 lpMsg->wParam, HIWORD(lpMsg->lParam) & 0xff);
1888                 if(GetKeyState(VK_SHIFT) & 0x8000) mask |= FSHIFT;
1889                 if(GetKeyState(VK_CONTROL) & 0x8000) mask |= FCONTROL;
1890                 if(GetKeyState(VK_MENU) & 0x8000) mask |= FALT;
1891                 if(mask == (lpAccelTbl[i].fVirt & (FSHIFT | FCONTROL | FALT))) goto found;
1892                 TRACE_(accel)("incorrect SHIFT/CTRL/ALT-state\n");
1893             }
1894             else
1895             {
1896                 if(!(lpMsg->lParam & 0x01000000))  /* no special_key */
1897                 {
1898                     if((lpAccelTbl[i].fVirt & FALT) && (lpMsg->lParam & 0x20000000))
1899                     {                                                  /* ^^ ALT pressed */
1900                         TRACE_(accel)("found accel for Alt-%c\n", LOWORD(lpMsg->wParam) & 0xff);
1901                         goto found;
1902                     }
1903                 }
1904             }
1905         }
1906     }
1907
1908     WARN_(accel)("couldn't translate accelerator key\n");
1909     HeapFree(GetProcessHeap(), 0, lpAccelTbl);
1910     return FALSE;
1911
1912 found:
1913     if(lpwCmd) *lpwCmd = lpAccelTbl[i].cmd;
1914     HeapFree(GetProcessHeap(), 0, lpAccelTbl);
1915     return TRUE;
1916 }
1917
1918 /***********************************************************************
1919  * ReleaseStgMedium [OLE32.@]
1920  */
1921 void WINAPI ReleaseStgMedium(
1922   STGMEDIUM* pmedium)
1923 {
1924   switch (pmedium->tymed)
1925   {
1926     case TYMED_HGLOBAL:
1927     {
1928       if ( (pmedium->pUnkForRelease==0) &&
1929            (pmedium->u.hGlobal!=0) )
1930         GlobalFree(pmedium->u.hGlobal);
1931       break;
1932     }
1933     case TYMED_FILE:
1934     {
1935       if (pmedium->u.lpszFileName!=0)
1936       {
1937         if (pmedium->pUnkForRelease==0)
1938         {
1939           DeleteFileW(pmedium->u.lpszFileName);
1940         }
1941
1942         CoTaskMemFree(pmedium->u.lpszFileName);
1943       }
1944       break;
1945     }
1946     case TYMED_ISTREAM:
1947     {
1948       if (pmedium->u.pstm!=0)
1949       {
1950         IStream_Release(pmedium->u.pstm);
1951       }
1952       break;
1953     }
1954     case TYMED_ISTORAGE:
1955     {
1956       if (pmedium->u.pstg!=0)
1957       {
1958         IStorage_Release(pmedium->u.pstg);
1959       }
1960       break;
1961     }
1962     case TYMED_GDI:
1963     {
1964       if ( (pmedium->pUnkForRelease==0) &&
1965            (pmedium->u.hBitmap!=0) )
1966         DeleteObject(pmedium->u.hBitmap);
1967       break;
1968     }
1969     case TYMED_MFPICT:
1970     {
1971       if ( (pmedium->pUnkForRelease==0) &&
1972            (pmedium->u.hMetaFilePict!=0) )
1973       {
1974         LPMETAFILEPICT pMP = GlobalLock(pmedium->u.hMetaFilePict);
1975         DeleteMetaFile(pMP->hMF);
1976         GlobalUnlock(pmedium->u.hMetaFilePict);
1977         GlobalFree(pmedium->u.hMetaFilePict);
1978       }
1979       break;
1980     }
1981     case TYMED_ENHMF:
1982     {
1983       if ( (pmedium->pUnkForRelease==0) &&
1984            (pmedium->u.hEnhMetaFile!=0) )
1985       {
1986         DeleteEnhMetaFile(pmedium->u.hEnhMetaFile);
1987       }
1988       break;
1989     }
1990     case TYMED_NULL:
1991     default:
1992       break;
1993   }
1994   pmedium->tymed=TYMED_NULL;
1995
1996   /*
1997    * After cleaning up, the unknown is released
1998    */
1999   if (pmedium->pUnkForRelease!=0)
2000   {
2001     IUnknown_Release(pmedium->pUnkForRelease);
2002     pmedium->pUnkForRelease = 0;
2003   }
2004 }
2005
2006 /***
2007  * OLEDD_Initialize()
2008  *
2009  * Initializes the OLE drag and drop data structures.
2010  */
2011 static void OLEDD_Initialize(void)
2012 {
2013     WNDCLASSW wndClass;
2014
2015     ZeroMemory (&wndClass, sizeof(WNDCLASSW));
2016     wndClass.style         = CS_GLOBALCLASS;
2017     wndClass.lpfnWndProc   = OLEDD_DragTrackerWindowProc;
2018     wndClass.cbClsExtra    = 0;
2019     wndClass.cbWndExtra    = sizeof(TrackerWindowInfo*);
2020     wndClass.hCursor       = 0;
2021     wndClass.hbrBackground = 0;
2022     wndClass.lpszClassName = OLEDD_DRAGTRACKERCLASS;
2023
2024     RegisterClassW (&wndClass);
2025 }
2026
2027 /***
2028  * OLEDD_DragTrackerWindowProc()
2029  *
2030  * This method is the WindowProcedure of the drag n drop tracking
2031  * window. During a drag n Drop operation, an invisible window is created
2032  * to receive the user input and act upon it. This procedure is in charge
2033  * of this behavior.
2034  */
2035
2036 #define DRAG_TIMER_ID 1
2037
2038 static LRESULT WINAPI OLEDD_DragTrackerWindowProc(
2039                          HWND   hwnd,
2040                          UINT   uMsg,
2041                          WPARAM wParam,
2042                          LPARAM   lParam)
2043 {
2044   switch (uMsg)
2045   {
2046     case WM_CREATE:
2047     {
2048       LPCREATESTRUCTA createStruct = (LPCREATESTRUCTA)lParam;
2049
2050       SetWindowLongPtrW(hwnd, 0, (LONG_PTR)createStruct->lpCreateParams);
2051       SetTimer(hwnd, DRAG_TIMER_ID, 50, NULL);
2052
2053       break;
2054     }
2055     case WM_TIMER:
2056     case WM_MOUSEMOVE:
2057     {
2058       OLEDD_TrackMouseMove((TrackerWindowInfo*)GetWindowLongPtrA(hwnd, 0));
2059       break;
2060     }
2061     case WM_LBUTTONUP:
2062     case WM_MBUTTONUP:
2063     case WM_RBUTTONUP:
2064     case WM_LBUTTONDOWN:
2065     case WM_MBUTTONDOWN:
2066     case WM_RBUTTONDOWN:
2067     {
2068       OLEDD_TrackStateChange((TrackerWindowInfo*)GetWindowLongPtrA(hwnd, 0));
2069       break;
2070     }
2071     case WM_DESTROY:
2072     {
2073       KillTimer(hwnd, DRAG_TIMER_ID);
2074       break;
2075     }
2076   }
2077
2078   /*
2079    * This is a window proc after all. Let's call the default.
2080    */
2081   return DefWindowProcW (hwnd, uMsg, wParam, lParam);
2082 }
2083
2084 /***
2085  * OLEDD_TrackMouseMove()
2086  *
2087  * This method is invoked while a drag and drop operation is in effect.
2088  * it will generate the appropriate callbacks in the drop source
2089  * and drop target. It will also provide the expected feedback to
2090  * the user.
2091  *
2092  * params:
2093  *    trackerInfo - Pointer to the structure identifying the
2094  *                  drag & drop operation that is currently
2095  *                  active.
2096  */
2097 static void OLEDD_TrackMouseMove(TrackerWindowInfo* trackerInfo)
2098 {
2099   HWND   hwndNewTarget = 0;
2100   HRESULT  hr = S_OK;
2101   POINT pt;
2102
2103   /*
2104    * Get the handle of the window under the mouse
2105    */
2106   pt.x = trackerInfo->curMousePos.x;
2107   pt.y = trackerInfo->curMousePos.y;
2108   hwndNewTarget = WindowFromPoint(pt);
2109
2110   /*
2111    * Every time, we re-initialize the effects passed to the
2112    * IDropTarget to the effects allowed by the source.
2113    */
2114   *trackerInfo->pdwEffect = trackerInfo->dwOKEffect;
2115
2116   /*
2117    * If we are hovering over the same target as before, send the
2118    * DragOver notification
2119    */
2120   if ( (trackerInfo->curDragTarget != 0) &&
2121        (trackerInfo->curTargetHWND == hwndNewTarget) )
2122   {
2123     IDropTarget_DragOver(trackerInfo->curDragTarget,
2124                          trackerInfo->dwKeyState,
2125                          trackerInfo->curMousePos,
2126                          trackerInfo->pdwEffect);
2127   }
2128   else
2129   {
2130     /*
2131      * If we changed window, we have to notify our old target and check for
2132      * the new one.
2133      */
2134     if (trackerInfo->curDragTarget)
2135       IDropTarget_DragLeave(trackerInfo->curDragTarget);
2136
2137     /*
2138      * Make sure we're hovering over a window.
2139      */
2140     if (hwndNewTarget)
2141     {
2142       /*
2143        * Find-out if there is a drag target under the mouse
2144        */
2145       HWND next_target_wnd = hwndNewTarget;
2146
2147       trackerInfo->curTargetHWND = hwndNewTarget;
2148
2149       while (next_target_wnd && !is_droptarget(next_target_wnd))
2150           next_target_wnd = GetParent(next_target_wnd);
2151
2152       if (next_target_wnd) hwndNewTarget = next_target_wnd;
2153
2154       trackerInfo->curDragTargetHWND = hwndNewTarget;
2155       if(trackerInfo->curDragTarget) IDropTarget_Release(trackerInfo->curDragTarget);
2156       trackerInfo->curDragTarget     = get_droptarget_pointer(hwndNewTarget);
2157
2158       /*
2159        * If there is, notify it that we just dragged-in
2160        */
2161       if (trackerInfo->curDragTarget)
2162       {
2163         hr = IDropTarget_DragEnter(trackerInfo->curDragTarget,
2164                                    trackerInfo->dataObject,
2165                                    trackerInfo->dwKeyState,
2166                                    trackerInfo->curMousePos,
2167                                    trackerInfo->pdwEffect);
2168
2169         /* failed DragEnter() means invalid target */
2170         if (hr != S_OK)
2171         {
2172           trackerInfo->curDragTargetHWND = 0;
2173           trackerInfo->curTargetHWND     = 0;
2174           IDropTarget_Release(trackerInfo->curDragTarget);
2175           trackerInfo->curDragTarget     = 0;
2176         }
2177       }
2178     }
2179     else
2180     {
2181       /*
2182        * The mouse is not over a window so we don't track anything.
2183        */
2184       trackerInfo->curDragTargetHWND = 0;
2185       trackerInfo->curTargetHWND     = 0;
2186       if(trackerInfo->curDragTarget) IDropTarget_Release(trackerInfo->curDragTarget);
2187       trackerInfo->curDragTarget     = 0;
2188     }
2189   }
2190
2191   /*
2192    * Now that we have done that, we have to tell the source to give
2193    * us feedback on the work being done by the target.  If we don't
2194    * have a target, simulate no effect.
2195    */
2196   if (trackerInfo->curDragTarget==0)
2197   {
2198     *trackerInfo->pdwEffect = DROPEFFECT_NONE;
2199   }
2200
2201   hr = IDropSource_GiveFeedback(trackerInfo->dropSource,
2202                                 *trackerInfo->pdwEffect);
2203
2204   /*
2205    * When we ask for feedback from the drop source, sometimes it will
2206    * do all the necessary work and sometimes it will not handle it
2207    * when that's the case, we must display the standard drag and drop
2208    * cursors.
2209    */
2210   if (hr == DRAGDROP_S_USEDEFAULTCURSORS)
2211   {
2212     HCURSOR hCur;
2213
2214     if (*trackerInfo->pdwEffect & DROPEFFECT_MOVE)
2215     {
2216       hCur = LoadCursorW(hProxyDll, MAKEINTRESOURCEW(1));
2217     }
2218     else if (*trackerInfo->pdwEffect & DROPEFFECT_COPY)
2219     {
2220       hCur = LoadCursorW(hProxyDll, MAKEINTRESOURCEW(2));
2221     }
2222     else if (*trackerInfo->pdwEffect & DROPEFFECT_LINK)
2223     {
2224       hCur = LoadCursorW(hProxyDll, MAKEINTRESOURCEW(3));
2225     }
2226     else
2227     {
2228       hCur = LoadCursorW(hProxyDll, MAKEINTRESOURCEW(0));
2229     }
2230
2231     SetCursor(hCur);
2232   }
2233 }
2234
2235 /***
2236  * OLEDD_TrackStateChange()
2237  *
2238  * This method is invoked while a drag and drop operation is in effect.
2239  * It is used to notify the drop target/drop source callbacks when
2240  * the state of the keyboard or mouse button change.
2241  *
2242  * params:
2243  *    trackerInfo - Pointer to the structure identifying the
2244  *                  drag & drop operation that is currently
2245  *                  active.
2246  */
2247 static void OLEDD_TrackStateChange(TrackerWindowInfo* trackerInfo)
2248 {
2249   /*
2250    * Ask the drop source what to do with the operation.
2251    */
2252   trackerInfo->returnValue = IDropSource_QueryContinueDrag(
2253                                trackerInfo->dropSource,
2254                                trackerInfo->escPressed,
2255                                trackerInfo->dwKeyState);
2256
2257   /*
2258    * All the return valued will stop the operation except the S_OK
2259    * return value.
2260    */
2261   if (trackerInfo->returnValue!=S_OK)
2262   {
2263     /*
2264      * Make sure the message loop in DoDragDrop stops
2265      */
2266     trackerInfo->trackingDone = TRUE;
2267
2268     /*
2269      * Release the mouse in case the drop target decides to show a popup
2270      * or a menu or something.
2271      */
2272     ReleaseCapture();
2273
2274     /*
2275      * If we end-up over a target, drop the object in the target or
2276      * inform the target that the operation was cancelled.
2277      */
2278     if (trackerInfo->curDragTarget)
2279     {
2280       switch (trackerInfo->returnValue)
2281       {
2282         /*
2283          * If the source wants us to complete the operation, we tell
2284          * the drop target that we just dropped the object in it.
2285          */
2286         case DRAGDROP_S_DROP:
2287           if (*trackerInfo->pdwEffect != DROPEFFECT_NONE)
2288             IDropTarget_Drop(trackerInfo->curDragTarget,
2289                              trackerInfo->dataObject,
2290                              trackerInfo->dwKeyState,
2291                              trackerInfo->curMousePos,
2292                              trackerInfo->pdwEffect);
2293           else
2294             IDropTarget_DragLeave(trackerInfo->curDragTarget);
2295           break;
2296
2297         /*
2298          * If the source told us that we should cancel, fool the drop
2299          * target by telling it that the mouse left it's window.
2300          * Also set the drop effect to "NONE" in case the application
2301          * ignores the result of DoDragDrop.
2302          */
2303         case DRAGDROP_S_CANCEL:
2304           IDropTarget_DragLeave(trackerInfo->curDragTarget);
2305           *trackerInfo->pdwEffect = DROPEFFECT_NONE;
2306           break;
2307       }
2308     }
2309   }
2310 }
2311
2312 /***
2313  * OLEDD_GetButtonState()
2314  *
2315  * This method will use the current state of the keyboard to build
2316  * a button state mask equivalent to the one passed in the
2317  * WM_MOUSEMOVE wParam.
2318  */
2319 static DWORD OLEDD_GetButtonState(void)
2320 {
2321   BYTE  keyboardState[256];
2322   DWORD keyMask = 0;
2323
2324   GetKeyboardState(keyboardState);
2325
2326   if ( (keyboardState[VK_SHIFT] & 0x80) !=0)
2327     keyMask |= MK_SHIFT;
2328
2329   if ( (keyboardState[VK_CONTROL] & 0x80) !=0)
2330     keyMask |= MK_CONTROL;
2331
2332   if ( (keyboardState[VK_LBUTTON] & 0x80) !=0)
2333     keyMask |= MK_LBUTTON;
2334
2335   if ( (keyboardState[VK_RBUTTON] & 0x80) !=0)
2336     keyMask |= MK_RBUTTON;
2337
2338   if ( (keyboardState[VK_MBUTTON] & 0x80) !=0)
2339     keyMask |= MK_MBUTTON;
2340
2341   return keyMask;
2342 }
2343
2344 /***
2345  * OLEDD_GetButtonState()
2346  *
2347  * This method will read the default value of the registry key in
2348  * parameter and extract a DWORD value from it. The registry key value
2349  * can be in a string key or a DWORD key.
2350  *
2351  * params:
2352  *     regKey   - Key to read the default value from
2353  *     pdwValue - Pointer to the location where the DWORD
2354  *                value is returned. This value is not modified
2355  *                if the value is not found.
2356  */
2357
2358 static void OLEUTL_ReadRegistryDWORDValue(
2359   HKEY   regKey,
2360   DWORD* pdwValue)
2361 {
2362   WCHAR buffer[20];
2363   DWORD cbData = sizeof(buffer);
2364   DWORD dwKeyType;
2365   LONG  lres;
2366
2367   lres = RegQueryValueExW(regKey,
2368                           emptyW,
2369                           NULL,
2370                           &dwKeyType,
2371                           (LPBYTE)buffer,
2372                           &cbData);
2373
2374   if (lres==ERROR_SUCCESS)
2375   {
2376     switch (dwKeyType)
2377     {
2378       case REG_DWORD:
2379         *pdwValue = *(DWORD*)buffer;
2380         break;
2381       case REG_EXPAND_SZ:
2382       case REG_MULTI_SZ:
2383       case REG_SZ:
2384         *pdwValue = (DWORD)strtoulW(buffer, NULL, 10);
2385         break;
2386     }
2387   }
2388 }
2389
2390 /******************************************************************************
2391  * OleDraw (OLE32.@)
2392  *
2393  * The operation of this function is documented literally in the WinAPI
2394  * documentation to involve a QueryInterface for the IViewObject interface,
2395  * followed by a call to IViewObject::Draw.
2396  */
2397 HRESULT WINAPI OleDraw(
2398         IUnknown *pUnk,
2399         DWORD dwAspect,
2400         HDC hdcDraw,
2401         LPCRECT lprcBounds)
2402 {
2403   HRESULT hres;
2404   IViewObject *viewobject;
2405
2406   hres = IUnknown_QueryInterface(pUnk,
2407                                  &IID_IViewObject,
2408                                  (void**)&viewobject);
2409
2410   if (SUCCEEDED(hres))
2411   {
2412     RECTL rectl;
2413
2414     rectl.left = lprcBounds->left;
2415     rectl.right = lprcBounds->right;
2416     rectl.top = lprcBounds->top;
2417     rectl.bottom = lprcBounds->bottom;
2418     hres = IViewObject_Draw(viewobject, dwAspect, -1, 0, 0, 0, hdcDraw, &rectl, 0, 0, 0);
2419
2420     IViewObject_Release(viewobject);
2421     return hres;
2422   }
2423   else
2424   {
2425     return DV_E_NOIVIEWOBJECT;
2426   }
2427 }
2428
2429 /***********************************************************************
2430  *             OleTranslateAccelerator [OLE32.@]
2431  */
2432 HRESULT WINAPI OleTranslateAccelerator (LPOLEINPLACEFRAME lpFrame,
2433                    LPOLEINPLACEFRAMEINFO lpFrameInfo, LPMSG lpmsg)
2434 {
2435     WORD wID;
2436
2437     TRACE("(%p,%p,%p)\n", lpFrame, lpFrameInfo, lpmsg);
2438
2439     if (IsAccelerator(lpFrameInfo->haccel,lpFrameInfo->cAccelEntries,lpmsg,&wID))
2440         return IOleInPlaceFrame_TranslateAccelerator(lpFrame,lpmsg,wID);
2441
2442     return S_FALSE;
2443 }
2444
2445 /******************************************************************************
2446  *              OleCreate        [OLE32.@]
2447  *
2448  */
2449 HRESULT WINAPI OleCreate(
2450         REFCLSID rclsid,
2451         REFIID riid,
2452         DWORD renderopt,
2453         LPFORMATETC pFormatEtc,
2454         LPOLECLIENTSITE pClientSite,
2455         LPSTORAGE pStg,
2456         LPVOID* ppvObj)
2457 {
2458     HRESULT hres;
2459     IUnknown * pUnk = NULL;
2460     IOleObject *pOleObject = NULL;
2461
2462     TRACE("(%s, %s, %d, %p, %p, %p, %p)\n", debugstr_guid(rclsid),
2463         debugstr_guid(riid), renderopt, pFormatEtc, pClientSite, pStg, ppvObj);
2464
2465     hres = CoCreateInstance(rclsid, 0, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER, riid, (LPVOID*)&pUnk);
2466
2467     if (SUCCEEDED(hres))
2468         hres = IStorage_SetClass(pStg, rclsid);
2469
2470     if (pClientSite && SUCCEEDED(hres))
2471     {
2472         hres = IUnknown_QueryInterface(pUnk, &IID_IOleObject, (LPVOID*)&pOleObject);
2473         if (SUCCEEDED(hres))
2474         {
2475             DWORD dwStatus;
2476             hres = IOleObject_GetMiscStatus(pOleObject, DVASPECT_CONTENT, &dwStatus);
2477         }
2478     }
2479
2480     if (SUCCEEDED(hres))
2481     {
2482         IPersistStorage * pPS;
2483         if (SUCCEEDED((hres = IUnknown_QueryInterface(pUnk, &IID_IPersistStorage, (LPVOID*)&pPS))))
2484         {
2485             TRACE("trying to set stg %p\n", pStg);
2486             hres = IPersistStorage_InitNew(pPS, pStg);
2487             TRACE("-- result 0x%08x\n", hres);
2488             IPersistStorage_Release(pPS);
2489         }
2490     }
2491
2492     if (pClientSite && SUCCEEDED(hres))
2493     {
2494         TRACE("trying to set clientsite %p\n", pClientSite);
2495         hres = IOleObject_SetClientSite(pOleObject, pClientSite);
2496         TRACE("-- result 0x%08x\n", hres);
2497     }
2498
2499     if (pOleObject)
2500         IOleObject_Release(pOleObject);
2501
2502     if (((renderopt == OLERENDER_DRAW) || (renderopt == OLERENDER_FORMAT)) &&
2503         SUCCEEDED(hres))
2504     {
2505         IRunnableObject *pRunnable;
2506         IOleCache *pOleCache;
2507         HRESULT hres2;
2508
2509         hres2 = IUnknown_QueryInterface(pUnk, &IID_IRunnableObject, (void **)&pRunnable);
2510         if (SUCCEEDED(hres2))
2511         {
2512             hres = IRunnableObject_Run(pRunnable, NULL);
2513             IRunnableObject_Release(pRunnable);
2514         }
2515
2516         if (SUCCEEDED(hres))
2517         {
2518             hres2 = IUnknown_QueryInterface(pUnk, &IID_IOleCache, (void **)&pOleCache);
2519             if (SUCCEEDED(hres2))
2520             {
2521                 DWORD dwConnection;
2522                 hres = IOleCache_Cache(pOleCache, pFormatEtc, ADVF_PRIMEFIRST, &dwConnection);
2523                 IOleCache_Release(pOleCache);
2524             }
2525         }
2526     }
2527
2528     if (FAILED(hres) && pUnk)
2529     {
2530         IUnknown_Release(pUnk);
2531         pUnk = NULL;
2532     }
2533
2534     *ppvObj = pUnk;
2535
2536     TRACE("-- %p\n", pUnk);
2537     return hres;
2538 }
2539
2540 /******************************************************************************
2541  *              OleGetAutoConvert        [OLE32.@]
2542  */
2543 HRESULT WINAPI OleGetAutoConvert(REFCLSID clsidOld, LPCLSID pClsidNew)
2544 {
2545     static const WCHAR wszAutoConvertTo[] = {'A','u','t','o','C','o','n','v','e','r','t','T','o',0};
2546     HKEY hkey = NULL;
2547     WCHAR buf[CHARS_IN_GUID];
2548     LONG len;
2549     HRESULT res = S_OK;
2550
2551     res = COM_OpenKeyForCLSID(clsidOld, wszAutoConvertTo, KEY_READ, &hkey);
2552     if (FAILED(res))
2553         goto done;
2554
2555     len = sizeof(buf);
2556     if (RegQueryValueW(hkey, NULL, buf, &len))
2557     {
2558         res = REGDB_E_KEYMISSING;
2559         goto done;
2560     }
2561     res = CLSIDFromString(buf, pClsidNew);
2562 done:
2563     if (hkey) RegCloseKey(hkey);
2564     return res;
2565 }
2566
2567 /******************************************************************************
2568  *              OleSetAutoConvert        [OLE32.@]
2569  */
2570 HRESULT WINAPI OleSetAutoConvert(REFCLSID clsidOld, REFCLSID clsidNew)
2571 {
2572     static const WCHAR wszAutoConvertTo[] = {'A','u','t','o','C','o','n','v','e','r','t','T','o',0};
2573     HKEY hkey = NULL;
2574     WCHAR szClsidNew[CHARS_IN_GUID];
2575     HRESULT res = S_OK;
2576
2577     TRACE("(%s,%s)\n", debugstr_guid(clsidOld), debugstr_guid(clsidNew));
2578
2579     res = COM_OpenKeyForCLSID(clsidOld, NULL, KEY_READ | KEY_WRITE, &hkey);
2580     if (FAILED(res))
2581         goto done;
2582     StringFromGUID2(clsidNew, szClsidNew, CHARS_IN_GUID);
2583     if (RegSetValueW(hkey, wszAutoConvertTo, REG_SZ, szClsidNew, (strlenW(szClsidNew)+1) * sizeof(WCHAR)))
2584     {
2585         res = REGDB_E_WRITEREGDB;
2586         goto done;
2587     }
2588
2589 done:
2590     if (hkey) RegCloseKey(hkey);
2591     return res;
2592 }
2593
2594 /******************************************************************************
2595  *              OleDoAutoConvert        [OLE32.@]
2596  */
2597 HRESULT WINAPI OleDoAutoConvert(LPSTORAGE pStg, LPCLSID pClsidNew)
2598 {
2599     FIXME("(%p,%p) : stub\n",pStg,pClsidNew);
2600     return E_NOTIMPL;
2601 }
2602
2603 /******************************************************************************
2604  *              OleIsRunning        [OLE32.@]
2605  */
2606 BOOL WINAPI OleIsRunning(LPOLEOBJECT pObject)
2607 {
2608     IRunnableObject *pRunnable;
2609     HRESULT hr;
2610     BOOL running;
2611
2612     TRACE("(%p)\n", pObject);
2613
2614     hr = IOleObject_QueryInterface(pObject, &IID_IRunnableObject, (void **)&pRunnable);
2615     if (FAILED(hr))
2616         return TRUE;
2617     running = IRunnableObject_IsRunning(pRunnable);
2618     IRunnableObject_Release(pRunnable);
2619     return running;
2620 }
2621
2622 /***********************************************************************
2623  *           OleNoteObjectVisible                           [OLE32.@]
2624  */
2625 HRESULT WINAPI OleNoteObjectVisible(LPUNKNOWN pUnknown, BOOL bVisible)
2626 {
2627     TRACE("(%p, %s)\n", pUnknown, bVisible ? "TRUE" : "FALSE");
2628     return CoLockObjectExternal(pUnknown, bVisible, TRUE);
2629 }
2630
2631
2632 /***********************************************************************
2633  *           OLE_FreeClipDataArray   [internal]
2634  *
2635  * NOTES:
2636  *  frees the data associated with an array of CLIPDATAs
2637  */
2638 static void OLE_FreeClipDataArray(ULONG count, CLIPDATA * pClipDataArray)
2639 {
2640     ULONG i;
2641     for (i = 0; i < count; i++)
2642         if (pClipDataArray[i].pClipData)
2643             CoTaskMemFree(pClipDataArray[i].pClipData);
2644 }
2645
2646 /***********************************************************************
2647  *           PropSysAllocString                     [OLE32.@]
2648  * NOTES:
2649  *  Basically a copy of SysAllocStringLen.
2650  */
2651 BSTR WINAPI PropSysAllocString(LPCOLESTR str)
2652 {
2653     DWORD  bufferSize;
2654     DWORD* newBuffer;
2655     WCHAR* stringBuffer;
2656     int len;
2657
2658     if (!str) return 0;
2659
2660     len = lstrlenW(str);
2661     /*
2662      * Find the length of the buffer passed-in, in bytes.
2663      */
2664     bufferSize = len * sizeof (WCHAR);
2665
2666     /*
2667      * Allocate a new buffer to hold the string.
2668      * Don't forget to keep an empty spot at the beginning of the
2669      * buffer for the character count and an extra character at the
2670      * end for the NULL.
2671      */
2672     newBuffer = HeapAlloc(GetProcessHeap(), 0,
2673                           bufferSize + sizeof(WCHAR) + sizeof(DWORD));
2674
2675     /*
2676      * If the memory allocation failed, return a null pointer.
2677      */
2678     if (newBuffer==0)
2679       return 0;
2680
2681     /*
2682      * Copy the length of the string in the placeholder.
2683      */
2684     *newBuffer = bufferSize;
2685
2686     /*
2687      * Skip the byte count.
2688      */
2689     newBuffer++;
2690
2691     memcpy(newBuffer, str, bufferSize);
2692
2693     /*
2694      * Make sure that there is a nul character at the end of the
2695      * string.
2696      */
2697     stringBuffer = (WCHAR*)newBuffer;
2698     stringBuffer[len] = '\0';
2699
2700     return stringBuffer;
2701 }
2702
2703 /***********************************************************************
2704  *           PropSysFreeString                      [OLE32.@]
2705  * NOTES
2706  *  Copy of SysFreeString.
2707  */
2708 void WINAPI PropSysFreeString(LPOLESTR str)
2709 {
2710     DWORD* bufferPointer;
2711
2712     /* NULL is a valid parameter */
2713     if(!str) return;
2714
2715     /*
2716      * We have to be careful when we free a BSTR pointer, it points to
2717      * the beginning of the string but it skips the byte count contained
2718      * before the string.
2719      */
2720     bufferPointer = (DWORD*)str;
2721
2722     bufferPointer--;
2723
2724     /*
2725      * Free the memory from its "real" origin.
2726      */
2727     HeapFree(GetProcessHeap(), 0, bufferPointer);
2728 }
2729
2730 /******************************************************************************
2731  * Check if a PROPVARIANT's type is valid.
2732  */
2733 static inline HRESULT PROPVARIANT_ValidateType(VARTYPE vt)
2734 {
2735     switch (vt)
2736     {
2737     case VT_EMPTY:
2738     case VT_NULL:
2739     case VT_I2:
2740     case VT_I4:
2741     case VT_R4:
2742     case VT_R8:
2743     case VT_CY:
2744     case VT_DATE:
2745     case VT_BSTR:
2746     case VT_ERROR:
2747     case VT_BOOL:
2748     case VT_DECIMAL:
2749     case VT_UI1:
2750     case VT_UI2:
2751     case VT_UI4:
2752     case VT_I8:
2753     case VT_UI8:
2754     case VT_LPSTR:
2755     case VT_LPWSTR:
2756     case VT_FILETIME:
2757     case VT_BLOB:
2758     case VT_STREAM:
2759     case VT_STORAGE:
2760     case VT_STREAMED_OBJECT:
2761     case VT_STORED_OBJECT:
2762     case VT_BLOB_OBJECT:
2763     case VT_CF:
2764     case VT_CLSID:
2765     case VT_I2|VT_VECTOR:
2766     case VT_I4|VT_VECTOR:
2767     case VT_R4|VT_VECTOR:
2768     case VT_R8|VT_VECTOR:
2769     case VT_CY|VT_VECTOR:
2770     case VT_DATE|VT_VECTOR:
2771     case VT_BSTR|VT_VECTOR:
2772     case VT_ERROR|VT_VECTOR:
2773     case VT_BOOL|VT_VECTOR:
2774     case VT_VARIANT|VT_VECTOR:
2775     case VT_UI1|VT_VECTOR:
2776     case VT_UI2|VT_VECTOR:
2777     case VT_UI4|VT_VECTOR:
2778     case VT_I8|VT_VECTOR:
2779     case VT_UI8|VT_VECTOR:
2780     case VT_LPSTR|VT_VECTOR:
2781     case VT_LPWSTR|VT_VECTOR:
2782     case VT_FILETIME|VT_VECTOR:
2783     case VT_CF|VT_VECTOR:
2784     case VT_CLSID|VT_VECTOR:
2785         return S_OK;
2786     }
2787     WARN("Bad type %d\n", vt);
2788     return STG_E_INVALIDPARAMETER;
2789 }
2790
2791 /***********************************************************************
2792  *           PropVariantClear                       [OLE32.@]
2793  */
2794 HRESULT WINAPI PropVariantClear(PROPVARIANT * pvar) /* [in/out] */
2795 {
2796     HRESULT hr;
2797
2798     TRACE("(%p)\n", pvar);
2799
2800     if (!pvar)
2801         return S_OK;
2802
2803     hr = PROPVARIANT_ValidateType(pvar->vt);
2804     if (FAILED(hr))
2805         return hr;
2806
2807     switch(pvar->vt)
2808     {
2809     case VT_EMPTY:
2810     case VT_NULL:
2811     case VT_I2:
2812     case VT_I4:
2813     case VT_R4:
2814     case VT_R8:
2815     case VT_CY:
2816     case VT_DATE:
2817     case VT_ERROR:
2818     case VT_BOOL:
2819     case VT_DECIMAL:
2820     case VT_UI1:
2821     case VT_UI2:
2822     case VT_UI4:
2823     case VT_I8:
2824     case VT_UI8:
2825     case VT_FILETIME:
2826         break;
2827     case VT_STREAM:
2828     case VT_STREAMED_OBJECT:
2829     case VT_STORAGE:
2830     case VT_STORED_OBJECT:
2831         if (pvar->u.pStream)
2832             IUnknown_Release(pvar->u.pStream);
2833         break;
2834     case VT_CLSID:
2835     case VT_LPSTR:
2836     case VT_LPWSTR:
2837         /* pick an arbitrary typed pointer - we don't care about the type
2838          * as we are just freeing it */
2839         CoTaskMemFree(pvar->u.puuid);
2840         break;
2841     case VT_BLOB:
2842     case VT_BLOB_OBJECT:
2843         CoTaskMemFree(pvar->u.blob.pBlobData);
2844         break;
2845     case VT_BSTR:
2846         if (pvar->u.bstrVal)
2847             PropSysFreeString(pvar->u.bstrVal);
2848         break;
2849     case VT_CF:
2850         if (pvar->u.pclipdata)
2851         {
2852             OLE_FreeClipDataArray(1, pvar->u.pclipdata);
2853             CoTaskMemFree(pvar->u.pclipdata);
2854         }
2855         break;
2856     default:
2857         if (pvar->vt & VT_VECTOR)
2858         {
2859             ULONG i;
2860
2861             switch (pvar->vt & ~VT_VECTOR)
2862             {
2863             case VT_VARIANT:
2864                 FreePropVariantArray(pvar->u.capropvar.cElems, pvar->u.capropvar.pElems);
2865                 break;
2866             case VT_CF:
2867                 OLE_FreeClipDataArray(pvar->u.caclipdata.cElems, pvar->u.caclipdata.pElems);
2868                 break;
2869             case VT_BSTR:
2870                 for (i = 0; i < pvar->u.cabstr.cElems; i++)
2871                     PropSysFreeString(pvar->u.cabstr.pElems[i]);
2872                 break;
2873             case VT_LPSTR:
2874                 for (i = 0; i < pvar->u.calpstr.cElems; i++)
2875                     CoTaskMemFree(pvar->u.calpstr.pElems[i]);
2876                 break;
2877             case VT_LPWSTR:
2878                 for (i = 0; i < pvar->u.calpwstr.cElems; i++)
2879                     CoTaskMemFree(pvar->u.calpwstr.pElems[i]);
2880                 break;
2881             }
2882             if (pvar->vt & ~VT_VECTOR)
2883             {
2884                 /* pick an arbitrary VT_VECTOR structure - they all have the same
2885                  * memory layout */
2886                 CoTaskMemFree(pvar->u.capropvar.pElems);
2887             }
2888         }
2889         else
2890             WARN("Invalid/unsupported type %d\n", pvar->vt);
2891     }
2892
2893     ZeroMemory(pvar, sizeof(*pvar));
2894
2895     return S_OK;
2896 }
2897
2898 /***********************************************************************
2899  *           PropVariantCopy                        [OLE32.@]
2900  */
2901 HRESULT WINAPI PropVariantCopy(PROPVARIANT *pvarDest,      /* [out] */
2902                                const PROPVARIANT *pvarSrc) /* [in] */
2903 {
2904     ULONG len;
2905     HRESULT hr;
2906
2907     TRACE("(%p, %p vt %04x)\n", pvarDest, pvarSrc, pvarSrc->vt);
2908
2909     hr = PROPVARIANT_ValidateType(pvarSrc->vt);
2910     if (FAILED(hr))
2911         return hr;
2912
2913     /* this will deal with most cases */
2914     *pvarDest = *pvarSrc;
2915
2916     switch(pvarSrc->vt)
2917     {
2918     case VT_EMPTY:
2919     case VT_NULL:
2920     case VT_I1:
2921     case VT_UI1:
2922     case VT_I2:
2923     case VT_UI2:
2924     case VT_BOOL:
2925     case VT_DECIMAL:
2926     case VT_I4:
2927     case VT_UI4:
2928     case VT_R4:
2929     case VT_ERROR:
2930     case VT_I8:
2931     case VT_UI8:
2932     case VT_R8:
2933     case VT_CY:
2934     case VT_DATE:
2935     case VT_FILETIME:
2936         break;
2937     case VT_STREAM:
2938     case VT_STREAMED_OBJECT:
2939     case VT_STORAGE:
2940     case VT_STORED_OBJECT:
2941         IUnknown_AddRef((LPUNKNOWN)pvarDest->u.pStream);
2942         break;
2943     case VT_CLSID:
2944         pvarDest->u.puuid = CoTaskMemAlloc(sizeof(CLSID));
2945         *pvarDest->u.puuid = *pvarSrc->u.puuid;
2946         break;
2947     case VT_LPSTR:
2948         len = strlen(pvarSrc->u.pszVal);
2949         pvarDest->u.pszVal = CoTaskMemAlloc((len+1)*sizeof(CHAR));
2950         CopyMemory(pvarDest->u.pszVal, pvarSrc->u.pszVal, (len+1)*sizeof(CHAR));
2951         break;
2952     case VT_LPWSTR:
2953         len = lstrlenW(pvarSrc->u.pwszVal);
2954         pvarDest->u.pwszVal = CoTaskMemAlloc((len+1)*sizeof(WCHAR));
2955         CopyMemory(pvarDest->u.pwszVal, pvarSrc->u.pwszVal, (len+1)*sizeof(WCHAR));
2956         break;
2957     case VT_BLOB:
2958     case VT_BLOB_OBJECT:
2959         if (pvarSrc->u.blob.pBlobData)
2960         {
2961             len = pvarSrc->u.blob.cbSize;
2962             pvarDest->u.blob.pBlobData = CoTaskMemAlloc(len);
2963             CopyMemory(pvarDest->u.blob.pBlobData, pvarSrc->u.blob.pBlobData, len);
2964         }
2965         break;
2966     case VT_BSTR:
2967         pvarDest->u.bstrVal = PropSysAllocString(pvarSrc->u.bstrVal);
2968         break;
2969     case VT_CF:
2970         if (pvarSrc->u.pclipdata)
2971         {
2972             len = pvarSrc->u.pclipdata->cbSize - sizeof(pvarSrc->u.pclipdata->ulClipFmt);
2973             pvarDest->u.pclipdata = CoTaskMemAlloc(sizeof (CLIPDATA));
2974             pvarDest->u.pclipdata->cbSize = pvarSrc->u.pclipdata->cbSize;
2975             pvarDest->u.pclipdata->ulClipFmt = pvarSrc->u.pclipdata->ulClipFmt;
2976             pvarDest->u.pclipdata->pClipData = CoTaskMemAlloc(len);
2977             CopyMemory(pvarDest->u.pclipdata->pClipData, pvarSrc->u.pclipdata->pClipData, len);
2978         }
2979         break;
2980     default:
2981         if (pvarSrc->vt & VT_VECTOR)
2982         {
2983             int elemSize;
2984             ULONG i;
2985
2986             switch(pvarSrc->vt & ~VT_VECTOR)
2987             {
2988             case VT_I1:       elemSize = sizeof(pvarSrc->u.cVal); break;
2989             case VT_UI1:      elemSize = sizeof(pvarSrc->u.bVal); break;
2990             case VT_I2:       elemSize = sizeof(pvarSrc->u.iVal); break;
2991             case VT_UI2:      elemSize = sizeof(pvarSrc->u.uiVal); break;
2992             case VT_BOOL:     elemSize = sizeof(pvarSrc->u.boolVal); break;
2993             case VT_I4:       elemSize = sizeof(pvarSrc->u.lVal); break;
2994             case VT_UI4:      elemSize = sizeof(pvarSrc->u.ulVal); break;
2995             case VT_R4:       elemSize = sizeof(pvarSrc->u.fltVal); break;
2996             case VT_R8:       elemSize = sizeof(pvarSrc->u.dblVal); break;
2997             case VT_ERROR:    elemSize = sizeof(pvarSrc->u.scode); break;
2998             case VT_I8:       elemSize = sizeof(pvarSrc->u.hVal); break;
2999             case VT_UI8:      elemSize = sizeof(pvarSrc->u.uhVal); break;
3000             case VT_CY:       elemSize = sizeof(pvarSrc->u.cyVal); break;
3001             case VT_DATE:     elemSize = sizeof(pvarSrc->u.date); break;
3002             case VT_FILETIME: elemSize = sizeof(pvarSrc->u.filetime); break;
3003             case VT_CLSID:    elemSize = sizeof(*pvarSrc->u.puuid); break;
3004             case VT_CF:       elemSize = sizeof(*pvarSrc->u.pclipdata); break;
3005             case VT_BSTR:     elemSize = sizeof(pvarSrc->u.bstrVal); break;
3006             case VT_LPSTR:    elemSize = sizeof(pvarSrc->u.pszVal); break;
3007             case VT_LPWSTR:   elemSize = sizeof(pvarSrc->u.pwszVal); break;
3008             case VT_VARIANT:  elemSize = sizeof(*pvarSrc->u.pvarVal); break;
3009
3010             default:
3011                 FIXME("Invalid element type: %ul\n", pvarSrc->vt & ~VT_VECTOR);
3012                 return E_INVALIDARG;
3013             }
3014             len = pvarSrc->u.capropvar.cElems;
3015             pvarDest->u.capropvar.pElems = CoTaskMemAlloc(len * elemSize);
3016             if (pvarSrc->vt == (VT_VECTOR | VT_VARIANT))
3017             {
3018                 for (i = 0; i < len; i++)
3019                     PropVariantCopy(&pvarDest->u.capropvar.pElems[i], &pvarSrc->u.capropvar.pElems[i]);
3020             }
3021             else if (pvarSrc->vt == (VT_VECTOR | VT_CF))
3022             {
3023                 FIXME("Copy clipformats\n");
3024             }
3025             else if (pvarSrc->vt == (VT_VECTOR | VT_BSTR))
3026             {
3027                 for (i = 0; i < len; i++)
3028                     pvarDest->u.cabstr.pElems[i] = PropSysAllocString(pvarSrc->u.cabstr.pElems[i]);
3029             }
3030             else if (pvarSrc->vt == (VT_VECTOR | VT_LPSTR))
3031             {
3032                 size_t strLen;
3033                 for (i = 0; i < len; i++)
3034                 {
3035                     strLen = lstrlenA(pvarSrc->u.calpstr.pElems[i]) + 1;
3036                     pvarDest->u.calpstr.pElems[i] = CoTaskMemAlloc(strLen);
3037                     memcpy(pvarDest->u.calpstr.pElems[i],
3038                      pvarSrc->u.calpstr.pElems[i], strLen);
3039                 }
3040             }
3041             else if (pvarSrc->vt == (VT_VECTOR | VT_LPWSTR))
3042             {
3043                 size_t strLen;
3044                 for (i = 0; i < len; i++)
3045                 {
3046                     strLen = (lstrlenW(pvarSrc->u.calpwstr.pElems[i]) + 1) *
3047                      sizeof(WCHAR);
3048                     pvarDest->u.calpstr.pElems[i] = CoTaskMemAlloc(strLen);
3049                     memcpy(pvarDest->u.calpstr.pElems[i],
3050                      pvarSrc->u.calpstr.pElems[i], strLen);
3051                 }
3052             }
3053             else
3054                 CopyMemory(pvarDest->u.capropvar.pElems, pvarSrc->u.capropvar.pElems, len * elemSize);
3055         }
3056         else
3057             WARN("Invalid/unsupported type %d\n", pvarSrc->vt);
3058     }
3059
3060     return S_OK;
3061 }
3062
3063 /***********************************************************************
3064  *           FreePropVariantArray                           [OLE32.@]
3065  */
3066 HRESULT WINAPI FreePropVariantArray(ULONG cVariants, /* [in] */
3067                                     PROPVARIANT *rgvars)    /* [in/out] */
3068 {
3069     ULONG i;
3070
3071     TRACE("(%u, %p)\n", cVariants, rgvars);
3072
3073     if (!rgvars)
3074         return E_INVALIDARG;
3075
3076     for(i = 0; i < cVariants; i++)
3077         PropVariantClear(&rgvars[i]);
3078
3079     return S_OK;
3080 }
3081
3082 /******************************************************************************
3083  * DllDebugObjectRPCHook (OLE32.@)
3084  * turns on and off internal debugging,  pointer is only used on macintosh
3085  */
3086
3087 BOOL WINAPI DllDebugObjectRPCHook(BOOL b, void *dummy)
3088 {
3089   FIXME("stub\n");
3090   return TRUE;
3091 }