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