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