git.oblomov.eu Git - wine/blob - dlls/ole32/ole2.c

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