ole/ole2.c

   1 /*
   2  *      OLE2 library
   3  *
   4  *      Copyright 1995  Martin von Loewis
   5  *      Copyright 1999  Francis Beaudet
   6  *      Copyright 1999  Noel Borthwick
   7  */
   8
   9 #include <assert.h>
  10 #include <stdlib.h>
  11 #include <strings.h>
  12
  13 #include "winuser.h"
  14 #include "winerror.h"
  15 #include "ole2.h"
  16 #include "process.h"
  17 #include "hook.h"
  18 #include "commctrl.h"
  19 #include "wine/obj_clientserver.h"
  20 #include "debug.h"
  21 #include "ole2ver.h"
  22 #include "winreg.h"
  23
  24 DEFAULT_DEBUG_CHANNEL(ole)
  25
  26 /******************************************************************************
  27  * These are static/global variables and internal data structures that the
  28  * OLE module uses to maintain it's state.
  29  */
  30 typedef struct tagDropTargetNode
  31 {
  32   HWND          hwndTarget;
  33   IDropTarget*    dropTarget;
  34   struct tagDropTargetNode* prevDropTarget;
  35   struct tagDropTargetNode* nextDropTarget;
  36 } DropTargetNode;
  37
  38 typedef struct tagTrackerWindowInfo
  39 {
  40   IDataObject* dataObject;
  41   IDropSource* dropSource;
  42   DWORD        dwOKEffect;
  43   DWORD*       pdwEffect;
  44   BOOL       trackingDone;
  45   HRESULT      returnValue;
  46
  47   BOOL       escPressed;
  48   HWND       curDragTargetHWND;
  49   IDropTarget* curDragTarget;
  50 } TrackerWindowInfo;
  51
  52 typedef struct tagOleMenuDescriptor  /* OleMenuDescriptor */
  53 {
  54   HWND               hwndFrame;         /* The containers frame window */
  55   HWND               hwndActiveObject;  /* The active objects window */
  56   OLEMENUGROUPWIDTHS mgw;               /* OLE menu group widths for the shared menu */
  57   HMENU              hmenuCombined;     /* The combined menu */
  58   BOOL               bIsServerItem;     /* True if the currently open popup belongs to the server */
  59 } OleMenuDescriptor;
  60
  61 typedef struct tagOleMenuHookItem   /* OleMenu hook item in per thread hook list */
  62 {
  63   DWORD tid;                /* Thread Id  */
  64   HANDLE hHeap;             /* Heap this is allocated from */
  65   HHOOK GetMsg_hHook;       /* message hook for WH_GETMESSAGE */
  66   HHOOK CallWndProc_hHook;  /* message hook for WH_CALLWNDPROC */
  67 } OleMenuHookItem;
  68
  69 /*
  70  * Dynamic pointer array of per thread message hooks (maintained by OleSetMenuDescriptor)
  71  */
  72 static HDPA OLEMenu_MsgHookDPA = NULL;
  73
  74 /*
  75  * This is the lock count on the OLE library. It is controlled by the
  76  * OLEInitialize/OLEUninitialize methods.
  77  */
  78 static ULONG OLE_moduleLockCount = 0;
  79
  80 /*
  81  * Name of our registered window class.
  82  */
  83 static const char OLEDD_DRAGTRACKERCLASS[] = "WineDragDropTracker32";
  84
  85 /*
  86  * This is the head of the Drop target container.
  87  */
  88 static DropTargetNode* targetListHead = NULL;
  89
  90 /******************************************************************************
  91  * These are the prototypes of miscelaneous utility methods
  92  */
  93 static void OLEUTL_ReadRegistryDWORDValue(HKEY regKey, DWORD* pdwValue);
  94
  95 /******************************************************************************
  96  * These are the prototypes of the utility methods used to manage a shared menu
  97  */
  98 static void OLEMenu_Initialize();
  99 static void OLEMenu_UnInitialize();
 100 BOOL OLEMenu_InstallHooks( DWORD tid );
 101 BOOL OLEMenu_UnInstallHooks( DWORD tid );
 102 OleMenuHookItem * OLEMenu_IsHookInstalled( DWORD tid, INT *pixHook );
 103 static BOOL OLEMenu_FindMainMenuIndex( HMENU hMainMenu, HMENU hPopupMenu, UINT *pnPos );
 104 BOOL OLEMenu_SetIsServerMenu( HMENU hmenu, OleMenuDescriptor *pOleMenuDescriptor );
 105 LRESULT CALLBACK OLEMenu_CallWndProc(INT code, WPARAM wParam, LPARAM lParam);
 106 LRESULT CALLBACK OLEMenu_GetMsgProc(INT code, WPARAM wParam, LPARAM lParam);
 107
 108 /******************************************************************************
 109  * These are the prototypes of the utility methods used for OLE Drag n Drop
 110  */
 111 static void            OLEDD_Initialize();
 112 static void            OLEDD_UnInitialize();
 113 static void            OLEDD_InsertDropTarget(
 114                          DropTargetNode* nodeToAdd);
 115 static DropTargetNode* OLEDD_ExtractDropTarget(
 116                          HWND hwndOfTarget);
 117 static DropTargetNode* OLEDD_FindDropTarget(
 118                          HWND hwndOfTarget);
 119 static LRESULT WINAPI  OLEDD_DragTrackerWindowProc(
 120                          HWND   hwnd,
 121                          UINT   uMsg,
 122                          WPARAM wParam,
 123                          LPARAM   lParam);
 124 static void OLEDD_TrackMouseMove(
 125                          TrackerWindowInfo* trackerInfo,
 126                          POINT            mousePos,
 127                          DWORD              keyState);
 128 static void OLEDD_TrackStateChange(
 129                          TrackerWindowInfo* trackerInfo,
 130                          POINT            mousePos,
 131                          DWORD              keyState);
 132 static DWORD OLEDD_GetButtonState();
 133
 134
 135 /******************************************************************************
 136  *              OleBuildVersion [OLE2.1]
 137  */
 138 DWORD WINAPI OleBuildVersion(void)
 139 {
 140     TRACE(ole,"(void)\n");
 141     return (rmm<<16)+rup;
 142 }
 143
 144 /***********************************************************************
 145  *           OleInitialize       (OLE2.2) (OLE32.108)
 146  */
 147 HRESULT WINAPI OleInitialize(LPVOID reserved)
 148 {
 149   HRESULT hr;
 150
 151   TRACE(ole, "(%p)\n", reserved);
 152
 153   /*
 154    * The first duty of the OleInitialize is to initialize the COM libraries.
 155    */
 156   hr = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
 157
 158   /*
 159    * If the CoInitializeEx call failed, the OLE libraries can't be
 160    * initialized.
 161    */
 162   if (FAILED(hr))
 163     return hr;
 164
 165   /*
 166    * Then, it has to initialize the OLE specific modules.
 167    * This includes:
 168    *     Clipboard
 169    *     Drag and Drop
 170    *     Object linking and Embedding
 171    *     In-place activation
 172    */
 173   if (OLE_moduleLockCount==0)
 174 {
 175     /*
 176      * Initialize the libraries.
 177      */
 178     TRACE(ole, "() - Initializing the OLE libraries\n");
 179
 180     /*
 181      * Drag and Drop
 182      */
 183     OLEDD_Initialize();
 184
 185     /*
 186      * OLE shared menu
 187      */
 188     OLEMenu_Initialize();
 189 }
 190
 191   /*
 192    * Then, we increase the lock count on the OLE module.
 193    */
 194   OLE_moduleLockCount++;
 195
 196   return hr;
 197 }
 198
 199 /******************************************************************************
 200  *              CoGetCurrentProcess     [COMPOBJ.34] [OLE2.2][OLE32.108]
 201  *
 202  * NOTES
 203  *   Is DWORD really the correct return type for this function?
 204  */
 205 DWORD WINAPI CoGetCurrentProcess(void) {
 206         return (DWORD)PROCESS_Current();
 207 }
 208
 209 /******************************************************************************
 210  *              OleUninitialize [OLE2.3] [OLE32.131]
 211  */
 212 void WINAPI OleUninitialize(void)
 213 {
 214   TRACE(ole, "()\n");
 215
 216   /*
 217    * Decrease the lock count on the OLE module.
 218    */
 219   OLE_moduleLockCount--;
 220
 221   /*
 222    * If we hit the bottom of the lock stack, free the libraries.
 223    */
 224   if (OLE_moduleLockCount==0)
 225   {
 226     /*
 227      * Actually free the libraries.
 228      */
 229     TRACE(ole, "() - Freeing the last reference count\n");
 230
 231     /*
 232      * Drag and Drop
 233      */
 234     OLEDD_UnInitialize();
 235
 236     /*
 237      * OLE shared menu
 238      */
 239     OLEMenu_UnInitialize();
 240   }
 241
 242   /*
 243    * Then, uninitialize the COM libraries.
 244    */
 245   CoUninitialize();
 246 }
 247
 248 /***********************************************************************
 249  *           OleFlushClipboard   [OLE2.76]
 250  */
 251 HRESULT WINAPI OleFlushClipboard16(void)
 252 {
 253     return S_OK;
 254 }
 255
 256 /***********************************************************************
 257  *           OleSetClipboard     [OLE32.127]
 258  */
 259 HRESULT WINAPI OleSetClipboard(LPVOID pDataObj)
 260 {
 261     FIXME(ole,"(%p), stub!\n", pDataObj);
 262     return S_OK;
 263 }
 264
 265 /******************************************************************************
 266  *              CoRegisterMessageFilter32       [OLE32.38]
 267  */
 268 HRESULT WINAPI CoRegisterMessageFilter(
 269     LPMESSAGEFILTER lpMessageFilter,    /* Pointer to interface */
 270     LPMESSAGEFILTER *lplpMessageFilter  /* Indirect pointer to prior instance if non-NULL */
 271 ) {
 272     FIXME(ole,"stub\n");
 273     if (lplpMessageFilter) {
 274         *lplpMessageFilter = NULL;
 275     }
 276     return S_OK;
 277 }
 278
 279 /******************************************************************************
 280  *              OleInitializeWOW        [OLE32.109]
 281  */
 282 HRESULT WINAPI OleInitializeWOW(DWORD x) {
 283         FIXME(ole,"(0x%08lx),stub!\n",x);
 284         return 0;
 285 }
 286
 287 /***********************************************************************
 288  *           RegisterDragDrop16 (OLE2.35)
 289  */
 290 HRESULT WINAPI RegisterDragDrop16(
 291         HWND16 hwnd,
 292         LPDROPTARGET pDropTarget
 293 ) {
 294         FIXME(ole,"(0x%04x,%p),stub!\n",hwnd,pDropTarget);
 295         return S_OK;
 296 }
 297
 298 /***********************************************************************
 299  *           RegisterDragDrop32 (OLE32.139)
 300  */
 301 HRESULT WINAPI RegisterDragDrop(
 302         HWND hwnd,
 303         LPDROPTARGET pDropTarget)
 304 {
 305   DropTargetNode* dropTargetInfo;
 306
 307   TRACE(ole,"(0x%x,%p)\n", hwnd, pDropTarget);
 308
 309   /*
 310    * First, check if the window is already registered.
 311    */
 312   dropTargetInfo = OLEDD_FindDropTarget(hwnd);
 313
 314   if (dropTargetInfo!=NULL)
 315     return DRAGDROP_E_ALREADYREGISTERED;
 316
 317   /*
 318    * If it's not there, we can add it. We first create a node for it.
 319    */
 320   dropTargetInfo = HeapAlloc(GetProcessHeap(), 0, sizeof(DropTargetNode));
 321
 322   if (dropTargetInfo==NULL)
 323     return E_OUTOFMEMORY;
 324
 325   dropTargetInfo->hwndTarget     = hwnd;
 326   dropTargetInfo->prevDropTarget = NULL;
 327   dropTargetInfo->nextDropTarget = NULL;
 328
 329   /*
 330    * Don't forget that this is an interface pointer, need to nail it down since
 331    * we keep a copy of it.
 332    */
 333   dropTargetInfo->dropTarget  = pDropTarget;
 334   IDropTarget_AddRef(dropTargetInfo->dropTarget);
 335
 336   OLEDD_InsertDropTarget(dropTargetInfo);
 337
 338         return S_OK;
 339 }
 340
 341 /***********************************************************************
 342  *           RevokeDragDrop16 (OLE2.36)
 343  */
 344 HRESULT WINAPI RevokeDragDrop16(
 345         HWND16 hwnd
 346 ) {
 347         FIXME(ole,"(0x%04x),stub!\n",hwnd);
 348         return S_OK;
 349 }
 350
 351 /***********************************************************************
 352  *           RevokeDragDrop32 (OLE32.141)
 353  */
 354 HRESULT WINAPI RevokeDragDrop(
 355         HWND hwnd)
 356 {
 357   DropTargetNode* dropTargetInfo;
 358
 359   TRACE(ole,"(0x%x)\n", hwnd);
 360
 361   /*
 362    * First, check if the window is already registered.
 363    */
 364   dropTargetInfo = OLEDD_ExtractDropTarget(hwnd);
 365
 366   /*
 367    * If it ain't in there, it's an error.
 368    */
 369   if (dropTargetInfo==NULL)
 370     return DRAGDROP_E_NOTREGISTERED;
 371
 372   /*
 373    * If it's in there, clean-up it's used memory and
 374    * references
 375    */
 376   IDropTarget_Release(dropTargetInfo->dropTarget);
 377   HeapFree(GetProcessHeap(), 0, dropTargetInfo);
 378
 379         return S_OK;
 380 }
 381
 382 /***********************************************************************
 383  *           OleRegGetUserType (OLE32.122)
 384  *
 385  * This implementation of OleRegGetUserType ignores the dwFormOfType
 386  * parameter and always returns the full name of the object. This is
 387  * not too bad since this is the case for many objects because of the
 388  * way they are registered.
 389  */
 390 HRESULT WINAPI OleRegGetUserType(
 391         REFCLSID clsid,
 392         DWORD dwFormOfType,
 393         LPOLESTR* pszUserType)
 394 {
 395   char  xclsid[50];
 396   char  keyName[60];
 397   DWORD dwKeyType;
 398   DWORD cbData;
 399   HKEY  clsidKey;
 400   LONG  hres;
 401
 402   /*
 403    * Initialize the out parameter.
 404    */
 405   *pszUserType = NULL;
 406
 407   /*
 408    * Build the key name we're looking for
 409    */
 410   WINE_StringFromCLSID((LPCLSID)clsid, xclsid);
 411
 412   strcpy(keyName, "CLSID\\");
 413   strcat(keyName, xclsid);
 414   strcat(keyName, "\\");
 415
 416   TRACE(ole,"(%s, %ld, %p)\n", keyName, dwFormOfType, pszUserType);
 417
 418   /*
 419    * Open the class id Key
 420    */
 421   hres = RegOpenKeyA(HKEY_CLASSES_ROOT,
 422                      keyName,
 423                      &clsidKey);
 424
 425   if (hres != ERROR_SUCCESS)
 426     return REGDB_E_CLASSNOTREG;
 427
 428   /*
 429    * Retrieve the size of the name string.
 430    */
 431   cbData = 0;
 432
 433   hres = RegQueryValueExA(clsidKey,
 434                           "",
 435                           NULL,
 436                           &dwKeyType,
 437                           NULL,
 438                           &cbData);
 439
 440   if (hres!=ERROR_SUCCESS)
 441   {
 442     RegCloseKey(clsidKey);
 443     return REGDB_E_READREGDB;
 444   }
 445
 446   /*
 447    * Allocate a buffer for the registry value.
 448    */
 449   *pszUserType = CoTaskMemAlloc(cbData);
 450
 451   if (*pszUserType==NULL)
 452   {
 453     RegCloseKey(clsidKey);
 454     return E_OUTOFMEMORY;
 455   }
 456
 457   hres = RegQueryValueExA(HKEY_CLASSES_ROOT,
 458                           "",
 459                           NULL,
 460                           &dwKeyType,
 461                           (LPBYTE)*pszUserType,
 462                           &cbData);
 463
 464   RegCloseKey(clsidKey);
 465
 466   if (hres!=ERROR_SUCCESS)
 467   {
 468     CoTaskMemFree(*pszUserType);
 469     *pszUserType=NULL;
 470
 471     return REGDB_E_READREGDB;
 472   }
 473
 474   return S_OK;
 475 }
 476
 477 /***********************************************************************
 478  * DoDragDrop32 [OLE32.65]
 479  */
 480 HRESULT WINAPI DoDragDrop (
 481   IDataObject *pDataObject,  /* ptr to the data obj           */
 482   IDropSource* pDropSource,  /* ptr to the source obj         */
 483   DWORD       dwOKEffect,    /* effects allowed by the source */
 484   DWORD       *pdwEffect)    /* ptr to effects of the source  */
 485 {
 486   TrackerWindowInfo trackerInfo;
 487   HWND            hwndTrackWindow;
 488   MSG             msg;
 489
 490   TRACE(ole,"(DataObject %p, DropSource %p)\n", pDataObject, pDropSource);
 491
 492   /*
 493    * Setup the drag n drop tracking window.
 494    */
 495   trackerInfo.dataObject        = pDataObject;
 496   trackerInfo.dropSource        = pDropSource;
 497   trackerInfo.dwOKEffect        = dwOKEffect;
 498   trackerInfo.pdwEffect         = pdwEffect;
 499   trackerInfo.trackingDone      = FALSE;
 500   trackerInfo.escPressed        = FALSE;
 501   trackerInfo.curDragTargetHWND = 0;
 502   trackerInfo.curDragTarget     = 0;
 503
 504   hwndTrackWindow = CreateWindowA(OLEDD_DRAGTRACKERCLASS,
 505                                     "TrackerWindow",
 506                                     WS_POPUP,
 507                                     CW_USEDEFAULT, CW_USEDEFAULT,
 508                                     CW_USEDEFAULT, CW_USEDEFAULT,
 509                                     0,
 510                                     0,
 511                                     0,
 512                                     (LPVOID)&trackerInfo);
 513
 514   if (hwndTrackWindow!=0)
 515   {
 516     /*
 517      * Capture the mouse input
 518      */
 519     SetCapture(hwndTrackWindow);
 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       if ( (msg.message >= WM_KEYFIRST) &&
 527            (msg.message <= WM_KEYFIRST) )
 528       {
 529         /*
 530          * When keyboard messages are sent to windows on this thread, we
 531          * want to ignore notify the drop source that the state changed.
 532          * in the case of the Escape key, we also notify the drop source
 533          * we give it a special meaning.
 534          */
 535         if ( (msg.message==WM_KEYDOWN) &&
 536              (msg.wParam==VK_ESCAPE) )
 537         {
 538           trackerInfo.escPressed = TRUE;
 539         }
 540
 541         /*
 542          * Notify the drop source.
 543          */
 544         OLEDD_TrackStateChange(&trackerInfo,
 545                                msg.pt,
 546                                OLEDD_GetButtonState());
 547       }
 548       else
 549       {
 550         /*
 551          * Dispatch the messages only when it's not a keyboard message.
 552          */
 553         DispatchMessageA(&msg);
 554       }
 555     }
 556
 557     /*
 558      * Destroy the temporary window.
 559      */
 560     DestroyWindow(hwndTrackWindow);
 561
 562     return trackerInfo.returnValue;
 563   }
 564
 565   return E_FAIL;
 566 }
 567
 568 /***********************************************************************
 569  * OleQueryLinkFromData32 [OLE32.118]
 570  */
 571 HRESULT WINAPI OleQueryLinkFromData(
 572   IDataObject* pSrcDataObject)
 573 {
 574   FIXME(ole,"(%p),stub!\n", pSrcDataObject);
 575   return S_OK;
 576 }
 577
 578 /***********************************************************************
 579  * OleRegGetMiscStatus [OLE32.121]
 580  */
 581 HRESULT WINAPI OleRegGetMiscStatus(
 582   REFCLSID clsid,
 583   DWORD    dwAspect,
 584   DWORD*   pdwStatus)
 585 {
 586   char    xclsid[50];
 587   char    keyName[60];
 588   HKEY    clsidKey;
 589   HKEY    miscStatusKey;
 590   HKEY    aspectKey;
 591   LONG    result;
 592
 593   /*
 594    * Initialize the out parameter.
 595    */
 596   *pdwStatus = 0;
 597
 598   /*
 599    * Build the key name we're looking for
 600    */
 601   WINE_StringFromCLSID((LPCLSID)clsid, xclsid);
 602
 603   strcpy(keyName, "CLSID\\");
 604   strcat(keyName, xclsid);
 605   strcat(keyName, "\\");
 606
 607   TRACE(ole,"(%s, %ld, %p)\n", keyName, dwAspect, pdwStatus);
 608
 609   /*
 610    * Open the class id Key
 611    */
 612   result = RegOpenKeyA(HKEY_CLASSES_ROOT,
 613                        keyName,
 614                        &clsidKey);
 615
 616   if (result != ERROR_SUCCESS)
 617     return REGDB_E_CLASSNOTREG;
 618
 619   /*
 620    * Get the MiscStatus
 621    */
 622   result = RegOpenKeyA(clsidKey,
 623                        "MiscStatus",
 624                        &miscStatusKey);
 625
 626
 627   if (result != ERROR_SUCCESS)
 628   {
 629     RegCloseKey(clsidKey);
 630     return REGDB_E_READREGDB;
 631   }
 632
 633   /*
 634    * Read the default value
 635    */
 636   OLEUTL_ReadRegistryDWORDValue(miscStatusKey, pdwStatus);
 637
 638   /*
 639    * Open the key specific to the requested aspect.
 640    */
 641   sprintf(keyName, "%ld", dwAspect);
 642
 643   result = RegOpenKeyA(miscStatusKey,
 644                        keyName,
 645                        &aspectKey);
 646
 647   if (result == ERROR_SUCCESS)
 648   {
 649     OLEUTL_ReadRegistryDWORDValue(aspectKey, pdwStatus);
 650     RegCloseKey(aspectKey);
 651   }
 652
 653   /*
 654    * Cleanup
 655    */
 656   RegCloseKey(miscStatusKey);
 657   RegCloseKey(clsidKey);
 658
 659   return S_OK;
 660 }
 661
 662 /******************************************************************************
 663  *              OleSetContainedObject        [OLE32.128]
 664  */
 665 HRESULT WINAPI OleSetContainedObject(
 666   LPUNKNOWN pUnknown,
 667   BOOL      fContained)
 668 {
 669   IRunnableObject* runnable = NULL;
 670   HRESULT          hres;
 671
 672   TRACE(ole,"(%p,%x), stub!\n", pUnknown, fContained);
 673
 674   hres = IUnknown_QueryInterface(pUnknown,
 675                                  &IID_IRunnableObject,
 676                                  (void**)&runnable);
 677
 678   if (SUCCEEDED(hres))
 679   {
 680     hres = IRunnableObject_SetContainedObject(runnable, fContained);
 681
 682     IRunnableObject_Release(runnable);
 683
 684     return hres;
 685   }
 686
 687   return S_OK;
 688 }
 689
 690 /******************************************************************************
 691  *              OleLoad        [OLE32.112]
 692  */
 693 HRESULT WINAPI OleLoad(
 694   LPSTORAGE       pStg,
 695   REFIID          riid,
 696   LPOLECLIENTSITE pClientSite,
 697   LPVOID*         ppvObj)
 698 {
 699   IPersistStorage* persistStorage = NULL;
 700   IOleObject*      oleObject      = NULL;
 701   STATSTG          storageInfo;
 702   HRESULT          hres;
 703
 704   TRACE(ole,"(%p,%p,%p,%p)\n", pStg, riid, pClientSite, ppvObj);
 705
 706   /*
 707    * TODO, Conversion ... OleDoAutoConvert
 708    */
 709
 710   /*
 711    * Get the class ID for the object.
 712    */
 713   hres = IStorage_Stat(pStg, &storageInfo, STATFLAG_NONAME);
 714
 715   /*
 716    * Now, try and create the handler for the object
 717    */
 718   hres = CoCreateInstance(&storageInfo.clsid,
 719                           NULL,
 720                           CLSCTX_INPROC_HANDLER,
 721                           &IID_IOleObject,
 722                           (void**)&oleObject);
 723
 724   /*
 725    * If that fails, as it will most times, load the default
 726    * OLE handler.
 727    */
 728   if (FAILED(hres))
 729   {
 730     hres = OleCreateDefaultHandler(&storageInfo.clsid,
 731                                    NULL,
 732                                    &IID_IOleObject,
 733                                    (void**)&oleObject);
 734   }
 735
 736   /*
 737    * If we couldn't find a handler... this is bad. Abort the whole thing.
 738    */
 739   if (FAILED(hres))
 740     return hres;
 741
 742   /*
 743    * Inform the new object of it's client site.
 744    */
 745   hres = IOleObject_SetClientSite(oleObject, pClientSite);
 746
 747   /*
 748    * Initialize the object with it's IPersistStorage interface.
 749    */
 750   hres = IOleObject_QueryInterface(oleObject,
 751                                    &IID_IPersistStorage,
 752                                    (void**)&persistStorage);
 753
 754   if (SUCCEEDED(hres))
 755   {
 756     IPersistStorage_Load(persistStorage, pStg);
 757
 758     IPersistStorage_Release(persistStorage);
 759     persistStorage = NULL;
 760   }
 761
 762   /*
 763    * Return the requested interface to the caller.
 764    */
 765   hres = IOleObject_QueryInterface(oleObject, riid, ppvObj);
 766
 767   /*
 768    * Cleanup interfaces used internally
 769    */
 770   IOleObject_Release(oleObject);
 771
 772   return hres;
 773 }
 774
 775 /***********************************************************************
 776  * OleGetClipboard32 [OLE32.105]
 777  */
 778 HRESULT WINAPI OleGetClipboard(
 779   IDataObject** ppDataObj)
 780 {
 781   FIXME(ole,"(%p),stub!\n", ppDataObj);
 782
 783   if (ppDataObj)
 784     *ppDataObj=0;
 785
 786   return E_FAIL;
 787 }
 788
 789
 790 /**************************************************************************
 791  * Internal methods to manage the shared OLE menu in response to the
 792  * OLE***MenuDescriptor API
 793  */
 794
 795 /***
 796  * OLEMenu_Initialize()
 797  *
 798  * Initializes the OLEMENU data structures.
 799  */
 800 static void OLEMenu_Initialize()
 801 {
 802   /* Create a dynamic pointer array to store the hook handles */
 803   if ( !OLEMenu_MsgHookDPA )
 804     OLEMenu_MsgHookDPA = DPA_CreateEx( 2, GetProcessHeap() );
 805 }
 806
 807 /***
 808  * OLEMenu_UnInitialize()
 809  *
 810  * Releases the OLEMENU data structures.
 811  */
 812 static void OLEMenu_UnInitialize()
 813 {
 814   /* Release the hook table */
 815   if ( OLEMenu_MsgHookDPA )
 816     DPA_Destroy( OLEMenu_MsgHookDPA );
 817
 818   OLEMenu_MsgHookDPA = NULL;
 819 }
 820
 821 /*************************************************************************
 822  * OLEMenu_InstallHooks
 823  * Install thread scope message hooks for WH_GETMESSAGE and WH_CALLWNDPROC
 824  *
 825  * RETURNS: TRUE if message hooks were succesfully installed
 826  *          FALSE on failure
 827  */
 828 BOOL OLEMenu_InstallHooks( DWORD tid )
 829 {
 830   OleMenuHookItem *pHookItem = NULL;
 831
 832   if ( !OLEMenu_MsgHookDPA ) /* No hook table? Create one */
 833   {
 834     /* Create a dynamic pointer array to store the hook handles */
 835     if ( !(OLEMenu_MsgHookDPA = DPA_CreateEx( 2, GetProcessHeap() )) )
 836       return FALSE;
 837   }
 838
 839   /* Create an entry for the hook table */
 840   if ( !(pHookItem = HeapAlloc(GetProcessHeap(), 0,
 841                                sizeof(OleMenuHookItem)) ) )
 842     return FALSE;
 843
 844   pHookItem->tid = tid;
 845   pHookItem->hHeap = GetProcessHeap();
 846
 847   /* Install a thread scope message hook for WH_GETMESSAGE */
 848   pHookItem->GetMsg_hHook = SetWindowsHookExA( WH_GETMESSAGE, OLEMenu_GetMsgProc,
 849                                                0, GetCurrentThreadId() );
 850   if ( !pHookItem->GetMsg_hHook )
 851     goto CLEANUP;
 852
 853   /* Install a thread scope message hook for WH_CALLWNDPROC */
 854   pHookItem->CallWndProc_hHook = SetWindowsHookExA( WH_CALLWNDPROC, OLEMenu_CallWndProc,
 855                                                     0, GetCurrentThreadId() );
 856   if ( !pHookItem->CallWndProc_hHook )
 857     goto CLEANUP;
 858
 859   /* Insert the hook table entry */
 860   if ( -1 == DPA_InsertPtr( OLEMenu_MsgHookDPA, 0, pHookItem ) )
 861     goto CLEANUP;
 862
 863   return TRUE;
 864
 865 CLEANUP:
 866   /* Unhook any hooks */
 867   if ( pHookItem->GetMsg_hHook )
 868     UnhookWindowsHookEx( pHookItem->GetMsg_hHook );
 869   if ( pHookItem->CallWndProc_hHook )
 870     UnhookWindowsHookEx( pHookItem->CallWndProc_hHook );
 871   /* Release the hook table entry */
 872   HeapFree(pHookItem->hHeap, 0, pHookItem );
 873
 874   return FALSE;
 875 }
 876
 877 /*************************************************************************
 878  * OLEMenu_UnInstallHooks
 879  * UnInstall thread scope message hooks for WH_GETMESSAGE and WH_CALLWNDPROC
 880  *
 881  * RETURNS: TRUE if message hooks were succesfully installed
 882  *          FALSE on failure
 883  */
 884 BOOL OLEMenu_UnInstallHooks( DWORD tid )
 885 {
 886   INT ixHook;
 887   OleMenuHookItem *pHookItem = NULL;
 888
 889   if ( !OLEMenu_MsgHookDPA )  /* No hooks set */
 890     return TRUE;
 891
 892   /* Lookup the hHook index for this tid */
 893   if ( !OLEMenu_IsHookInstalled( tid , &ixHook ) )
 894     return TRUE;
 895
 896   /* Remove the hook entry from the table(the pointer itself is not deleted) */
 897   if ( !( pHookItem = DPA_DeletePtr(OLEMenu_MsgHookDPA, ixHook) ) )
 898     return FALSE;
 899
 900   /* Uninstall the hooks installed for this thread */
 901   if ( !UnhookWindowsHookEx( pHookItem->GetMsg_hHook ) )
 902     goto CLEANUP;
 903   if ( !UnhookWindowsHookEx( pHookItem->CallWndProc_hHook ) )
 904     goto CLEANUP;
 905
 906   /* Release the hook table entry */
 907   HeapFree(pHookItem->hHeap, 0, pHookItem );
 908
 909   return TRUE;
 910
 911 CLEANUP:
 912   /* Release the hook table entry */
 913   if (pHookItem)
 914     HeapFree(pHookItem->hHeap, 0, pHookItem );
 915
 916   return FALSE;
 917 }
 918
 919 /*************************************************************************
 920  * OLEMenu_IsHookInstalled
 921  * Tests if OLEMenu hooks have been installed for a thread
 922  *
 923  * RETURNS: The pointer and index of the hook table entry for the tid
 924  *          NULL and -1 for the index if no hooks were installed for this thread
 925  */
 926 OleMenuHookItem * OLEMenu_IsHookInstalled( DWORD tid, INT *pixHook )
 927 {
 928   INT ixHook;
 929   OleMenuHookItem *pHookItem = NULL;
 930
 931   if ( pixHook )
 932     *pixHook = -1;
 933
 934   if ( !OLEMenu_MsgHookDPA )  /* No hooks set */
 935     return NULL;
 936
 937   /* Do a simple linear search for an entry whose tid matches ours.
 938    * We really need a map but efficiency is not a concern here. */
 939   for( ixHook = 0; ; ixHook++ )
 940   {
 941     /* Retrieve the hook entry */
 942     if ( !( pHookItem = DPA_GetPtr(OLEMenu_MsgHookDPA, ixHook) ) )
 943       return NULL;
 944
 945     if ( tid == pHookItem->tid )
 946     {
 947       if ( pixHook )
 948         *pixHook = ixHook;
 949       return pHookItem;
 950     }
 951   }
 952
 953   return NULL;
 954 }
 955
 956 /***********************************************************************
 957  *           OLEMenu_FindMainMenuIndex
 958  *
 959  * Used by OLEMenu API to find the top level group a menu item belongs to.
 960  * On success pnPos contains the index of the item in the top level menu group
 961  *
 962  * RETURNS: TRUE if the ID was found, FALSE on failure
 963  */
 964 static BOOL OLEMenu_FindMainMenuIndex( HMENU hMainMenu, HMENU hPopupMenu, UINT *pnPos )
 965 {
 966   UINT i, nItems;
 967
 968   nItems = GetMenuItemCount( hMainMenu );
 969
 970   for (i = 0; i < nItems; i++)
 971   {
 972     HMENU hsubmenu;
 973
 974     /*  Is the current item a submenu? */
 975     if ( (hsubmenu = GetSubMenu(hMainMenu, i)) )
 976     {
 977       /* If the handle is the same we're done */
 978       if ( hsubmenu == hPopupMenu )
 979       {
 980         if (pnPos)
 981           *pnPos = i;
 982         return TRUE;
 983       }
 984       /* Recursively search without updating pnPos */
 985       else if ( OLEMenu_FindMainMenuIndex( hsubmenu, hPopupMenu, NULL ) )
 986       {
 987         if (pnPos)
 988           *pnPos = i;
 989         return TRUE;
 990       }
 991     }
 992   }
 993
 994   return FALSE;
 995 }
 996
 997 /***********************************************************************
 998  *           OLEMenu_SetIsServerMenu
 999  *
1000  * Checks whether a popup menu belongs to a shared menu group which is
1001  * owned by the server, and sets the menu descriptor state accordingly.
1002  * All menu messages from these groups should be routed to the server.
1003  *
1004  * RETURNS: TRUE if the popup menu is part of a server owned group
1005  *          FASE if the popup menu is part of a container owned group
1006  */
1007 BOOL OLEMenu_SetIsServerMenu( HMENU hmenu, OleMenuDescriptor *pOleMenuDescriptor )
1008 {
1009   UINT nPos = 0, nWidth, i;
1010
1011   pOleMenuDescriptor->bIsServerItem = FALSE;
1012
1013   /* Don't bother searching if the popup is the combined menu itself */
1014   if ( hmenu == pOleMenuDescriptor->hmenuCombined )
1015     return FALSE;
1016
1017   /* Find the menu item index in the shared OLE menu that this item belongs to */
1018   if ( !OLEMenu_FindMainMenuIndex( pOleMenuDescriptor->hmenuCombined, hmenu,  &nPos ) )
1019     return FALSE;
1020
1021   /* The group widths array has counts for the number of elements
1022    * in the groups File, Edit, Container, Object, Window, Help.
1023    * The Edit, Object & Help groups belong to the server object
1024    * and the other three belong to the container.
1025    * Loop thru the group widths and locate the group we are a member of.
1026    */
1027   for ( i = 0, nWidth = 0; i < 6; i++ )
1028   {
1029     nWidth += pOleMenuDescriptor->mgw.width[i];
1030     if ( nPos < nWidth )
1031     {
1032       /* Odd elements are server menu widths */
1033       pOleMenuDescriptor->bIsServerItem = (i%2) ? TRUE : FALSE;
1034       break;
1035     }
1036   }
1037
1038   return pOleMenuDescriptor->bIsServerItem;
1039 }
1040
1041 /*************************************************************************
1042  * OLEMenu_CallWndProc
1043  * Thread scope WH_CALLWNDPROC hook proc filter function (callback)
1044  * This is invoked from a message hook installed in OleSetMenuDescriptor.
1045  */
1046 LRESULT CALLBACK OLEMenu_CallWndProc(INT code, WPARAM wParam, LPARAM lParam)
1047 {
1048   LPCWPSTRUCT pMsg = NULL;
1049   HOLEMENU hOleMenu = 0;
1050   OleMenuDescriptor *pOleMenuDescriptor = NULL;
1051   OleMenuHookItem *pHookItem = NULL;
1052   WORD fuFlags;
1053
1054   TRACE(ole,"%i, %04x, %08x\n", code, wParam, (unsigned)lParam );
1055
1056   /* Check if we're being asked to process the message */
1057   if ( HC_ACTION != code )
1058     goto NEXTHOOK;
1059
1060   /* Retrieve the current message being dispatched from lParam */
1061   pMsg = (LPCWPSTRUCT)lParam;
1062
1063   /* Check if the message is destined for a window we are interested in:
1064    * If the window has an OLEMenu property we may need to dispatch
1065    * the menu message to its active objects window instead. */
1066
1067   hOleMenu = (HOLEMENU)GetPropA( pMsg->hwnd, "PROP_OLEMenuDescriptor" );
1068   if ( !hOleMenu )
1069     goto NEXTHOOK;
1070
1071   /* Get the menu descriptor */
1072   pOleMenuDescriptor = (OleMenuDescriptor *) GlobalLock( hOleMenu );
1073   if ( !pOleMenuDescriptor ) /* Bad descriptor! */
1074     goto NEXTHOOK;
1075
1076   /* Process menu messages */
1077   switch( pMsg->message )
1078   {
1079     case WM_INITMENU:
1080     {
1081       /* Reset the menu descriptor state */
1082       pOleMenuDescriptor->bIsServerItem = FALSE;
1083
1084       /* Send this message to the server as well */
1085       SendMessageA( pOleMenuDescriptor->hwndActiveObject,
1086                   pMsg->message, pMsg->wParam, pMsg->lParam );
1087       goto NEXTHOOK;
1088     }
1089
1090     case WM_INITMENUPOPUP:
1091     {
1092       /* Save the state for whether this is a server owned menu */
1093       OLEMenu_SetIsServerMenu( (HMENU)pMsg->wParam, pOleMenuDescriptor );
1094       break;
1095     }
1096
1097     case WM_MENUSELECT:
1098     {
1099       fuFlags = HIWORD(pMsg->wParam);  /* Get flags */
1100       if ( fuFlags & MF_SYSMENU )
1101          goto NEXTHOOK;
1102
1103       /* Save the state for whether this is a server owned popup menu */
1104       else if ( fuFlags & MF_POPUP )
1105         OLEMenu_SetIsServerMenu( (HMENU)pMsg->lParam, pOleMenuDescriptor );
1106
1107       break;
1108     }
1109
1110     case WM_DRAWITEM:
1111     {
1112       LPDRAWITEMSTRUCT lpdis = (LPDRAWITEMSTRUCT) pMsg->lParam;
1113       if ( pMsg->wParam != 0 || lpdis->CtlType != ODT_MENU )
1114         goto NEXTHOOK;  /* Not a menu message */
1115
1116       break;
1117     }
1118
1119     default:
1120       goto NEXTHOOK;
1121   }
1122
1123   /* If the message was for the server dispatch it accordingly */
1124   if ( pOleMenuDescriptor->bIsServerItem )
1125   {
1126     SendMessageA( pOleMenuDescriptor->hwndActiveObject,
1127                   pMsg->message, pMsg->wParam, pMsg->lParam );
1128   }
1129
1130 NEXTHOOK:
1131   if ( pOleMenuDescriptor )
1132     GlobalUnlock( hOleMenu );
1133
1134   /* Lookup the hook item for the current thread */
1135   if ( !( pHookItem = OLEMenu_IsHookInstalled( GetCurrentThreadId(), NULL ) ) )
1136   {
1137     /* This should never fail!! */
1138     WARN(ole, "could not retrieve hHook for current thread!\n" );
1139     return 0;
1140   }
1141
1142   /* Pass on the message to the next hooker */
1143   return CallNextHookEx( pHookItem->CallWndProc_hHook, code, wParam, lParam );
1144 }
1145
1146 /*************************************************************************
1147  * OLEMenu_GetMsgProc
1148  * Thread scope WH_GETMESSAGE hook proc filter function (callback)
1149  * This is invoked from a message hook installed in OleSetMenuDescriptor.
1150  */
1151 LRESULT CALLBACK OLEMenu_GetMsgProc(INT code, WPARAM wParam, LPARAM lParam)
1152 {
1153   LPMSG pMsg = NULL;
1154   HOLEMENU hOleMenu = 0;
1155   OleMenuDescriptor *pOleMenuDescriptor = NULL;
1156   OleMenuHookItem *pHookItem = NULL;
1157   WORD wCode;
1158
1159   TRACE(ole,"%i, %04x, %08x\n", code, wParam, (unsigned)lParam );
1160
1161   /* Check if we're being asked to process a  messages */
1162   if ( HC_ACTION != code )
1163     goto NEXTHOOK;
1164
1165   /* Retrieve the current message being dispatched from lParam */
1166   pMsg = (LPMSG)lParam;
1167
1168   /* Check if the message is destined for a window we are interested in:
1169    * If the window has an OLEMenu property we may need to dispatch
1170    * the menu message to its active objects window instead. */
1171
1172   hOleMenu = (HOLEMENU)GetPropA( pMsg->hwnd, "PROP_OLEMenuDescriptor" );
1173   if ( !hOleMenu )
1174     goto NEXTHOOK;
1175
1176   /* Process menu messages */
1177   switch( pMsg->message )
1178   {
1179     case WM_COMMAND:
1180     {
1181       wCode = HIWORD(pMsg->wParam);  /* Get notification code */
1182       if ( wCode )
1183         goto NEXTHOOK;  /* Not a menu message */
1184       break;
1185     }
1186     default:
1187       goto NEXTHOOK;
1188   }
1189
1190   /* Get the menu descriptor */
1191   pOleMenuDescriptor = (OleMenuDescriptor *) GlobalLock( hOleMenu );
1192   if ( !pOleMenuDescriptor ) /* Bad descriptor! */
1193     goto NEXTHOOK;
1194
1195   /* If the message was for the server dispatch it accordingly */
1196   if ( pOleMenuDescriptor->bIsServerItem )
1197   {
1198     /* Change the hWnd in the message to the active objects hWnd.
1199      * The message loop which reads this message will automatically
1200      * dispatch it to the embedded objects window. */
1201     pMsg->hwnd = pOleMenuDescriptor->hwndActiveObject;
1202   }
1203
1204 NEXTHOOK:
1205   if ( pOleMenuDescriptor )
1206     GlobalUnlock( hOleMenu );
1207
1208   /* Lookup the hook item for the current thread */
1209   if ( !( pHookItem = OLEMenu_IsHookInstalled( GetCurrentThreadId(), NULL ) ) )
1210   {
1211     /* This should never fail!! */
1212     WARN(ole, "could not retrieve hHook for current thread!\n" );
1213     return FALSE;
1214   }
1215
1216   /* Pass on the message to the next hooker */
1217   return CallNextHookEx( pHookItem->GetMsg_hHook, code, wParam, lParam );
1218 }
1219
1220 /***********************************************************************
1221  * OleCreateMenuDescriptor [OLE32.97]
1222  * Creates an OLE menu descriptor for OLE to use when dispatching
1223  * menu messages and commands.
1224  *
1225  * PARAMS:
1226  *    hmenuCombined  -  Handle to the objects combined menu
1227  *    lpMenuWidths   -  Pointer to array of 6 LONG's indicating menus per group
1228  *
1229  */
1230 HOLEMENU WINAPI OleCreateMenuDescriptor(
1231   HMENU                hmenuCombined,
1232   LPOLEMENUGROUPWIDTHS lpMenuWidths)
1233 {
1234   HOLEMENU hOleMenu;
1235   OleMenuDescriptor *pOleMenuDescriptor;
1236   int i;
1237
1238   if ( !hmenuCombined || !lpMenuWidths )
1239     return 0;
1240
1241   /* Create an OLE menu descriptor */
1242   if ( !(hOleMenu = GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT,
1243                                 sizeof(OleMenuDescriptor) ) ) )
1244   return 0;
1245
1246   pOleMenuDescriptor = (OleMenuDescriptor *) GlobalLock( hOleMenu );
1247   if ( !pOleMenuDescriptor )
1248     return 0;
1249
1250   /* Initialize menu group widths and hmenu */
1251   for ( i = 0; i < 6; i++ )
1252     pOleMenuDescriptor->mgw.width[i] = lpMenuWidths->width[i];
1253
1254   pOleMenuDescriptor->hmenuCombined = hmenuCombined;
1255   pOleMenuDescriptor->bIsServerItem = FALSE;
1256   GlobalUnlock( hOleMenu );
1257
1258   return hOleMenu;
1259 }
1260
1261 /***********************************************************************
1262  * OleDestroyMenuDescriptor [OLE32.99]
1263  * Destroy the shared menu descriptor
1264  */
1265 HRESULT WINAPI OleDestroyMenuDescriptor(
1266   HOLEMENU hmenuDescriptor)
1267 {
1268   if ( hmenuDescriptor )
1269     GlobalFree( hmenuDescriptor );
1270         return S_OK;
1271 }
1272
1273 /***********************************************************************
1274  * OleSetMenuDescriptor [OLE32.129]
1275  * Installs or removes OLE dispatching code for the containers frame window
1276  * FIXME: The lpFrame and lpActiveObject parameters are currently ignored
1277  * OLE should install context sensitive help F1 filtering for the app when
1278  * these are non null.
1279  *
1280  * PARAMS:
1281  *     hOleMenu         Handle to composite menu descriptor
1282  *     hwndFrame        Handle to containers frame window
1283  *     hwndActiveObject Handle to objects in-place activation window
1284  *     lpFrame          Pointer to IOleInPlaceFrame on containers window
1285  *     lpActiveObject   Pointer to IOleInPlaceActiveObject on active in-place object
1286  *
1287  * RETURNS:
1288  *      S_OK                               - menu installed correctly
1289  *      E_FAIL, E_INVALIDARG, E_UNEXPECTED - failure
1290  */
1291 HRESULT WINAPI OleSetMenuDescriptor(
1292   HOLEMENU               hOleMenu,
1293   HWND                   hwndFrame,
1294   HWND                   hwndActiveObject,
1295   LPOLEINPLACEFRAME        lpFrame,
1296   LPOLEINPLACEACTIVEOBJECT lpActiveObject)
1297 {
1298   OleMenuDescriptor *pOleMenuDescriptor = NULL;
1299
1300   /* Check args */
1301   if ( !hwndFrame || (hOleMenu && !hwndActiveObject) )
1302     return E_INVALIDARG;
1303
1304   if ( lpFrame || lpActiveObject )
1305   {
1306      FIXME(ole,"(%x, %x, %x, %p, %p), Context sensitive help filtering not implemented!\n",
1307         (unsigned int)hOleMenu,
1308         hwndFrame,
1309         hwndActiveObject,
1310         lpFrame,
1311         lpActiveObject);
1312   }
1313
1314   /* Set up a message hook to intercept the containers frame window messages.
1315    * The message filter is responsible for dispatching menu messages from the
1316    * shared menu which are intended for the object.
1317    */
1318
1319   if ( hOleMenu )  /* Want to install dispatching code */
1320   {
1321     /* If OLEMenu hooks are already installed for this thread, fail
1322      * Note: This effectively means that OleSetMenuDescriptor cannot
1323      * be called twice in succession on the same frame window
1324      * without first calling it with a null hOleMenu to uninstall */
1325     if ( OLEMenu_IsHookInstalled( GetCurrentThreadId(), NULL ) )
1326   return E_FAIL;
1327
1328     /* Get the menu descriptor */
1329     pOleMenuDescriptor = (OleMenuDescriptor *) GlobalLock( hOleMenu );
1330     if ( !pOleMenuDescriptor )
1331       return E_UNEXPECTED;
1332
1333     /* Update the menu descriptor */
1334     pOleMenuDescriptor->hwndFrame = hwndFrame;
1335     pOleMenuDescriptor->hwndActiveObject = hwndActiveObject;
1336
1337     GlobalUnlock( hOleMenu );
1338     pOleMenuDescriptor = NULL;
1339
1340     /* Add a menu descriptor windows property to the frame window */
1341     SetPropA( hwndFrame, "PROP_OLEMenuDescriptor", hOleMenu );
1342
1343     /* Install thread scope message hooks for WH_GETMESSAGE and WH_CALLWNDPROC */
1344     if ( !OLEMenu_InstallHooks( GetCurrentThreadId() ) )
1345       return E_FAIL;
1346   }
1347   else  /* Want to uninstall dispatching code */
1348   {
1349     /* Uninstall the hooks */
1350     if ( !OLEMenu_UnInstallHooks( GetCurrentThreadId() ) )
1351       return E_FAIL;
1352
1353     /* Remove the menu descriptor property from the frame window */
1354     RemovePropA( hwndFrame, "PROP_OLEMenuDescriptor" );
1355   }
1356
1357   return S_OK;
1358 }
1359
1360 /***********************************************************************
1361  * ReleaseStgMedium [OLE32.140]
1362  */
1363 void WINAPI ReleaseStgMedium(
1364   STGMEDIUM* pmedium)
1365 {
1366   switch (pmedium->tymed)
1367   {
1368     case TYMED_HGLOBAL:
1369     {
1370       if ( (pmedium->pUnkForRelease==0) &&
1371            (pmedium->u.hGlobal!=0) )
1372         GlobalFree(pmedium->u.hGlobal);
1373
1374       pmedium->u.hGlobal = 0;
1375       break;
1376     }
1377     case TYMED_FILE:
1378     {
1379       if (pmedium->u.lpszFileName!=0)
1380       {
1381         if (pmedium->pUnkForRelease==0)
1382         {
1383           DeleteFileW(pmedium->u.lpszFileName);
1384         }
1385
1386         CoTaskMemFree(pmedium->u.lpszFileName);
1387       }
1388
1389       pmedium->u.lpszFileName = 0;
1390       break;
1391     }
1392     case TYMED_ISTREAM:
1393     {
1394       if (pmedium->u.pstm!=0)
1395       {
1396         IStream_Release(pmedium->u.pstm);
1397       }
1398
1399       pmedium->u.pstm = 0;
1400       break;
1401     }
1402     case TYMED_ISTORAGE:
1403     {
1404       if (pmedium->u.pstg!=0)
1405       {
1406         IStorage_Release(pmedium->u.pstg);
1407       }
1408
1409       pmedium->u.pstg = 0;
1410       break;
1411     }
1412     case TYMED_GDI:
1413     {
1414       if ( (pmedium->pUnkForRelease==0) &&
1415            (pmedium->u.hGlobal!=0) )
1416         DeleteObject(pmedium->u.hGlobal);
1417
1418       pmedium->u.hGlobal = 0;
1419       break;
1420     }
1421     case TYMED_MFPICT:
1422     {
1423       if ( (pmedium->pUnkForRelease==0) &&
1424            (pmedium->u.hMetaFilePict!=0) )
1425       {
1426         DeleteMetaFile(pmedium->u.hMetaFilePict);
1427         GlobalFree(pmedium->u.hMetaFilePict);
1428       }
1429
1430       pmedium->u.hMetaFilePict = 0;
1431       break;
1432     }
1433     case TYMED_ENHMF:
1434     {
1435       if ( (pmedium->pUnkForRelease==0) &&
1436            (pmedium->u.hEnhMetaFile!=0) )
1437       {
1438         DeleteEnhMetaFile(pmedium->u.hEnhMetaFile);
1439       }
1440
1441       pmedium->u.hEnhMetaFile = 0;
1442       break;
1443     }
1444     case TYMED_NULL:
1445     default:
1446       break;
1447   }
1448
1449   /*
1450    * After cleaning up, the unknown is released
1451    */
1452   if (pmedium->pUnkForRelease!=0)
1453   {
1454     IUnknown_Release(pmedium->pUnkForRelease);
1455     pmedium->pUnkForRelease = 0;
1456   }
1457 }
1458
1459 /***
1460  * OLEDD_Initialize()
1461  *
1462  * Initializes the OLE drag and drop data structures.
1463  */
1464 static void OLEDD_Initialize()
1465 {
1466     WNDCLASSA wndClass;
1467
1468     ZeroMemory (&wndClass, sizeof(WNDCLASSA));
1469     wndClass.style         = CS_GLOBALCLASS;
1470     wndClass.lpfnWndProc   = (WNDPROC)OLEDD_DragTrackerWindowProc;
1471     wndClass.cbClsExtra    = 0;
1472     wndClass.cbWndExtra    = sizeof(TrackerWindowInfo*);
1473     wndClass.hCursor       = 0;
1474     wndClass.hbrBackground = 0;
1475     wndClass.lpszClassName = OLEDD_DRAGTRACKERCLASS;
1476
1477     RegisterClassA (&wndClass);
1478 }
1479
1480 /***
1481  * OLEDD_UnInitialize()
1482  *
1483  * Releases the OLE drag and drop data structures.
1484  */
1485 static void OLEDD_UnInitialize()
1486 {
1487   /*
1488    * Simply empty the list.
1489    */
1490   while (targetListHead!=NULL)
1491   {
1492     RevokeDragDrop(targetListHead->hwndTarget);
1493   }
1494 }
1495
1496 /***
1497  * OLEDD_InsertDropTarget()
1498  *
1499  * Insert the target node in the tree.
1500  */
1501 static void OLEDD_InsertDropTarget(DropTargetNode* nodeToAdd)
1502 {
1503   DropTargetNode*  curNode;
1504   DropTargetNode** parentNodeLink;
1505
1506   /*
1507    * Iterate the tree to find the insertion point.
1508    */
1509   curNode        = targetListHead;
1510   parentNodeLink = &targetListHead;
1511
1512   while (curNode!=NULL)
1513   {
1514     if (nodeToAdd->hwndTarget<curNode->hwndTarget)
1515     {
1516       /*
1517        * If the node we want to add has a smaller HWND, go left
1518        */
1519       parentNodeLink = &curNode->prevDropTarget;
1520       curNode        =  curNode->prevDropTarget;
1521     }
1522     else if (nodeToAdd->hwndTarget>curNode->hwndTarget)
1523     {
1524       /*
1525        * If the node we want to add has a larger HWND, go right
1526        */
1527       parentNodeLink = &curNode->nextDropTarget;
1528       curNode        =  curNode->nextDropTarget;
1529     }
1530     else
1531     {
1532       /*
1533        * The item was found in the list. It shouldn't have been there
1534        */
1535       assert(FALSE);
1536       return;
1537     }
1538   }
1539
1540   /*
1541    * If we get here, we have found a spot for our item. The parentNodeLink
1542    * pointer points to the pointer that we have to modify.
1543    * The curNode should be NULL. We just have to establish the link and Voila!
1544    */
1545   assert(curNode==NULL);
1546   assert(parentNodeLink!=NULL);
1547   assert(*parentNodeLink==NULL);
1548
1549   *parentNodeLink=nodeToAdd;
1550 }
1551
1552 /***
1553  * OLEDD_ExtractDropTarget()
1554  *
1555  * Removes the target node from the tree.
1556  */
1557 static DropTargetNode* OLEDD_ExtractDropTarget(HWND hwndOfTarget)
1558 {
1559   DropTargetNode*  curNode;
1560   DropTargetNode** parentNodeLink;
1561
1562   /*
1563    * Iterate the tree to find the insertion point.
1564    */
1565   curNode        = targetListHead;
1566   parentNodeLink = &targetListHead;
1567
1568   while (curNode!=NULL)
1569   {
1570     if (hwndOfTarget<curNode->hwndTarget)
1571     {
1572       /*
1573        * If the node we want to add has a smaller HWND, go left
1574        */
1575       parentNodeLink = &curNode->prevDropTarget;
1576       curNode        =  curNode->prevDropTarget;
1577     }
1578     else if (hwndOfTarget>curNode->hwndTarget)
1579     {
1580       /*
1581        * If the node we want to add has a larger HWND, go right
1582        */
1583       parentNodeLink = &curNode->nextDropTarget;
1584       curNode        =  curNode->nextDropTarget;
1585     }
1586     else
1587     {
1588       /*
1589        * The item was found in the list. Detach it from it's parent and
1590        * re-insert it's kids in the tree.
1591        */
1592       assert(parentNodeLink!=NULL);
1593       assert(*parentNodeLink==curNode);
1594
1595       /*
1596        * We arbitrately re-attach the left sub-tree to the parent.
1597        */
1598       *parentNodeLink = curNode->prevDropTarget;
1599
1600       /*
1601        * And we re-insert the right subtree
1602        */
1603       if (curNode->nextDropTarget!=NULL)
1604       {
1605         OLEDD_InsertDropTarget(curNode->nextDropTarget);
1606       }
1607
1608       /*
1609        * The node we found is still a valid node once we complete
1610        * the unlinking of the kids.
1611        */
1612       curNode->nextDropTarget=NULL;
1613       curNode->prevDropTarget=NULL;
1614
1615       return curNode;
1616     }
1617   }
1618
1619   /*
1620    * If we get here, the node is not in the tree
1621    */
1622   return NULL;
1623 }
1624
1625 /***
1626  * OLEDD_FindDropTarget()
1627  *
1628  * Finds information about the drop target.
1629  */
1630 static DropTargetNode* OLEDD_FindDropTarget(HWND hwndOfTarget)
1631 {
1632   DropTargetNode*  curNode;
1633
1634   /*
1635    * Iterate the tree to find the HWND value.
1636    */
1637   curNode        = targetListHead;
1638
1639   while (curNode!=NULL)
1640   {
1641     if (hwndOfTarget<curNode->hwndTarget)
1642     {
1643       /*
1644        * If the node we want to add has a smaller HWND, go left
1645        */
1646       curNode =  curNode->prevDropTarget;
1647     }
1648     else if (hwndOfTarget>curNode->hwndTarget)
1649     {
1650       /*
1651        * If the node we want to add has a larger HWND, go right
1652        */
1653       curNode =  curNode->nextDropTarget;
1654     }
1655     else
1656     {
1657       /*
1658        * The item was found in the list.
1659        */
1660       return curNode;
1661     }
1662   }
1663
1664   /*
1665    * If we get here, the item is not in the list
1666    */
1667   return NULL;
1668 }
1669
1670 /***
1671  * OLEDD_DragTrackerWindowProc()
1672  *
1673  * This method is the WindowProcedure of the drag n drop tracking
1674  * window. During a drag n Drop operation, an invisible window is created
1675  * to receive the user input and act upon it. This procedure is in charge
1676  * of this behavior.
1677  */
1678 static LRESULT WINAPI OLEDD_DragTrackerWindowProc(
1679                          HWND   hwnd,
1680                          UINT   uMsg,
1681                          WPARAM wParam,
1682                          LPARAM   lParam)
1683 {
1684   switch (uMsg)
1685   {
1686     case WM_CREATE:
1687     {
1688       LPCREATESTRUCTA createStruct = (LPCREATESTRUCTA)lParam;
1689
1690       SetWindowLongA(hwnd, 0, (LONG)createStruct->lpCreateParams);
1691
1692
1693       break;
1694     }
1695     case WM_MOUSEMOVE:
1696     {
1697       TrackerWindowInfo* trackerInfo = (TrackerWindowInfo*)GetWindowLongA(hwnd, 0);
1698       POINT            mousePos;
1699
1700       /*
1701        * Get the current mouse position in screen coordinates.
1702        */
1703       mousePos.x = LOWORD(lParam);
1704       mousePos.y = HIWORD(lParam);
1705       ClientToScreen(hwnd, &mousePos);
1706
1707       /*
1708        * Track the movement of the mouse.
1709        */
1710       OLEDD_TrackMouseMove(trackerInfo, mousePos, wParam);
1711
1712       break;
1713     }
1714     case WM_LBUTTONUP:
1715     case WM_MBUTTONUP:
1716     case WM_RBUTTONUP:
1717     case WM_LBUTTONDOWN:
1718     case WM_MBUTTONDOWN:
1719     case WM_RBUTTONDOWN:
1720     {
1721       TrackerWindowInfo* trackerInfo = (TrackerWindowInfo*)GetWindowLongA(hwnd, 0);
1722       POINT            mousePos;
1723
1724       /*
1725        * Get the current mouse position in screen coordinates.
1726        */
1727       mousePos.x = LOWORD(lParam);
1728       mousePos.y = HIWORD(lParam);
1729       ClientToScreen(hwnd, &mousePos);
1730
1731       /*
1732        * Notify everyone that the button state changed
1733        * TODO: Check if the "escape" key was pressed.
1734        */
1735       OLEDD_TrackStateChange(trackerInfo, mousePos, wParam);
1736
1737       break;
1738     }
1739   }
1740
1741   /*
1742    * This is a window proc after all. Let's call the default.
1743    */
1744   return DefWindowProcA (hwnd, uMsg, wParam, lParam);
1745 }
1746
1747 /***
1748  * OLEDD_TrackMouseMove()
1749  *
1750  * This method is invoked while a drag and drop operation is in effect.
1751  * it will generate the appropriate callbacks in the drop source
1752  * and drop target. It will also provide the expected feedback to
1753  * the user.
1754  *
1755  * params:
1756  *    trackerInfo - Pointer to the structure identifying the
1757  *                  drag & drop operation that is currently
1758  *                  active.
1759  *    mousePos    - Current position of the mouse in screen
1760  *                  coordinates.
1761  *    keyState    - Contains the state of the shift keys and the
1762  *                  mouse buttons (MK_LBUTTON and the like)
1763  */
1764 static void OLEDD_TrackMouseMove(
1765   TrackerWindowInfo* trackerInfo,
1766   POINT            mousePos,
1767   DWORD              keyState)
1768 {
1769   HWND   hwndNewTarget = 0;
1770   HRESULT  hr = S_OK;
1771
1772   /*
1773    * Get the handle of the window under the mouse
1774    */
1775   hwndNewTarget = WindowFromPoint(mousePos);
1776
1777   /*
1778    * Every time, we re-initialize the effects passed to the
1779    * IDropTarget to the effects allowed by the source.
1780    */
1781   *trackerInfo->pdwEffect = trackerInfo->dwOKEffect;
1782
1783   /*
1784    * If we are hovering over the same target as before, send the
1785    * DragOver notification
1786    */
1787   if ( (trackerInfo->curDragTarget != 0) &&
1788        (trackerInfo->curDragTargetHWND==hwndNewTarget) )
1789   {
1790     POINTL  mousePosParam;
1791
1792     /*
1793      * The documentation tells me that the coordinate should be in the target
1794      * window's coordinate space. However, the tests I made tell me the
1795      * coordinates should be in screen coordinates.
1796      */
1797     mousePosParam.x = mousePos.x;
1798     mousePosParam.y = mousePos.y;
1799
1800     IDropTarget_DragOver(trackerInfo->curDragTarget,
1801                          keyState,
1802                          mousePosParam,
1803                          trackerInfo->pdwEffect);
1804   }
1805   else
1806   {
1807     DropTargetNode* newDropTargetNode = 0;
1808
1809     /*
1810      * If we changed window, we have to notify our old target and check for
1811      * the new one.
1812      */
1813     if (trackerInfo->curDragTarget!=0)
1814     {
1815       IDropTarget_DragLeave(trackerInfo->curDragTarget);
1816     }
1817
1818     /*
1819      * Make sure we're hovering over a window.
1820      */
1821     if (hwndNewTarget!=0)
1822     {
1823       /*
1824        * Find-out if there is a drag target under the mouse
1825        */
1826       newDropTargetNode = OLEDD_FindDropTarget(hwndNewTarget);
1827
1828       trackerInfo->curDragTargetHWND = hwndNewTarget;
1829       trackerInfo->curDragTarget     = newDropTargetNode ? newDropTargetNode->dropTarget : 0;
1830
1831       /*
1832        * If there is, notify it that we just dragged-in
1833        */
1834       if (trackerInfo->curDragTarget!=0)
1835       {
1836         POINTL  mousePosParam;
1837
1838         /*
1839          * The documentation tells me that the coordinate should be in the target
1840          * window's coordinate space. However, the tests I made tell me the
1841          * coordinates should be in screen coordinates.
1842          */
1843         mousePosParam.x = mousePos.x;
1844         mousePosParam.y = mousePos.y;
1845
1846         IDropTarget_DragEnter(trackerInfo->curDragTarget,
1847                               trackerInfo->dataObject,
1848                               keyState,
1849                               mousePosParam,
1850                               trackerInfo->pdwEffect);
1851       }
1852     }
1853     else
1854     {
1855       /*
1856        * The mouse is not over a window so we don't track anything.
1857        */
1858       trackerInfo->curDragTargetHWND = 0;
1859       trackerInfo->curDragTarget     = 0;
1860     }
1861   }
1862
1863   /*
1864    * Now that we have done that, we have to tell the source to give
1865    * us feedback on the work being done by the target.  If we don't
1866    * have a target, simulate no effect.
1867    */
1868   if (trackerInfo->curDragTarget==0)
1869   {
1870     *trackerInfo->pdwEffect = DROPEFFECT_NONE;
1871   }
1872
1873   hr = IDropSource_GiveFeedback(trackerInfo->dropSource,
1874                                 *trackerInfo->pdwEffect);
1875
1876   /*
1877    * When we ask for feedback from the drop source, sometimes it will
1878    * do all the necessary work and sometimes it will not handle it
1879    * when that's the case, we must display the standard drag and drop
1880    * cursors.
1881    */
1882   if (hr==DRAGDROP_S_USEDEFAULTCURSORS)
1883   {
1884     if ( (*trackerInfo->pdwEffect & DROPEFFECT_MOVE) ||
1885          (*trackerInfo->pdwEffect & DROPEFFECT_COPY) ||
1886          (*trackerInfo->pdwEffect & DROPEFFECT_LINK) )
1887     {
1888       SetCursor(LoadCursorA(0, IDC_SIZEALLA));
1889     }
1890     else
1891     {
1892       SetCursor(LoadCursorA(0, IDC_NOA));
1893     }
1894   }
1895 }
1896
1897 /***
1898  * OLEDD_TrackStateChange()
1899  *
1900  * This method is invoked while a drag and drop operation is in effect.
1901  * It is used to notify the drop target/drop source callbacks when
1902  * the state of the keyboard or mouse button change.
1903  *
1904  * params:
1905  *    trackerInfo - Pointer to the structure identifying the
1906  *                  drag & drop operation that is currently
1907  *                  active.
1908  *    mousePos    - Current position of the mouse in screen
1909  *                  coordinates.
1910  *    keyState    - Contains the state of the shift keys and the
1911  *                  mouse buttons (MK_LBUTTON and the like)
1912  */
1913 static void OLEDD_TrackStateChange(
1914   TrackerWindowInfo* trackerInfo,
1915   POINT            mousePos,
1916   DWORD              keyState)
1917 {
1918   /*
1919    * Ask the drop source what to do with the operation.
1920    */
1921   trackerInfo->returnValue = IDropSource_QueryContinueDrag(
1922                                trackerInfo->dropSource,
1923                                trackerInfo->escPressed,
1924                                keyState);
1925
1926   /*
1927    * All the return valued will stop the operation except the S_OK
1928    * return value.
1929    */
1930   if (trackerInfo->returnValue!=S_OK)
1931   {
1932     /*
1933      * Make sure the message loop in DoDragDrop stops
1934      */
1935     trackerInfo->trackingDone = TRUE;
1936
1937     /*
1938      * Release the mouse in case the drop target decides to show a popup
1939      * or a menu or something.
1940      */
1941     ReleaseCapture();
1942
1943     /*
1944      * If we end-up over a target, drop the object in the target or
1945      * inform the target that the operation was cancelled.
1946      */
1947     if (trackerInfo->curDragTarget!=0)
1948     {
1949       switch (trackerInfo->returnValue)
1950       {
1951         /*
1952          * If the source wants us to complete the operation, we tell
1953          * the drop target that we just dropped the object in it.
1954          */
1955         case DRAGDROP_S_DROP:
1956         {
1957           POINTL  mousePosParam;
1958
1959           /*
1960            * The documentation tells me that the coordinate should be
1961            * in the target window's coordinate space. However, the tests
1962            * I made tell me the coordinates should be in screen coordinates.
1963            */
1964           mousePosParam.x = mousePos.x;
1965           mousePosParam.y = mousePos.y;
1966
1967           IDropTarget_Drop(trackerInfo->curDragTarget,
1968                            trackerInfo->dataObject,
1969                            keyState,
1970                            mousePosParam,
1971                            trackerInfo->pdwEffect);
1972           break;
1973         }
1974         /*
1975          * If the source told us that we should cancel, fool the drop
1976          * target by telling it that the mouse left it's window.
1977          */
1978         case DRAGDROP_S_CANCEL:
1979           IDropTarget_DragLeave(trackerInfo->curDragTarget);
1980           break;
1981       }
1982     }
1983   }
1984 }
1985
1986 /***
1987  * OLEDD_GetButtonState()
1988  *
1989  * This method will use the current state of the keyboard to build
1990  * a button state mask equivalent to the one passed in the
1991  * WM_MOUSEMOVE wParam.
1992  */
1993 static DWORD OLEDD_GetButtonState()
1994 {
1995   BYTE  keyboardState[256];
1996   DWORD keyMask = 0;
1997
1998   GetKeyboardState(keyboardState);
1999
2000   if ( (keyboardState[VK_SHIFT] & 0x80) !=0)
2001     keyMask |= MK_SHIFT;
2002
2003   if ( (keyboardState[VK_CONTROL] & 0x80) !=0)
2004     keyMask |= MK_CONTROL;
2005
2006   if ( (keyboardState[VK_LBUTTON] & 0x80) !=0)
2007     keyMask |= MK_LBUTTON;
2008
2009   if ( (keyboardState[VK_RBUTTON] & 0x80) !=0)
2010     keyMask |= MK_RBUTTON;
2011
2012   if ( (keyboardState[VK_MBUTTON] & 0x80) !=0)
2013     keyMask |= MK_MBUTTON;
2014
2015   return keyMask;
2016 }
2017
2018 /***
2019  * OLEDD_GetButtonState()
2020  *
2021  * This method will read the default value of the registry key in
2022  * parameter and extract a DWORD value from it. The registry key value
2023  * can be in a string key or a DWORD key.
2024  *
2025  * params:
2026  *     regKey   - Key to read the default value from
2027  *     pdwValue - Pointer to the location where the DWORD
2028  *                value is returned. This value is not modified
2029  *                if the value is not found.
2030  */
2031
2032 static void OLEUTL_ReadRegistryDWORDValue(
2033   HKEY   regKey,
2034   DWORD* pdwValue)
2035 {
2036   char  buffer[20];
2037   DWORD dwKeyType;
2038   DWORD cbData = 20;
2039   LONG  lres;
2040
2041   lres = RegQueryValueExA(regKey,
2042                           "",
2043                           NULL,
2044                           &dwKeyType,
2045                           (LPBYTE)buffer,
2046                           &cbData);
2047
2048   if (lres==ERROR_SUCCESS)
2049   {
2050     switch (dwKeyType)
2051     {
2052       case REG_DWORD:
2053         *pdwValue = *(DWORD*)buffer;
2054         break;
2055       case REG_EXPAND_SZ:
2056       case REG_MULTI_SZ:
2057       case REG_SZ:
2058         *pdwValue = (DWORD)strtoul(buffer, NULL, 10);
2059         break;
2060     }
2061   }
2062 }
2063