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