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

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