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