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