ole/ole2.c

   1 /*
   2  *      OLE2 library
   3  *
   4  *      Copyright 1995  Martin von Loewis
   5  *      Copyright 1999  Francis Beaudet
   6  *      Copyright 1999  Noel Borthwick
   7  */
   8
   9 #include <assert.h>
  10
  11 #include "winuser.h"
  12 #include "winerror.h"
  13 #include "ole2.h"
  14 #include "process.h"
  15 #include "hook.h"
  16 #include "commctrl.h"
  17 #include "wine/obj_clientserver.h"
  18 #include "debug.h"
  19 #include "ole2ver.h"
  20
  21 /******************************************************************************
  22  * These are static/global variables and internal data structures that the
  23  * OLE module uses to maintain it's state.
  24  */
  25 typedef struct tagDropTargetNode
  26 {
  27   HWND          hwndTarget;
  28   IDropTarget*    dropTarget;
  29   struct tagDropTargetNode* prevDropTarget;
  30   struct tagDropTargetNode* nextDropTarget;
  31 } DropTargetNode;
  32
  33 typedef struct tagTrackerWindowInfo
  34 {
  35   IDataObject* dataObject;
  36   IDropSource* dropSource;
  37   DWORD        dwOKEffect;
  38   DWORD*       pdwEffect;
  39   BOOL       trackingDone;
  40   HRESULT      returnValue;
  41
  42   BOOL       escPressed;
  43   HWND       curDragTargetHWND;
  44   IDropTarget* curDragTarget;
  45 } TrackerWindowInfo;
  46
  47 typedef struct tagOleMenuDescriptor  /* OleMenuDescriptor */
  48 {
  49   HWND               hwndFrame;         /* The containers frame window */
  50   HWND               hwndActiveObject;  /* The active objects window */
  51   OLEMENUGROUPWIDTHS mgw;               /* OLE menu group widths for the shared menu */
  52   HMENU              hmenuCombined;     /* The combined menu */
  53   BOOL               bIsServerItem;     /* True if the currently open popup belongs to the server */
  54 } OleMenuDescriptor;
  55
  56 typedef struct tagOleMenuHookItem   /* OleMenu hook item in per thread hook list */
  57 {
  58   DWORD tid;                /* Thread Id  */
  59   HANDLE hHeap;             /* Heap this is allocated from */
  60   HHOOK GetMsg_hHook;       /* message hook for WH_GETMESSAGE */
  61   HHOOK CallWndProc_hHook;  /* message hook for WH_CALLWNDPROC */
  62 } OleMenuHookItem;
  63
  64 /*
  65  * Dynamic pointer array of per thread message hooks (maintained by OleSetMenuDescriptor)
  66  */
  67 static HDPA OLEMenu_MsgHookDPA = NULL;
  68
  69 /*
  70  * This is the lock count on the OLE library. It is controlled by the
  71  * OLEInitialize/OLEUninitialize methods.
  72  */
  73 static ULONG OLE_moduleLockCount = 0;
  74
  75 /*
  76  * Name of our registered window class.
  77  */
  78 static const char OLEDD_DRAGTRACKERCLASS[] = "WineDragDropTracker32";
  79
  80 /*
  81  * This is the head of the Drop target container.
  82  */
  83 static DropTargetNode* targetListHead = NULL;
  84
  85 /******************************************************************************
  86  * These are the prototypes of the utility methods used to manage a shared menu
  87  */
  88 static void OLEMenu_Initialize();
  89 static void OLEMenu_UnInitialize();
  90 BOOL OLEMenu_InstallHooks( DWORD tid );
  91 BOOL OLEMenu_UnInstallHooks( DWORD tid );
  92 OleMenuHookItem * OLEMenu_IsHookInstalled( DWORD tid, INT *pixHook );
  93 static BOOL OLEMenu_FindMainMenuIndex( HMENU hMainMenu, HMENU hPopupMenu, UINT *pnPos );
  94 BOOL OLEMenu_SetIsServerMenu( HMENU hmenu, OleMenuDescriptor *pOleMenuDescriptor );
  95 LRESULT CALLBACK OLEMenu_CallWndProc(INT code, WPARAM wParam, LPARAM lParam);
  96 LRESULT CALLBACK OLEMenu_GetMsgProc(INT code, WPARAM wParam, LPARAM lParam);
  97
  98 /******************************************************************************
  99  * These are the prototypes of the utility methods used for OLE Drag n Drop
 100  */
 101 static void            OLEDD_Initialize();
 102 static void            OLEDD_UnInitialize();
 103 static void            OLEDD_InsertDropTarget(
 104                          DropTargetNode* nodeToAdd);
 105 static DropTargetNode* OLEDD_ExtractDropTarget(
 106                          HWND hwndOfTarget);
 107 static DropTargetNode* OLEDD_FindDropTarget(
 108                          HWND hwndOfTarget);
 109 static LRESULT WINAPI  OLEDD_DragTrackerWindowProc(
 110                          HWND   hwnd,
 111                          UINT   uMsg,
 112                          WPARAM wParam,
 113                          LPARAM   lParam);
 114 static void OLEDD_TrackMouseMove(
 115                          TrackerWindowInfo* trackerInfo,
 116                          POINT            mousePos,
 117                          DWORD              keyState);
 118 static void OLEDD_TrackStateChange(
 119                          TrackerWindowInfo* trackerInfo,
 120                          POINT            mousePos,
 121                          DWORD              keyState);
 122 static DWORD OLEDD_GetButtonState();
 123
 124
 125 /******************************************************************************
 126  *              OleBuildVersion [OLE2.1]
 127  */
 128 DWORD WINAPI OleBuildVersion(void)
 129 {
 130     TRACE(ole,"(void)\n");
 131     return (rmm<<16)+rup;
 132 }
 133
 134 /***********************************************************************
 135  *           OleInitialize       (OLE2.2) (OLE32.108)
 136  */
 137 HRESULT WINAPI OleInitialize(LPVOID reserved)
 138 {
 139   HRESULT hr;
 140
 141   TRACE(ole, "(%p)\n", reserved);
 142
 143   /*
 144    * The first duty of the OleInitialize is to initialize the COM libraries.
 145    */
 146   hr = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
 147
 148   /*
 149    * If the CoInitializeEx call failed, the OLE libraries can't be
 150    * initialized.
 151    */
 152   if (FAILED(hr))
 153     return hr;
 154
 155   /*
 156    * Then, it has to initialize the OLE specific modules.
 157    * This includes:
 158    *     Clipboard
 159    *     Drag and Drop
 160    *     Object linking and Embedding
 161    *     In-place activation
 162    */
 163   if (OLE_moduleLockCount==0)
 164 {
 165     /*
 166      * Initialize the libraries.
 167      */
 168     TRACE(ole, "() - Initializing the OLE libraries\n");
 169
 170     /*
 171      * Drag and Drop
 172      */
 173     OLEDD_Initialize();
 174
 175     /*
 176      * OLE shared menu
 177      */
 178     OLEMenu_Initialize();
 179 }
 180
 181   /*
 182    * Then, we increase the lock count on the OLE module.
 183    */
 184   OLE_moduleLockCount++;
 185
 186   return hr;
 187 }
 188
 189 /******************************************************************************
 190  *              CoGetCurrentProcess     [COMPOBJ.34] [OLE2.2][OLE32.108]
 191  *
 192  * NOTES
 193  *   Is DWORD really the correct return type for this function?
 194  */
 195 DWORD WINAPI CoGetCurrentProcess(void) {
 196         return (DWORD)PROCESS_Current();
 197 }
 198
 199 /******************************************************************************
 200  *              OleUninitialize [OLE2.3] [OLE32.131]
 201  */
 202 void WINAPI OleUninitialize(void)
 203 {
 204   TRACE(ole, "()\n");
 205
 206   /*
 207    * Decrease the lock count on the OLE module.
 208    */
 209   OLE_moduleLockCount--;
 210
 211   /*
 212    * If we hit the bottom of the lock stack, free the libraries.
 213    */
 214   if (OLE_moduleLockCount==0)
 215   {
 216     /*
 217      * Actually free the libraries.
 218      */
 219     TRACE(ole, "() - Freeing the last reference count\n");
 220
 221     /*
 222      * Drag and Drop
 223      */
 224     OLEDD_UnInitialize();
 225
 226     /*
 227      * OLE shared menu
 228      */
 229     OLEMenu_UnInitialize();
 230   }
 231
 232   /*
 233    * Then, uninitialize the COM libraries.
 234    */
 235   CoUninitialize();
 236 }
 237
 238 /***********************************************************************
 239  *           OleFlushClipboard   [OLE2.76]
 240  */
 241 HRESULT WINAPI OleFlushClipboard16(void)
 242 {
 243     return S_OK;
 244 }
 245
 246 /***********************************************************************
 247  *           OleSetClipboard     [OLE32.127]
 248  */
 249 HRESULT WINAPI OleSetClipboard(LPVOID pDataObj)
 250 {
 251     FIXME(ole,"(%p), stub!\n", pDataObj);
 252     return S_OK;
 253 }
 254
 255 /******************************************************************************
 256  *              CoRegisterMessageFilter32       [OLE32.38]
 257  */
 258 HRESULT WINAPI CoRegisterMessageFilter(
 259     LPMESSAGEFILTER lpMessageFilter,    /* Pointer to interface */
 260     LPMESSAGEFILTER *lplpMessageFilter  /* Indirect pointer to prior instance if non-NULL */
 261 ) {
 262     FIXME(ole,"stub\n");
 263     if (lplpMessageFilter) {
 264         *lplpMessageFilter = NULL;
 265     }
 266     return S_OK;
 267 }
 268
 269 /******************************************************************************
 270  *              OleInitializeWOW        [OLE32.109]
 271  */
 272 HRESULT WINAPI OleInitializeWOW(DWORD x) {
 273         FIXME(ole,"(0x%08lx),stub!\n",x);
 274         return 0;
 275 }
 276
 277 /***********************************************************************
 278  *           RegisterDragDrop16 (OLE2.35)
 279  */
 280 HRESULT WINAPI RegisterDragDrop16(
 281         HWND16 hwnd,
 282         LPDROPTARGET pDropTarget
 283 ) {
 284         FIXME(ole,"(0x%04x,%p),stub!\n",hwnd,pDropTarget);
 285         return S_OK;
 286 }
 287
 288 /***********************************************************************
 289  *           RegisterDragDrop32 (OLE32.139)
 290  */
 291 HRESULT WINAPI RegisterDragDrop(
 292         HWND hwnd,
 293         LPDROPTARGET pDropTarget)
 294 {
 295   DropTargetNode* dropTargetInfo;
 296
 297   TRACE(ole,"(0x%x,%p)\n", hwnd, pDropTarget);
 298
 299   /*
 300    * First, check if the window is already registered.
 301    */
 302   dropTargetInfo = OLEDD_FindDropTarget(hwnd);
 303
 304   if (dropTargetInfo!=NULL)
 305     return DRAGDROP_E_ALREADYREGISTERED;
 306
 307   /*
 308    * If it's not there, we can add it. We first create a node for it.
 309    */
 310   dropTargetInfo = HeapAlloc(GetProcessHeap(), 0, sizeof(DropTargetNode));
 311
 312   if (dropTargetInfo==NULL)
 313     return E_OUTOFMEMORY;
 314
 315   dropTargetInfo->hwndTarget     = hwnd;
 316   dropTargetInfo->prevDropTarget = NULL;
 317   dropTargetInfo->nextDropTarget = NULL;
 318
 319   /*
 320    * Don't forget that this is an interface pointer, need to nail it down since
 321    * we keep a copy of it.
 322    */
 323   dropTargetInfo->dropTarget  = pDropTarget;
 324   IDropTarget_AddRef(dropTargetInfo->dropTarget);
 325
 326   OLEDD_InsertDropTarget(dropTargetInfo);
 327
 328         return S_OK;
 329 }
 330
 331 /***********************************************************************
 332  *           RevokeDragDrop16 (OLE2.36)
 333  */
 334 HRESULT WINAPI RevokeDragDrop16(
 335         HWND16 hwnd
 336 ) {
 337         FIXME(ole,"(0x%04x),stub!\n",hwnd);
 338         return S_OK;
 339 }
 340
 341 /***********************************************************************
 342  *           RevokeDragDrop32 (OLE32.141)
 343  */
 344 HRESULT WINAPI RevokeDragDrop(
 345         HWND hwnd)
 346 {
 347   DropTargetNode* dropTargetInfo;
 348
 349   TRACE(ole,"(0x%x)\n", hwnd);
 350
 351   /*
 352    * First, check if the window is already registered.
 353    */
 354   dropTargetInfo = OLEDD_ExtractDropTarget(hwnd);
 355
 356   /*
 357    * If it ain't in there, it's an error.
 358    */
 359   if (dropTargetInfo==NULL)
 360     return DRAGDROP_E_NOTREGISTERED;
 361
 362   /*
 363    * If it's in there, clean-up it's used memory and
 364    * references
 365    */
 366   IDropTarget_Release(dropTargetInfo->dropTarget);
 367   HeapFree(GetProcessHeap(), 0, dropTargetInfo);
 368
 369         return S_OK;
 370 }
 371
 372 /***********************************************************************
 373  *           OleRegGetUserType (OLE32.122)
 374  */
 375 HRESULT WINAPI OleRegGetUserType(
 376         REFCLSID clsid,
 377         DWORD dwFormOfType,
 378         LPOLESTR* pszUserType)
 379 {
 380         FIXME(ole,",stub!\n");
 381         return S_OK;
 382 }
 383
 384 /***********************************************************************
 385  * DoDragDrop32 [OLE32.65]
 386  */
 387 HRESULT WINAPI DoDragDrop (
 388   IDataObject *pDataObject,  /* ptr to the data obj           */
 389   IDropSource* pDropSource,  /* ptr to the source obj         */
 390   DWORD       dwOKEffect,    /* effects allowed by the source */
 391   DWORD       *pdwEffect)    /* ptr to effects of the source  */
 392 {
 393   TrackerWindowInfo trackerInfo;
 394   HWND            hwndTrackWindow;
 395   MSG             msg;
 396
 397   TRACE(ole,"(DataObject %p, DropSource %p)\n", pDataObject, pDropSource);
 398
 399   /*
 400    * Setup the drag n drop tracking window.
 401    */
 402   trackerInfo.dataObject        = pDataObject;
 403   trackerInfo.dropSource        = pDropSource;
 404   trackerInfo.dwOKEffect        = dwOKEffect;
 405   trackerInfo.pdwEffect         = pdwEffect;
 406   trackerInfo.trackingDone      = FALSE;
 407   trackerInfo.escPressed        = FALSE;
 408   trackerInfo.curDragTargetHWND = 0;
 409   trackerInfo.curDragTarget     = 0;
 410
 411   hwndTrackWindow = CreateWindowA(OLEDD_DRAGTRACKERCLASS,
 412                                     "TrackerWindow",
 413                                     WS_POPUP,
 414                                     CW_USEDEFAULT, CW_USEDEFAULT,
 415                                     CW_USEDEFAULT, CW_USEDEFAULT,
 416                                     0,
 417                                     0,
 418                                     0,
 419                                     (LPVOID)&trackerInfo);
 420
 421   if (hwndTrackWindow!=0)
 422   {
 423     /*
 424      * Capture the mouse input
 425      */
 426     SetCapture(hwndTrackWindow);
 427
 428     /*
 429      * Pump messages. All mouse input should go the the capture window.
 430      */
 431     while (!trackerInfo.trackingDone && GetMessageA(&msg, 0, 0, 0) )
 432     {
 433       if ( (msg.message >= WM_KEYFIRST) &&
 434            (msg.message <= WM_KEYFIRST) )
 435       {
 436         /*
 437          * When keyboard messages are sent to windows on this thread, we
 438          * want to ignore notify the drop source that the state changed.
 439          * in the case of the Escape key, we also notify the drop source
 440          * we give it a special meaning.
 441          */
 442         if ( (msg.message==WM_KEYDOWN) &&
 443              (msg.wParam==VK_ESCAPE) )
 444         {
 445           trackerInfo.escPressed = TRUE;
 446         }
 447
 448         /*
 449          * Notify the drop source.
 450          */
 451         OLEDD_TrackStateChange(&trackerInfo,
 452                                msg.pt,
 453                                OLEDD_GetButtonState());
 454       }
 455       else
 456       {
 457         /*
 458          * Dispatch the messages only when it's not a keyboard message.
 459          */
 460         DispatchMessageA(&msg);
 461       }
 462     }
 463
 464     /*
 465      * Destroy the temporary window.
 466      */
 467     DestroyWindow(hwndTrackWindow);
 468
 469     return trackerInfo.returnValue;
 470   }
 471
 472   return E_FAIL;
 473 }
 474
 475 /***********************************************************************
 476  * OleQueryLinkFromData32 [OLE32.118]
 477  */
 478 HRESULT WINAPI OleQueryLinkFromData(
 479   IDataObject* pSrcDataObject)
 480 {
 481   FIXME(ole,"(%p),stub!\n", pSrcDataObject);
 482   return S_OK;
 483 }
 484
 485 /***********************************************************************
 486  * OleRegGetMiscStatus [OLE32.121]
 487  */
 488 HRESULT WINAPI OleRegGetMiscStatus(
 489   REFCLSID clsid,
 490   DWORD    dwAspect,
 491   DWORD*   pdwStatus)
 492 {
 493   FIXME(ole,"(),stub!\n");
 494   return REGDB_E_CLASSNOTREG;
 495 }
 496
 497 /***********************************************************************
 498  * OleGetClipboard32 [OLE32.105]
 499  */
 500 HRESULT WINAPI OleGetClipboard(
 501   IDataObject** ppDataObj)
 502 {
 503   FIXME(ole,"(%p),stub!\n", ppDataObj);
 504
 505   if (ppDataObj)
 506     *ppDataObj=0;
 507
 508   return E_FAIL;
 509 }
 510
 511
 512 /**************************************************************************
 513  * Internal methods to manage the shared OLE menu in response to the
 514  * OLE***MenuDescriptor API
 515  */
 516
 517 /***
 518  * OLEMenu_Initialize()
 519  *
 520  * Initializes the OLEMENU data structures.
 521  */
 522 static void OLEMenu_Initialize()
 523 {
 524   /* Create a dynamic pointer array to store the hook handles */
 525   if ( !OLEMenu_MsgHookDPA )
 526     OLEMenu_MsgHookDPA = DPA_CreateEx( 2, GetProcessHeap() );
 527 }
 528
 529 /***
 530  * OLEMenu_UnInitialize()
 531  *
 532  * Releases the OLEMENU data structures.
 533  */
 534 static void OLEMenu_UnInitialize()
 535 {
 536   /* Release the hook table */
 537   if ( OLEMenu_MsgHookDPA )
 538     DPA_Destroy( OLEMenu_MsgHookDPA );
 539
 540   OLEMenu_MsgHookDPA = NULL;
 541 }
 542
 543 /*************************************************************************
 544  * OLEMenu_InstallHooks
 545  * Install thread scope message hooks for WH_GETMESSAGE and WH_CALLWNDPROC
 546  *
 547  * RETURNS: TRUE if message hooks were succesfully installed
 548  *          FALSE on failure
 549  */
 550 BOOL OLEMenu_InstallHooks( DWORD tid )
 551 {
 552   OleMenuHookItem *pHookItem = NULL;
 553
 554   if ( !OLEMenu_MsgHookDPA ) /* No hook table? Create one */
 555   {
 556     /* Create a dynamic pointer array to store the hook handles */
 557     if ( !(OLEMenu_MsgHookDPA = DPA_CreateEx( 2, GetProcessHeap() )) )
 558       return FALSE;
 559   }
 560
 561   /* Create an entry for the hook table */
 562   if ( !(pHookItem = HeapAlloc(GetProcessHeap(), 0,
 563                                sizeof(OleMenuHookItem)) ) )
 564     return FALSE;
 565
 566   pHookItem->tid = tid;
 567   pHookItem->hHeap = GetProcessHeap();
 568
 569   /* Install a thread scope message hook for WH_GETMESSAGE */
 570   pHookItem->GetMsg_hHook = SetWindowsHookExA( WH_GETMESSAGE, OLEMenu_GetMsgProc,
 571                                                0, GetCurrentThreadId() );
 572   if ( !pHookItem->GetMsg_hHook )
 573     goto CLEANUP;
 574
 575   /* Install a thread scope message hook for WH_CALLWNDPROC */
 576   pHookItem->CallWndProc_hHook = SetWindowsHookExA( WH_CALLWNDPROC, OLEMenu_CallWndProc,
 577                                                     0, GetCurrentThreadId() );
 578   if ( !pHookItem->CallWndProc_hHook )
 579     goto CLEANUP;
 580
 581   /* Insert the hook table entry */
 582   if ( -1 == DPA_InsertPtr( OLEMenu_MsgHookDPA, 0, pHookItem ) )
 583     goto CLEANUP;
 584
 585   return TRUE;
 586
 587 CLEANUP:
 588   /* Unhook any hooks */
 589   if ( pHookItem->GetMsg_hHook )
 590     UnhookWindowsHookEx( pHookItem->GetMsg_hHook );
 591   if ( pHookItem->CallWndProc_hHook )
 592     UnhookWindowsHookEx( pHookItem->CallWndProc_hHook );
 593   /* Release the hook table entry */
 594   HeapFree(pHookItem->hHeap, 0, pHookItem );
 595
 596   return FALSE;
 597 }
 598
 599 /*************************************************************************
 600  * OLEMenu_UnInstallHooks
 601  * UnInstall thread scope message hooks for WH_GETMESSAGE and WH_CALLWNDPROC
 602  *
 603  * RETURNS: TRUE if message hooks were succesfully installed
 604  *          FALSE on failure
 605  */
 606 BOOL OLEMenu_UnInstallHooks( DWORD tid )
 607 {
 608   INT ixHook;
 609   OleMenuHookItem *pHookItem = NULL;
 610
 611   if ( !OLEMenu_MsgHookDPA )  /* No hooks set */
 612     return TRUE;
 613
 614   /* Lookup the hHook index for this tid */
 615   if ( !OLEMenu_IsHookInstalled( tid , &ixHook ) )
 616     return TRUE;
 617
 618   /* Remove the hook entry from the table(the pointer itself is not deleted) */
 619   if ( !( pHookItem = DPA_DeletePtr(OLEMenu_MsgHookDPA, ixHook) ) )
 620     return FALSE;
 621
 622   /* Uninstall the hooks installed for this thread */
 623   if ( !UnhookWindowsHookEx( pHookItem->GetMsg_hHook ) )
 624     goto CLEANUP;
 625   if ( !UnhookWindowsHookEx( pHookItem->CallWndProc_hHook ) )
 626     goto CLEANUP;
 627
 628   /* Release the hook table entry */
 629   HeapFree(pHookItem->hHeap, 0, pHookItem );
 630
 631   return TRUE;
 632
 633 CLEANUP:
 634   /* Release the hook table entry */
 635   if (pHookItem)
 636     HeapFree(pHookItem->hHeap, 0, pHookItem );
 637
 638   return FALSE;
 639 }
 640
 641 /*************************************************************************
 642  * OLEMenu_IsHookInstalled
 643  * Tests if OLEMenu hooks have been installed for a thread
 644  *
 645  * RETURNS: The pointer and index of the hook table entry for the tid
 646  *          NULL and -1 for the index if no hooks were installed for this thread
 647  */
 648 OleMenuHookItem * OLEMenu_IsHookInstalled( DWORD tid, INT *pixHook )
 649 {
 650   INT ixHook;
 651   OleMenuHookItem *pHookItem = NULL;
 652
 653   if ( pixHook )
 654     *pixHook = -1;
 655
 656   if ( !OLEMenu_MsgHookDPA )  /* No hooks set */
 657     return NULL;
 658
 659   /* Do a simple linear search for an entry whose tid matches ours.
 660    * We really need a map but efficiency is not a concern here. */
 661   for( ixHook = 0; ; ixHook++ )
 662   {
 663     /* Retrieve the hook entry */
 664     if ( !( pHookItem = DPA_GetPtr(OLEMenu_MsgHookDPA, ixHook) ) )
 665       return NULL;
 666
 667     if ( tid == pHookItem->tid )
 668     {
 669       if ( pixHook )
 670         *pixHook = ixHook;
 671       return pHookItem;
 672     }
 673   }
 674
 675   return NULL;
 676 }
 677
 678 /***********************************************************************
 679  *           OLEMenu_FindMainMenuIndex
 680  *
 681  * Used by OLEMenu API to find the top level group a menu item belongs to.
 682  * On success pnPos contains the index of the item in the top level menu group
 683  *
 684  * RETURNS: TRUE if the ID was found, FALSE on failure
 685  */
 686 static BOOL OLEMenu_FindMainMenuIndex( HMENU hMainMenu, HMENU hPopupMenu, UINT *pnPos )
 687 {
 688   UINT i, nItems;
 689
 690   nItems = GetMenuItemCount( hMainMenu );
 691
 692   for (i = 0; i < nItems; i++)
 693   {
 694     HMENU hsubmenu;
 695
 696     /*  Is the current item a submenu? */
 697     if ( (hsubmenu = GetSubMenu(hMainMenu, i)) )
 698     {
 699       /* If the handle is the same we're done */
 700       if ( hsubmenu == hPopupMenu )
 701       {
 702         if (pnPos)
 703           *pnPos = i;
 704         return TRUE;
 705       }
 706       /* Recursively search without updating pnPos */
 707       else if ( OLEMenu_FindMainMenuIndex( hsubmenu, hPopupMenu, NULL ) )
 708       {
 709         if (pnPos)
 710           *pnPos = i;
 711         return TRUE;
 712       }
 713     }
 714   }
 715
 716   return FALSE;
 717 }
 718
 719 /***********************************************************************
 720  *           OLEMenu_SetIsServerMenu
 721  *
 722  * Checks whether a popup menu belongs to a shared menu group which is
 723  * owned by the server, and sets the menu descriptor state accordingly.
 724  * All menu messages from these groups should be routed to the server.
 725  *
 726  * RETURNS: TRUE if the popup menu is part of a server owned group
 727  *          FASE if the popup menu is part of a container owned group
 728  */
 729 BOOL OLEMenu_SetIsServerMenu( HMENU hmenu, OleMenuDescriptor *pOleMenuDescriptor )
 730 {
 731   UINT nPos = 0, nWidth, i;
 732
 733   pOleMenuDescriptor->bIsServerItem = FALSE;
 734
 735   /* Don't bother searching if the popup is the combined menu itself */
 736   if ( hmenu == pOleMenuDescriptor->hmenuCombined )
 737     return FALSE;
 738
 739   /* Find the menu item index in the shared OLE menu that this item belongs to */
 740   if ( !OLEMenu_FindMainMenuIndex( pOleMenuDescriptor->hmenuCombined, hmenu,  &nPos ) )
 741     return FALSE;
 742
 743   /* The group widths array has counts for the number of elements
 744    * in the groups File, Edit, Container, Object, Window, Help.
 745    * The Edit, Object & Help groups belong to the server object
 746    * and the other three belong to the container.
 747    * Loop thru the group widths and locate the group we are a member of.
 748    */
 749   for ( i = 0, nWidth = 0; i < 6; i++ )
 750   {
 751     nWidth += pOleMenuDescriptor->mgw.width[i];
 752     if ( nPos < nWidth )
 753     {
 754       /* Odd elements are server menu widths */
 755       pOleMenuDescriptor->bIsServerItem = (i%2) ? TRUE : FALSE;
 756       break;
 757     }
 758   }
 759
 760   return pOleMenuDescriptor->bIsServerItem;
 761 }
 762
 763 /*************************************************************************
 764  * OLEMenu_CallWndProc
 765  * Thread scope WH_CALLWNDPROC hook proc filter function (callback)
 766  * This is invoked from a message hook installed in OleSetMenuDescriptor.
 767  */
 768 LRESULT CALLBACK OLEMenu_CallWndProc(INT code, WPARAM wParam, LPARAM lParam)
 769 {
 770   LPCWPSTRUCT pMsg = NULL;
 771   HOLEMENU hOleMenu = 0;
 772   OleMenuDescriptor *pOleMenuDescriptor = NULL;
 773   OleMenuHookItem *pHookItem = NULL;
 774   WORD fuFlags;
 775
 776   TRACE(ole,"%i, %04x, %08x\n", code, wParam, (unsigned)lParam );
 777
 778   /* Check if we're being asked to process the message */
 779   if ( HC_ACTION != code )
 780     goto NEXTHOOK;
 781
 782   /* Retrieve the current message being dispatched from lParam */
 783   pMsg = (LPCWPSTRUCT)lParam;
 784
 785   /* Check if the message is destined for a window we are interested in:
 786    * If the window has an OLEMenu property we may need to dispatch
 787    * the menu message to its active objects window instead. */
 788
 789   hOleMenu = (HOLEMENU)GetPropA( pMsg->hwnd, "PROP_OLEMenuDescriptor" );
 790   if ( !hOleMenu )
 791     goto NEXTHOOK;
 792
 793   /* Get the menu descriptor */
 794   pOleMenuDescriptor = (OleMenuDescriptor *) GlobalLock( hOleMenu );
 795   if ( !pOleMenuDescriptor ) /* Bad descriptor! */
 796     goto NEXTHOOK;
 797
 798   /* Process menu messages */
 799   switch( pMsg->message )
 800   {
 801     case WM_INITMENU:
 802     {
 803       /* Reset the menu descriptor state */
 804       pOleMenuDescriptor->bIsServerItem = FALSE;
 805
 806       /* Send this message to the server as well */
 807       SendMessageA( pOleMenuDescriptor->hwndActiveObject,
 808                   pMsg->message, pMsg->wParam, pMsg->lParam );
 809       goto NEXTHOOK;
 810     }
 811
 812     case WM_INITMENUPOPUP:
 813     {
 814       /* Save the state for whether this is a server owned menu */
 815       OLEMenu_SetIsServerMenu( (HMENU)pMsg->wParam, pOleMenuDescriptor );
 816       break;
 817     }
 818
 819     case WM_MENUSELECT:
 820     {
 821       fuFlags = HIWORD(pMsg->wParam);  /* Get flags */
 822       if ( fuFlags & MF_SYSMENU )
 823          goto NEXTHOOK;
 824
 825       /* Save the state for whether this is a server owned popup menu */
 826       else if ( fuFlags & MF_POPUP )
 827         OLEMenu_SetIsServerMenu( (HMENU)pMsg->lParam, pOleMenuDescriptor );
 828
 829       break;
 830     }
 831
 832     case WM_DRAWITEM:
 833     {
 834       LPDRAWITEMSTRUCT lpdis = (LPDRAWITEMSTRUCT) pMsg->lParam;
 835       if ( pMsg->wParam != 0 || lpdis->CtlType != ODT_MENU )
 836         goto NEXTHOOK;  /* Not a menu message */
 837
 838       break;
 839     }
 840
 841     default:
 842       goto NEXTHOOK;
 843   }
 844
 845   /* If the message was for the server dispatch it accordingly */
 846   if ( pOleMenuDescriptor->bIsServerItem )
 847   {
 848     SendMessageA( pOleMenuDescriptor->hwndActiveObject,
 849                   pMsg->message, pMsg->wParam, pMsg->lParam );
 850   }
 851
 852 NEXTHOOK:
 853   if ( pOleMenuDescriptor )
 854     GlobalUnlock( hOleMenu );
 855
 856   /* Lookup the hook item for the current thread */
 857   if ( !( pHookItem = OLEMenu_IsHookInstalled( GetCurrentThreadId(), NULL ) ) )
 858   {
 859     /* This should never fail!! */
 860     WARN(ole, "could not retrieve hHook for current thread!\n" );
 861     return 0;
 862   }
 863
 864   /* Pass on the message to the next hooker */
 865   return CallNextHookEx( pHookItem->CallWndProc_hHook, code, wParam, lParam );
 866 }
 867
 868 /*************************************************************************
 869  * OLEMenu_GetMsgProc
 870  * Thread scope WH_GETMESSAGE hook proc filter function (callback)
 871  * This is invoked from a message hook installed in OleSetMenuDescriptor.
 872  */
 873 LRESULT CALLBACK OLEMenu_GetMsgProc(INT code, WPARAM wParam, LPARAM lParam)
 874 {
 875   LPMSG pMsg = NULL;
 876   HOLEMENU hOleMenu = 0;
 877   OleMenuDescriptor *pOleMenuDescriptor = NULL;
 878   OleMenuHookItem *pHookItem = NULL;
 879   WORD wCode;
 880
 881   TRACE(ole,"%i, %04x, %08x\n", code, wParam, (unsigned)lParam );
 882
 883   /* Check if we're being asked to process a  messages */
 884   if ( HC_ACTION != code )
 885     goto NEXTHOOK;
 886
 887   /* Retrieve the current message being dispatched from lParam */
 888   pMsg = (LPMSG)lParam;
 889
 890   /* Check if the message is destined for a window we are interested in:
 891    * If the window has an OLEMenu property we may need to dispatch
 892    * the menu message to its active objects window instead. */
 893
 894   hOleMenu = (HOLEMENU)GetPropA( pMsg->hwnd, "PROP_OLEMenuDescriptor" );
 895   if ( !hOleMenu )
 896     goto NEXTHOOK;
 897
 898   /* Process menu messages */
 899   switch( pMsg->message )
 900   {
 901     case WM_COMMAND:
 902     {
 903       wCode = HIWORD(pMsg->wParam);  /* Get notification code */
 904       if ( wCode )
 905         goto NEXTHOOK;  /* Not a menu message */
 906       break;
 907     }
 908     default:
 909       goto NEXTHOOK;
 910   }
 911
 912   /* Get the menu descriptor */
 913   pOleMenuDescriptor = (OleMenuDescriptor *) GlobalLock( hOleMenu );
 914   if ( !pOleMenuDescriptor ) /* Bad descriptor! */
 915     goto NEXTHOOK;
 916
 917   /* If the message was for the server dispatch it accordingly */
 918   if ( pOleMenuDescriptor->bIsServerItem )
 919   {
 920     /* Change the hWnd in the message to the active objects hWnd.
 921      * The message loop which reads this message will automatically
 922      * dispatch it to the embedded objects window. */
 923     pMsg->hwnd = pOleMenuDescriptor->hwndActiveObject;
 924   }
 925
 926 NEXTHOOK:
 927   if ( pOleMenuDescriptor )
 928     GlobalUnlock( hOleMenu );
 929
 930   /* Lookup the hook item for the current thread */
 931   if ( !( pHookItem = OLEMenu_IsHookInstalled( GetCurrentThreadId(), NULL ) ) )
 932   {
 933     /* This should never fail!! */
 934     WARN(ole, "could not retrieve hHook for current thread!\n" );
 935     return FALSE;
 936   }
 937
 938   /* Pass on the message to the next hooker */
 939   return CallNextHookEx( pHookItem->GetMsg_hHook, code, wParam, lParam );
 940 }
 941
 942 /***********************************************************************
 943  * OleCreateMenuDescriptor [OLE32.97]
 944  * Creates an OLE menu descriptor for OLE to use when dispatching
 945  * menu messages and commands.
 946  *
 947  * PARAMS:
 948  *    hmenuCombined  -  Handle to the objects combined menu
 949  *    lpMenuWidths   -  Pointer to array of 6 LONG's indicating menus per group
 950  *
 951  */
 952 HOLEMENU WINAPI OleCreateMenuDescriptor(
 953   HMENU                hmenuCombined,
 954   LPOLEMENUGROUPWIDTHS lpMenuWidths)
 955 {
 956   HOLEMENU hOleMenu;
 957   OleMenuDescriptor *pOleMenuDescriptor;
 958   int i;
 959
 960   if ( !hmenuCombined || !lpMenuWidths )
 961     return 0;
 962
 963   /* Create an OLE menu descriptor */
 964   if ( !(hOleMenu = GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT,
 965                                 sizeof(OleMenuDescriptor) ) ) )
 966   return 0;
 967
 968   pOleMenuDescriptor = (OleMenuDescriptor *) GlobalLock( hOleMenu );
 969   if ( !pOleMenuDescriptor )
 970     return 0;
 971
 972   /* Initialize menu group widths and hmenu */
 973   for ( i = 0; i < 6; i++ )
 974     pOleMenuDescriptor->mgw.width[i] = lpMenuWidths->width[i];
 975
 976   pOleMenuDescriptor->hmenuCombined = hmenuCombined;
 977   pOleMenuDescriptor->bIsServerItem = FALSE;
 978   GlobalUnlock( hOleMenu );
 979
 980   return hOleMenu;
 981 }
 982
 983 /***********************************************************************
 984  * OleDestroyMenuDescriptor [OLE32.99]
 985  * Destroy the shared menu descriptor
 986  */
 987 HRESULT WINAPI OleDestroyMenuDescriptor(
 988   HOLEMENU hmenuDescriptor)
 989 {
 990   if ( hmenuDescriptor )
 991     GlobalFree( hmenuDescriptor );
 992         return S_OK;
 993 }
 994
 995 /***********************************************************************
 996  * OleSetMenuDescriptor [OLE32.129]
 997  * Installs or removes OLE dispatching code for the containers frame window
 998  * FIXME: The lpFrame and lpActiveObject parameters are currently ignored
 999  * OLE should install context sensitive help F1 filtering for the app when
1000  * these are non null.
1001  *
1002  * PARAMS:
1003  *     hOleMenu         Handle to composite menu descriptor
1004  *     hwndFrame        Handle to containers frame window
1005  *     hwndActiveObject Handle to objects in-place activation window
1006  *     lpFrame          Pointer to IOleInPlaceFrame on containers window
1007  *     lpActiveObject   Pointer to IOleInPlaceActiveObject on active in-place object
1008  *
1009  * RETURNS:
1010  *      S_OK                               - menu installed correctly
1011  *      E_FAIL, E_INVALIDARG, E_UNEXPECTED - failure
1012  */
1013 HRESULT WINAPI OleSetMenuDescriptor(
1014   HOLEMENU               hOleMenu,
1015   HWND                   hwndFrame,
1016   HWND                   hwndActiveObject,
1017   LPOLEINPLACEFRAME        lpFrame,
1018   LPOLEINPLACEACTIVEOBJECT lpActiveObject)
1019 {
1020   OleMenuDescriptor *pOleMenuDescriptor = NULL;
1021
1022   /* Check args */
1023   if ( !hwndFrame || (hOleMenu && !hwndActiveObject) )
1024     return E_INVALIDARG;
1025
1026   if ( lpFrame || lpActiveObject )
1027   {
1028      FIXME(ole,"(%x, %x, %x, %p, %p), Context sensitive help filtering not implemented!\n",
1029         (unsigned int)hOleMenu,
1030         hwndFrame,
1031         hwndActiveObject,
1032         lpFrame,
1033         lpActiveObject);
1034   }
1035
1036   /* Set up a message hook to intercept the containers frame window messages.
1037    * The message filter is responsible for dispatching menu messages from the
1038    * shared menu which are intended for the object.
1039    */
1040
1041   if ( hOleMenu )  /* Want to install dispatching code */
1042   {
1043     /* If OLEMenu hooks are already installed for this thread, fail
1044      * Note: This effectively means that OleSetMenuDescriptor cannot
1045      * be called twice in succession on the same frame window
1046      * without first calling it with a null hOleMenu to uninstall */
1047     if ( OLEMenu_IsHookInstalled( GetCurrentThreadId(), NULL ) )
1048   return E_FAIL;
1049
1050     /* Get the menu descriptor */
1051     pOleMenuDescriptor = (OleMenuDescriptor *) GlobalLock( hOleMenu );
1052     if ( !pOleMenuDescriptor )
1053       return E_UNEXPECTED;
1054
1055     /* Update the menu descriptor */
1056     pOleMenuDescriptor->hwndFrame = hwndFrame;
1057     pOleMenuDescriptor->hwndActiveObject = hwndActiveObject;
1058
1059     GlobalUnlock( hOleMenu );
1060     pOleMenuDescriptor = NULL;
1061
1062     /* Add a menu descriptor windows property to the frame window */
1063     SetPropA( hwndFrame, "PROP_OLEMenuDescriptor", hOleMenu );
1064
1065     /* Install thread scope message hooks for WH_GETMESSAGE and WH_CALLWNDPROC */
1066     if ( !OLEMenu_InstallHooks( GetCurrentThreadId() ) )
1067       return E_FAIL;
1068   }
1069   else  /* Want to uninstall dispatching code */
1070   {
1071     /* Uninstall the hooks */
1072     if ( !OLEMenu_UnInstallHooks( GetCurrentThreadId() ) )
1073       return E_FAIL;
1074
1075     /* Remove the menu descriptor property from the frame window */
1076     RemovePropA( hwndFrame, "PROP_OLEMenuDescriptor" );
1077   }
1078
1079   return S_OK;
1080 }
1081
1082 /***********************************************************************
1083  * ReleaseStgMedium [OLE32.140]
1084  */
1085 void WINAPI ReleaseStgMedium(
1086   STGMEDIUM* pmedium)
1087 {
1088   switch (pmedium->tymed)
1089   {
1090     case TYMED_HGLOBAL:
1091     {
1092       if ( (pmedium->pUnkForRelease==0) &&
1093            (pmedium->u.hGlobal!=0) )
1094         GlobalFree(pmedium->u.hGlobal);
1095
1096       pmedium->u.hGlobal = 0;
1097       break;
1098     }
1099     case TYMED_FILE:
1100     {
1101       if (pmedium->u.lpszFileName!=0)
1102       {
1103         if (pmedium->pUnkForRelease==0)
1104         {
1105           DeleteFileW(pmedium->u.lpszFileName);
1106         }
1107
1108         CoTaskMemFree(pmedium->u.lpszFileName);
1109       }
1110
1111       pmedium->u.lpszFileName = 0;
1112       break;
1113     }
1114     case TYMED_ISTREAM:
1115     {
1116       if (pmedium->u.pstm!=0)
1117       {
1118         IStream_Release(pmedium->u.pstm);
1119       }
1120
1121       pmedium->u.pstm = 0;
1122       break;
1123     }
1124     case TYMED_ISTORAGE:
1125     {
1126       if (pmedium->u.pstg!=0)
1127       {
1128         IStorage_Release(pmedium->u.pstg);
1129       }
1130
1131       pmedium->u.pstg = 0;
1132       break;
1133     }
1134     case TYMED_GDI:
1135     {
1136       if ( (pmedium->pUnkForRelease==0) &&
1137            (pmedium->u.hGlobal!=0) )
1138         DeleteObject(pmedium->u.hGlobal);
1139
1140       pmedium->u.hGlobal = 0;
1141       break;
1142     }
1143     case TYMED_MFPICT:
1144     {
1145       if ( (pmedium->pUnkForRelease==0) &&
1146            (pmedium->u.hMetaFilePict!=0) )
1147       {
1148         DeleteMetaFile(pmedium->u.hMetaFilePict);
1149         GlobalFree(pmedium->u.hMetaFilePict);
1150       }
1151
1152       pmedium->u.hMetaFilePict = 0;
1153       break;
1154     }
1155     case TYMED_ENHMF:
1156     {
1157       if ( (pmedium->pUnkForRelease==0) &&
1158            (pmedium->u.hEnhMetaFile!=0) )
1159       {
1160         DeleteEnhMetaFile(pmedium->u.hEnhMetaFile);
1161       }
1162
1163       pmedium->u.hEnhMetaFile = 0;
1164       break;
1165     }
1166     case TYMED_NULL:
1167     default:
1168       break;
1169   }
1170
1171   /*
1172    * After cleaning up, the unknown is released
1173    */
1174   if (pmedium->pUnkForRelease!=0)
1175   {
1176     IUnknown_Release(pmedium->pUnkForRelease);
1177     pmedium->pUnkForRelease = 0;
1178   }
1179 }
1180
1181 /***
1182  * OLEDD_Initialize()
1183  *
1184  * Initializes the OLE drag and drop data structures.
1185  */
1186 static void OLEDD_Initialize()
1187 {
1188     WNDCLASSA wndClass;
1189
1190     ZeroMemory (&wndClass, sizeof(WNDCLASSA));
1191     wndClass.style         = CS_GLOBALCLASS;
1192     wndClass.lpfnWndProc   = (WNDPROC)OLEDD_DragTrackerWindowProc;
1193     wndClass.cbClsExtra    = 0;
1194     wndClass.cbWndExtra    = sizeof(TrackerWindowInfo*);
1195     wndClass.hCursor       = 0;
1196     wndClass.hbrBackground = 0;
1197     wndClass.lpszClassName = OLEDD_DRAGTRACKERCLASS;
1198
1199     RegisterClassA (&wndClass);
1200 }
1201
1202 /***
1203  * OLEDD_UnInitialize()
1204  *
1205  * Releases the OLE drag and drop data structures.
1206  */
1207 static void OLEDD_UnInitialize()
1208 {
1209   /*
1210    * Simply empty the list.
1211    */
1212   while (targetListHead!=NULL)
1213   {
1214     RevokeDragDrop(targetListHead->hwndTarget);
1215   }
1216 }
1217
1218 /***
1219  * OLEDD_InsertDropTarget()
1220  *
1221  * Insert the target node in the tree.
1222  */
1223 static void OLEDD_InsertDropTarget(DropTargetNode* nodeToAdd)
1224 {
1225   DropTargetNode*  curNode;
1226   DropTargetNode** parentNodeLink;
1227
1228   /*
1229    * Iterate the tree to find the insertion point.
1230    */
1231   curNode        = targetListHead;
1232   parentNodeLink = &targetListHead;
1233
1234   while (curNode!=NULL)
1235   {
1236     if (nodeToAdd->hwndTarget<curNode->hwndTarget)
1237     {
1238       /*
1239        * If the node we want to add has a smaller HWND, go left
1240        */
1241       parentNodeLink = &curNode->prevDropTarget;
1242       curNode        =  curNode->prevDropTarget;
1243     }
1244     else if (nodeToAdd->hwndTarget>curNode->hwndTarget)
1245     {
1246       /*
1247        * If the node we want to add has a larger HWND, go right
1248        */
1249       parentNodeLink = &curNode->nextDropTarget;
1250       curNode        =  curNode->nextDropTarget;
1251     }
1252     else
1253     {
1254       /*
1255        * The item was found in the list. It shouldn't have been there
1256        */
1257       assert(FALSE);
1258       return;
1259     }
1260   }
1261
1262   /*
1263    * If we get here, we have found a spot for our item. The parentNodeLink
1264    * pointer points to the pointer that we have to modify.
1265    * The curNode should be NULL. We just have to establish the link and Voila!
1266    */
1267   assert(curNode==NULL);
1268   assert(parentNodeLink!=NULL);
1269   assert(*parentNodeLink==NULL);
1270
1271   *parentNodeLink=nodeToAdd;
1272 }
1273
1274 /***
1275  * OLEDD_ExtractDropTarget()
1276  *
1277  * Removes the target node from the tree.
1278  */
1279 static DropTargetNode* OLEDD_ExtractDropTarget(HWND hwndOfTarget)
1280 {
1281   DropTargetNode*  curNode;
1282   DropTargetNode** parentNodeLink;
1283
1284   /*
1285    * Iterate the tree to find the insertion point.
1286    */
1287   curNode        = targetListHead;
1288   parentNodeLink = &targetListHead;
1289
1290   while (curNode!=NULL)
1291   {
1292     if (hwndOfTarget<curNode->hwndTarget)
1293     {
1294       /*
1295        * If the node we want to add has a smaller HWND, go left
1296        */
1297       parentNodeLink = &curNode->prevDropTarget;
1298       curNode        =  curNode->prevDropTarget;
1299     }
1300     else if (hwndOfTarget>curNode->hwndTarget)
1301     {
1302       /*
1303        * If the node we want to add has a larger HWND, go right
1304        */
1305       parentNodeLink = &curNode->nextDropTarget;
1306       curNode        =  curNode->nextDropTarget;
1307     }
1308     else
1309     {
1310       /*
1311        * The item was found in the list. Detach it from it's parent and
1312        * re-insert it's kids in the tree.
1313        */
1314       assert(parentNodeLink!=NULL);
1315       assert(*parentNodeLink==curNode);
1316
1317       /*
1318        * We arbitrately re-attach the left sub-tree to the parent.
1319        */
1320       *parentNodeLink = curNode->prevDropTarget;
1321
1322       /*
1323        * And we re-insert the right subtree
1324        */
1325       if (curNode->nextDropTarget!=NULL)
1326       {
1327         OLEDD_InsertDropTarget(curNode->nextDropTarget);
1328       }
1329
1330       /*
1331        * The node we found is still a valid node once we complete
1332        * the unlinking of the kids.
1333        */
1334       curNode->nextDropTarget=NULL;
1335       curNode->prevDropTarget=NULL;
1336
1337       return curNode;
1338     }
1339   }
1340
1341   /*
1342    * If we get here, the node is not in the tree
1343    */
1344   return NULL;
1345 }
1346
1347 /***
1348  * OLEDD_FindDropTarget()
1349  *
1350  * Finds information about the drop target.
1351  */
1352 static DropTargetNode* OLEDD_FindDropTarget(HWND hwndOfTarget)
1353 {
1354   DropTargetNode*  curNode;
1355
1356   /*
1357    * Iterate the tree to find the HWND value.
1358    */
1359   curNode        = targetListHead;
1360
1361   while (curNode!=NULL)
1362   {
1363     if (hwndOfTarget<curNode->hwndTarget)
1364     {
1365       /*
1366        * If the node we want to add has a smaller HWND, go left
1367        */
1368       curNode =  curNode->prevDropTarget;
1369     }
1370     else if (hwndOfTarget>curNode->hwndTarget)
1371     {
1372       /*
1373        * If the node we want to add has a larger HWND, go right
1374        */
1375       curNode =  curNode->nextDropTarget;
1376     }
1377     else
1378     {
1379       /*
1380        * The item was found in the list.
1381        */
1382       return curNode;
1383     }
1384   }
1385
1386   /*
1387    * If we get here, the item is not in the list
1388    */
1389   return NULL;
1390 }
1391
1392 /***
1393  * OLEDD_DragTrackerWindowProc()
1394  *
1395  * This method is the WindowProcedure of the drag n drop tracking
1396  * window. During a drag n Drop operation, an invisible window is created
1397  * to receive the user input and act upon it. This procedure is in charge
1398  * of this behavior.
1399  */
1400 static LRESULT WINAPI OLEDD_DragTrackerWindowProc(
1401                          HWND   hwnd,
1402                          UINT   uMsg,
1403                          WPARAM wParam,
1404                          LPARAM   lParam)
1405 {
1406   switch (uMsg)
1407   {
1408     case WM_CREATE:
1409     {
1410       LPCREATESTRUCTA createStruct = (LPCREATESTRUCTA)lParam;
1411
1412       SetWindowLongA(hwnd, 0, (LONG)createStruct->lpCreateParams);
1413
1414
1415       break;
1416     }
1417     case WM_MOUSEMOVE:
1418     {
1419       TrackerWindowInfo* trackerInfo = (TrackerWindowInfo*)GetWindowLongA(hwnd, 0);
1420       POINT            mousePos;
1421
1422       /*
1423        * Get the current mouse position in screen coordinates.
1424        */
1425       mousePos.x = LOWORD(lParam);
1426       mousePos.y = HIWORD(lParam);
1427       ClientToScreen(hwnd, &mousePos);
1428
1429       /*
1430        * Track the movement of the mouse.
1431        */
1432       OLEDD_TrackMouseMove(trackerInfo, mousePos, wParam);
1433
1434       break;
1435     }
1436     case WM_LBUTTONUP:
1437     case WM_MBUTTONUP:
1438     case WM_RBUTTONUP:
1439     case WM_LBUTTONDOWN:
1440     case WM_MBUTTONDOWN:
1441     case WM_RBUTTONDOWN:
1442     {
1443       TrackerWindowInfo* trackerInfo = (TrackerWindowInfo*)GetWindowLongA(hwnd, 0);
1444       POINT            mousePos;
1445
1446       /*
1447        * Get the current mouse position in screen coordinates.
1448        */
1449       mousePos.x = LOWORD(lParam);
1450       mousePos.y = HIWORD(lParam);
1451       ClientToScreen(hwnd, &mousePos);
1452
1453       /*
1454        * Notify everyone that the button state changed
1455        * TODO: Check if the "escape" key was pressed.
1456        */
1457       OLEDD_TrackStateChange(trackerInfo, mousePos, wParam);
1458
1459       break;
1460     }
1461   }
1462
1463   /*
1464    * This is a window proc after all. Let's call the default.
1465    */
1466   return DefWindowProcA (hwnd, uMsg, wParam, lParam);
1467 }
1468
1469 /***
1470  * OLEDD_TrackMouseMove()
1471  *
1472  * This method is invoked while a drag and drop operation is in effect.
1473  * it will generate the appropriate callbacks in the drop source
1474  * and drop target. It will also provide the expected feedback to
1475  * the user.
1476  *
1477  * params:
1478  *    trackerInfo - Pointer to the structure identifying the
1479  *                  drag & drop operation that is currently
1480  *                  active.
1481  *    mousePos    - Current position of the mouse in screen
1482  *                  coordinates.
1483  *    keyState    - Contains the state of the shift keys and the
1484  *                  mouse buttons (MK_LBUTTON and the like)
1485  */
1486 static void OLEDD_TrackMouseMove(
1487   TrackerWindowInfo* trackerInfo,
1488   POINT            mousePos,
1489   DWORD              keyState)
1490 {
1491   HWND   hwndNewTarget = 0;
1492   HRESULT  hr = S_OK;
1493
1494   /*
1495    * Get the handle of the window under the mouse
1496    */
1497   hwndNewTarget = WindowFromPoint(mousePos);
1498
1499   /*
1500    * If we are hovering over the same target as before, send the
1501    * DragOver notification
1502    */
1503   if ( (trackerInfo->curDragTarget != 0) &&
1504        (trackerInfo->curDragTargetHWND==hwndNewTarget) )
1505   {
1506     POINTL  mousePosParam;
1507
1508     /*
1509      * The documentation tells me that the coordinate should be in the target
1510      * window's coordinate space. However, the tests I made tell me the
1511      * coordinates should be in screen coordinates.
1512      */
1513     mousePosParam.x = mousePos.x;
1514     mousePosParam.y = mousePos.y;
1515
1516     IDropTarget_DragOver(trackerInfo->curDragTarget,
1517                          keyState,
1518                          mousePosParam,
1519                          trackerInfo->pdwEffect);
1520   }
1521   else
1522 {
1523     DropTargetNode* newDropTargetNode = 0;
1524
1525     /*
1526      * If we changed window, we have to notify our old target and check for
1527      * the new one.
1528      */
1529     if (trackerInfo->curDragTarget!=0)
1530     {
1531       IDropTarget_DragLeave(trackerInfo->curDragTarget);
1532     }
1533
1534     /*
1535      * Make sure we're hovering over a window.
1536      */
1537     if (hwndNewTarget!=0)
1538     {
1539       /*
1540        * Find-out if there is a drag target under the mouse
1541        */
1542       newDropTargetNode = OLEDD_FindDropTarget(hwndNewTarget);
1543
1544       trackerInfo->curDragTargetHWND = hwndNewTarget;
1545       trackerInfo->curDragTarget     = newDropTargetNode ? newDropTargetNode->dropTarget : 0;
1546
1547       /*
1548        * If there is, notify it that we just dragged-in
1549        */
1550       if (trackerInfo->curDragTarget!=0)
1551       {
1552         POINTL  mousePosParam;
1553
1554         /*
1555          * The documentation tells me that the coordinate should be in the target
1556          * window's coordinate space. However, the tests I made tell me the
1557          * coordinates should be in screen coordinates.
1558          */
1559         mousePosParam.x = mousePos.x;
1560         mousePosParam.y = mousePos.y;
1561
1562         IDropTarget_DragEnter(trackerInfo->curDragTarget,
1563                               trackerInfo->dataObject,
1564                               keyState,
1565                               mousePosParam,
1566                               trackerInfo->pdwEffect);
1567       }
1568     }
1569     else
1570     {
1571       /*
1572        * The mouse is not over a window so we don't track anything.
1573        */
1574       trackerInfo->curDragTargetHWND = 0;
1575       trackerInfo->curDragTarget     = 0;
1576     }
1577   }
1578
1579   /*
1580    * Now that we have done that, we have to tell the source to give
1581    * us feedback on the work being done by the target.  If we don't
1582    * have a target, simulate no effect.
1583    */
1584   if (trackerInfo->curDragTarget==0)
1585   {
1586     *trackerInfo->pdwEffect = DROPEFFECT_NONE;
1587   }
1588
1589   hr = IDropSource_GiveFeedback(trackerInfo->dropSource,
1590                                 *trackerInfo->pdwEffect);
1591
1592   /*
1593    * When we ask for feedback from the drop source, sometimes it will
1594    * do all the necessary work and sometimes it will not handle it
1595    * when that's the case, we must display the standard drag and drop
1596    * cursors.
1597    */
1598   if (hr==DRAGDROP_S_USEDEFAULTCURSORS)
1599   {
1600     if ( (*trackerInfo->pdwEffect & DROPEFFECT_MOVE) ||
1601          (*trackerInfo->pdwEffect & DROPEFFECT_COPY) ||
1602          (*trackerInfo->pdwEffect & DROPEFFECT_LINK) )
1603     {
1604       SetCursor(LoadCursorA(0, IDC_SIZEALLA));
1605     }
1606     else
1607     {
1608       SetCursor(LoadCursorA(0, IDC_NOA));
1609     }
1610   }
1611 }
1612
1613 /***
1614  * OLEDD_TrackStateChange()
1615  *
1616  * This method is invoked while a drag and drop operation is in effect.
1617  * It is used to notify the drop target/drop source callbacks when
1618  * the state of the keyboard or mouse button change.
1619  *
1620  * params:
1621  *    trackerInfo - Pointer to the structure identifying the
1622  *                  drag & drop operation that is currently
1623  *                  active.
1624  *    mousePos    - Current position of the mouse in screen
1625  *                  coordinates.
1626  *    keyState    - Contains the state of the shift keys and the
1627  *                  mouse buttons (MK_LBUTTON and the like)
1628  */
1629 static void OLEDD_TrackStateChange(
1630   TrackerWindowInfo* trackerInfo,
1631   POINT            mousePos,
1632   DWORD              keyState)
1633 {
1634   /*
1635    * Ask the drop source what to do with the operation.
1636    */
1637   trackerInfo->returnValue = IDropSource_QueryContinueDrag(
1638                                trackerInfo->dropSource,
1639                                trackerInfo->escPressed,
1640                                keyState);
1641
1642   /*
1643    * All the return valued will stop the operation except the S_OK
1644    * return value.
1645    */
1646   if (trackerInfo->returnValue!=S_OK)
1647   {
1648     /*
1649      * Make sure the message loop in DoDragDrop stops
1650      */
1651     trackerInfo->trackingDone = TRUE;
1652
1653     /*
1654      * Release the mouse in case the drop target decides to show a popup
1655      * or a menu or something.
1656      */
1657     ReleaseCapture();
1658
1659     /*
1660      * If we end-up over a target, drop the object in the target or
1661      * inform the target that the operation was cancelled.
1662      */
1663     if (trackerInfo->curDragTarget!=0)
1664     {
1665       switch (trackerInfo->returnValue)
1666       {
1667         /*
1668          * If the source wants us to complete the operation, we tell
1669          * the drop target that we just dropped the object in it.
1670          */
1671         case DRAGDROP_S_DROP:
1672         {
1673           POINTL  mousePosParam;
1674
1675           /*
1676            * The documentation tells me that the coordinate should be
1677            * in the target window's coordinate space. However, the tests
1678            * I made tell me the coordinates should be in screen coordinates.
1679            */
1680           mousePosParam.x = mousePos.x;
1681           mousePosParam.y = mousePos.y;
1682
1683           IDropTarget_Drop(trackerInfo->curDragTarget,
1684                            trackerInfo->dataObject,
1685                            keyState,
1686                            mousePosParam,
1687                            trackerInfo->pdwEffect);
1688           break;
1689         }
1690         /*
1691          * If the source told us that we should cancel, fool the drop
1692          * target by telling it that the mouse left it's window.
1693          */
1694         case DRAGDROP_S_CANCEL:
1695           IDropTarget_DragLeave(trackerInfo->curDragTarget);
1696           break;
1697       }
1698     }
1699   }
1700 }
1701
1702 /***
1703  * OLEDD_GetButtonState()
1704  *
1705  * This method will use the current state of the keyboard to build
1706  * a button state mask equivalent to the one passed in the
1707  * WM_MOUSEMOVE wParam.
1708  */
1709 static DWORD OLEDD_GetButtonState()
1710 {
1711   BYTE  keyboardState[256];
1712   DWORD keyMask = 0;
1713
1714   GetKeyboardState(keyboardState);
1715
1716   if ( (keyboardState[VK_SHIFT] & 0x80) !=0)
1717     keyMask |= MK_SHIFT;
1718
1719   if ( (keyboardState[VK_CONTROL] & 0x80) !=0)
1720     keyMask |= MK_CONTROL;
1721
1722   if ( (keyboardState[VK_LBUTTON] & 0x80) !=0)
1723     keyMask |= MK_LBUTTON;
1724
1725   if ( (keyboardState[VK_RBUTTON] & 0x80) !=0)
1726     keyMask |= MK_RBUTTON;
1727
1728   if ( (keyboardState[VK_MBUTTON] & 0x80) !=0)
1729     keyMask |= MK_MBUTTON;
1730
1731   return keyMask;
1732 }
1733
1734