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