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

   1 /*
   2  *      OLE2 library
   3  *
   4  * Copyright 1995 Martin von Loewis
   5  * Copyright 1999 Francis Beaudet
   6  * Copyright 1999 Noel Borthwick
   7  * Copyright 1999, 2000 Marcus Meissner
   8  * Copyright 2005 Juan Lang
   9  *
  10  * This library is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * This library is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with this library; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  23  */
  24
  25 #include "config.h"
  26
  27 #include <assert.h>
  28 #include <stdlib.h>
  29 #include <stdarg.h>
  30 #include <stdio.h>
  31 #include <string.h>
  32
  33 #define COBJMACROS
  34 #define NONAMELESSUNION
  35 #define NONAMELESSSTRUCT
  36
  37 #include "windef.h"
  38 #include "winbase.h"
  39 #include "winerror.h"
  40 #include "wingdi.h"
  41 #include "winuser.h"
  42 #include "winnls.h"
  43 #include "winreg.h"
  44 #include "commctrl.h"
  45 #include "ole2.h"
  46 #include "ole2ver.h"
  47 #include "wownt32.h"
  48
  49 #include "wine/unicode.h"
  50 #include "compobj_private.h"
  51
  52 #include "wine/debug.h"
  53
  54 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  55 WINE_DECLARE_DEBUG_CHANNEL(accel);
  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(void);
 129 static void OLEMenu_UnInitialize(void);
 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 extern void OLEClipbrd_UnInitialize(void);
 142 extern void OLEClipbrd_Initialize(void);
 143
 144 /******************************************************************************
 145  * These are the prototypes of the utility methods used for OLE Drag n Drop
 146  */
 147 static void            OLEDD_Initialize(void);
 148 static void            OLEDD_UnInitialize(void);
 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(void);
 169
 170
 171 /******************************************************************************
 172  *              OleBuildVersion [OLE2.1]
 173  *              OleBuildVersion [OLE32.@]
 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.@)
 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  *              OleUninitialize [OLE2.3]
 244  *              OleUninitialize [OLE32.@]
 245  */
 246 void WINAPI OleUninitialize(void)
 247 {
 248   TRACE("()\n");
 249
 250   /*
 251    * Decrease the lock count on the OLE module.
 252    */
 253   OLE_moduleLockCount--;
 254
 255   /*
 256    * If we hit the bottom of the lock stack, free the libraries.
 257    */
 258   if (OLE_moduleLockCount==0)
 259   {
 260     /*
 261      * Actually free the libraries.
 262      */
 263     TRACE("() - Freeing the last reference count\n");
 264
 265     /*
 266      * OLE Clipboard
 267      */
 268     OLEClipbrd_UnInitialize();
 269
 270     /*
 271      * Drag and Drop
 272      */
 273     OLEDD_UnInitialize();
 274
 275     /*
 276      * OLE shared menu
 277      */
 278     OLEMenu_UnInitialize();
 279   }
 280
 281   /*
 282    * Then, uninitialize the COM libraries.
 283    */
 284   CoUninitialize();
 285 }
 286
 287 /******************************************************************************
 288  *              OleInitializeWOW        [OLE32.@]
 289  */
 290 HRESULT WINAPI OleInitializeWOW(DWORD x, DWORD y) {
 291         FIXME("(0x%08lx, 0x%08lx),stub!\n",x, y);
 292         return 0;
 293 }
 294
 295 /***********************************************************************
 296  *           RegisterDragDrop (OLE32.@)
 297  */
 298 HRESULT WINAPI RegisterDragDrop(
 299         HWND hwnd,
 300         LPDROPTARGET pDropTarget)
 301 {
 302   DropTargetNode* dropTargetInfo;
 303
 304   TRACE("(%p,%p)\n", hwnd, pDropTarget);
 305
 306   if (!pDropTarget)
 307     return E_INVALIDARG;
 308
 309   /*
 310    * First, check if the window is already registered.
 311    */
 312   dropTargetInfo = OLEDD_FindDropTarget(hwnd);
 313
 314   if (dropTargetInfo!=NULL)
 315     return DRAGDROP_E_ALREADYREGISTERED;
 316
 317   /*
 318    * If it's not there, we can add it. We first create a node for it.
 319    */
 320   dropTargetInfo = HeapAlloc(GetProcessHeap(), 0, sizeof(DropTargetNode));
 321
 322   if (dropTargetInfo==NULL)
 323     return E_OUTOFMEMORY;
 324
 325   dropTargetInfo->hwndTarget     = hwnd;
 326   dropTargetInfo->prevDropTarget = NULL;
 327   dropTargetInfo->nextDropTarget = NULL;
 328
 329   /*
 330    * Don't forget that this is an interface pointer, need to nail it down since
 331    * we keep a copy of it.
 332    */
 333   dropTargetInfo->dropTarget  = pDropTarget;
 334   IDropTarget_AddRef(dropTargetInfo->dropTarget);
 335
 336   OLEDD_InsertDropTarget(dropTargetInfo);
 337
 338         return S_OK;
 339 }
 340
 341 /***********************************************************************
 342  *           RevokeDragDrop (OLE32.@)
 343  */
 344 HRESULT WINAPI RevokeDragDrop(
 345         HWND hwnd)
 346 {
 347   DropTargetNode* dropTargetInfo;
 348
 349   TRACE("(%p)\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.@)
 374  *
 375  * This implementation of OleRegGetUserType ignores the dwFormOfType
 376  * parameter and always returns the full name of the object. This is
 377  * not too bad since this is the case for many objects because of the
 378  * way they are registered.
 379  */
 380 HRESULT WINAPI OleRegGetUserType(
 381         REFCLSID clsid,
 382         DWORD dwFormOfType,
 383         LPOLESTR* pszUserType)
 384 {
 385   char    keyName[60];
 386   DWORD   dwKeyType;
 387   DWORD   cbData;
 388   HKEY    clsidKey;
 389   LONG    hres;
 390   LPSTR   buffer;
 391   HRESULT retVal;
 392   /*
 393    * Initialize the out parameter.
 394    */
 395   *pszUserType = NULL;
 396
 397   /*
 398    * Build the key name we're looking for
 399    */
 400   sprintf( keyName, "CLSID\\{%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}\\",
 401            clsid->Data1, clsid->Data2, clsid->Data3,
 402            clsid->Data4[0], clsid->Data4[1], clsid->Data4[2], clsid->Data4[3],
 403            clsid->Data4[4], clsid->Data4[5], clsid->Data4[6], clsid->Data4[7] );
 404
 405   TRACE("(%s, %ld, %p)\n", keyName, dwFormOfType, pszUserType);
 406
 407   /*
 408    * Open the class id Key
 409    */
 410   hres = RegOpenKeyA(HKEY_CLASSES_ROOT,
 411                      keyName,
 412                      &clsidKey);
 413
 414   if (hres != ERROR_SUCCESS)
 415     return REGDB_E_CLASSNOTREG;
 416
 417   /*
 418    * Retrieve the size of the name string.
 419    */
 420   cbData = 0;
 421
 422   hres = RegQueryValueExA(clsidKey,
 423                           "",
 424                           NULL,
 425                           &dwKeyType,
 426                           NULL,
 427                           &cbData);
 428
 429   if (hres!=ERROR_SUCCESS)
 430   {
 431     RegCloseKey(clsidKey);
 432     return REGDB_E_READREGDB;
 433   }
 434
 435   /*
 436    * Allocate a buffer for the registry value.
 437    */
 438   *pszUserType = CoTaskMemAlloc(cbData*2);
 439
 440   if (*pszUserType==NULL)
 441   {
 442     RegCloseKey(clsidKey);
 443     return E_OUTOFMEMORY;
 444   }
 445
 446   buffer = HeapAlloc(GetProcessHeap(), 0, cbData);
 447
 448   if (buffer == NULL)
 449   {
 450     RegCloseKey(clsidKey);
 451     CoTaskMemFree(*pszUserType);
 452     *pszUserType=NULL;
 453     return E_OUTOFMEMORY;
 454   }
 455
 456   hres = RegQueryValueExA(clsidKey,
 457                           "",
 458                           NULL,
 459                           &dwKeyType,
 460                           (LPBYTE) buffer,
 461                           &cbData);
 462
 463   RegCloseKey(clsidKey);
 464
 465
 466   if (hres!=ERROR_SUCCESS)
 467   {
 468     CoTaskMemFree(*pszUserType);
 469     *pszUserType=NULL;
 470
 471     retVal = REGDB_E_READREGDB;
 472   }
 473   else
 474   {
 475     MultiByteToWideChar( CP_ACP, 0, buffer, -1, *pszUserType, cbData /*FIXME*/ );
 476     retVal = S_OK;
 477   }
 478   HeapFree(GetProcessHeap(), 0, buffer);
 479
 480   return retVal;
 481 }
 482
 483 /***********************************************************************
 484  * DoDragDrop [OLE32.@]
 485  */
 486 HRESULT WINAPI DoDragDrop (
 487   IDataObject *pDataObject,  /* [in] ptr to the data obj           */
 488   IDropSource* pDropSource,  /* [in] ptr to the source obj         */
 489   DWORD       dwOKEffect,    /* [in] effects allowed by the source */
 490   DWORD       *pdwEffect)    /* [out] ptr to effects of the source */
 491 {
 492   TrackerWindowInfo trackerInfo;
 493   HWND            hwndTrackWindow;
 494   MSG             msg;
 495
 496   TRACE("(DataObject %p, DropSource %p)\n", pDataObject, pDropSource);
 497
 498   /*
 499    * Setup the drag n drop tracking window.
 500    */
 501   if (!IsValidInterface((LPUNKNOWN)pDropSource))
 502       return E_INVALIDARG;
 503
 504   trackerInfo.dataObject        = pDataObject;
 505   trackerInfo.dropSource        = pDropSource;
 506   trackerInfo.dwOKEffect        = dwOKEffect;
 507   trackerInfo.pdwEffect         = pdwEffect;
 508   trackerInfo.trackingDone      = FALSE;
 509   trackerInfo.escPressed        = FALSE;
 510   trackerInfo.curDragTargetHWND = 0;
 511   trackerInfo.curTargetHWND     = 0;
 512   trackerInfo.curDragTarget     = 0;
 513
 514   hwndTrackWindow = CreateWindowA(OLEDD_DRAGTRACKERCLASS,
 515                                     "TrackerWindow",
 516                                     WS_POPUP,
 517                                     CW_USEDEFAULT, CW_USEDEFAULT,
 518                                     CW_USEDEFAULT, CW_USEDEFAULT,
 519                                     0,
 520                                     0,
 521                                     0,
 522                                     (LPVOID)&trackerInfo);
 523
 524   if (hwndTrackWindow!=0)
 525   {
 526     /*
 527      * Capture the mouse input
 528      */
 529     SetCapture(hwndTrackWindow);
 530
 531     /*
 532      * Pump messages. All mouse input should go the the capture window.
 533      */
 534     while (!trackerInfo.trackingDone && GetMessageA(&msg, 0, 0, 0) )
 535     {
 536       if ( (msg.message >= WM_KEYFIRST) &&
 537            (msg.message <= WM_KEYLAST) )
 538       {
 539         /*
 540          * When keyboard messages are sent to windows on this thread, we
 541          * want to ignore notify the drop source that the state changed.
 542          * in the case of the Escape key, we also notify the drop source
 543          * we give it a special meaning.
 544          */
 545         if ( (msg.message==WM_KEYDOWN) &&
 546              (msg.wParam==VK_ESCAPE) )
 547         {
 548           trackerInfo.escPressed = TRUE;
 549         }
 550
 551         /*
 552          * Notify the drop source.
 553          */
 554         OLEDD_TrackStateChange(&trackerInfo,
 555                                msg.pt,
 556                                OLEDD_GetButtonState());
 557       }
 558       else
 559       {
 560         /*
 561          * Dispatch the messages only when it's not a keyboard message.
 562          */
 563         DispatchMessageA(&msg);
 564       }
 565     }
 566
 567     /*
 568      * Destroy the temporary window.
 569      */
 570     DestroyWindow(hwndTrackWindow);
 571
 572     return trackerInfo.returnValue;
 573   }
 574
 575   return E_FAIL;
 576 }
 577
 578 /***********************************************************************
 579  * OleQueryLinkFromData [OLE32.@]
 580  */
 581 HRESULT WINAPI OleQueryLinkFromData(
 582   IDataObject* pSrcDataObject)
 583 {
 584   FIXME("(%p),stub!\n", pSrcDataObject);
 585   return S_OK;
 586 }
 587
 588 /***********************************************************************
 589  * OleRegGetMiscStatus [OLE32.@]
 590  */
 591 HRESULT WINAPI OleRegGetMiscStatus(
 592   REFCLSID clsid,
 593   DWORD    dwAspect,
 594   DWORD*   pdwStatus)
 595 {
 596   char    keyName[60];
 597   HKEY    clsidKey;
 598   HKEY    miscStatusKey;
 599   HKEY    aspectKey;
 600   LONG    result;
 601
 602   /*
 603    * Initialize the out parameter.
 604    */
 605   *pdwStatus = 0;
 606
 607   /*
 608    * Build the key name we're looking for
 609    */
 610   sprintf( keyName, "CLSID\\{%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}\\",
 611            clsid->Data1, clsid->Data2, clsid->Data3,
 612            clsid->Data4[0], clsid->Data4[1], clsid->Data4[2], clsid->Data4[3],
 613            clsid->Data4[4], clsid->Data4[5], clsid->Data4[6], clsid->Data4[7] );
 614
 615   TRACE("(%s, %ld, %p)\n", keyName, dwAspect, pdwStatus);
 616
 617   /*
 618    * Open the class id Key
 619    */
 620   result = RegOpenKeyA(HKEY_CLASSES_ROOT,
 621                        keyName,
 622                        &clsidKey);
 623
 624   if (result != ERROR_SUCCESS)
 625     return REGDB_E_CLASSNOTREG;
 626
 627   /*
 628    * Get the MiscStatus
 629    */
 630   result = RegOpenKeyA(clsidKey,
 631                        "MiscStatus",
 632                        &miscStatusKey);
 633
 634
 635   if (result != ERROR_SUCCESS)
 636   {
 637     RegCloseKey(clsidKey);
 638     return REGDB_E_READREGDB;
 639   }
 640
 641   /*
 642    * Read the default value
 643    */
 644   OLEUTL_ReadRegistryDWORDValue(miscStatusKey, pdwStatus);
 645
 646   /*
 647    * Open the key specific to the requested aspect.
 648    */
 649   sprintf(keyName, "%ld", dwAspect);
 650
 651   result = RegOpenKeyA(miscStatusKey,
 652                        keyName,
 653                        &aspectKey);
 654
 655   if (result == ERROR_SUCCESS)
 656   {
 657     OLEUTL_ReadRegistryDWORDValue(aspectKey, pdwStatus);
 658     RegCloseKey(aspectKey);
 659   }
 660
 661   /*
 662    * Cleanup
 663    */
 664   RegCloseKey(miscStatusKey);
 665   RegCloseKey(clsidKey);
 666
 667   return S_OK;
 668 }
 669
 670 static HRESULT EnumOLEVERB_Construct(HKEY hkeyVerb, ULONG index, IEnumOLEVERB **ppenum);
 671
 672 typedef struct
 673 {
 674     const IEnumOLEVERBVtbl *lpvtbl;
 675     LONG ref;
 676
 677     HKEY hkeyVerb;
 678     ULONG index;
 679 } EnumOLEVERB;
 680
 681 static HRESULT WINAPI EnumOLEVERB_QueryInterface(
 682     IEnumOLEVERB *iface, REFIID riid, void **ppv)
 683 {
 684     TRACE("(%s, %p)\n", debugstr_guid(riid), ppv);
 685     if (IsEqualIID(riid, &IID_IUnknown) ||
 686         IsEqualIID(riid, &IID_IEnumOLEVERB))
 687     {
 688         IUnknown_AddRef(iface);
 689         *ppv = iface;
 690         return S_OK;
 691     }
 692     return E_NOINTERFACE;
 693 }
 694
 695 static ULONG WINAPI EnumOLEVERB_AddRef(
 696     IEnumOLEVERB *iface)
 697 {
 698     EnumOLEVERB *This = (EnumOLEVERB *)iface;
 699     TRACE("()\n");
 700     return InterlockedIncrement(&This->ref);
 701 }
 702
 703 static ULONG WINAPI EnumOLEVERB_Release(
 704     IEnumOLEVERB *iface)
 705 {
 706     EnumOLEVERB *This = (EnumOLEVERB *)iface;
 707     LONG refs = InterlockedDecrement(&This->ref);
 708     TRACE("()\n");
 709     if (!refs)
 710     {
 711         RegCloseKey(This->hkeyVerb);
 712         HeapFree(GetProcessHeap(), 0, This);
 713     }
 714     return refs;
 715 }
 716
 717 static HRESULT WINAPI EnumOLEVERB_Next(
 718     IEnumOLEVERB *iface, ULONG celt, LPOLEVERB rgelt,
 719     ULONG *pceltFetched)
 720 {
 721     EnumOLEVERB *This = (EnumOLEVERB *)iface;
 722     HRESULT hr = S_OK;
 723
 724     TRACE("(%ld, %p, %p)\n", celt, rgelt, pceltFetched);
 725
 726     if (pceltFetched)
 727         *pceltFetched = 0;
 728
 729     for (; celt; celt--, rgelt++)
 730     {
 731         WCHAR wszSubKey[20];
 732         LONG cbData;
 733         LPWSTR pwszOLEVERB;
 734         LPWSTR pwszMenuFlags;
 735         LPWSTR pwszAttribs;
 736         LONG res = RegEnumKeyW(This->hkeyVerb, This->index, wszSubKey, sizeof(wszSubKey)/sizeof(wszSubKey[0]));
 737         if (res == ERROR_NO_MORE_ITEMS)
 738         {
 739             hr = S_FALSE;
 740             break;
 741         }
 742         else if (res != ERROR_SUCCESS)
 743         {
 744             ERR("RegEnumKeyW failed with error %ld\n", res);
 745             hr = REGDB_E_READREGDB;
 746             break;
 747         }
 748         res = RegQueryValueW(This->hkeyVerb, wszSubKey, NULL, &cbData);
 749         if (res != ERROR_SUCCESS)
 750         {
 751             ERR("RegQueryValueW failed with error %ld\n", res);
 752             hr = REGDB_E_READREGDB;
 753             break;
 754         }
 755         pwszOLEVERB = CoTaskMemAlloc(cbData);
 756         if (!pwszOLEVERB)
 757         {
 758             hr = E_OUTOFMEMORY;
 759             break;
 760         }
 761         res = RegQueryValueW(This->hkeyVerb, wszSubKey, pwszOLEVERB, &cbData);
 762         if (res != ERROR_SUCCESS)
 763         {
 764             ERR("RegQueryValueW failed with error %ld\n", res);
 765             hr = REGDB_E_READREGDB;
 766             CoTaskMemFree(pwszOLEVERB);
 767             break;
 768         }
 769
 770         TRACE("verb string: %s\n", debugstr_w(pwszOLEVERB));
 771         pwszMenuFlags = strchrW(pwszOLEVERB, ',');
 772         if (!pwszMenuFlags)
 773         {
 774             hr = OLEOBJ_E_INVALIDVERB;
 775             CoTaskMemFree(pwszOLEVERB);
 776             break;
 777         }
 778         /* nul terminate the name string and advance to first character */
 779         *pwszMenuFlags = '\0';
 780         pwszMenuFlags++;
 781         pwszAttribs = strchrW(pwszMenuFlags, ',');
 782         if (!pwszAttribs)
 783         {
 784             hr = OLEOBJ_E_INVALIDVERB;
 785             CoTaskMemFree(pwszOLEVERB);
 786             break;
 787         }
 788         /* nul terminate the menu string and advance to first character */
 789         *pwszAttribs = '\0';
 790         pwszAttribs++;
 791
 792         /* fill out structure for this verb */
 793         rgelt->lVerb = atolW(wszSubKey);
 794         rgelt->lpszVerbName = pwszOLEVERB; /* user should free */
 795         rgelt->fuFlags = atolW(pwszMenuFlags);
 796         rgelt->grfAttribs = atolW(pwszAttribs);
 797
 798         if (pceltFetched)
 799             *pceltFetched++;
 800         This->index++;
 801     }
 802     return hr;
 803 }
 804
 805 static HRESULT WINAPI EnumOLEVERB_Skip(
 806     IEnumOLEVERB *iface, ULONG celt)
 807 {
 808     EnumOLEVERB *This = (EnumOLEVERB *)iface;
 809
 810     TRACE("(%ld)\n", celt);
 811
 812     This->index += celt;
 813     return S_OK;
 814 }
 815
 816 static HRESULT WINAPI EnumOLEVERB_Reset(
 817     IEnumOLEVERB *iface)
 818 {
 819     EnumOLEVERB *This = (EnumOLEVERB *)iface;
 820
 821     TRACE("()\n");
 822
 823     This->index = 0;
 824     return S_OK;
 825 }
 826
 827 static HRESULT WINAPI EnumOLEVERB_Clone(
 828     IEnumOLEVERB *iface,
 829     IEnumOLEVERB **ppenum)
 830 {
 831     EnumOLEVERB *This = (EnumOLEVERB *)iface;
 832     HKEY hkeyVerb;
 833     TRACE("(%p)\n", ppenum);
 834     if (!DuplicateHandle(GetCurrentProcess(), This->hkeyVerb, GetCurrentProcess(), (HANDLE *)&hkeyVerb, 0, FALSE, DUPLICATE_SAME_ACCESS))
 835         return HRESULT_FROM_WIN32(GetLastError());
 836     return EnumOLEVERB_Construct(hkeyVerb, This->index, ppenum);
 837 }
 838
 839 static const IEnumOLEVERBVtbl EnumOLEVERB_VTable =
 840 {
 841     EnumOLEVERB_QueryInterface,
 842     EnumOLEVERB_AddRef,
 843     EnumOLEVERB_Release,
 844     EnumOLEVERB_Next,
 845     EnumOLEVERB_Skip,
 846     EnumOLEVERB_Reset,
 847     EnumOLEVERB_Clone
 848 };
 849
 850 static HRESULT EnumOLEVERB_Construct(HKEY hkeyVerb, ULONG index, IEnumOLEVERB **ppenum)
 851 {
 852     EnumOLEVERB *This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
 853     if (!This)
 854     {
 855         RegCloseKey(hkeyVerb);
 856         return E_OUTOFMEMORY;
 857     }
 858     This->lpvtbl = &EnumOLEVERB_VTable;
 859     This->ref = 1;
 860     This->index = index;
 861     This->hkeyVerb = hkeyVerb;
 862     *ppenum = (IEnumOLEVERB *)&This->lpvtbl;
 863     return S_OK;
 864 }
 865
 866 /***********************************************************************
 867  *           OleRegEnumVerbs    [OLE32.@]
 868  *
 869  * Enumerates verbs associated with a class stored in the registry.
 870  *
 871  * PARAMS
 872  *  clsid  [I] Class ID to enumerate the verbs for.
 873  *  ppenum [O] Enumerator.
 874  *
 875  * RETURNS
 876  *  S_OK: Success.
 877  *  REGDB_E_CLASSNOTREG: The specified class does not have a key in the registry.
 878  *  REGDB_E_READREGDB: The class key could not be opened for some other reason.
 879  *  OLE_E_REGDB_KEY: The Verb subkey for the class is not present.
 880  *  OLEOBJ_E_NOVERBS: The Verb subkey for the class is empty.
 881  */
 882 HRESULT WINAPI OleRegEnumVerbs (REFCLSID clsid, LPENUMOLEVERB* ppenum)
 883 {
 884     LONG res;
 885     HKEY hkeyVerb;
 886     DWORD dwSubKeys;
 887     static const WCHAR wszVerb[] = {'V','e','r','b',0};
 888
 889     TRACE("(%s, %p)\n", debugstr_guid(clsid), ppenum);
 890
 891     res = COM_OpenKeyForCLSID(clsid, wszVerb, KEY_READ, &hkeyVerb);
 892     if (FAILED(res))
 893     {
 894         if (res == REGDB_E_CLASSNOTREG)
 895             ERR("CLSID %s not registered\n", debugstr_guid(clsid));
 896         else if (res == REGDB_E_KEYMISSING)
 897             ERR("no Verbs key for class %s\n", debugstr_guid(clsid));
 898         else
 899             ERR("failed to open Verbs key for CLSID %s with error %ld\n",
 900                 debugstr_guid(clsid), res);
 901         return res;
 902     }
 903
 904     res = RegQueryInfoKeyW(hkeyVerb, NULL, NULL, NULL, &dwSubKeys, NULL,
 905                           NULL, NULL, NULL, NULL, NULL, NULL);
 906     if (res != ERROR_SUCCESS)
 907     {
 908         ERR("failed to get subkey count with error %ld\n", GetLastError());
 909         return REGDB_E_READREGDB;
 910     }
 911
 912     if (!dwSubKeys)
 913     {
 914         WARN("class %s has no verbs\n", debugstr_guid(clsid));
 915         RegCloseKey(hkeyVerb);
 916         return OLEOBJ_E_NOVERBS;
 917     }
 918
 919     return EnumOLEVERB_Construct(hkeyVerb, 0, ppenum);
 920 }
 921
 922 /******************************************************************************
 923  *              OleSetContainedObject        [OLE32.@]
 924  */
 925 HRESULT WINAPI OleSetContainedObject(
 926   LPUNKNOWN pUnknown,
 927   BOOL      fContained)
 928 {
 929   IRunnableObject* runnable = NULL;
 930   HRESULT          hres;
 931
 932   TRACE("(%p,%x), stub!\n", pUnknown, fContained);
 933
 934   hres = IUnknown_QueryInterface(pUnknown,
 935                                  &IID_IRunnableObject,
 936                                  (void**)&runnable);
 937
 938   if (SUCCEEDED(hres))
 939   {
 940     hres = IRunnableObject_SetContainedObject(runnable, fContained);
 941
 942     IRunnableObject_Release(runnable);
 943
 944     return hres;
 945   }
 946
 947   return S_OK;
 948 }
 949
 950 /******************************************************************************
 951  *              OleLoad        [OLE32.@]
 952  */
 953 HRESULT WINAPI OleLoad(
 954   LPSTORAGE       pStg,
 955   REFIID          riid,
 956   LPOLECLIENTSITE pClientSite,
 957   LPVOID*         ppvObj)
 958 {
 959   IPersistStorage* persistStorage = NULL;
 960   IOleObject*      oleObject      = NULL;
 961   STATSTG          storageInfo;
 962   HRESULT          hres;
 963
 964   TRACE("(%p,%p,%p,%p)\n", pStg, riid, pClientSite, ppvObj);
 965
 966   /*
 967    * TODO, Conversion ... OleDoAutoConvert
 968    */
 969
 970   /*
 971    * Get the class ID for the object.
 972    */
 973   hres = IStorage_Stat(pStg, &storageInfo, STATFLAG_NONAME);
 974
 975   /*
 976    * Now, try and create the handler for the object
 977    */
 978   hres = CoCreateInstance(&storageInfo.clsid,
 979                           NULL,
 980                           CLSCTX_INPROC_HANDLER,
 981                           &IID_IOleObject,
 982                           (void**)&oleObject);
 983
 984   /*
 985    * If that fails, as it will most times, load the default
 986    * OLE handler.
 987    */
 988   if (FAILED(hres))
 989   {
 990     hres = OleCreateDefaultHandler(&storageInfo.clsid,
 991                                    NULL,
 992                                    &IID_IOleObject,
 993                                    (void**)&oleObject);
 994   }
 995
 996   /*
 997    * If we couldn't find a handler... this is bad. Abort the whole thing.
 998    */
 999   if (FAILED(hres))
1000     return hres;
1001
1002   /*
1003    * Inform the new object of it's client site.
1004    */
1005   hres = IOleObject_SetClientSite(oleObject, pClientSite);
1006
1007   /*
1008    * Initialize the object with it's IPersistStorage interface.
1009    */
1010   hres = IOleObject_QueryInterface(oleObject,
1011                                    &IID_IPersistStorage,
1012                                    (void**)&persistStorage);
1013
1014   if (SUCCEEDED(hres))
1015   {
1016     IPersistStorage_Load(persistStorage, pStg);
1017
1018     IPersistStorage_Release(persistStorage);
1019     persistStorage = NULL;
1020   }
1021
1022   /*
1023    * Return the requested interface to the caller.
1024    */
1025   hres = IOleObject_QueryInterface(oleObject, riid, ppvObj);
1026
1027   /*
1028    * Cleanup interfaces used internally
1029    */
1030   IOleObject_Release(oleObject);
1031
1032   return hres;
1033 }
1034
1035 /***********************************************************************
1036  *           OleSave     [OLE32.@]
1037  */
1038 HRESULT WINAPI OleSave(
1039   LPPERSISTSTORAGE pPS,
1040   LPSTORAGE        pStg,
1041   BOOL             fSameAsLoad)
1042 {
1043   HRESULT hres;
1044   CLSID   objectClass;
1045
1046   TRACE("(%p,%p,%x)\n", pPS, pStg, fSameAsLoad);
1047
1048   /*
1049    * First, we transfer the class ID (if available)
1050    */
1051   hres = IPersistStorage_GetClassID(pPS, &objectClass);
1052
1053   if (SUCCEEDED(hres))
1054   {
1055     WriteClassStg(pStg, &objectClass);
1056   }
1057
1058   /*
1059    * Then, we ask the object to save itself to the
1060    * storage. If it is successful, we commit the storage.
1061    */
1062   hres = IPersistStorage_Save(pPS, pStg, fSameAsLoad);
1063
1064   if (SUCCEEDED(hres))
1065   {
1066     IStorage_Commit(pStg,
1067                     STGC_DEFAULT);
1068   }
1069
1070   return hres;
1071 }
1072
1073
1074 /******************************************************************************
1075  *              OleLockRunning        [OLE32.@]
1076  */
1077 HRESULT WINAPI OleLockRunning(LPUNKNOWN pUnknown, BOOL fLock, BOOL fLastUnlockCloses)
1078 {
1079   IRunnableObject* runnable = NULL;
1080   HRESULT          hres;
1081
1082   TRACE("(%p,%x,%x)\n", pUnknown, fLock, fLastUnlockCloses);
1083
1084   hres = IUnknown_QueryInterface(pUnknown,
1085                                  &IID_IRunnableObject,
1086                                  (void**)&runnable);
1087
1088   if (SUCCEEDED(hres))
1089   {
1090     hres = IRunnableObject_LockRunning(runnable, fLock, fLastUnlockCloses);
1091
1092     IRunnableObject_Release(runnable);
1093
1094     return hres;
1095   }
1096   else
1097     return E_INVALIDARG;
1098 }
1099
1100
1101 /**************************************************************************
1102  * Internal methods to manage the shared OLE menu in response to the
1103  * OLE***MenuDescriptor API
1104  */
1105
1106 /***
1107  * OLEMenu_Initialize()
1108  *
1109  * Initializes the OLEMENU data structures.
1110  */
1111 static void OLEMenu_Initialize()
1112 {
1113 }
1114
1115 /***
1116  * OLEMenu_UnInitialize()
1117  *
1118  * Releases the OLEMENU data structures.
1119  */
1120 static void OLEMenu_UnInitialize()
1121 {
1122 }
1123
1124 /*************************************************************************
1125  * OLEMenu_InstallHooks
1126  * Install thread scope message hooks for WH_GETMESSAGE and WH_CALLWNDPROC
1127  *
1128  * RETURNS: TRUE if message hooks were successfully installed
1129  *          FALSE on failure
1130  */
1131 BOOL OLEMenu_InstallHooks( DWORD tid )
1132 {
1133   OleMenuHookItem *pHookItem = NULL;
1134
1135   /* Create an entry for the hook table */
1136   if ( !(pHookItem = HeapAlloc(GetProcessHeap(), 0,
1137                                sizeof(OleMenuHookItem)) ) )
1138     return FALSE;
1139
1140   pHookItem->tid = tid;
1141   pHookItem->hHeap = GetProcessHeap();
1142
1143   /* Install a thread scope message hook for WH_GETMESSAGE */
1144   pHookItem->GetMsg_hHook = SetWindowsHookExA( WH_GETMESSAGE, OLEMenu_GetMsgProc,
1145                                                0, GetCurrentThreadId() );
1146   if ( !pHookItem->GetMsg_hHook )
1147     goto CLEANUP;
1148
1149   /* Install a thread scope message hook for WH_CALLWNDPROC */
1150   pHookItem->CallWndProc_hHook = SetWindowsHookExA( WH_CALLWNDPROC, OLEMenu_CallWndProc,
1151                                                     0, GetCurrentThreadId() );
1152   if ( !pHookItem->CallWndProc_hHook )
1153     goto CLEANUP;
1154
1155   /* Insert the hook table entry */
1156   pHookItem->next = hook_list;
1157   hook_list = pHookItem;
1158
1159   return TRUE;
1160
1161 CLEANUP:
1162   /* Unhook any hooks */
1163   if ( pHookItem->GetMsg_hHook )
1164     UnhookWindowsHookEx( pHookItem->GetMsg_hHook );
1165   if ( pHookItem->CallWndProc_hHook )
1166     UnhookWindowsHookEx( pHookItem->CallWndProc_hHook );
1167   /* Release the hook table entry */
1168   HeapFree(pHookItem->hHeap, 0, pHookItem );
1169
1170   return FALSE;
1171 }
1172
1173 /*************************************************************************
1174  * OLEMenu_UnInstallHooks
1175  * UnInstall thread scope message hooks for WH_GETMESSAGE and WH_CALLWNDPROC
1176  *
1177  * RETURNS: TRUE if message hooks were successfully installed
1178  *          FALSE on failure
1179  */
1180 BOOL OLEMenu_UnInstallHooks( DWORD tid )
1181 {
1182   OleMenuHookItem *pHookItem = NULL;
1183   OleMenuHookItem **ppHook = &hook_list;
1184
1185   while (*ppHook)
1186   {
1187       if ((*ppHook)->tid == tid)
1188       {
1189           pHookItem = *ppHook;
1190           *ppHook = pHookItem->next;
1191           break;
1192       }
1193       ppHook = &(*ppHook)->next;
1194   }
1195   if (!pHookItem) return FALSE;
1196
1197   /* Uninstall the hooks installed for this thread */
1198   if ( !UnhookWindowsHookEx( pHookItem->GetMsg_hHook ) )
1199     goto CLEANUP;
1200   if ( !UnhookWindowsHookEx( pHookItem->CallWndProc_hHook ) )
1201     goto CLEANUP;
1202
1203   /* Release the hook table entry */
1204   HeapFree(pHookItem->hHeap, 0, pHookItem );
1205
1206   return TRUE;
1207
1208 CLEANUP:
1209   /* Release the hook table entry */
1210   HeapFree(pHookItem->hHeap, 0, pHookItem );
1211
1212   return FALSE;
1213 }
1214
1215 /*************************************************************************
1216  * OLEMenu_IsHookInstalled
1217  * Tests if OLEMenu hooks have been installed for a thread
1218  *
1219  * RETURNS: The pointer and index of the hook table entry for the tid
1220  *          NULL and -1 for the index if no hooks were installed for this thread
1221  */
1222 OleMenuHookItem * OLEMenu_IsHookInstalled( DWORD tid )
1223 {
1224   OleMenuHookItem *pHookItem = NULL;
1225
1226   /* Do a simple linear search for an entry whose tid matches ours.
1227    * We really need a map but efficiency is not a concern here. */
1228   for (pHookItem = hook_list; pHookItem; pHookItem = pHookItem->next)
1229   {
1230     if ( tid == pHookItem->tid )
1231       return pHookItem;
1232   }
1233
1234   return NULL;
1235 }
1236
1237 /***********************************************************************
1238  *           OLEMenu_FindMainMenuIndex
1239  *
1240  * Used by OLEMenu API to find the top level group a menu item belongs to.
1241  * On success pnPos contains the index of the item in the top level menu group
1242  *
1243  * RETURNS: TRUE if the ID was found, FALSE on failure
1244  */
1245 static BOOL OLEMenu_FindMainMenuIndex( HMENU hMainMenu, HMENU hPopupMenu, UINT *pnPos )
1246 {
1247   UINT i, nItems;
1248
1249   nItems = GetMenuItemCount( hMainMenu );
1250
1251   for (i = 0; i < nItems; i++)
1252   {
1253     HMENU hsubmenu;
1254
1255     /*  Is the current item a submenu? */
1256     if ( (hsubmenu = GetSubMenu(hMainMenu, i)) )
1257     {
1258       /* If the handle is the same we're done */
1259       if ( hsubmenu == hPopupMenu )
1260       {
1261         if (pnPos)
1262           *pnPos = i;
1263         return TRUE;
1264       }
1265       /* Recursively search without updating pnPos */
1266       else if ( OLEMenu_FindMainMenuIndex( hsubmenu, hPopupMenu, NULL ) )
1267       {
1268         if (pnPos)
1269           *pnPos = i;
1270         return TRUE;
1271       }
1272     }
1273   }
1274
1275   return FALSE;
1276 }
1277
1278 /***********************************************************************
1279  *           OLEMenu_SetIsServerMenu
1280  *
1281  * Checks whether a popup menu belongs to a shared menu group which is
1282  * owned by the server, and sets the menu descriptor state accordingly.
1283  * All menu messages from these groups should be routed to the server.
1284  *
1285  * RETURNS: TRUE if the popup menu is part of a server owned group
1286  *          FALSE if the popup menu is part of a container owned group
1287  */
1288 BOOL OLEMenu_SetIsServerMenu( HMENU hmenu, OleMenuDescriptor *pOleMenuDescriptor )
1289 {
1290   UINT nPos = 0, nWidth, i;
1291
1292   pOleMenuDescriptor->bIsServerItem = FALSE;
1293
1294   /* Don't bother searching if the popup is the combined menu itself */
1295   if ( hmenu == pOleMenuDescriptor->hmenuCombined )
1296     return FALSE;
1297
1298   /* Find the menu item index in the shared OLE menu that this item belongs to */
1299   if ( !OLEMenu_FindMainMenuIndex( pOleMenuDescriptor->hmenuCombined, hmenu,  &nPos ) )
1300     return FALSE;
1301
1302   /* The group widths array has counts for the number of elements
1303    * in the groups File, Edit, Container, Object, Window, Help.
1304    * The Edit, Object & Help groups belong to the server object
1305    * and the other three belong to the container.
1306    * Loop through the group widths and locate the group we are a member of.
1307    */
1308   for ( i = 0, nWidth = 0; i < 6; i++ )
1309   {
1310     nWidth += pOleMenuDescriptor->mgw.width[i];
1311     if ( nPos < nWidth )
1312     {
1313       /* Odd elements are server menu widths */
1314       pOleMenuDescriptor->bIsServerItem = (i%2) ? TRUE : FALSE;
1315       break;
1316     }
1317   }
1318
1319   return pOleMenuDescriptor->bIsServerItem;
1320 }
1321
1322 /*************************************************************************
1323  * OLEMenu_CallWndProc
1324  * Thread scope WH_CALLWNDPROC hook proc filter function (callback)
1325  * This is invoked from a message hook installed in OleSetMenuDescriptor.
1326  */
1327 LRESULT CALLBACK OLEMenu_CallWndProc(INT code, WPARAM wParam, LPARAM lParam)
1328 {
1329   LPCWPSTRUCT pMsg = NULL;
1330   HOLEMENU hOleMenu = 0;
1331   OleMenuDescriptor *pOleMenuDescriptor = NULL;
1332   OleMenuHookItem *pHookItem = NULL;
1333   WORD fuFlags;
1334
1335   TRACE("%i, %04x, %08x\n", code, wParam, (unsigned)lParam );
1336
1337   /* Check if we're being asked to process the message */
1338   if ( HC_ACTION != code )
1339     goto NEXTHOOK;
1340
1341   /* Retrieve the current message being dispatched from lParam */
1342   pMsg = (LPCWPSTRUCT)lParam;
1343
1344   /* Check if the message is destined for a window we are interested in:
1345    * If the window has an OLEMenu property we may need to dispatch
1346    * the menu message to its active objects window instead. */
1347
1348   hOleMenu = (HOLEMENU)GetPropA( pMsg->hwnd, "PROP_OLEMenuDescriptor" );
1349   if ( !hOleMenu )
1350     goto NEXTHOOK;
1351
1352   /* Get the menu descriptor */
1353   pOleMenuDescriptor = (OleMenuDescriptor *) GlobalLock( hOleMenu );
1354   if ( !pOleMenuDescriptor ) /* Bad descriptor! */
1355     goto NEXTHOOK;
1356
1357   /* Process menu messages */
1358   switch( pMsg->message )
1359   {
1360     case WM_INITMENU:
1361     {
1362       /* Reset the menu descriptor state */
1363       pOleMenuDescriptor->bIsServerItem = FALSE;
1364
1365       /* Send this message to the server as well */
1366       SendMessageA( pOleMenuDescriptor->hwndActiveObject,
1367                   pMsg->message, pMsg->wParam, pMsg->lParam );
1368       goto NEXTHOOK;
1369     }
1370
1371     case WM_INITMENUPOPUP:
1372     {
1373       /* Save the state for whether this is a server owned menu */
1374       OLEMenu_SetIsServerMenu( (HMENU)pMsg->wParam, pOleMenuDescriptor );
1375       break;
1376     }
1377
1378     case WM_MENUSELECT:
1379     {
1380       fuFlags = HIWORD(pMsg->wParam);  /* Get flags */
1381       if ( fuFlags & MF_SYSMENU )
1382          goto NEXTHOOK;
1383
1384       /* Save the state for whether this is a server owned popup menu */
1385       else if ( fuFlags & MF_POPUP )
1386         OLEMenu_SetIsServerMenu( (HMENU)pMsg->lParam, pOleMenuDescriptor );
1387
1388       break;
1389     }
1390
1391     case WM_DRAWITEM:
1392     {
1393       LPDRAWITEMSTRUCT lpdis = (LPDRAWITEMSTRUCT) pMsg->lParam;
1394       if ( pMsg->wParam != 0 || lpdis->CtlType != ODT_MENU )
1395         goto NEXTHOOK;  /* Not a menu message */
1396
1397       break;
1398     }
1399
1400     default:
1401       goto NEXTHOOK;
1402   }
1403
1404   /* If the message was for the server dispatch it accordingly */
1405   if ( pOleMenuDescriptor->bIsServerItem )
1406   {
1407     SendMessageA( pOleMenuDescriptor->hwndActiveObject,
1408                   pMsg->message, pMsg->wParam, pMsg->lParam );
1409   }
1410
1411 NEXTHOOK:
1412   if ( pOleMenuDescriptor )
1413     GlobalUnlock( hOleMenu );
1414
1415   /* Lookup the hook item for the current thread */
1416   if ( !( pHookItem = OLEMenu_IsHookInstalled( GetCurrentThreadId() ) ) )
1417   {
1418     /* This should never fail!! */
1419     WARN("could not retrieve hHook for current thread!\n" );
1420     return 0;
1421   }
1422
1423   /* Pass on the message to the next hooker */
1424   return CallNextHookEx( pHookItem->CallWndProc_hHook, code, wParam, lParam );
1425 }
1426
1427 /*************************************************************************
1428  * OLEMenu_GetMsgProc
1429  * Thread scope WH_GETMESSAGE hook proc filter function (callback)
1430  * This is invoked from a message hook installed in OleSetMenuDescriptor.
1431  */
1432 LRESULT CALLBACK OLEMenu_GetMsgProc(INT code, WPARAM wParam, LPARAM lParam)
1433 {
1434   LPMSG pMsg = NULL;
1435   HOLEMENU hOleMenu = 0;
1436   OleMenuDescriptor *pOleMenuDescriptor = NULL;
1437   OleMenuHookItem *pHookItem = NULL;
1438   WORD wCode;
1439
1440   TRACE("%i, %04x, %08x\n", code, wParam, (unsigned)lParam );
1441
1442   /* Check if we're being asked to process a  messages */
1443   if ( HC_ACTION != code )
1444     goto NEXTHOOK;
1445
1446   /* Retrieve the current message being dispatched from lParam */
1447   pMsg = (LPMSG)lParam;
1448
1449   /* Check if the message is destined for a window we are interested in:
1450    * If the window has an OLEMenu property we may need to dispatch
1451    * the menu message to its active objects window instead. */
1452
1453   hOleMenu = (HOLEMENU)GetPropA( pMsg->hwnd, "PROP_OLEMenuDescriptor" );
1454   if ( !hOleMenu )
1455     goto NEXTHOOK;
1456
1457   /* Process menu messages */
1458   switch( pMsg->message )
1459   {
1460     case WM_COMMAND:
1461     {
1462       wCode = HIWORD(pMsg->wParam);  /* Get notification code */
1463       if ( wCode )
1464         goto NEXTHOOK;  /* Not a menu message */
1465       break;
1466     }
1467     default:
1468       goto NEXTHOOK;
1469   }
1470
1471   /* Get the menu descriptor */
1472   pOleMenuDescriptor = (OleMenuDescriptor *) GlobalLock( hOleMenu );
1473   if ( !pOleMenuDescriptor ) /* Bad descriptor! */
1474     goto NEXTHOOK;
1475
1476   /* If the message was for the server dispatch it accordingly */
1477   if ( pOleMenuDescriptor->bIsServerItem )
1478   {
1479     /* Change the hWnd in the message to the active objects hWnd.
1480      * The message loop which reads this message will automatically
1481      * dispatch it to the embedded objects window. */
1482     pMsg->hwnd = pOleMenuDescriptor->hwndActiveObject;
1483   }
1484
1485 NEXTHOOK:
1486   if ( pOleMenuDescriptor )
1487     GlobalUnlock( hOleMenu );
1488
1489   /* Lookup the hook item for the current thread */
1490   if ( !( pHookItem = OLEMenu_IsHookInstalled( GetCurrentThreadId() ) ) )
1491   {
1492     /* This should never fail!! */
1493     WARN("could not retrieve hHook for current thread!\n" );
1494     return FALSE;
1495   }
1496
1497   /* Pass on the message to the next hooker */
1498   return CallNextHookEx( pHookItem->GetMsg_hHook, code, wParam, lParam );
1499 }
1500
1501 /***********************************************************************
1502  * OleCreateMenuDescriptor [OLE32.@]
1503  * Creates an OLE menu descriptor for OLE to use when dispatching
1504  * menu messages and commands.
1505  *
1506  * PARAMS:
1507  *    hmenuCombined  -  Handle to the objects combined menu
1508  *    lpMenuWidths   -  Pointer to array of 6 LONG's indicating menus per group
1509  *
1510  */
1511 HOLEMENU WINAPI OleCreateMenuDescriptor(
1512   HMENU                hmenuCombined,
1513   LPOLEMENUGROUPWIDTHS lpMenuWidths)
1514 {
1515   HOLEMENU hOleMenu;
1516   OleMenuDescriptor *pOleMenuDescriptor;
1517   int i;
1518
1519   if ( !hmenuCombined || !lpMenuWidths )
1520     return 0;
1521
1522   /* Create an OLE menu descriptor */
1523   if ( !(hOleMenu = GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT,
1524                                 sizeof(OleMenuDescriptor) ) ) )
1525   return 0;
1526
1527   pOleMenuDescriptor = (OleMenuDescriptor *) GlobalLock( hOleMenu );
1528   if ( !pOleMenuDescriptor )
1529     return 0;
1530
1531   /* Initialize menu group widths and hmenu */
1532   for ( i = 0; i < 6; i++ )
1533     pOleMenuDescriptor->mgw.width[i] = lpMenuWidths->width[i];
1534
1535   pOleMenuDescriptor->hmenuCombined = hmenuCombined;
1536   pOleMenuDescriptor->bIsServerItem = FALSE;
1537   GlobalUnlock( hOleMenu );
1538
1539   return hOleMenu;
1540 }
1541
1542 /***********************************************************************
1543  * OleDestroyMenuDescriptor [OLE32.@]
1544  * Destroy the shared menu descriptor
1545  */
1546 HRESULT WINAPI OleDestroyMenuDescriptor(
1547   HOLEMENU hmenuDescriptor)
1548 {
1549   if ( hmenuDescriptor )
1550     GlobalFree( hmenuDescriptor );
1551         return S_OK;
1552 }
1553
1554 /***********************************************************************
1555  * OleSetMenuDescriptor [OLE32.@]
1556  * Installs or removes OLE dispatching code for the containers frame window.
1557  *
1558  * PARAMS
1559  *     hOleMenu         Handle to composite menu descriptor
1560  *     hwndFrame        Handle to containers frame window
1561  *     hwndActiveObject Handle to objects in-place activation window
1562  *     lpFrame          Pointer to IOleInPlaceFrame on containers window
1563  *     lpActiveObject   Pointer to IOleInPlaceActiveObject on active in-place object
1564  *
1565  * RETURNS
1566  *      S_OK                               - menu installed correctly
1567  *      E_FAIL, E_INVALIDARG, E_UNEXPECTED - failure
1568  *
1569  * FIXME
1570  *      The lpFrame and lpActiveObject parameters are currently ignored
1571  *      OLE should install context sensitive help F1 filtering for the app when
1572  *      these are non null.
1573  */
1574 HRESULT WINAPI OleSetMenuDescriptor(
1575   HOLEMENU               hOleMenu,
1576   HWND                   hwndFrame,
1577   HWND                   hwndActiveObject,
1578   LPOLEINPLACEFRAME        lpFrame,
1579   LPOLEINPLACEACTIVEOBJECT lpActiveObject)
1580 {
1581   OleMenuDescriptor *pOleMenuDescriptor = NULL;
1582
1583   /* Check args */
1584   if ( !hwndFrame || (hOleMenu && !hwndActiveObject) )
1585     return E_INVALIDARG;
1586
1587   if ( lpFrame || lpActiveObject )
1588   {
1589      FIXME("(%p, %p, %p, %p, %p), Context sensitive help filtering not implemented!\n",
1590         hOleMenu,
1591         hwndFrame,
1592         hwndActiveObject,
1593         lpFrame,
1594         lpActiveObject);
1595   }
1596
1597   /* Set up a message hook to intercept the containers frame window messages.
1598    * The message filter is responsible for dispatching menu messages from the
1599    * shared menu which are intended for the object.
1600    */
1601
1602   if ( hOleMenu )  /* Want to install dispatching code */
1603   {
1604     /* If OLEMenu hooks are already installed for this thread, fail
1605      * Note: This effectively means that OleSetMenuDescriptor cannot
1606      * be called twice in succession on the same frame window
1607      * without first calling it with a null hOleMenu to uninstall */
1608     if ( OLEMenu_IsHookInstalled( GetCurrentThreadId() ) )
1609   return E_FAIL;
1610
1611     /* Get the menu descriptor */
1612     pOleMenuDescriptor = (OleMenuDescriptor *) GlobalLock( hOleMenu );
1613     if ( !pOleMenuDescriptor )
1614       return E_UNEXPECTED;
1615
1616     /* Update the menu descriptor */
1617     pOleMenuDescriptor->hwndFrame = hwndFrame;
1618     pOleMenuDescriptor->hwndActiveObject = hwndActiveObject;
1619
1620     GlobalUnlock( hOleMenu );
1621     pOleMenuDescriptor = NULL;
1622
1623     /* Add a menu descriptor windows property to the frame window */
1624     SetPropA( hwndFrame, "PROP_OLEMenuDescriptor", hOleMenu );
1625
1626     /* Install thread scope message hooks for WH_GETMESSAGE and WH_CALLWNDPROC */
1627     if ( !OLEMenu_InstallHooks( GetCurrentThreadId() ) )
1628       return E_FAIL;
1629   }
1630   else  /* Want to uninstall dispatching code */
1631   {
1632     /* Uninstall the hooks */
1633     if ( !OLEMenu_UnInstallHooks( GetCurrentThreadId() ) )
1634       return E_FAIL;
1635
1636     /* Remove the menu descriptor property from the frame window */
1637     RemovePropA( hwndFrame, "PROP_OLEMenuDescriptor" );
1638   }
1639
1640   return S_OK;
1641 }
1642
1643 /******************************************************************************
1644  *              IsAccelerator        [OLE32.@]
1645  * Mostly copied from controls/menu.c TranslateAccelerator implementation
1646  */
1647 BOOL WINAPI IsAccelerator(HACCEL hAccel, int cAccelEntries, LPMSG lpMsg, WORD* lpwCmd)
1648 {
1649     LPACCEL lpAccelTbl;
1650     int i;
1651
1652     if(!lpMsg) return FALSE;
1653     if (!hAccel)
1654     {
1655         WARN_(accel)("NULL accel handle\n");
1656         return FALSE;
1657     }
1658     if((lpMsg->message != WM_KEYDOWN &&
1659         lpMsg->message != WM_KEYUP &&
1660         lpMsg->message != WM_SYSKEYDOWN &&
1661         lpMsg->message != WM_SYSKEYUP &&
1662         lpMsg->message != WM_CHAR)) return FALSE;
1663     lpAccelTbl = HeapAlloc(GetProcessHeap(), 0, cAccelEntries * sizeof(ACCEL));
1664     if (NULL == lpAccelTbl)
1665     {
1666         return FALSE;
1667     }
1668     if (CopyAcceleratorTableW(hAccel, lpAccelTbl, cAccelEntries) != cAccelEntries)
1669     {
1670         WARN_(accel)("CopyAcceleratorTableW failed\n");
1671         HeapFree(GetProcessHeap(), 0, lpAccelTbl);
1672         return FALSE;
1673     }
1674
1675     TRACE_(accel)("hAccel=%p, cAccelEntries=%d,"
1676                 "msg->hwnd=%p, msg->message=%04x, wParam=%08x, lParam=%08lx\n",
1677                 hAccel, cAccelEntries,
1678                 lpMsg->hwnd, lpMsg->message, lpMsg->wParam, lpMsg->lParam);
1679     for(i = 0; i < cAccelEntries; i++)
1680     {
1681         if(lpAccelTbl[i].key != lpMsg->wParam)
1682             continue;
1683
1684         if(lpMsg->message == WM_CHAR)
1685         {
1686             if(!(lpAccelTbl[i].fVirt & FALT) && !(lpAccelTbl[i].fVirt & FVIRTKEY))
1687             {
1688                 TRACE_(accel)("found accel for WM_CHAR: ('%c')\n", lpMsg->wParam & 0xff);
1689                 goto found;
1690             }
1691         }
1692         else
1693         {
1694             if(lpAccelTbl[i].fVirt & FVIRTKEY)
1695             {
1696                 INT mask = 0;
1697                 TRACE_(accel)("found accel for virt_key %04x (scan %04x)\n",
1698                                 lpMsg->wParam, HIWORD(lpMsg->lParam) & 0xff);
1699                 if(GetKeyState(VK_SHIFT) & 0x8000) mask |= FSHIFT;
1700                 if(GetKeyState(VK_CONTROL) & 0x8000) mask |= FCONTROL;
1701                 if(GetKeyState(VK_MENU) & 0x8000) mask |= FALT;
1702                 if(mask == (lpAccelTbl[i].fVirt & (FSHIFT | FCONTROL | FALT))) goto found;
1703                 TRACE_(accel)("incorrect SHIFT/CTRL/ALT-state\n");
1704             }
1705             else
1706             {
1707                 if(!(lpMsg->lParam & 0x01000000))  /* no special_key */
1708                 {
1709                     if((lpAccelTbl[i].fVirt & FALT) && (lpMsg->lParam & 0x20000000))
1710                     {                                                  /* ^^ ALT pressed */
1711                         TRACE_(accel)("found accel for Alt-%c\n", lpMsg->wParam & 0xff);
1712                         goto found;
1713                     }
1714                 }
1715             }
1716         }
1717     }
1718
1719     WARN_(accel)("couldn't translate accelerator key\n");
1720     HeapFree(GetProcessHeap(), 0, lpAccelTbl);
1721     return FALSE;
1722
1723 found:
1724     if(lpwCmd) *lpwCmd = lpAccelTbl[i].cmd;
1725     HeapFree(GetProcessHeap(), 0, lpAccelTbl);
1726     return TRUE;
1727 }
1728
1729 /***********************************************************************
1730  * ReleaseStgMedium [OLE32.@]
1731  */
1732 void WINAPI ReleaseStgMedium(
1733   STGMEDIUM* pmedium)
1734 {
1735   switch (pmedium->tymed)
1736   {
1737     case TYMED_HGLOBAL:
1738     {
1739       if ( (pmedium->pUnkForRelease==0) &&
1740            (pmedium->u.hGlobal!=0) )
1741         GlobalFree(pmedium->u.hGlobal);
1742       break;
1743     }
1744     case TYMED_FILE:
1745     {
1746       if (pmedium->u.lpszFileName!=0)
1747       {
1748         if (pmedium->pUnkForRelease==0)
1749         {
1750           DeleteFileW(pmedium->u.lpszFileName);
1751         }
1752
1753         CoTaskMemFree(pmedium->u.lpszFileName);
1754       }
1755       break;
1756     }
1757     case TYMED_ISTREAM:
1758     {
1759       if (pmedium->u.pstm!=0)
1760       {
1761         IStream_Release(pmedium->u.pstm);
1762       }
1763       break;
1764     }
1765     case TYMED_ISTORAGE:
1766     {
1767       if (pmedium->u.pstg!=0)
1768       {
1769         IStorage_Release(pmedium->u.pstg);
1770       }
1771       break;
1772     }
1773     case TYMED_GDI:
1774     {
1775       if ( (pmedium->pUnkForRelease==0) &&
1776            (pmedium->u.hBitmap!=0) )
1777         DeleteObject(pmedium->u.hBitmap);
1778       break;
1779     }
1780     case TYMED_MFPICT:
1781     {
1782       if ( (pmedium->pUnkForRelease==0) &&
1783            (pmedium->u.hMetaFilePict!=0) )
1784       {
1785         LPMETAFILEPICT pMP = GlobalLock(pmedium->u.hMetaFilePict);
1786         DeleteMetaFile(pMP->hMF);
1787         GlobalUnlock(pmedium->u.hMetaFilePict);
1788         GlobalFree(pmedium->u.hMetaFilePict);
1789       }
1790       break;
1791     }
1792     case TYMED_ENHMF:
1793     {
1794       if ( (pmedium->pUnkForRelease==0) &&
1795            (pmedium->u.hEnhMetaFile!=0) )
1796       {
1797         DeleteEnhMetaFile(pmedium->u.hEnhMetaFile);
1798       }
1799       break;
1800     }
1801     case TYMED_NULL:
1802     default:
1803       break;
1804   }
1805   pmedium->tymed=TYMED_NULL;
1806
1807   /*
1808    * After cleaning up, the unknown is released
1809    */
1810   if (pmedium->pUnkForRelease!=0)
1811   {
1812     IUnknown_Release(pmedium->pUnkForRelease);
1813     pmedium->pUnkForRelease = 0;
1814   }
1815 }
1816
1817 /***
1818  * OLEDD_Initialize()
1819  *
1820  * Initializes the OLE drag and drop data structures.
1821  */
1822 static void OLEDD_Initialize()
1823 {
1824     WNDCLASSA wndClass;
1825
1826     ZeroMemory (&wndClass, sizeof(WNDCLASSA));
1827     wndClass.style         = CS_GLOBALCLASS;
1828     wndClass.lpfnWndProc   = OLEDD_DragTrackerWindowProc;
1829     wndClass.cbClsExtra    = 0;
1830     wndClass.cbWndExtra    = sizeof(TrackerWindowInfo*);
1831     wndClass.hCursor       = 0;
1832     wndClass.hbrBackground = 0;
1833     wndClass.lpszClassName = OLEDD_DRAGTRACKERCLASS;
1834
1835     RegisterClassA (&wndClass);
1836 }
1837
1838 /***
1839  * OLEDD_UnInitialize()
1840  *
1841  * Releases the OLE drag and drop data structures.
1842  */
1843 static void OLEDD_UnInitialize()
1844 {
1845   /*
1846    * Simply empty the list.
1847    */
1848   while (targetListHead!=NULL)
1849   {
1850     RevokeDragDrop(targetListHead->hwndTarget);
1851   }
1852 }
1853
1854 /***
1855  * OLEDD_InsertDropTarget()
1856  *
1857  * Insert the target node in the tree.
1858  */
1859 static void OLEDD_InsertDropTarget(DropTargetNode* nodeToAdd)
1860 {
1861   DropTargetNode*  curNode;
1862   DropTargetNode** parentNodeLink;
1863
1864   /*
1865    * Iterate the tree to find the insertion point.
1866    */
1867   curNode        = targetListHead;
1868   parentNodeLink = &targetListHead;
1869
1870   while (curNode!=NULL)
1871   {
1872     if (nodeToAdd->hwndTarget<curNode->hwndTarget)
1873     {
1874       /*
1875        * If the node we want to add has a smaller HWND, go left
1876        */
1877       parentNodeLink = &curNode->prevDropTarget;
1878       curNode        =  curNode->prevDropTarget;
1879     }
1880     else if (nodeToAdd->hwndTarget>curNode->hwndTarget)
1881     {
1882       /*
1883        * If the node we want to add has a larger HWND, go right
1884        */
1885       parentNodeLink = &curNode->nextDropTarget;
1886       curNode        =  curNode->nextDropTarget;
1887     }
1888     else
1889     {
1890       /*
1891        * The item was found in the list. It shouldn't have been there
1892        */
1893       assert(FALSE);
1894       return;
1895     }
1896   }
1897
1898   /*
1899    * If we get here, we have found a spot for our item. The parentNodeLink
1900    * pointer points to the pointer that we have to modify.
1901    * The curNode should be NULL. We just have to establish the link and Voila!
1902    */
1903   assert(curNode==NULL);
1904   assert(parentNodeLink!=NULL);
1905   assert(*parentNodeLink==NULL);
1906
1907   *parentNodeLink=nodeToAdd;
1908 }
1909
1910 /***
1911  * OLEDD_ExtractDropTarget()
1912  *
1913  * Removes the target node from the tree.
1914  */
1915 static DropTargetNode* OLEDD_ExtractDropTarget(HWND hwndOfTarget)
1916 {
1917   DropTargetNode*  curNode;
1918   DropTargetNode** parentNodeLink;
1919
1920   /*
1921    * Iterate the tree to find the insertion point.
1922    */
1923   curNode        = targetListHead;
1924   parentNodeLink = &targetListHead;
1925
1926   while (curNode!=NULL)
1927   {
1928     if (hwndOfTarget<curNode->hwndTarget)
1929     {
1930       /*
1931        * If the node we want to add has a smaller HWND, go left
1932        */
1933       parentNodeLink = &curNode->prevDropTarget;
1934       curNode        =  curNode->prevDropTarget;
1935     }
1936     else if (hwndOfTarget>curNode->hwndTarget)
1937     {
1938       /*
1939        * If the node we want to add has a larger HWND, go right
1940        */
1941       parentNodeLink = &curNode->nextDropTarget;
1942       curNode        =  curNode->nextDropTarget;
1943     }
1944     else
1945     {
1946       /*
1947        * The item was found in the list. Detach it from it's parent and
1948        * re-insert it's kids in the tree.
1949        */
1950       assert(parentNodeLink!=NULL);
1951       assert(*parentNodeLink==curNode);
1952
1953       /*
1954        * We arbitrately re-attach the left sub-tree to the parent.
1955        */
1956       *parentNodeLink = curNode->prevDropTarget;
1957
1958       /*
1959        * And we re-insert the right subtree
1960        */
1961       if (curNode->nextDropTarget!=NULL)
1962       {
1963         OLEDD_InsertDropTarget(curNode->nextDropTarget);
1964       }
1965
1966       /*
1967        * The node we found is still a valid node once we complete
1968        * the unlinking of the kids.
1969        */
1970       curNode->nextDropTarget=NULL;
1971       curNode->prevDropTarget=NULL;
1972
1973       return curNode;
1974     }
1975   }
1976
1977   /*
1978    * If we get here, the node is not in the tree
1979    */
1980   return NULL;
1981 }
1982
1983 /***
1984  * OLEDD_FindDropTarget()
1985  *
1986  * Finds information about the drop target.
1987  */
1988 static DropTargetNode* OLEDD_FindDropTarget(HWND hwndOfTarget)
1989 {
1990   DropTargetNode*  curNode;
1991
1992   /*
1993    * Iterate the tree to find the HWND value.
1994    */
1995   curNode        = targetListHead;
1996
1997   while (curNode!=NULL)
1998   {
1999     if (hwndOfTarget<curNode->hwndTarget)
2000     {
2001       /*
2002        * If the node we want to add has a smaller HWND, go left
2003        */
2004       curNode =  curNode->prevDropTarget;
2005     }
2006     else if (hwndOfTarget>curNode->hwndTarget)
2007     {
2008       /*
2009        * If the node we want to add has a larger HWND, go right
2010        */
2011       curNode =  curNode->nextDropTarget;
2012     }
2013     else
2014     {
2015       /*
2016        * The item was found in the list.
2017        */
2018       return curNode;
2019     }
2020   }
2021
2022   /*
2023    * If we get here, the item is not in the list
2024    */
2025   return NULL;
2026 }
2027
2028 /***
2029  * OLEDD_DragTrackerWindowProc()
2030  *
2031  * This method is the WindowProcedure of the drag n drop tracking
2032  * window. During a drag n Drop operation, an invisible window is created
2033  * to receive the user input and act upon it. This procedure is in charge
2034  * of this behavior.
2035  */
2036 static LRESULT WINAPI OLEDD_DragTrackerWindowProc(
2037                          HWND   hwnd,
2038                          UINT   uMsg,
2039                          WPARAM wParam,
2040                          LPARAM   lParam)
2041 {
2042   switch (uMsg)
2043   {
2044     case WM_CREATE:
2045     {
2046       LPCREATESTRUCTA createStruct = (LPCREATESTRUCTA)lParam;
2047
2048       SetWindowLongA(hwnd, 0, (LONG)createStruct->lpCreateParams);
2049
2050
2051       break;
2052     }
2053     case WM_MOUSEMOVE:
2054     {
2055       TrackerWindowInfo* trackerInfo = (TrackerWindowInfo*)GetWindowLongA(hwnd, 0);
2056       POINT            mousePos;
2057
2058       /*
2059        * Get the current mouse position in screen coordinates.
2060        */
2061       mousePos.x = LOWORD(lParam);
2062       mousePos.y = HIWORD(lParam);
2063       ClientToScreen(hwnd, &mousePos);
2064
2065       /*
2066        * Track the movement of the mouse.
2067        */
2068       OLEDD_TrackMouseMove(trackerInfo, mousePos, wParam);
2069
2070       break;
2071     }
2072     case WM_LBUTTONUP:
2073     case WM_MBUTTONUP:
2074     case WM_RBUTTONUP:
2075     case WM_LBUTTONDOWN:
2076     case WM_MBUTTONDOWN:
2077     case WM_RBUTTONDOWN:
2078     {
2079       TrackerWindowInfo* trackerInfo = (TrackerWindowInfo*)GetWindowLongA(hwnd, 0);
2080       POINT            mousePos;
2081
2082       /*
2083        * Get the current mouse position in screen coordinates.
2084        */
2085       mousePos.x = LOWORD(lParam);
2086       mousePos.y = HIWORD(lParam);
2087       ClientToScreen(hwnd, &mousePos);
2088
2089       /*
2090        * Notify everyone that the button state changed
2091        * TODO: Check if the "escape" key was pressed.
2092        */
2093       OLEDD_TrackStateChange(trackerInfo, mousePos, wParam);
2094
2095       break;
2096     }
2097   }
2098
2099   /*
2100    * This is a window proc after all. Let's call the default.
2101    */
2102   return DefWindowProcA (hwnd, uMsg, wParam, lParam);
2103 }
2104
2105 /***
2106  * OLEDD_TrackMouseMove()
2107  *
2108  * This method is invoked while a drag and drop operation is in effect.
2109  * it will generate the appropriate callbacks in the drop source
2110  * and drop target. It will also provide the expected feedback to
2111  * the user.
2112  *
2113  * params:
2114  *    trackerInfo - Pointer to the structure identifying the
2115  *                  drag & drop operation that is currently
2116  *                  active.
2117  *    mousePos    - Current position of the mouse in screen
2118  *                  coordinates.
2119  *    keyState    - Contains the state of the shift keys and the
2120  *                  mouse buttons (MK_LBUTTON and the like)
2121  */
2122 static void OLEDD_TrackMouseMove(
2123   TrackerWindowInfo* trackerInfo,
2124   POINT            mousePos,
2125   DWORD              keyState)
2126 {
2127   HWND   hwndNewTarget = 0;
2128   HRESULT  hr = S_OK;
2129
2130   /*
2131    * Get the handle of the window under the mouse
2132    */
2133   hwndNewTarget = WindowFromPoint(mousePos);
2134
2135   /*
2136    * Every time, we re-initialize the effects passed to the
2137    * IDropTarget to the effects allowed by the source.
2138    */
2139   *trackerInfo->pdwEffect = trackerInfo->dwOKEffect;
2140
2141   /*
2142    * If we are hovering over the same target as before, send the
2143    * DragOver notification
2144    */
2145   if ( (trackerInfo->curDragTarget != 0) &&
2146        (trackerInfo->curTargetHWND == hwndNewTarget) )
2147   {
2148     POINTL  mousePosParam;
2149
2150     /*
2151      * The documentation tells me that the coordinate should be in the target
2152      * window's coordinate space. However, the tests I made tell me the
2153      * coordinates should be in screen coordinates.
2154      */
2155     mousePosParam.x = mousePos.x;
2156     mousePosParam.y = mousePos.y;
2157
2158     IDropTarget_DragOver(trackerInfo->curDragTarget,
2159                          keyState,
2160                          mousePosParam,
2161                          trackerInfo->pdwEffect);
2162   }
2163   else
2164   {
2165     DropTargetNode* newDropTargetNode = 0;
2166
2167     /*
2168      * If we changed window, we have to notify our old target and check for
2169      * the new one.
2170      */
2171     if (trackerInfo->curDragTarget!=0)
2172     {
2173       IDropTarget_DragLeave(trackerInfo->curDragTarget);
2174     }
2175
2176     /*
2177      * Make sure we're hovering over a window.
2178      */
2179     if (hwndNewTarget!=0)
2180     {
2181       /*
2182        * Find-out if there is a drag target under the mouse
2183        */
2184       HWND nexttar = hwndNewTarget;
2185       trackerInfo->curTargetHWND = hwndNewTarget;
2186
2187       do {
2188         newDropTargetNode = OLEDD_FindDropTarget(nexttar);
2189       } while (!newDropTargetNode && (nexttar = GetParent(nexttar)) != 0);
2190       if(nexttar) hwndNewTarget = nexttar;
2191
2192       trackerInfo->curDragTargetHWND = hwndNewTarget;
2193       trackerInfo->curDragTarget     = newDropTargetNode ? newDropTargetNode->dropTarget : 0;
2194
2195       /*
2196        * If there is, notify it that we just dragged-in
2197        */
2198       if (trackerInfo->curDragTarget!=0)
2199       {
2200         POINTL  mousePosParam;
2201
2202         /*
2203          * The documentation tells me that the coordinate should be in the target
2204          * window's coordinate space. However, the tests I made tell me the
2205          * coordinates should be in screen coordinates.
2206          */
2207         mousePosParam.x = mousePos.x;
2208         mousePosParam.y = mousePos.y;
2209
2210         IDropTarget_DragEnter(trackerInfo->curDragTarget,
2211                               trackerInfo->dataObject,
2212                               keyState,
2213                               mousePosParam,
2214                               trackerInfo->pdwEffect);
2215       }
2216     }
2217     else
2218     {
2219       /*
2220        * The mouse is not over a window so we don't track anything.
2221        */
2222       trackerInfo->curDragTargetHWND = 0;
2223       trackerInfo->curTargetHWND     = 0;
2224       trackerInfo->curDragTarget     = 0;
2225     }
2226   }
2227
2228   /*
2229    * Now that we have done that, we have to tell the source to give
2230    * us feedback on the work being done by the target.  If we don't
2231    * have a target, simulate no effect.
2232    */
2233   if (trackerInfo->curDragTarget==0)
2234   {
2235     *trackerInfo->pdwEffect = DROPEFFECT_NONE;
2236   }
2237
2238   hr = IDropSource_GiveFeedback(trackerInfo->dropSource,
2239                                 *trackerInfo->pdwEffect);
2240
2241   /*
2242    * When we ask for feedback from the drop source, sometimes it will
2243    * do all the necessary work and sometimes it will not handle it
2244    * when that's the case, we must display the standard drag and drop
2245    * cursors.
2246    */
2247   if (hr==DRAGDROP_S_USEDEFAULTCURSORS)
2248   {
2249     if (*trackerInfo->pdwEffect & DROPEFFECT_MOVE)
2250     {
2251       SetCursor(LoadCursorA(OLE32_hInstance, MAKEINTRESOURCEA(1)));
2252     }
2253     else if (*trackerInfo->pdwEffect & DROPEFFECT_COPY)
2254     {
2255       SetCursor(LoadCursorA(OLE32_hInstance, MAKEINTRESOURCEA(2)));
2256     }
2257     else if (*trackerInfo->pdwEffect & DROPEFFECT_LINK)
2258     {
2259       SetCursor(LoadCursorA(OLE32_hInstance, MAKEINTRESOURCEA(3)));
2260     }
2261     else
2262     {
2263       SetCursor(LoadCursorA(OLE32_hInstance, MAKEINTRESOURCEA(0)));
2264     }
2265   }
2266 }
2267
2268 /***
2269  * OLEDD_TrackStateChange()
2270  *
2271  * This method is invoked while a drag and drop operation is in effect.
2272  * It is used to notify the drop target/drop source callbacks when
2273  * the state of the keyboard or mouse button change.
2274  *
2275  * params:
2276  *    trackerInfo - Pointer to the structure identifying the
2277  *                  drag & drop operation that is currently
2278  *                  active.
2279  *    mousePos    - Current position of the mouse in screen
2280  *                  coordinates.
2281  *    keyState    - Contains the state of the shift keys and the
2282  *                  mouse buttons (MK_LBUTTON and the like)
2283  */
2284 static void OLEDD_TrackStateChange(
2285   TrackerWindowInfo* trackerInfo,
2286   POINT            mousePos,
2287   DWORD              keyState)
2288 {
2289   /*
2290    * Ask the drop source what to do with the operation.
2291    */
2292   trackerInfo->returnValue = IDropSource_QueryContinueDrag(
2293                                trackerInfo->dropSource,
2294                                trackerInfo->escPressed,
2295                                keyState);
2296
2297   /*
2298    * All the return valued will stop the operation except the S_OK
2299    * return value.
2300    */
2301   if (trackerInfo->returnValue!=S_OK)
2302   {
2303     /*
2304      * Make sure the message loop in DoDragDrop stops
2305      */
2306     trackerInfo->trackingDone = TRUE;
2307
2308     /*
2309      * Release the mouse in case the drop target decides to show a popup
2310      * or a menu or something.
2311      */
2312     ReleaseCapture();
2313
2314     /*
2315      * If we end-up over a target, drop the object in the target or
2316      * inform the target that the operation was cancelled.
2317      */
2318     if (trackerInfo->curDragTarget!=0)
2319     {
2320       switch (trackerInfo->returnValue)
2321       {
2322         /*
2323          * If the source wants us to complete the operation, we tell
2324          * the drop target that we just dropped the object in it.
2325          */
2326         case DRAGDROP_S_DROP:
2327         {
2328           POINTL  mousePosParam;
2329
2330           /*
2331            * The documentation tells me that the coordinate should be
2332            * in the target window's coordinate space. However, the tests
2333            * I made tell me the coordinates should be in screen coordinates.
2334            */
2335           mousePosParam.x = mousePos.x;
2336           mousePosParam.y = mousePos.y;
2337
2338           IDropTarget_Drop(trackerInfo->curDragTarget,
2339                            trackerInfo->dataObject,
2340                            keyState,
2341                            mousePosParam,
2342                            trackerInfo->pdwEffect);
2343           break;
2344         }
2345         /*
2346          * If the source told us that we should cancel, fool the drop
2347          * target by telling it that the mouse left it's window.
2348          * Also set the drop effect to "NONE" in case the application
2349          * ignores the result of DoDragDrop.
2350          */
2351         case DRAGDROP_S_CANCEL:
2352           IDropTarget_DragLeave(trackerInfo->curDragTarget);
2353           *trackerInfo->pdwEffect = DROPEFFECT_NONE;
2354           break;
2355       }
2356     }
2357   }
2358 }
2359
2360 /***
2361  * OLEDD_GetButtonState()
2362  *
2363  * This method will use the current state of the keyboard to build
2364  * a button state mask equivalent to the one passed in the
2365  * WM_MOUSEMOVE wParam.
2366  */
2367 static DWORD OLEDD_GetButtonState()
2368 {
2369   BYTE  keyboardState[256];
2370   DWORD keyMask = 0;
2371
2372   GetKeyboardState(keyboardState);
2373
2374   if ( (keyboardState[VK_SHIFT] & 0x80) !=0)
2375     keyMask |= MK_SHIFT;
2376
2377   if ( (keyboardState[VK_CONTROL] & 0x80) !=0)
2378     keyMask |= MK_CONTROL;
2379
2380   if ( (keyboardState[VK_LBUTTON] & 0x80) !=0)
2381     keyMask |= MK_LBUTTON;
2382
2383   if ( (keyboardState[VK_RBUTTON] & 0x80) !=0)
2384     keyMask |= MK_RBUTTON;
2385
2386   if ( (keyboardState[VK_MBUTTON] & 0x80) !=0)
2387     keyMask |= MK_MBUTTON;
2388
2389   return keyMask;
2390 }
2391
2392 /***
2393  * OLEDD_GetButtonState()
2394  *
2395  * This method will read the default value of the registry key in
2396  * parameter and extract a DWORD value from it. The registry key value
2397  * can be in a string key or a DWORD key.
2398  *
2399  * params:
2400  *     regKey   - Key to read the default value from
2401  *     pdwValue - Pointer to the location where the DWORD
2402  *                value is returned. This value is not modified
2403  *                if the value is not found.
2404  */
2405
2406 static void OLEUTL_ReadRegistryDWORDValue(
2407   HKEY   regKey,
2408   DWORD* pdwValue)
2409 {
2410   char  buffer[20];
2411   DWORD dwKeyType;
2412   DWORD cbData = 20;
2413   LONG  lres;
2414
2415   lres = RegQueryValueExA(regKey,
2416                           "",
2417                           NULL,
2418                           &dwKeyType,
2419                           (LPBYTE)buffer,
2420                           &cbData);
2421
2422   if (lres==ERROR_SUCCESS)
2423   {
2424     switch (dwKeyType)
2425     {
2426       case REG_DWORD:
2427         *pdwValue = *(DWORD*)buffer;
2428         break;
2429       case REG_EXPAND_SZ:
2430       case REG_MULTI_SZ:
2431       case REG_SZ:
2432         *pdwValue = (DWORD)strtoul(buffer, NULL, 10);
2433         break;
2434     }
2435   }
2436 }
2437
2438 /******************************************************************************
2439  * OleDraw (OLE32.@)
2440  *
2441  * The operation of this function is documented literally in the WinAPI
2442  * documentation to involve a QueryInterface for the IViewObject interface,
2443  * followed by a call to IViewObject::Draw.
2444  */
2445 HRESULT WINAPI OleDraw(
2446         IUnknown *pUnk,
2447         DWORD dwAspect,
2448         HDC hdcDraw,
2449         LPCRECT lprcBounds)
2450 {
2451   HRESULT hres;
2452   IViewObject *viewobject;
2453
2454   hres = IUnknown_QueryInterface(pUnk,
2455                                  &IID_IViewObject,
2456                                  (void**)&viewobject);
2457
2458   if (SUCCEEDED(hres))
2459   {
2460     RECTL rectl;
2461
2462     rectl.left = lprcBounds->left;
2463     rectl.right = lprcBounds->right;
2464     rectl.top = lprcBounds->top;
2465     rectl.bottom = lprcBounds->bottom;
2466     hres = IViewObject_Draw(viewobject, dwAspect, -1, 0, 0, 0, hdcDraw, &rectl, 0, 0, 0);
2467
2468     IViewObject_Release(viewobject);
2469     return hres;
2470   }
2471   else
2472   {
2473     return DV_E_NOIVIEWOBJECT;
2474   }
2475 }
2476
2477 /***********************************************************************
2478  *             OleTranslateAccelerator [OLE32.@]
2479  */
2480 HRESULT WINAPI OleTranslateAccelerator (LPOLEINPLACEFRAME lpFrame,
2481                    LPOLEINPLACEFRAMEINFO lpFrameInfo, LPMSG lpmsg)
2482 {
2483     WORD wID;
2484
2485     TRACE("(%p,%p,%p)\n", lpFrame, lpFrameInfo, lpmsg);
2486
2487     if (IsAccelerator(lpFrameInfo->haccel,lpFrameInfo->cAccelEntries,lpmsg,&wID))
2488         return IOleInPlaceFrame_TranslateAccelerator(lpFrame,lpmsg,wID);
2489
2490     return S_FALSE;
2491 }
2492
2493 /******************************************************************************
2494  *              OleCreate        [OLE32.@]
2495  *
2496  */
2497 HRESULT WINAPI OleCreate(
2498         REFCLSID rclsid,
2499         REFIID riid,
2500         DWORD renderopt,
2501         LPFORMATETC pFormatEtc,
2502         LPOLECLIENTSITE pClientSite,
2503         LPSTORAGE pStg,
2504         LPVOID* ppvObj)
2505 {
2506     HRESULT hres, hres1;
2507     IUnknown * pUnk = NULL;
2508
2509     FIXME("\n\t%s\n\t%s semi-stub!\n", debugstr_guid(rclsid), debugstr_guid(riid));
2510
2511     if (SUCCEEDED((hres = CoCreateInstance(rclsid, 0, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER|CLSCTX_LOCAL_SERVER , riid, (LPVOID*)&pUnk))))
2512     {
2513         if (pClientSite)
2514         {
2515             IOleObject * pOE;
2516             IPersistStorage * pPS;
2517             if (SUCCEEDED((hres = IUnknown_QueryInterface( pUnk, &IID_IOleObject, (LPVOID*)&pOE))))
2518             {
2519                 TRACE("trying to set clientsite %p\n", pClientSite);
2520                 hres1 = IOleObject_SetClientSite(pOE, pClientSite);
2521                 TRACE("-- result 0x%08lx\n", hres1);
2522                 IOleObject_Release(pOE);
2523             }
2524             if (SUCCEEDED((hres = IUnknown_QueryInterface( pUnk, &IID_IPersistStorage, (LPVOID*)&pPS))))
2525             {
2526                 TRACE("trying to set stg %p\n", pStg);
2527                 hres1 = IPersistStorage_InitNew(pPS, pStg);
2528                 TRACE("-- result 0x%08lx\n", hres1);
2529                 IPersistStorage_Release(pPS);
2530             }
2531         }
2532     }
2533
2534     *ppvObj = pUnk;
2535
2536     TRACE("-- %p\n", pUnk);
2537     return hres;
2538 }
2539
2540 /******************************************************************************
2541  *              OleSetAutoConvert        [OLE32.@]
2542  */
2543 HRESULT WINAPI OleSetAutoConvert(REFCLSID clsidOld, REFCLSID clsidNew)
2544 {
2545     static const WCHAR wszAutoConvertTo[] = {'A','u','t','o','C','o','n','v','e','r','t','T','o',0};
2546     HKEY hkey = NULL;
2547     WCHAR szClsidNew[CHARS_IN_GUID];
2548     HRESULT res = S_OK;
2549
2550     TRACE("(%s,%s)\n", debugstr_guid(clsidOld), debugstr_guid(clsidNew));
2551
2552     res = COM_OpenKeyForCLSID(clsidOld, NULL, KEY_READ | KEY_WRITE, &hkey);
2553     if (FAILED(res))
2554         goto done;
2555     StringFromGUID2(clsidNew, szClsidNew, CHARS_IN_GUID);
2556     if (RegSetValueW(hkey, wszAutoConvertTo, REG_SZ, szClsidNew, (strlenW(szClsidNew)+1) * sizeof(WCHAR)))
2557     {
2558         res = REGDB_E_WRITEREGDB;
2559         goto done;
2560     }
2561
2562 done:
2563     if (hkey) RegCloseKey(hkey);
2564     return res;
2565 }
2566
2567 /******************************************************************************
2568  *              OleDoAutoConvert        [OLE32.@]
2569  */
2570 HRESULT WINAPI OleDoAutoConvert(LPSTORAGE pStg, LPCLSID pClsidNew)
2571 {
2572     FIXME("(%p,%p) : stub\n",pStg,pClsidNew);
2573     return E_NOTIMPL;
2574 }
2575
2576 /******************************************************************************
2577  *              OleIsRunning        [OLE32.@]
2578  */
2579 BOOL WINAPI OleIsRunning(LPOLEOBJECT pObject)
2580 {
2581     IRunnableObject *pRunnable;
2582     HRESULT hr;
2583     BOOL running;
2584
2585     TRACE("(%p)\n", pObject);
2586
2587     hr = IOleObject_QueryInterface(pObject, &IID_IRunnableObject, (void **)&pRunnable);
2588     if (FAILED(hr))
2589         return FALSE;
2590     running = IRunnableObject_IsRunning(pRunnable);
2591     IRunnableObject_Release(pRunnable);
2592     return running;
2593 }
2594
2595 /***********************************************************************
2596  *           OLE_FreeClipDataArray   [internal]
2597  *
2598  * NOTES:
2599  *  frees the data associated with an array of CLIPDATAs
2600  */
2601 static void OLE_FreeClipDataArray(ULONG count, CLIPDATA * pClipDataArray)
2602 {
2603     ULONG i;
2604     for (i = 0; i < count; i++)
2605         if (pClipDataArray[i].pClipData)
2606             CoTaskMemFree(pClipDataArray[i].pClipData);
2607 }
2608
2609 /***********************************************************************
2610  *           PropSysAllocString                     [OLE32.@]
2611  * NOTES:
2612  *  Basically a copy of SysAllocStringLen.
2613  */
2614 BSTR WINAPI PropSysAllocString(LPCOLESTR str)
2615 {
2616     DWORD  bufferSize;
2617     DWORD* newBuffer;
2618     WCHAR* stringBuffer;
2619     int len;
2620
2621     if (!str) return 0;
2622
2623     len = lstrlenW(str);
2624     /*
2625      * Find the length of the buffer passed-in in bytes.
2626      */
2627     bufferSize = len * sizeof (WCHAR);
2628
2629     /*
2630      * Allocate a new buffer to hold the string.
2631      * don't forget to keep an empty spot at the beginning of the
2632      * buffer for the character count and an extra character at the
2633      * end for the NULL.
2634      */
2635     newBuffer = HeapAlloc(GetProcessHeap(), 0,
2636                           bufferSize + sizeof(WCHAR) + sizeof(DWORD));
2637
2638     /*
2639      * If the memory allocation failed, return a null pointer.
2640      */
2641     if (newBuffer==0)
2642       return 0;
2643
2644     /*
2645      * Copy the length of the string in the placeholder.
2646      */
2647     *newBuffer = bufferSize;
2648
2649     /*
2650      * Skip the byte count.
2651      */
2652     newBuffer++;
2653
2654     /*
2655      * Copy the information in the buffer.
2656      * Since it is valid to pass a NULL pointer here, we'll initialize the
2657      * buffer to nul if it is the case.
2658      */
2659     if (str != 0)
2660       memcpy(newBuffer, str, bufferSize);
2661     else
2662       memset(newBuffer, 0, bufferSize);
2663
2664     /*
2665      * Make sure that there is a nul character at the end of the
2666      * string.
2667      */
2668     stringBuffer = (WCHAR*)newBuffer;
2669     stringBuffer[len] = L'\0';
2670
2671     return (LPWSTR)stringBuffer;
2672 }
2673
2674 /***********************************************************************
2675  *           PropSysFreeString                      [OLE32.@]
2676  * NOTES
2677  *  Copy of SysFreeString.
2678  */
2679 void WINAPI PropSysFreeString(LPOLESTR str)
2680 {
2681     DWORD* bufferPointer;
2682
2683     /* NULL is a valid parameter */
2684     if(!str) return;
2685
2686     /*
2687      * We have to be careful when we free a BSTR pointer, it points to
2688      * the beginning of the string but it skips the byte count contained
2689      * before the string.
2690      */
2691     bufferPointer = (DWORD*)str;
2692
2693     bufferPointer--;
2694
2695     /*
2696      * Free the memory from its "real" origin.
2697      */
2698     HeapFree(GetProcessHeap(), 0, bufferPointer);
2699 }
2700
2701 /******************************************************************************
2702  * Check if a PROPVARIANT's type is valid.
2703  */
2704 static inline HRESULT PROPVARIANT_ValidateType(VARTYPE vt)
2705 {
2706     switch (vt)
2707     {
2708     case VT_EMPTY:
2709     case VT_NULL:
2710     case VT_I2:
2711     case VT_I4:
2712     case VT_R4:
2713     case VT_R8:
2714     case VT_CY:
2715     case VT_DATE:
2716     case VT_BSTR:
2717     case VT_ERROR:
2718     case VT_BOOL:
2719     case VT_UI1:
2720     case VT_UI2:
2721     case VT_UI4:
2722     case VT_I8:
2723     case VT_UI8:
2724     case VT_LPSTR:
2725     case VT_LPWSTR:
2726     case VT_FILETIME:
2727     case VT_BLOB:
2728     case VT_STREAM:
2729     case VT_STORAGE:
2730     case VT_STREAMED_OBJECT:
2731     case VT_STORED_OBJECT:
2732     case VT_BLOB_OBJECT:
2733     case VT_CF:
2734     case VT_CLSID:
2735     case VT_I2|VT_VECTOR:
2736     case VT_I4|VT_VECTOR:
2737     case VT_R4|VT_VECTOR:
2738     case VT_R8|VT_VECTOR:
2739     case VT_CY|VT_VECTOR:
2740     case VT_DATE|VT_VECTOR:
2741     case VT_BSTR|VT_VECTOR:
2742     case VT_ERROR|VT_VECTOR:
2743     case VT_BOOL|VT_VECTOR:
2744     case VT_VARIANT|VT_VECTOR:
2745     case VT_UI1|VT_VECTOR:
2746     case VT_UI2|VT_VECTOR:
2747     case VT_UI4|VT_VECTOR:
2748     case VT_I8|VT_VECTOR:
2749     case VT_UI8|VT_VECTOR:
2750     case VT_LPSTR|VT_VECTOR:
2751     case VT_LPWSTR|VT_VECTOR:
2752     case VT_FILETIME|VT_VECTOR:
2753     case VT_CF|VT_VECTOR:
2754     case VT_CLSID|VT_VECTOR:
2755         return S_OK;
2756     }
2757     WARN("Bad type %d\n", vt);
2758     return STG_E_INVALIDPARAMETER;
2759 }
2760
2761 /***********************************************************************
2762  *           PropVariantClear                       [OLE32.@]
2763  */
2764 HRESULT WINAPI PropVariantClear(PROPVARIANT * pvar) /* [in/out] */
2765 {
2766     HRESULT hr;
2767
2768     TRACE("(%p)\n", pvar);
2769
2770     if (!pvar)
2771         return S_OK;
2772
2773     hr = PROPVARIANT_ValidateType(pvar->vt);
2774     if (FAILED(hr))
2775         return hr;
2776
2777     switch(pvar->vt)
2778     {
2779     case VT_STREAM:
2780     case VT_STREAMED_OBJECT:
2781     case VT_STORAGE:
2782     case VT_STORED_OBJECT:
2783         if (pvar->u.pStream)
2784             IUnknown_Release(pvar->u.pStream);
2785         break;
2786     case VT_CLSID:
2787     case VT_LPSTR:
2788     case VT_LPWSTR:
2789         /* pick an arbitary typed pointer - we don't care about the type
2790          * as we are just freeing it */
2791         CoTaskMemFree(pvar->u.puuid);
2792         break;
2793     case VT_BLOB:
2794     case VT_BLOB_OBJECT:
2795         CoTaskMemFree(pvar->u.blob.pBlobData);
2796         break;
2797     case VT_BSTR:
2798         if (pvar->u.bstrVal)
2799             PropSysFreeString(pvar->u.bstrVal);
2800         break;
2801    case VT_CF:
2802         if (pvar->u.pclipdata)
2803         {
2804             OLE_FreeClipDataArray(1, pvar->u.pclipdata);
2805             CoTaskMemFree(pvar->u.pclipdata);
2806         }
2807         break;
2808     default:
2809         if (pvar->vt & VT_VECTOR)
2810         {
2811             ULONG i;
2812
2813             switch (pvar->vt & ~VT_VECTOR)
2814             {
2815             case VT_VARIANT:
2816                 FreePropVariantArray(pvar->u.capropvar.cElems, pvar->u.capropvar.pElems);
2817                 break;
2818             case VT_CF:
2819                 OLE_FreeClipDataArray(pvar->u.caclipdata.cElems, pvar->u.caclipdata.pElems);
2820                 break;
2821             case VT_BSTR:
2822                 for (i = 0; i < pvar->u.cabstr.cElems; i++)
2823                     PropSysFreeString(pvar->u.cabstr.pElems[i]);
2824                 break;
2825             case VT_LPSTR:
2826                 for (i = 0; i < pvar->u.calpstr.cElems; i++)
2827                     CoTaskMemFree(pvar->u.calpstr.pElems[i]);
2828                 break;
2829             case VT_LPWSTR:
2830                 for (i = 0; i < pvar->u.calpwstr.cElems; i++)
2831                     CoTaskMemFree(pvar->u.calpwstr.pElems[i]);
2832                 break;
2833             }
2834             if (pvar->vt & ~VT_VECTOR)
2835             {
2836                 /* pick an arbitary VT_VECTOR structure - they all have the same
2837                  * memory layout */
2838                 CoTaskMemFree(pvar->u.capropvar.pElems);
2839             }
2840         }
2841         else
2842             WARN("Invalid/unsupported type %d\n", pvar->vt);
2843     }
2844
2845     ZeroMemory(pvar, sizeof(*pvar));
2846
2847     return S_OK;
2848 }
2849
2850 /***********************************************************************
2851  *           PropVariantCopy                        [OLE32.@]
2852  */
2853 HRESULT WINAPI PropVariantCopy(PROPVARIANT *pvarDest,      /* [out] */
2854                                const PROPVARIANT *pvarSrc) /* [in] */
2855 {
2856     ULONG len;
2857     HRESULT hr;
2858
2859     TRACE("(%p, %p)\n", pvarDest, pvarSrc);
2860
2861     hr = PROPVARIANT_ValidateType(pvarSrc->vt);
2862     if (FAILED(hr))
2863         return hr;
2864
2865     /* this will deal with most cases */
2866     CopyMemory(pvarDest, pvarSrc, sizeof(*pvarDest));
2867
2868     switch(pvarSrc->vt)
2869     {
2870     case VT_STREAM:
2871     case VT_STREAMED_OBJECT:
2872     case VT_STORAGE:
2873     case VT_STORED_OBJECT:
2874         IUnknown_AddRef((LPUNKNOWN)pvarDest->u.pStream);
2875         break;
2876     case VT_CLSID:
2877         pvarDest->u.puuid = CoTaskMemAlloc(sizeof(CLSID));
2878         CopyMemory(pvarDest->u.puuid, pvarSrc->u.puuid, sizeof(CLSID));
2879         break;
2880     case VT_LPSTR:
2881         len = strlen(pvarSrc->u.pszVal);
2882         pvarDest->u.pszVal = CoTaskMemAlloc((len+1)*sizeof(CHAR));
2883         CopyMemory(pvarDest->u.pszVal, pvarSrc->u.pszVal, (len+1)*sizeof(CHAR));
2884         break;
2885     case VT_LPWSTR:
2886         len = lstrlenW(pvarSrc->u.pwszVal);
2887         pvarDest->u.pwszVal = CoTaskMemAlloc((len+1)*sizeof(WCHAR));
2888         CopyMemory(pvarDest->u.pwszVal, pvarSrc->u.pwszVal, (len+1)*sizeof(WCHAR));
2889         break;
2890     case VT_BLOB:
2891     case VT_BLOB_OBJECT:
2892         if (pvarSrc->u.blob.pBlobData)
2893         {
2894             len = pvarSrc->u.blob.cbSize;
2895             pvarDest->u.blob.pBlobData = CoTaskMemAlloc(len);
2896             CopyMemory(pvarDest->u.blob.pBlobData, pvarSrc->u.blob.pBlobData, len);
2897         }
2898         break;
2899     case VT_BSTR:
2900         pvarDest->u.bstrVal = PropSysAllocString(pvarSrc->u.bstrVal);
2901         break;
2902     case VT_CF:
2903         if (pvarSrc->u.pclipdata)
2904         {
2905             len = pvarSrc->u.pclipdata->cbSize - sizeof(pvarSrc->u.pclipdata->ulClipFmt);
2906             CoTaskMemAlloc(len);
2907             CopyMemory(pvarDest->u.pclipdata->pClipData, pvarSrc->u.pclipdata->pClipData, len);
2908         }
2909         break;
2910     default:
2911         if (pvarSrc->vt & VT_VECTOR)
2912         {
2913             int elemSize;
2914             ULONG i;
2915
2916             switch(pvarSrc->vt & ~VT_VECTOR)
2917             {
2918             case VT_I1:       elemSize = sizeof(pvarSrc->u.cVal); break;
2919             case VT_UI1:      elemSize = sizeof(pvarSrc->u.bVal); break;
2920             case VT_I2:       elemSize = sizeof(pvarSrc->u.iVal); break;
2921             case VT_UI2:      elemSize = sizeof(pvarSrc->u.uiVal); break;
2922             case VT_BOOL:     elemSize = sizeof(pvarSrc->u.boolVal); break;
2923             case VT_I4:       elemSize = sizeof(pvarSrc->u.lVal); break;
2924             case VT_UI4:      elemSize = sizeof(pvarSrc->u.ulVal); break;
2925             case VT_R4:       elemSize = sizeof(pvarSrc->u.fltVal); break;
2926             case VT_R8:       elemSize = sizeof(pvarSrc->u.dblVal); break;
2927             case VT_ERROR:    elemSize = sizeof(pvarSrc->u.scode); break;
2928             case VT_I8:       elemSize = sizeof(pvarSrc->u.hVal); break;
2929             case VT_UI8:      elemSize = sizeof(pvarSrc->u.uhVal); break;
2930             case VT_CY:       elemSize = sizeof(pvarSrc->u.cyVal); break;
2931             case VT_DATE:     elemSize = sizeof(pvarSrc->u.date); break;
2932             case VT_FILETIME: elemSize = sizeof(pvarSrc->u.filetime); break;
2933             case VT_CLSID:    elemSize = sizeof(*pvarSrc->u.puuid); break;
2934             case VT_CF:       elemSize = sizeof(*pvarSrc->u.pclipdata); break;
2935             case VT_BSTR:     elemSize = sizeof(*pvarSrc->u.bstrVal); break;
2936             case VT_LPSTR:    elemSize = sizeof(*pvarSrc->u.pszVal); break;
2937             case VT_LPWSTR:   elemSize = sizeof(*pvarSrc->u.pwszVal); break;
2938
2939             case VT_VARIANT:
2940             default:
2941                 FIXME("Invalid element type: %ul\n", pvarSrc->vt & ~VT_VECTOR);
2942                 return E_INVALIDARG;
2943             }
2944             len = pvarSrc->u.capropvar.cElems;
2945             pvarDest->u.capropvar.pElems = CoTaskMemAlloc(len * elemSize);
2946             if (pvarSrc->vt == (VT_VECTOR | VT_VARIANT))
2947             {
2948                 for (i = 0; i < len; i++)
2949                     PropVariantCopy(&pvarDest->u.capropvar.pElems[i], &pvarSrc->u.capropvar.pElems[i]);
2950             }
2951             else if (pvarSrc->vt == (VT_VECTOR | VT_CF))
2952             {
2953                 FIXME("Copy clipformats\n");
2954             }
2955             else if (pvarSrc->vt == (VT_VECTOR | VT_BSTR))
2956             {
2957                 for (i = 0; i < len; i++)
2958                     pvarDest->u.cabstr.pElems[i] = PropSysAllocString(pvarSrc->u.cabstr.pElems[i]);
2959             }
2960             else if (pvarSrc->vt == (VT_VECTOR | VT_LPSTR))
2961             {
2962                 size_t strLen;
2963                 for (i = 0; i < len; i++)
2964                 {
2965                     strLen = lstrlenA(pvarSrc->u.calpstr.pElems[i]) + 1;
2966                     pvarDest->u.calpstr.pElems[i] = CoTaskMemAlloc(strLen);
2967                     memcpy(pvarDest->u.calpstr.pElems[i],
2968                      pvarSrc->u.calpstr.pElems[i], strLen);
2969                 }
2970             }
2971             else if (pvarSrc->vt == (VT_VECTOR | VT_LPWSTR))
2972             {
2973                 size_t strLen;
2974                 for (i = 0; i < len; i++)
2975                 {
2976                     strLen = (lstrlenW(pvarSrc->u.calpwstr.pElems[i]) + 1) *
2977                      sizeof(WCHAR);
2978                     pvarDest->u.calpstr.pElems[i] = CoTaskMemAlloc(strLen);
2979                     memcpy(pvarDest->u.calpstr.pElems[i],
2980                      pvarSrc->u.calpstr.pElems[i], strLen);
2981                 }
2982             }
2983             else
2984                 CopyMemory(pvarDest->u.capropvar.pElems, pvarSrc->u.capropvar.pElems, len * elemSize);
2985         }
2986         else
2987             WARN("Invalid/unsupported type %d\n", pvarSrc->vt);
2988     }
2989
2990     return S_OK;
2991 }
2992
2993 /***********************************************************************
2994  *           FreePropVariantArray                           [OLE32.@]
2995  */
2996 HRESULT WINAPI FreePropVariantArray(ULONG cVariants, /* [in] */
2997                                     PROPVARIANT *rgvars)    /* [in/out] */
2998 {
2999     ULONG i;
3000
3001     TRACE("(%lu, %p)\n", cVariants, rgvars);
3002
3003     for(i = 0; i < cVariants; i++)
3004         PropVariantClear(&rgvars[i]);
3005
3006     return S_OK;
3007 }
3008
3009 /******************************************************************************
3010  * DllDebugObjectRPCHook (OLE32.@)
3011  * turns on and off internal debugging,  pointer is only used on macintosh
3012  */
3013
3014 BOOL WINAPI DllDebugObjectRPCHook(BOOL b, void *dummy)
3015 {
3016   FIXME("stub\n");
3017   return TRUE;
3018 }