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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, 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 "ole2.h"
  45 #include "ole2ver.h"
  46
  47 #include "wine/unicode.h"
  48 #include "compobj_private.h"
  49 #include "wine/list.h"
  50
  51 #include "wine/debug.h"
  52
  53 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  54 WINE_DECLARE_DEBUG_CHANNEL(accel);
  55
  56 /******************************************************************************
  57  * These are static/global variables and internal data structures that the
  58  * OLE module uses to maintain it's state.
  59  */
  60 typedef struct tagDropTargetNode
  61 {
  62   HWND          hwndTarget;
  63   IDropTarget*  dropTarget;
  64   struct list   entry;
  65 } DropTargetNode;
  66
  67 typedef struct tagTrackerWindowInfo
  68 {
  69   IDataObject* dataObject;
  70   IDropSource* dropSource;
  71   DWORD        dwOKEffect;
  72   DWORD*       pdwEffect;
  73   BOOL       trackingDone;
  74   HRESULT      returnValue;
  75
  76   BOOL       escPressed;
  77   HWND       curTargetHWND;     /* window the mouse is hovering over */
  78   HWND       curDragTargetHWND; /* might be a ancestor of curTargetHWND */
  79   IDropTarget* curDragTarget;
  80   POINTL     curMousePos;       /* current position of the mouse in screen coordinates */
  81   DWORD      dwKeyState;        /* current state of the shift and ctrl keys and the mouse buttons */
  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 LONG OLE_moduleLockCount = 0;
 109
 110 /*
 111  * Name of our registered window class.
 112  */
 113 static const WCHAR OLEDD_DRAGTRACKERCLASS[] =
 114   {'W','i','n','e','D','r','a','g','D','r','o','p','T','r','a','c','k','e','r','3','2',0};
 115
 116 /*
 117  * Name of menu descriptor property.
 118  */
 119 static const WCHAR prop_olemenuW[] =
 120   {'P','R','O','P','_','O','L','E','M','e','n','u','D','e','s','c','r','i','p','t','o','r',0};
 121
 122 /*
 123  * This is the head of the Drop target container.
 124  */
 125 static struct list targetListHead = LIST_INIT(targetListHead);
 126
 127 /******************************************************************************
 128  * These are the prototypes of miscellaneous utility methods
 129  */
 130 static void OLEUTL_ReadRegistryDWORDValue(HKEY regKey, DWORD* pdwValue);
 131
 132 /******************************************************************************
 133  * These are the prototypes of the utility methods used to manage a shared menu
 134  */
 135 static void OLEMenu_Initialize(void);
 136 static void OLEMenu_UnInitialize(void);
 137 static BOOL OLEMenu_InstallHooks( DWORD tid );
 138 static BOOL OLEMenu_UnInstallHooks( DWORD tid );
 139 static OleMenuHookItem * OLEMenu_IsHookInstalled( DWORD tid );
 140 static BOOL OLEMenu_FindMainMenuIndex( HMENU hMainMenu, HMENU hPopupMenu, UINT *pnPos );
 141 static BOOL OLEMenu_SetIsServerMenu( HMENU hmenu, OleMenuDescriptor *pOleMenuDescriptor );
 142 static LRESULT CALLBACK OLEMenu_CallWndProc(INT code, WPARAM wParam, LPARAM lParam);
 143 static LRESULT CALLBACK OLEMenu_GetMsgProc(INT code, WPARAM wParam, LPARAM lParam);
 144
 145 /******************************************************************************
 146  * These are the prototypes of the OLE Clipboard initialization methods (in clipboard.c)
 147  */
 148 extern void OLEClipbrd_UnInitialize(void);
 149 extern void OLEClipbrd_Initialize(void);
 150
 151 /******************************************************************************
 152  * These are the prototypes of the utility methods used for OLE Drag n Drop
 153  */
 154 static void            OLEDD_Initialize(void);
 155 static DropTargetNode* OLEDD_FindDropTarget(
 156                          HWND hwndOfTarget);
 157 static void            OLEDD_FreeDropTarget(DropTargetNode*, BOOL);
 158 static LRESULT WINAPI  OLEDD_DragTrackerWindowProc(
 159                          HWND   hwnd,
 160                          UINT   uMsg,
 161                          WPARAM wParam,
 162                          LPARAM   lParam);
 163 static void OLEDD_TrackMouseMove(
 164                          TrackerWindowInfo* trackerInfo);
 165 static void OLEDD_TrackStateChange(
 166                          TrackerWindowInfo* trackerInfo);
 167 static DWORD OLEDD_GetButtonState(void);
 168
 169
 170 /******************************************************************************
 171  *              OleBuildVersion [OLE32.@]
 172  */
 173 DWORD WINAPI OleBuildVersion(void)
 174 {
 175     TRACE("Returning version %d, build %d.\n", rmm, rup);
 176     return (rmm<<16)+rup;
 177 }
 178
 179 /***********************************************************************
 180  *           OleInitialize       (OLE32.@)
 181  */
 182 HRESULT WINAPI OleInitialize(LPVOID reserved)
 183 {
 184   HRESULT hr;
 185
 186   TRACE("(%p)\n", reserved);
 187
 188   /*
 189    * The first duty of the OleInitialize is to initialize the COM libraries.
 190    */
 191   hr = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
 192
 193   /*
 194    * If the CoInitializeEx call failed, the OLE libraries can't be
 195    * initialized.
 196    */
 197   if (FAILED(hr))
 198     return hr;
 199
 200   if (!COM_CurrentInfo()->ole_inits)
 201     hr = S_OK;
 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 (!COM_CurrentInfo()->ole_inits++ &&
 212       InterlockedIncrement(&OLE_moduleLockCount) == 1)
 213   {
 214     /*
 215      * Initialize the libraries.
 216      */
 217     TRACE("() - Initializing the OLE libraries\n");
 218
 219     /*
 220      * OLE Clipboard
 221      */
 222     OLEClipbrd_Initialize();
 223
 224     /*
 225      * Drag and Drop
 226      */
 227     OLEDD_Initialize();
 228
 229     /*
 230      * OLE shared menu
 231      */
 232     OLEMenu_Initialize();
 233   }
 234
 235   return hr;
 236 }
 237
 238 /******************************************************************************
 239  *              OleUninitialize [OLE32.@]
 240  */
 241 void WINAPI OleUninitialize(void)
 242 {
 243   TRACE("()\n");
 244
 245   /*
 246    * If we hit the bottom of the lock stack, free the libraries.
 247    */
 248   if (!--COM_CurrentInfo()->ole_inits && !InterlockedDecrement(&OLE_moduleLockCount))
 249   {
 250     /*
 251      * Actually free the libraries.
 252      */
 253     TRACE("() - Freeing the last reference count\n");
 254
 255     /*
 256      * OLE Clipboard
 257      */
 258     OLEClipbrd_UnInitialize();
 259
 260     /*
 261      * OLE shared menu
 262      */
 263     OLEMenu_UnInitialize();
 264   }
 265
 266   /*
 267    * Then, uninitialize the COM libraries.
 268    */
 269   CoUninitialize();
 270 }
 271
 272 /******************************************************************************
 273  *              OleInitializeWOW        [OLE32.@]
 274  */
 275 HRESULT WINAPI OleInitializeWOW(DWORD x, DWORD y) {
 276         FIXME("(0x%08x, 0x%08x),stub!\n",x, y);
 277         return 0;
 278 }
 279
 280 /***********************************************************************
 281  *           RegisterDragDrop (OLE32.@)
 282  */
 283 HRESULT WINAPI RegisterDragDrop(
 284         HWND hwnd,
 285         LPDROPTARGET pDropTarget)
 286 {
 287   DropTargetNode* dropTargetInfo;
 288
 289   TRACE("(%p,%p)\n", hwnd, pDropTarget);
 290
 291   if (!COM_CurrentApt())
 292   {
 293     ERR("COM not initialized\n");
 294     return E_OUTOFMEMORY;
 295   }
 296
 297   if (!pDropTarget)
 298     return E_INVALIDARG;
 299
 300   if (!IsWindow(hwnd))
 301   {
 302     ERR("invalid hwnd %p\n", hwnd);
 303     return DRAGDROP_E_INVALIDHWND;
 304   }
 305
 306   /*
 307    * First, check if the window is already registered.
 308    */
 309   dropTargetInfo = OLEDD_FindDropTarget(hwnd);
 310
 311   if (dropTargetInfo!=NULL)
 312     return DRAGDROP_E_ALREADYREGISTERED;
 313
 314   /*
 315    * If it's not there, we can add it. We first create a node for it.
 316    */
 317   dropTargetInfo = HeapAlloc(GetProcessHeap(), 0, sizeof(DropTargetNode));
 318
 319   if (dropTargetInfo==NULL)
 320     return E_OUTOFMEMORY;
 321
 322   dropTargetInfo->hwndTarget     = hwnd;
 323
 324   /*
 325    * Don't forget that this is an interface pointer, need to nail it down since
 326    * we keep a copy of it.
 327    */
 328   IDropTarget_AddRef(pDropTarget);
 329   dropTargetInfo->dropTarget  = pDropTarget;
 330
 331   list_add_tail(&targetListHead, &dropTargetInfo->entry);
 332
 333   return S_OK;
 334 }
 335
 336 /***********************************************************************
 337  *           RevokeDragDrop (OLE32.@)
 338  */
 339 HRESULT WINAPI RevokeDragDrop(
 340         HWND hwnd)
 341 {
 342   DropTargetNode* dropTargetInfo;
 343
 344   TRACE("(%p)\n", hwnd);
 345
 346   if (!IsWindow(hwnd))
 347   {
 348     ERR("invalid hwnd %p\n", hwnd);
 349     return DRAGDROP_E_INVALIDHWND;
 350   }
 351
 352   /*
 353    * First, check if the window is already registered.
 354    */
 355   dropTargetInfo = OLEDD_FindDropTarget(hwnd);
 356
 357   /*
 358    * If it ain't in there, it's an error.
 359    */
 360   if (dropTargetInfo==NULL)
 361     return DRAGDROP_E_NOTREGISTERED;
 362
 363   OLEDD_FreeDropTarget(dropTargetInfo, TRUE);
 364
 365   return S_OK;
 366 }
 367
 368 /***********************************************************************
 369  *           OleRegGetUserType (OLE32.@)
 370  *
 371  * This implementation of OleRegGetUserType ignores the dwFormOfType
 372  * parameter and always returns the full name of the object. This is
 373  * not too bad since this is the case for many objects because of the
 374  * way they are registered.
 375  */
 376 HRESULT WINAPI OleRegGetUserType(
 377         REFCLSID clsid,
 378         DWORD dwFormOfType,
 379         LPOLESTR* pszUserType)
 380 {
 381   char    keyName[60];
 382   DWORD   dwKeyType;
 383   DWORD   cbData;
 384   HKEY    clsidKey;
 385   LONG    hres;
 386   LPSTR   buffer;
 387   HRESULT retVal;
 388   /*
 389    * Initialize the out parameter.
 390    */
 391   *pszUserType = NULL;
 392
 393   /*
 394    * Build the key name we're looking for
 395    */
 396   sprintf( keyName, "CLSID\\{%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}\\",
 397            clsid->Data1, clsid->Data2, clsid->Data3,
 398            clsid->Data4[0], clsid->Data4[1], clsid->Data4[2], clsid->Data4[3],
 399            clsid->Data4[4], clsid->Data4[5], clsid->Data4[6], clsid->Data4[7] );
 400
 401   TRACE("(%s, %d, %p)\n", keyName, dwFormOfType, pszUserType);
 402
 403   /*
 404    * Open the class id Key
 405    */
 406   hres = RegOpenKeyA(HKEY_CLASSES_ROOT,
 407                      keyName,
 408                      &clsidKey);
 409
 410   if (hres != ERROR_SUCCESS)
 411     return REGDB_E_CLASSNOTREG;
 412
 413   /*
 414    * Retrieve the size of the name string.
 415    */
 416   cbData = 0;
 417
 418   hres = RegQueryValueExA(clsidKey,
 419                           "",
 420                           NULL,
 421                           &dwKeyType,
 422                           NULL,
 423                           &cbData);
 424
 425   if (hres!=ERROR_SUCCESS)
 426   {
 427     RegCloseKey(clsidKey);
 428     return REGDB_E_READREGDB;
 429   }
 430
 431   /*
 432    * Allocate a buffer for the registry value.
 433    */
 434   *pszUserType = CoTaskMemAlloc(cbData*2);
 435
 436   if (*pszUserType==NULL)
 437   {
 438     RegCloseKey(clsidKey);
 439     return E_OUTOFMEMORY;
 440   }
 441
 442   buffer = HeapAlloc(GetProcessHeap(), 0, cbData);
 443
 444   if (buffer == NULL)
 445   {
 446     RegCloseKey(clsidKey);
 447     CoTaskMemFree(*pszUserType);
 448     *pszUserType=NULL;
 449     return E_OUTOFMEMORY;
 450   }
 451
 452   hres = RegQueryValueExA(clsidKey,
 453                           "",
 454                           NULL,
 455                           &dwKeyType,
 456                           (LPBYTE) buffer,
 457                           &cbData);
 458
 459   RegCloseKey(clsidKey);
 460
 461
 462   if (hres!=ERROR_SUCCESS)
 463   {
 464     CoTaskMemFree(*pszUserType);
 465     *pszUserType=NULL;
 466
 467     retVal = REGDB_E_READREGDB;
 468   }
 469   else
 470   {
 471     MultiByteToWideChar( CP_ACP, 0, buffer, -1, *pszUserType, cbData /*FIXME*/ );
 472     retVal = S_OK;
 473   }
 474   HeapFree(GetProcessHeap(), 0, buffer);
 475
 476   return retVal;
 477 }
 478
 479 /***********************************************************************
 480  * DoDragDrop [OLE32.@]
 481  */
 482 HRESULT WINAPI DoDragDrop (
 483   IDataObject *pDataObject,  /* [in] ptr to the data obj           */
 484   IDropSource* pDropSource,  /* [in] ptr to the source obj         */
 485   DWORD       dwOKEffect,    /* [in] effects allowed by the source */
 486   DWORD       *pdwEffect)    /* [out] ptr to effects of the source */
 487 {
 488   static const WCHAR trackerW[] = {'T','r','a','c','k','e','r','W','i','n','d','o','w',0};
 489   TrackerWindowInfo trackerInfo;
 490   HWND            hwndTrackWindow;
 491   MSG             msg;
 492
 493   TRACE("(%p, %p, %d, %p)\n", pDataObject, pDropSource, dwOKEffect, pdwEffect);
 494
 495   if (!pDataObject || !pDropSource || !pdwEffect)
 496       return E_INVALIDARG;
 497
 498   /*
 499    * Setup the drag n drop tracking window.
 500    */
 501
 502   trackerInfo.dataObject        = pDataObject;
 503   trackerInfo.dropSource        = pDropSource;
 504   trackerInfo.dwOKEffect        = dwOKEffect;
 505   trackerInfo.pdwEffect         = pdwEffect;
 506   trackerInfo.trackingDone      = FALSE;
 507   trackerInfo.escPressed        = FALSE;
 508   trackerInfo.curDragTargetHWND = 0;
 509   trackerInfo.curTargetHWND     = 0;
 510   trackerInfo.curDragTarget     = 0;
 511
 512   hwndTrackWindow = CreateWindowW(OLEDD_DRAGTRACKERCLASS, trackerW,
 513                                   WS_POPUP, CW_USEDEFAULT, CW_USEDEFAULT,
 514                                   CW_USEDEFAULT, CW_USEDEFAULT, 0, 0, 0,
 515                                   &trackerInfo);
 516
 517   if (hwndTrackWindow)
 518   {
 519     /*
 520      * Capture the mouse input
 521      */
 522     SetCapture(hwndTrackWindow);
 523
 524     msg.message = 0;
 525
 526     /*
 527      * Pump messages. All mouse input should go to the capture window.
 528      */
 529     while (!trackerInfo.trackingDone && GetMessageW(&msg, 0, 0, 0) )
 530     {
 531       trackerInfo.curMousePos.x = msg.pt.x;
 532       trackerInfo.curMousePos.y = msg.pt.y;
 533       trackerInfo.dwKeyState = OLEDD_GetButtonState();
 534
 535       if ( (msg.message >= WM_KEYFIRST) &&
 536            (msg.message <= WM_KEYLAST) )
 537       {
 538         /*
 539          * When keyboard messages are sent to windows on this thread, we
 540          * want to ignore notify the drop source that the state changed.
 541          * in the case of the Escape key, we also notify the drop source
 542          * we give it a special meaning.
 543          */
 544         if ( (msg.message==WM_KEYDOWN) &&
 545              (msg.wParam==VK_ESCAPE) )
 546         {
 547           trackerInfo.escPressed = TRUE;
 548         }
 549
 550         /*
 551          * Notify the drop source.
 552          */
 553         OLEDD_TrackStateChange(&trackerInfo);
 554       }
 555       else
 556       {
 557         /*
 558          * Dispatch the messages only when it's not a keyboard message.
 559          */
 560         DispatchMessageW(&msg);
 561       }
 562     }
 563
 564     /* re-post the quit message to outer message loop */
 565     if (msg.message == WM_QUIT)
 566         PostQuitMessage(msg.wParam);
 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_FALSE;
 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\\{%08x-%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, %d, %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, "%d", 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("(%d, %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 %d\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 %d\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 %d\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("(%d)\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 %d\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 %d\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)\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  *              OleRun        [OLE32.@]
 952  *
 953  * Set the OLE object to the running state.
 954  *
 955  * PARAMS
 956  *  pUnknown [I] OLE object to run.
 957  *
 958  * RETURNS
 959  *  Success: S_OK.
 960  *  Failure: Any HRESULT code.
 961  */
 962 HRESULT WINAPI OleRun(LPUNKNOWN pUnknown)
 963 {
 964     IRunnableObject *runable;
 965     HRESULT hres;
 966
 967     TRACE("(%p)\n", pUnknown);
 968
 969     hres = IUnknown_QueryInterface(pUnknown, &IID_IRunnableObject, (void**)&runable);
 970     if (FAILED(hres))
 971         return S_OK; /* Appears to return no error. */
 972
 973     hres = IRunnableObject_Run(runable, NULL);
 974     IRunnableObject_Release(runable);
 975     return hres;
 976 }
 977
 978 /******************************************************************************
 979  *              OleLoad        [OLE32.@]
 980  */
 981 HRESULT WINAPI OleLoad(
 982   LPSTORAGE       pStg,
 983   REFIID          riid,
 984   LPOLECLIENTSITE pClientSite,
 985   LPVOID*         ppvObj)
 986 {
 987   IPersistStorage* persistStorage = NULL;
 988   IUnknown*        pUnk;
 989   IOleObject*      pOleObject      = NULL;
 990   STATSTG          storageInfo;
 991   HRESULT          hres;
 992
 993   TRACE("(%p, %s, %p, %p)\n", pStg, debugstr_guid(riid), pClientSite, ppvObj);
 994
 995   *ppvObj = NULL;
 996
 997   /*
 998    * TODO, Conversion ... OleDoAutoConvert
 999    */
1000
1001   /*
1002    * Get the class ID for the object.
1003    */
1004   hres = IStorage_Stat(pStg, &storageInfo, STATFLAG_NONAME);
1005
1006   /*
1007    * Now, try and create the handler for the object
1008    */
1009   hres = CoCreateInstance(&storageInfo.clsid,
1010                           NULL,
1011                           CLSCTX_INPROC_HANDLER|CLSCTX_INPROC_SERVER,
1012                           riid,
1013                           (void**)&pUnk);
1014
1015   /*
1016    * If that fails, as it will most times, load the default
1017    * OLE handler.
1018    */
1019   if (FAILED(hres))
1020   {
1021     hres = OleCreateDefaultHandler(&storageInfo.clsid,
1022                                    NULL,
1023                                    riid,
1024                                    (void**)&pUnk);
1025   }
1026
1027   /*
1028    * If we couldn't find a handler... this is bad. Abort the whole thing.
1029    */
1030   if (FAILED(hres))
1031     return hres;
1032
1033   if (pClientSite)
1034   {
1035     hres = IUnknown_QueryInterface(pUnk, &IID_IOleObject, (void **)&pOleObject);
1036     if (SUCCEEDED(hres))
1037     {
1038         DWORD dwStatus;
1039         hres = IOleObject_GetMiscStatus(pOleObject, DVASPECT_CONTENT, &dwStatus);
1040     }
1041   }
1042
1043   if (SUCCEEDED(hres))
1044     /*
1045      * Initialize the object with it's IPersistStorage interface.
1046      */
1047     hres = IOleObject_QueryInterface(pUnk,
1048                                      &IID_IPersistStorage,
1049                                      (void**)&persistStorage);
1050
1051   if (SUCCEEDED(hres))
1052   {
1053     hres = IPersistStorage_Load(persistStorage, pStg);
1054
1055     IPersistStorage_Release(persistStorage);
1056     persistStorage = NULL;
1057   }
1058
1059   if (SUCCEEDED(hres) && pClientSite)
1060     /*
1061      * Inform the new object of it's client site.
1062      */
1063     hres = IOleObject_SetClientSite(pOleObject, pClientSite);
1064
1065   /*
1066    * Cleanup interfaces used internally
1067    */
1068   if (pOleObject)
1069     IOleObject_Release(pOleObject);
1070
1071   if (SUCCEEDED(hres))
1072   {
1073     IOleLink *pOleLink;
1074     HRESULT hres1;
1075     hres1 = IUnknown_QueryInterface(pUnk, &IID_IOleLink, (void **)&pOleLink);
1076     if (SUCCEEDED(hres1))
1077     {
1078       FIXME("handle OLE link\n");
1079       IOleLink_Release(pOleLink);
1080     }
1081   }
1082
1083   if (FAILED(hres))
1084   {
1085     IUnknown_Release(pUnk);
1086     pUnk = NULL;
1087   }
1088
1089   *ppvObj = pUnk;
1090
1091   return hres;
1092 }
1093
1094 /***********************************************************************
1095  *           OleSave     [OLE32.@]
1096  */
1097 HRESULT WINAPI OleSave(
1098   LPPERSISTSTORAGE pPS,
1099   LPSTORAGE        pStg,
1100   BOOL             fSameAsLoad)
1101 {
1102   HRESULT hres;
1103   CLSID   objectClass;
1104
1105   TRACE("(%p,%p,%x)\n", pPS, pStg, fSameAsLoad);
1106
1107   /*
1108    * First, we transfer the class ID (if available)
1109    */
1110   hres = IPersistStorage_GetClassID(pPS, &objectClass);
1111
1112   if (SUCCEEDED(hres))
1113   {
1114     WriteClassStg(pStg, &objectClass);
1115   }
1116
1117   /*
1118    * Then, we ask the object to save itself to the
1119    * storage. If it is successful, we commit the storage.
1120    */
1121   hres = IPersistStorage_Save(pPS, pStg, fSameAsLoad);
1122
1123   if (SUCCEEDED(hres))
1124   {
1125     IStorage_Commit(pStg,
1126                     STGC_DEFAULT);
1127   }
1128
1129   return hres;
1130 }
1131
1132
1133 /******************************************************************************
1134  *              OleLockRunning        [OLE32.@]
1135  */
1136 HRESULT WINAPI OleLockRunning(LPUNKNOWN pUnknown, BOOL fLock, BOOL fLastUnlockCloses)
1137 {
1138   IRunnableObject* runnable = NULL;
1139   HRESULT          hres;
1140
1141   TRACE("(%p,%x,%x)\n", pUnknown, fLock, fLastUnlockCloses);
1142
1143   hres = IUnknown_QueryInterface(pUnknown,
1144                                  &IID_IRunnableObject,
1145                                  (void**)&runnable);
1146
1147   if (SUCCEEDED(hres))
1148   {
1149     hres = IRunnableObject_LockRunning(runnable, fLock, fLastUnlockCloses);
1150
1151     IRunnableObject_Release(runnable);
1152
1153     return hres;
1154   }
1155
1156   return S_OK;
1157 }
1158
1159
1160 /**************************************************************************
1161  * Internal methods to manage the shared OLE menu in response to the
1162  * OLE***MenuDescriptor API
1163  */
1164
1165 /***
1166  * OLEMenu_Initialize()
1167  *
1168  * Initializes the OLEMENU data structures.
1169  */
1170 static void OLEMenu_Initialize(void)
1171 {
1172 }
1173
1174 /***
1175  * OLEMenu_UnInitialize()
1176  *
1177  * Releases the OLEMENU data structures.
1178  */
1179 static void OLEMenu_UnInitialize(void)
1180 {
1181 }
1182
1183 /*************************************************************************
1184  * OLEMenu_InstallHooks
1185  * Install thread scope message hooks for WH_GETMESSAGE and WH_CALLWNDPROC
1186  *
1187  * RETURNS: TRUE if message hooks were successfully installed
1188  *          FALSE on failure
1189  */
1190 static BOOL OLEMenu_InstallHooks( DWORD tid )
1191 {
1192   OleMenuHookItem *pHookItem;
1193
1194   /* Create an entry for the hook table */
1195   if ( !(pHookItem = HeapAlloc(GetProcessHeap(), 0,
1196                                sizeof(OleMenuHookItem)) ) )
1197     return FALSE;
1198
1199   pHookItem->tid = tid;
1200   pHookItem->hHeap = GetProcessHeap();
1201   pHookItem->CallWndProc_hHook = NULL;
1202
1203   /* Install a thread scope message hook for WH_GETMESSAGE */
1204   pHookItem->GetMsg_hHook = SetWindowsHookExW( WH_GETMESSAGE, OLEMenu_GetMsgProc,
1205                                                0, GetCurrentThreadId() );
1206   if ( !pHookItem->GetMsg_hHook )
1207     goto CLEANUP;
1208
1209   /* Install a thread scope message hook for WH_CALLWNDPROC */
1210   pHookItem->CallWndProc_hHook = SetWindowsHookExW( WH_CALLWNDPROC, OLEMenu_CallWndProc,
1211                                                     0, GetCurrentThreadId() );
1212   if ( !pHookItem->CallWndProc_hHook )
1213     goto CLEANUP;
1214
1215   /* Insert the hook table entry */
1216   pHookItem->next = hook_list;
1217   hook_list = pHookItem;
1218
1219   return TRUE;
1220
1221 CLEANUP:
1222   /* Unhook any hooks */
1223   if ( pHookItem->GetMsg_hHook )
1224     UnhookWindowsHookEx( pHookItem->GetMsg_hHook );
1225   if ( pHookItem->CallWndProc_hHook )
1226     UnhookWindowsHookEx( pHookItem->CallWndProc_hHook );
1227   /* Release the hook table entry */
1228   HeapFree(pHookItem->hHeap, 0, pHookItem );
1229
1230   return FALSE;
1231 }
1232
1233 /*************************************************************************
1234  * OLEMenu_UnInstallHooks
1235  * UnInstall thread scope message hooks for WH_GETMESSAGE and WH_CALLWNDPROC
1236  *
1237  * RETURNS: TRUE if message hooks were successfully installed
1238  *          FALSE on failure
1239  */
1240 static BOOL OLEMenu_UnInstallHooks( DWORD tid )
1241 {
1242   OleMenuHookItem *pHookItem = NULL;
1243   OleMenuHookItem **ppHook = &hook_list;
1244
1245   while (*ppHook)
1246   {
1247       if ((*ppHook)->tid == tid)
1248       {
1249           pHookItem = *ppHook;
1250           *ppHook = pHookItem->next;
1251           break;
1252       }
1253       ppHook = &(*ppHook)->next;
1254   }
1255   if (!pHookItem) return FALSE;
1256
1257   /* Uninstall the hooks installed for this thread */
1258   if ( !UnhookWindowsHookEx( pHookItem->GetMsg_hHook ) )
1259     goto CLEANUP;
1260   if ( !UnhookWindowsHookEx( pHookItem->CallWndProc_hHook ) )
1261     goto CLEANUP;
1262
1263   /* Release the hook table entry */
1264   HeapFree(pHookItem->hHeap, 0, pHookItem );
1265
1266   return TRUE;
1267
1268 CLEANUP:
1269   /* Release the hook table entry */
1270   HeapFree(pHookItem->hHeap, 0, pHookItem );
1271
1272   return FALSE;
1273 }
1274
1275 /*************************************************************************
1276  * OLEMenu_IsHookInstalled
1277  * Tests if OLEMenu hooks have been installed for a thread
1278  *
1279  * RETURNS: The pointer and index of the hook table entry for the tid
1280  *          NULL and -1 for the index if no hooks were installed for this thread
1281  */
1282 static OleMenuHookItem * OLEMenu_IsHookInstalled( DWORD tid )
1283 {
1284   OleMenuHookItem *pHookItem;
1285
1286   /* Do a simple linear search for an entry whose tid matches ours.
1287    * We really need a map but efficiency is not a concern here. */
1288   for (pHookItem = hook_list; pHookItem; pHookItem = pHookItem->next)
1289   {
1290     if ( tid == pHookItem->tid )
1291       return pHookItem;
1292   }
1293
1294   return NULL;
1295 }
1296
1297 /***********************************************************************
1298  *           OLEMenu_FindMainMenuIndex
1299  *
1300  * Used by OLEMenu API to find the top level group a menu item belongs to.
1301  * On success pnPos contains the index of the item in the top level menu group
1302  *
1303  * RETURNS: TRUE if the ID was found, FALSE on failure
1304  */
1305 static BOOL OLEMenu_FindMainMenuIndex( HMENU hMainMenu, HMENU hPopupMenu, UINT *pnPos )
1306 {
1307   INT i, nItems;
1308
1309   nItems = GetMenuItemCount( hMainMenu );
1310
1311   for (i = 0; i < nItems; i++)
1312   {
1313     HMENU hsubmenu;
1314
1315     /*  Is the current item a submenu? */
1316     if ( (hsubmenu = GetSubMenu(hMainMenu, i)) )
1317     {
1318       /* If the handle is the same we're done */
1319       if ( hsubmenu == hPopupMenu )
1320       {
1321         if (pnPos)
1322           *pnPos = i;
1323         return TRUE;
1324       }
1325       /* Recursively search without updating pnPos */
1326       else if ( OLEMenu_FindMainMenuIndex( hsubmenu, hPopupMenu, NULL ) )
1327       {
1328         if (pnPos)
1329           *pnPos = i;
1330         return TRUE;
1331       }
1332     }
1333   }
1334
1335   return FALSE;
1336 }
1337
1338 /***********************************************************************
1339  *           OLEMenu_SetIsServerMenu
1340  *
1341  * Checks whether a popup menu belongs to a shared menu group which is
1342  * owned by the server, and sets the menu descriptor state accordingly.
1343  * All menu messages from these groups should be routed to the server.
1344  *
1345  * RETURNS: TRUE if the popup menu is part of a server owned group
1346  *          FALSE if the popup menu is part of a container owned group
1347  */
1348 static BOOL OLEMenu_SetIsServerMenu( HMENU hmenu, OleMenuDescriptor *pOleMenuDescriptor )
1349 {
1350   UINT nPos = 0, nWidth, i;
1351
1352   pOleMenuDescriptor->bIsServerItem = FALSE;
1353
1354   /* Don't bother searching if the popup is the combined menu itself */
1355   if ( hmenu == pOleMenuDescriptor->hmenuCombined )
1356     return FALSE;
1357
1358   /* Find the menu item index in the shared OLE menu that this item belongs to */
1359   if ( !OLEMenu_FindMainMenuIndex( pOleMenuDescriptor->hmenuCombined, hmenu,  &nPos ) )
1360     return FALSE;
1361
1362   /* The group widths array has counts for the number of elements
1363    * in the groups File, Edit, Container, Object, Window, Help.
1364    * The Edit, Object & Help groups belong to the server object
1365    * and the other three belong to the container.
1366    * Loop through the group widths and locate the group we are a member of.
1367    */
1368   for ( i = 0, nWidth = 0; i < 6; i++ )
1369   {
1370     nWidth += pOleMenuDescriptor->mgw.width[i];
1371     if ( nPos < nWidth )
1372     {
1373       /* Odd elements are server menu widths */
1374       pOleMenuDescriptor->bIsServerItem = (i%2) ? TRUE : FALSE;
1375       break;
1376     }
1377   }
1378
1379   return pOleMenuDescriptor->bIsServerItem;
1380 }
1381
1382 /*************************************************************************
1383  * OLEMenu_CallWndProc
1384  * Thread scope WH_CALLWNDPROC hook proc filter function (callback)
1385  * This is invoked from a message hook installed in OleSetMenuDescriptor.
1386  */
1387 static LRESULT CALLBACK OLEMenu_CallWndProc(INT code, WPARAM wParam, LPARAM lParam)
1388 {
1389   LPCWPSTRUCT pMsg;
1390   HOLEMENU hOleMenu = 0;
1391   OleMenuDescriptor *pOleMenuDescriptor = NULL;
1392   OleMenuHookItem *pHookItem = NULL;
1393   WORD fuFlags;
1394
1395   TRACE("%i, %04lx, %08lx\n", code, wParam, lParam );
1396
1397   /* Check if we're being asked to process the message */
1398   if ( HC_ACTION != code )
1399     goto NEXTHOOK;
1400
1401   /* Retrieve the current message being dispatched from lParam */
1402   pMsg = (LPCWPSTRUCT)lParam;
1403
1404   /* Check if the message is destined for a window we are interested in:
1405    * If the window has an OLEMenu property we may need to dispatch
1406    * the menu message to its active objects window instead. */
1407
1408   hOleMenu = GetPropW( pMsg->hwnd, prop_olemenuW );
1409   if ( !hOleMenu )
1410     goto NEXTHOOK;
1411
1412   /* Get the menu descriptor */
1413   pOleMenuDescriptor = GlobalLock( hOleMenu );
1414   if ( !pOleMenuDescriptor ) /* Bad descriptor! */
1415     goto NEXTHOOK;
1416
1417   /* Process menu messages */
1418   switch( pMsg->message )
1419   {
1420     case WM_INITMENU:
1421     {
1422       /* Reset the menu descriptor state */
1423       pOleMenuDescriptor->bIsServerItem = FALSE;
1424
1425       /* Send this message to the server as well */
1426       SendMessageW( pOleMenuDescriptor->hwndActiveObject,
1427                   pMsg->message, pMsg->wParam, pMsg->lParam );
1428       goto NEXTHOOK;
1429     }
1430
1431     case WM_INITMENUPOPUP:
1432     {
1433       /* Save the state for whether this is a server owned menu */
1434       OLEMenu_SetIsServerMenu( (HMENU)pMsg->wParam, pOleMenuDescriptor );
1435       break;
1436     }
1437
1438     case WM_MENUSELECT:
1439     {
1440       fuFlags = HIWORD(pMsg->wParam);  /* Get flags */
1441       if ( fuFlags & MF_SYSMENU )
1442          goto NEXTHOOK;
1443
1444       /* Save the state for whether this is a server owned popup menu */
1445       else if ( fuFlags & MF_POPUP )
1446         OLEMenu_SetIsServerMenu( (HMENU)pMsg->lParam, pOleMenuDescriptor );
1447
1448       break;
1449     }
1450
1451     case WM_DRAWITEM:
1452     {
1453       LPDRAWITEMSTRUCT lpdis = (LPDRAWITEMSTRUCT) pMsg->lParam;
1454       if ( pMsg->wParam != 0 || lpdis->CtlType != ODT_MENU )
1455         goto NEXTHOOK;  /* Not a menu message */
1456
1457       break;
1458     }
1459
1460     default:
1461       goto NEXTHOOK;
1462   }
1463
1464   /* If the message was for the server dispatch it accordingly */
1465   if ( pOleMenuDescriptor->bIsServerItem )
1466   {
1467     SendMessageW( pOleMenuDescriptor->hwndActiveObject,
1468                   pMsg->message, pMsg->wParam, pMsg->lParam );
1469   }
1470
1471 NEXTHOOK:
1472   if ( pOleMenuDescriptor )
1473     GlobalUnlock( hOleMenu );
1474
1475   /* Lookup the hook item for the current thread */
1476   if ( !( pHookItem = OLEMenu_IsHookInstalled( GetCurrentThreadId() ) ) )
1477   {
1478     /* This should never fail!! */
1479     WARN("could not retrieve hHook for current thread!\n" );
1480     return 0;
1481   }
1482
1483   /* Pass on the message to the next hooker */
1484   return CallNextHookEx( pHookItem->CallWndProc_hHook, code, wParam, lParam );
1485 }
1486
1487 /*************************************************************************
1488  * OLEMenu_GetMsgProc
1489  * Thread scope WH_GETMESSAGE hook proc filter function (callback)
1490  * This is invoked from a message hook installed in OleSetMenuDescriptor.
1491  */
1492 static LRESULT CALLBACK OLEMenu_GetMsgProc(INT code, WPARAM wParam, LPARAM lParam)
1493 {
1494   LPMSG pMsg;
1495   HOLEMENU hOleMenu = 0;
1496   OleMenuDescriptor *pOleMenuDescriptor = NULL;
1497   OleMenuHookItem *pHookItem = NULL;
1498   WORD wCode;
1499
1500   TRACE("%i, %04lx, %08lx\n", code, wParam, lParam );
1501
1502   /* Check if we're being asked to process a  messages */
1503   if ( HC_ACTION != code )
1504     goto NEXTHOOK;
1505
1506   /* Retrieve the current message being dispatched from lParam */
1507   pMsg = (LPMSG)lParam;
1508
1509   /* Check if the message is destined for a window we are interested in:
1510    * If the window has an OLEMenu property we may need to dispatch
1511    * the menu message to its active objects window instead. */
1512
1513   hOleMenu = GetPropW( pMsg->hwnd, prop_olemenuW );
1514   if ( !hOleMenu )
1515     goto NEXTHOOK;
1516
1517   /* Process menu messages */
1518   switch( pMsg->message )
1519   {
1520     case WM_COMMAND:
1521     {
1522       wCode = HIWORD(pMsg->wParam);  /* Get notification code */
1523       if ( wCode )
1524         goto NEXTHOOK;  /* Not a menu message */
1525       break;
1526     }
1527     default:
1528       goto NEXTHOOK;
1529   }
1530
1531   /* Get the menu descriptor */
1532   pOleMenuDescriptor = GlobalLock( hOleMenu );
1533   if ( !pOleMenuDescriptor ) /* Bad descriptor! */
1534     goto NEXTHOOK;
1535
1536   /* If the message was for the server dispatch it accordingly */
1537   if ( pOleMenuDescriptor->bIsServerItem )
1538   {
1539     /* Change the hWnd in the message to the active objects hWnd.
1540      * The message loop which reads this message will automatically
1541      * dispatch it to the embedded objects window. */
1542     pMsg->hwnd = pOleMenuDescriptor->hwndActiveObject;
1543   }
1544
1545 NEXTHOOK:
1546   if ( pOleMenuDescriptor )
1547     GlobalUnlock( hOleMenu );
1548
1549   /* Lookup the hook item for the current thread */
1550   if ( !( pHookItem = OLEMenu_IsHookInstalled( GetCurrentThreadId() ) ) )
1551   {
1552     /* This should never fail!! */
1553     WARN("could not retrieve hHook for current thread!\n" );
1554     return FALSE;
1555   }
1556
1557   /* Pass on the message to the next hooker */
1558   return CallNextHookEx( pHookItem->GetMsg_hHook, code, wParam, lParam );
1559 }
1560
1561 /***********************************************************************
1562  * OleCreateMenuDescriptor [OLE32.@]
1563  * Creates an OLE menu descriptor for OLE to use when dispatching
1564  * menu messages and commands.
1565  *
1566  * PARAMS:
1567  *    hmenuCombined  -  Handle to the objects combined menu
1568  *    lpMenuWidths   -  Pointer to array of 6 LONG's indicating menus per group
1569  *
1570  */
1571 HOLEMENU WINAPI OleCreateMenuDescriptor(
1572   HMENU                hmenuCombined,
1573   LPOLEMENUGROUPWIDTHS lpMenuWidths)
1574 {
1575   HOLEMENU hOleMenu;
1576   OleMenuDescriptor *pOleMenuDescriptor;
1577   int i;
1578
1579   if ( !hmenuCombined || !lpMenuWidths )
1580     return 0;
1581
1582   /* Create an OLE menu descriptor */
1583   if ( !(hOleMenu = GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT,
1584                                 sizeof(OleMenuDescriptor) ) ) )
1585   return 0;
1586
1587   pOleMenuDescriptor = GlobalLock( hOleMenu );
1588   if ( !pOleMenuDescriptor )
1589     return 0;
1590
1591   /* Initialize menu group widths and hmenu */
1592   for ( i = 0; i < 6; i++ )
1593     pOleMenuDescriptor->mgw.width[i] = lpMenuWidths->width[i];
1594
1595   pOleMenuDescriptor->hmenuCombined = hmenuCombined;
1596   pOleMenuDescriptor->bIsServerItem = FALSE;
1597   GlobalUnlock( hOleMenu );
1598
1599   return hOleMenu;
1600 }
1601
1602 /***********************************************************************
1603  * OleDestroyMenuDescriptor [OLE32.@]
1604  * Destroy the shared menu descriptor
1605  */
1606 HRESULT WINAPI OleDestroyMenuDescriptor(
1607   HOLEMENU hmenuDescriptor)
1608 {
1609   if ( hmenuDescriptor )
1610     GlobalFree( hmenuDescriptor );
1611         return S_OK;
1612 }
1613
1614 /***********************************************************************
1615  * OleSetMenuDescriptor [OLE32.@]
1616  * Installs or removes OLE dispatching code for the containers frame window.
1617  *
1618  * PARAMS
1619  *     hOleMenu         Handle to composite menu descriptor
1620  *     hwndFrame        Handle to containers frame window
1621  *     hwndActiveObject Handle to objects in-place activation window
1622  *     lpFrame          Pointer to IOleInPlaceFrame on containers window
1623  *     lpActiveObject   Pointer to IOleInPlaceActiveObject on active in-place object
1624  *
1625  * RETURNS
1626  *      S_OK                               - menu installed correctly
1627  *      E_FAIL, E_INVALIDARG, E_UNEXPECTED - failure
1628  *
1629  * FIXME
1630  *      The lpFrame and lpActiveObject parameters are currently ignored
1631  *      OLE should install context sensitive help F1 filtering for the app when
1632  *      these are non null.
1633  */
1634 HRESULT WINAPI OleSetMenuDescriptor(
1635   HOLEMENU               hOleMenu,
1636   HWND                   hwndFrame,
1637   HWND                   hwndActiveObject,
1638   LPOLEINPLACEFRAME        lpFrame,
1639   LPOLEINPLACEACTIVEOBJECT lpActiveObject)
1640 {
1641   OleMenuDescriptor *pOleMenuDescriptor = NULL;
1642
1643   /* Check args */
1644   if ( !hwndFrame || (hOleMenu && !hwndActiveObject) )
1645     return E_INVALIDARG;
1646
1647   if ( lpFrame || lpActiveObject )
1648   {
1649      FIXME("(%p, %p, %p, %p, %p), Context sensitive help filtering not implemented!\n",
1650         hOleMenu,
1651         hwndFrame,
1652         hwndActiveObject,
1653         lpFrame,
1654         lpActiveObject);
1655   }
1656
1657   /* Set up a message hook to intercept the containers frame window messages.
1658    * The message filter is responsible for dispatching menu messages from the
1659    * shared menu which are intended for the object.
1660    */
1661
1662   if ( hOleMenu )  /* Want to install dispatching code */
1663   {
1664     /* If OLEMenu hooks are already installed for this thread, fail
1665      * Note: This effectively means that OleSetMenuDescriptor cannot
1666      * be called twice in succession on the same frame window
1667      * without first calling it with a null hOleMenu to uninstall */
1668     if ( OLEMenu_IsHookInstalled( GetCurrentThreadId() ) )
1669   return E_FAIL;
1670
1671     /* Get the menu descriptor */
1672     pOleMenuDescriptor = GlobalLock( hOleMenu );
1673     if ( !pOleMenuDescriptor )
1674       return E_UNEXPECTED;
1675
1676     /* Update the menu descriptor */
1677     pOleMenuDescriptor->hwndFrame = hwndFrame;
1678     pOleMenuDescriptor->hwndActiveObject = hwndActiveObject;
1679
1680     GlobalUnlock( hOleMenu );
1681     pOleMenuDescriptor = NULL;
1682
1683     /* Add a menu descriptor windows property to the frame window */
1684     SetPropW( hwndFrame, prop_olemenuW, hOleMenu );
1685
1686     /* Install thread scope message hooks for WH_GETMESSAGE and WH_CALLWNDPROC */
1687     if ( !OLEMenu_InstallHooks( GetCurrentThreadId() ) )
1688       return E_FAIL;
1689   }
1690   else  /* Want to uninstall dispatching code */
1691   {
1692     /* Uninstall the hooks */
1693     if ( !OLEMenu_UnInstallHooks( GetCurrentThreadId() ) )
1694       return E_FAIL;
1695
1696     /* Remove the menu descriptor property from the frame window */
1697     RemovePropW( hwndFrame, prop_olemenuW );
1698   }
1699
1700   return S_OK;
1701 }
1702
1703 /******************************************************************************
1704  *              IsAccelerator        [OLE32.@]
1705  * Mostly copied from controls/menu.c TranslateAccelerator implementation
1706  */
1707 BOOL WINAPI IsAccelerator(HACCEL hAccel, int cAccelEntries, LPMSG lpMsg, WORD* lpwCmd)
1708 {
1709     LPACCEL lpAccelTbl;
1710     int i;
1711
1712     if(!lpMsg) return FALSE;
1713     if (!hAccel)
1714     {
1715         WARN_(accel)("NULL accel handle\n");
1716         return FALSE;
1717     }
1718     if((lpMsg->message != WM_KEYDOWN &&
1719         lpMsg->message != WM_SYSKEYDOWN &&
1720         lpMsg->message != WM_SYSCHAR &&
1721         lpMsg->message != WM_CHAR)) return FALSE;
1722     lpAccelTbl = HeapAlloc(GetProcessHeap(), 0, cAccelEntries * sizeof(ACCEL));
1723     if (NULL == lpAccelTbl)
1724     {
1725         return FALSE;
1726     }
1727     if (CopyAcceleratorTableW(hAccel, lpAccelTbl, cAccelEntries) != cAccelEntries)
1728     {
1729         WARN_(accel)("CopyAcceleratorTableW failed\n");
1730         HeapFree(GetProcessHeap(), 0, lpAccelTbl);
1731         return FALSE;
1732     }
1733
1734     TRACE_(accel)("hAccel=%p, cAccelEntries=%d,"
1735                 "msg->hwnd=%p, msg->message=%04x, wParam=%08lx, lParam=%08lx\n",
1736                 hAccel, cAccelEntries,
1737                 lpMsg->hwnd, lpMsg->message, lpMsg->wParam, lpMsg->lParam);
1738     for(i = 0; i < cAccelEntries; i++)
1739     {
1740         if(lpAccelTbl[i].key != lpMsg->wParam)
1741             continue;
1742
1743         if(lpMsg->message == WM_CHAR)
1744         {
1745             if(!(lpAccelTbl[i].fVirt & FALT) && !(lpAccelTbl[i].fVirt & FVIRTKEY))
1746             {
1747                 TRACE_(accel)("found accel for WM_CHAR: ('%c')\n", LOWORD(lpMsg->wParam) & 0xff);
1748                 goto found;
1749             }
1750         }
1751         else
1752         {
1753             if(lpAccelTbl[i].fVirt & FVIRTKEY)
1754             {
1755                 INT mask = 0;
1756                 TRACE_(accel)("found accel for virt_key %04lx (scan %04x)\n",
1757                                 lpMsg->wParam, HIWORD(lpMsg->lParam) & 0xff);
1758                 if(GetKeyState(VK_SHIFT) & 0x8000) mask |= FSHIFT;
1759                 if(GetKeyState(VK_CONTROL) & 0x8000) mask |= FCONTROL;
1760                 if(GetKeyState(VK_MENU) & 0x8000) mask |= FALT;
1761                 if(mask == (lpAccelTbl[i].fVirt & (FSHIFT | FCONTROL | FALT))) goto found;
1762                 TRACE_(accel)("incorrect SHIFT/CTRL/ALT-state\n");
1763             }
1764             else
1765             {
1766                 if(!(lpMsg->lParam & 0x01000000))  /* no special_key */
1767                 {
1768                     if((lpAccelTbl[i].fVirt & FALT) && (lpMsg->lParam & 0x20000000))
1769                     {                                                  /* ^^ ALT pressed */
1770                         TRACE_(accel)("found accel for Alt-%c\n", LOWORD(lpMsg->wParam) & 0xff);
1771                         goto found;
1772                     }
1773                 }
1774             }
1775         }
1776     }
1777
1778     WARN_(accel)("couldn't translate accelerator key\n");
1779     HeapFree(GetProcessHeap(), 0, lpAccelTbl);
1780     return FALSE;
1781
1782 found:
1783     if(lpwCmd) *lpwCmd = lpAccelTbl[i].cmd;
1784     HeapFree(GetProcessHeap(), 0, lpAccelTbl);
1785     return TRUE;
1786 }
1787
1788 /***********************************************************************
1789  * ReleaseStgMedium [OLE32.@]
1790  */
1791 void WINAPI ReleaseStgMedium(
1792   STGMEDIUM* pmedium)
1793 {
1794   switch (pmedium->tymed)
1795   {
1796     case TYMED_HGLOBAL:
1797     {
1798       if ( (pmedium->pUnkForRelease==0) &&
1799            (pmedium->u.hGlobal!=0) )
1800         GlobalFree(pmedium->u.hGlobal);
1801       break;
1802     }
1803     case TYMED_FILE:
1804     {
1805       if (pmedium->u.lpszFileName!=0)
1806       {
1807         if (pmedium->pUnkForRelease==0)
1808         {
1809           DeleteFileW(pmedium->u.lpszFileName);
1810         }
1811
1812         CoTaskMemFree(pmedium->u.lpszFileName);
1813       }
1814       break;
1815     }
1816     case TYMED_ISTREAM:
1817     {
1818       if (pmedium->u.pstm!=0)
1819       {
1820         IStream_Release(pmedium->u.pstm);
1821       }
1822       break;
1823     }
1824     case TYMED_ISTORAGE:
1825     {
1826       if (pmedium->u.pstg!=0)
1827       {
1828         IStorage_Release(pmedium->u.pstg);
1829       }
1830       break;
1831     }
1832     case TYMED_GDI:
1833     {
1834       if ( (pmedium->pUnkForRelease==0) &&
1835            (pmedium->u.hBitmap!=0) )
1836         DeleteObject(pmedium->u.hBitmap);
1837       break;
1838     }
1839     case TYMED_MFPICT:
1840     {
1841       if ( (pmedium->pUnkForRelease==0) &&
1842            (pmedium->u.hMetaFilePict!=0) )
1843       {
1844         LPMETAFILEPICT pMP = GlobalLock(pmedium->u.hMetaFilePict);
1845         DeleteMetaFile(pMP->hMF);
1846         GlobalUnlock(pmedium->u.hMetaFilePict);
1847         GlobalFree(pmedium->u.hMetaFilePict);
1848       }
1849       break;
1850     }
1851     case TYMED_ENHMF:
1852     {
1853       if ( (pmedium->pUnkForRelease==0) &&
1854            (pmedium->u.hEnhMetaFile!=0) )
1855       {
1856         DeleteEnhMetaFile(pmedium->u.hEnhMetaFile);
1857       }
1858       break;
1859     }
1860     case TYMED_NULL:
1861     default:
1862       break;
1863   }
1864   pmedium->tymed=TYMED_NULL;
1865
1866   /*
1867    * After cleaning up, the unknown is released
1868    */
1869   if (pmedium->pUnkForRelease!=0)
1870   {
1871     IUnknown_Release(pmedium->pUnkForRelease);
1872     pmedium->pUnkForRelease = 0;
1873   }
1874 }
1875
1876 /***
1877  * OLEDD_Initialize()
1878  *
1879  * Initializes the OLE drag and drop data structures.
1880  */
1881 static void OLEDD_Initialize(void)
1882 {
1883     WNDCLASSW wndClass;
1884
1885     ZeroMemory (&wndClass, sizeof(WNDCLASSW));
1886     wndClass.style         = CS_GLOBALCLASS;
1887     wndClass.lpfnWndProc   = OLEDD_DragTrackerWindowProc;
1888     wndClass.cbClsExtra    = 0;
1889     wndClass.cbWndExtra    = sizeof(TrackerWindowInfo*);
1890     wndClass.hCursor       = 0;
1891     wndClass.hbrBackground = 0;
1892     wndClass.lpszClassName = OLEDD_DRAGTRACKERCLASS;
1893
1894     RegisterClassW (&wndClass);
1895 }
1896
1897 /***
1898  * OLEDD_FreeDropTarget()
1899  *
1900  * Frees the drag and drop data structure
1901  */
1902 static void OLEDD_FreeDropTarget(DropTargetNode *dropTargetInfo, BOOL release_drop_target)
1903 {
1904   list_remove(&dropTargetInfo->entry);
1905   if (release_drop_target) IDropTarget_Release(dropTargetInfo->dropTarget);
1906   HeapFree(GetProcessHeap(), 0, dropTargetInfo);
1907 }
1908
1909 /***
1910  * OLEDD_UnInitialize()
1911  *
1912  * Releases the OLE drag and drop data structures.
1913  */
1914 void OLEDD_UnInitialize(void)
1915 {
1916   /*
1917    * Simply empty the list.
1918    */
1919   while (!list_empty(&targetListHead))
1920   {
1921     DropTargetNode* curNode = LIST_ENTRY(list_head(&targetListHead), DropTargetNode, entry);
1922     OLEDD_FreeDropTarget(curNode, FALSE);
1923   }
1924 }
1925
1926 /***
1927  * OLEDD_FindDropTarget()
1928  *
1929  * Finds information about the drop target.
1930  */
1931 static DropTargetNode* OLEDD_FindDropTarget(HWND hwndOfTarget)
1932 {
1933   DropTargetNode*  curNode;
1934
1935   /*
1936    * Iterate the list to find the HWND value.
1937    */
1938   LIST_FOR_EACH_ENTRY(curNode, &targetListHead, DropTargetNode, entry)
1939     if (hwndOfTarget==curNode->hwndTarget)
1940       return curNode;
1941
1942   /*
1943    * If we get here, the item is not in the list
1944    */
1945   return NULL;
1946 }
1947
1948 /***
1949  * OLEDD_DragTrackerWindowProc()
1950  *
1951  * This method is the WindowProcedure of the drag n drop tracking
1952  * window. During a drag n Drop operation, an invisible window is created
1953  * to receive the user input and act upon it. This procedure is in charge
1954  * of this behavior.
1955  */
1956
1957 #define DRAG_TIMER_ID 1
1958
1959 static LRESULT WINAPI OLEDD_DragTrackerWindowProc(
1960                          HWND   hwnd,
1961                          UINT   uMsg,
1962                          WPARAM wParam,
1963                          LPARAM   lParam)
1964 {
1965   switch (uMsg)
1966   {
1967     case WM_CREATE:
1968     {
1969       LPCREATESTRUCTA createStruct = (LPCREATESTRUCTA)lParam;
1970
1971       SetWindowLongPtrW(hwnd, 0, (LONG_PTR)createStruct->lpCreateParams);
1972       SetTimer(hwnd, DRAG_TIMER_ID, 50, NULL);
1973
1974       break;
1975     }
1976     case WM_TIMER:
1977     case WM_MOUSEMOVE:
1978     {
1979       OLEDD_TrackMouseMove((TrackerWindowInfo*)GetWindowLongPtrA(hwnd, 0));
1980       break;
1981     }
1982     case WM_LBUTTONUP:
1983     case WM_MBUTTONUP:
1984     case WM_RBUTTONUP:
1985     case WM_LBUTTONDOWN:
1986     case WM_MBUTTONDOWN:
1987     case WM_RBUTTONDOWN:
1988     {
1989       OLEDD_TrackStateChange((TrackerWindowInfo*)GetWindowLongPtrA(hwnd, 0));
1990       break;
1991     }
1992     case WM_DESTROY:
1993     {
1994       KillTimer(hwnd, DRAG_TIMER_ID);
1995       break;
1996     }
1997   }
1998
1999   /*
2000    * This is a window proc after all. Let's call the default.
2001    */
2002   return DefWindowProcW (hwnd, uMsg, wParam, lParam);
2003 }
2004
2005 /***
2006  * OLEDD_TrackMouseMove()
2007  *
2008  * This method is invoked while a drag and drop operation is in effect.
2009  * it will generate the appropriate callbacks in the drop source
2010  * and drop target. It will also provide the expected feedback to
2011  * the user.
2012  *
2013  * params:
2014  *    trackerInfo - Pointer to the structure identifying the
2015  *                  drag & drop operation that is currently
2016  *                  active.
2017  */
2018 static void OLEDD_TrackMouseMove(TrackerWindowInfo* trackerInfo)
2019 {
2020   HWND   hwndNewTarget = 0;
2021   HRESULT  hr = S_OK;
2022   POINT pt;
2023
2024   /*
2025    * Get the handle of the window under the mouse
2026    */
2027   pt.x = trackerInfo->curMousePos.x;
2028   pt.y = trackerInfo->curMousePos.y;
2029   hwndNewTarget = WindowFromPoint(pt);
2030
2031   /*
2032    * Every time, we re-initialize the effects passed to the
2033    * IDropTarget to the effects allowed by the source.
2034    */
2035   *trackerInfo->pdwEffect = trackerInfo->dwOKEffect;
2036
2037   /*
2038    * If we are hovering over the same target as before, send the
2039    * DragOver notification
2040    */
2041   if ( (trackerInfo->curDragTarget != 0) &&
2042        (trackerInfo->curTargetHWND == hwndNewTarget) )
2043   {
2044     IDropTarget_DragOver(trackerInfo->curDragTarget,
2045                          trackerInfo->dwKeyState,
2046                          trackerInfo->curMousePos,
2047                          trackerInfo->pdwEffect);
2048   }
2049   else
2050   {
2051     DropTargetNode* newDropTargetNode = 0;
2052
2053     /*
2054      * If we changed window, we have to notify our old target and check for
2055      * the new one.
2056      */
2057     if (trackerInfo->curDragTarget!=0)
2058     {
2059       IDropTarget_DragLeave(trackerInfo->curDragTarget);
2060     }
2061
2062     /*
2063      * Make sure we're hovering over a window.
2064      */
2065     if (hwndNewTarget!=0)
2066     {
2067       /*
2068        * Find-out if there is a drag target under the mouse
2069        */
2070       HWND nexttar = hwndNewTarget;
2071       trackerInfo->curTargetHWND = hwndNewTarget;
2072
2073       do {
2074         newDropTargetNode = OLEDD_FindDropTarget(nexttar);
2075       } while (!newDropTargetNode && (nexttar = GetParent(nexttar)) != 0);
2076       if(nexttar) hwndNewTarget = nexttar;
2077
2078       trackerInfo->curDragTargetHWND = hwndNewTarget;
2079       trackerInfo->curDragTarget     = newDropTargetNode ? newDropTargetNode->dropTarget : 0;
2080
2081       /*
2082        * If there is, notify it that we just dragged-in
2083        */
2084       if (trackerInfo->curDragTarget)
2085       {
2086         hr = IDropTarget_DragEnter(trackerInfo->curDragTarget,
2087                                    trackerInfo->dataObject,
2088                                    trackerInfo->dwKeyState,
2089                                    trackerInfo->curMousePos,
2090                                    trackerInfo->pdwEffect);
2091
2092         /* failed DragEnter() means invalid target */
2093         if (hr != S_OK)
2094         {
2095           trackerInfo->curDragTargetHWND = 0;
2096           trackerInfo->curTargetHWND     = 0;
2097           trackerInfo->curDragTarget     = 0;
2098         }
2099       }
2100     }
2101     else
2102     {
2103       /*
2104        * The mouse is not over a window so we don't track anything.
2105        */
2106       trackerInfo->curDragTargetHWND = 0;
2107       trackerInfo->curTargetHWND     = 0;
2108       trackerInfo->curDragTarget     = 0;
2109     }
2110   }
2111
2112   /*
2113    * Now that we have done that, we have to tell the source to give
2114    * us feedback on the work being done by the target.  If we don't
2115    * have a target, simulate no effect.
2116    */
2117   if (trackerInfo->curDragTarget==0)
2118   {
2119     *trackerInfo->pdwEffect = DROPEFFECT_NONE;
2120   }
2121
2122   hr = IDropSource_GiveFeedback(trackerInfo->dropSource,
2123                                 *trackerInfo->pdwEffect);
2124
2125   /*
2126    * When we ask for feedback from the drop source, sometimes it will
2127    * do all the necessary work and sometimes it will not handle it
2128    * when that's the case, we must display the standard drag and drop
2129    * cursors.
2130    */
2131   if (hr == DRAGDROP_S_USEDEFAULTCURSORS)
2132   {
2133     HCURSOR hCur;
2134
2135     if (*trackerInfo->pdwEffect & DROPEFFECT_MOVE)
2136     {
2137       hCur = LoadCursorW(hProxyDll, MAKEINTRESOURCEW(1));
2138     }
2139     else if (*trackerInfo->pdwEffect & DROPEFFECT_COPY)
2140     {
2141       hCur = LoadCursorW(hProxyDll, MAKEINTRESOURCEW(2));
2142     }
2143     else if (*trackerInfo->pdwEffect & DROPEFFECT_LINK)
2144     {
2145       hCur = LoadCursorW(hProxyDll, MAKEINTRESOURCEW(3));
2146     }
2147     else
2148     {
2149       hCur = LoadCursorW(hProxyDll, MAKEINTRESOURCEW(0));
2150     }
2151
2152     SetCursor(hCur);
2153   }
2154 }
2155
2156 /***
2157  * OLEDD_TrackStateChange()
2158  *
2159  * This method is invoked while a drag and drop operation is in effect.
2160  * It is used to notify the drop target/drop source callbacks when
2161  * the state of the keyboard or mouse button change.
2162  *
2163  * params:
2164  *    trackerInfo - Pointer to the structure identifying the
2165  *                  drag & drop operation that is currently
2166  *                  active.
2167  */
2168 static void OLEDD_TrackStateChange(TrackerWindowInfo* trackerInfo)
2169 {
2170   /*
2171    * Ask the drop source what to do with the operation.
2172    */
2173   trackerInfo->returnValue = IDropSource_QueryContinueDrag(
2174                                trackerInfo->dropSource,
2175                                trackerInfo->escPressed,
2176                                trackerInfo->dwKeyState);
2177
2178   /*
2179    * All the return valued will stop the operation except the S_OK
2180    * return value.
2181    */
2182   if (trackerInfo->returnValue!=S_OK)
2183   {
2184     /*
2185      * Make sure the message loop in DoDragDrop stops
2186      */
2187     trackerInfo->trackingDone = TRUE;
2188
2189     /*
2190      * Release the mouse in case the drop target decides to show a popup
2191      * or a menu or something.
2192      */
2193     ReleaseCapture();
2194
2195     /*
2196      * If we end-up over a target, drop the object in the target or
2197      * inform the target that the operation was cancelled.
2198      */
2199     if (trackerInfo->curDragTarget)
2200     {
2201       switch (trackerInfo->returnValue)
2202       {
2203         /*
2204          * If the source wants us to complete the operation, we tell
2205          * the drop target that we just dropped the object in it.
2206          */
2207         case DRAGDROP_S_DROP:
2208           if (*trackerInfo->pdwEffect != DROPEFFECT_NONE)
2209             IDropTarget_Drop(trackerInfo->curDragTarget,
2210                              trackerInfo->dataObject,
2211                              trackerInfo->dwKeyState,
2212                              trackerInfo->curMousePos,
2213                              trackerInfo->pdwEffect);
2214           else
2215             IDropTarget_DragLeave(trackerInfo->curDragTarget);
2216           break;
2217
2218         /*
2219          * If the source told us that we should cancel, fool the drop
2220          * target by telling it that the mouse left it's window.
2221          * Also set the drop effect to "NONE" in case the application
2222          * ignores the result of DoDragDrop.
2223          */
2224         case DRAGDROP_S_CANCEL:
2225           IDropTarget_DragLeave(trackerInfo->curDragTarget);
2226           *trackerInfo->pdwEffect = DROPEFFECT_NONE;
2227           break;
2228       }
2229     }
2230   }
2231 }
2232
2233 /***
2234  * OLEDD_GetButtonState()
2235  *
2236  * This method will use the current state of the keyboard to build
2237  * a button state mask equivalent to the one passed in the
2238  * WM_MOUSEMOVE wParam.
2239  */
2240 static DWORD OLEDD_GetButtonState(void)
2241 {
2242   BYTE  keyboardState[256];
2243   DWORD keyMask = 0;
2244
2245   GetKeyboardState(keyboardState);
2246
2247   if ( (keyboardState[VK_SHIFT] & 0x80) !=0)
2248     keyMask |= MK_SHIFT;
2249
2250   if ( (keyboardState[VK_CONTROL] & 0x80) !=0)
2251     keyMask |= MK_CONTROL;
2252
2253   if ( (keyboardState[VK_LBUTTON] & 0x80) !=0)
2254     keyMask |= MK_LBUTTON;
2255
2256   if ( (keyboardState[VK_RBUTTON] & 0x80) !=0)
2257     keyMask |= MK_RBUTTON;
2258
2259   if ( (keyboardState[VK_MBUTTON] & 0x80) !=0)
2260     keyMask |= MK_MBUTTON;
2261
2262   return keyMask;
2263 }
2264
2265 /***
2266  * OLEDD_GetButtonState()
2267  *
2268  * This method will read the default value of the registry key in
2269  * parameter and extract a DWORD value from it. The registry key value
2270  * can be in a string key or a DWORD key.
2271  *
2272  * params:
2273  *     regKey   - Key to read the default value from
2274  *     pdwValue - Pointer to the location where the DWORD
2275  *                value is returned. This value is not modified
2276  *                if the value is not found.
2277  */
2278
2279 static void OLEUTL_ReadRegistryDWORDValue(
2280   HKEY   regKey,
2281   DWORD* pdwValue)
2282 {
2283   char  buffer[20];
2284   DWORD cbData = sizeof(buffer);
2285   DWORD dwKeyType;
2286   LONG  lres;
2287
2288   lres = RegQueryValueExA(regKey,
2289                           "",
2290                           NULL,
2291                           &dwKeyType,
2292                           (LPBYTE)buffer,
2293                           &cbData);
2294
2295   if (lres==ERROR_SUCCESS)
2296   {
2297     switch (dwKeyType)
2298     {
2299       case REG_DWORD:
2300         *pdwValue = *(DWORD*)buffer;
2301         break;
2302       case REG_EXPAND_SZ:
2303       case REG_MULTI_SZ:
2304       case REG_SZ:
2305         *pdwValue = (DWORD)strtoul(buffer, NULL, 10);
2306         break;
2307     }
2308   }
2309 }
2310
2311 /******************************************************************************
2312  * OleDraw (OLE32.@)
2313  *
2314  * The operation of this function is documented literally in the WinAPI
2315  * documentation to involve a QueryInterface for the IViewObject interface,
2316  * followed by a call to IViewObject::Draw.
2317  */
2318 HRESULT WINAPI OleDraw(
2319         IUnknown *pUnk,
2320         DWORD dwAspect,
2321         HDC hdcDraw,
2322         LPCRECT lprcBounds)
2323 {
2324   HRESULT hres;
2325   IViewObject *viewobject;
2326
2327   hres = IUnknown_QueryInterface(pUnk,
2328                                  &IID_IViewObject,
2329                                  (void**)&viewobject);
2330
2331   if (SUCCEEDED(hres))
2332   {
2333     RECTL rectl;
2334
2335     rectl.left = lprcBounds->left;
2336     rectl.right = lprcBounds->right;
2337     rectl.top = lprcBounds->top;
2338     rectl.bottom = lprcBounds->bottom;
2339     hres = IViewObject_Draw(viewobject, dwAspect, -1, 0, 0, 0, hdcDraw, &rectl, 0, 0, 0);
2340
2341     IViewObject_Release(viewobject);
2342     return hres;
2343   }
2344   else
2345   {
2346     return DV_E_NOIVIEWOBJECT;
2347   }
2348 }
2349
2350 /***********************************************************************
2351  *             OleTranslateAccelerator [OLE32.@]
2352  */
2353 HRESULT WINAPI OleTranslateAccelerator (LPOLEINPLACEFRAME lpFrame,
2354                    LPOLEINPLACEFRAMEINFO lpFrameInfo, LPMSG lpmsg)
2355 {
2356     WORD wID;
2357
2358     TRACE("(%p,%p,%p)\n", lpFrame, lpFrameInfo, lpmsg);
2359
2360     if (IsAccelerator(lpFrameInfo->haccel,lpFrameInfo->cAccelEntries,lpmsg,&wID))
2361         return IOleInPlaceFrame_TranslateAccelerator(lpFrame,lpmsg,wID);
2362
2363     return S_FALSE;
2364 }
2365
2366 /******************************************************************************
2367  *              OleCreate        [OLE32.@]
2368  *
2369  */
2370 HRESULT WINAPI OleCreate(
2371         REFCLSID rclsid,
2372         REFIID riid,
2373         DWORD renderopt,
2374         LPFORMATETC pFormatEtc,
2375         LPOLECLIENTSITE pClientSite,
2376         LPSTORAGE pStg,
2377         LPVOID* ppvObj)
2378 {
2379     HRESULT hres;
2380     IUnknown * pUnk = NULL;
2381     IOleObject *pOleObject = NULL;
2382
2383     TRACE("(%s, %s, %d, %p, %p, %p, %p)\n", debugstr_guid(rclsid),
2384         debugstr_guid(riid), renderopt, pFormatEtc, pClientSite, pStg, ppvObj);
2385
2386     hres = CoCreateInstance(rclsid, 0, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER, riid, (LPVOID*)&pUnk);
2387
2388     if (SUCCEEDED(hres))
2389         hres = IStorage_SetClass(pStg, rclsid);
2390
2391     if (pClientSite && SUCCEEDED(hres))
2392     {
2393         hres = IUnknown_QueryInterface(pUnk, &IID_IOleObject, (LPVOID*)&pOleObject);
2394         if (SUCCEEDED(hres))
2395         {
2396             DWORD dwStatus;
2397             hres = IOleObject_GetMiscStatus(pOleObject, DVASPECT_CONTENT, &dwStatus);
2398         }
2399     }
2400
2401     if (SUCCEEDED(hres))
2402     {
2403         IPersistStorage * pPS;
2404         if (SUCCEEDED((hres = IUnknown_QueryInterface(pUnk, &IID_IPersistStorage, (LPVOID*)&pPS))))
2405         {
2406             TRACE("trying to set stg %p\n", pStg);
2407             hres = IPersistStorage_InitNew(pPS, pStg);
2408             TRACE("-- result 0x%08x\n", hres);
2409             IPersistStorage_Release(pPS);
2410         }
2411     }
2412
2413     if (pClientSite && SUCCEEDED(hres))
2414     {
2415         TRACE("trying to set clientsite %p\n", pClientSite);
2416         hres = IOleObject_SetClientSite(pOleObject, pClientSite);
2417         TRACE("-- result 0x%08x\n", hres);
2418     }
2419
2420     if (pOleObject)
2421         IOleObject_Release(pOleObject);
2422
2423     if (((renderopt == OLERENDER_DRAW) || (renderopt == OLERENDER_FORMAT)) &&
2424         SUCCEEDED(hres))
2425     {
2426         IRunnableObject *pRunnable;
2427         IOleCache *pOleCache;
2428         HRESULT hres2;
2429
2430         hres2 = IUnknown_QueryInterface(pUnk, &IID_IRunnableObject, (void **)&pRunnable);
2431         if (SUCCEEDED(hres2))
2432         {
2433             hres = IRunnableObject_Run(pRunnable, NULL);
2434             IRunnableObject_Release(pRunnable);
2435         }
2436
2437         if (SUCCEEDED(hres))
2438         {
2439             hres2 = IUnknown_QueryInterface(pUnk, &IID_IOleCache, (void **)&pOleCache);
2440             if (SUCCEEDED(hres2))
2441             {
2442                 DWORD dwConnection;
2443                 hres = IOleCache_Cache(pOleCache, pFormatEtc, ADVF_PRIMEFIRST, &dwConnection);
2444                 IOleCache_Release(pOleCache);
2445             }
2446         }
2447     }
2448
2449     if (FAILED(hres) && pUnk)
2450     {
2451         IUnknown_Release(pUnk);
2452         pUnk = NULL;
2453     }
2454
2455     *ppvObj = pUnk;
2456
2457     TRACE("-- %p\n", pUnk);
2458     return hres;
2459 }
2460
2461 /******************************************************************************
2462  *              OleGetAutoConvert        [OLE32.@]
2463  */
2464 HRESULT WINAPI OleGetAutoConvert(REFCLSID clsidOld, LPCLSID pClsidNew)
2465 {
2466     static const WCHAR wszAutoConvertTo[] = {'A','u','t','o','C','o','n','v','e','r','t','T','o',0};
2467     HKEY hkey = NULL;
2468     WCHAR buf[CHARS_IN_GUID];
2469     LONG len;
2470     HRESULT res = S_OK;
2471
2472     res = COM_OpenKeyForCLSID(clsidOld, wszAutoConvertTo, KEY_READ, &hkey);
2473     if (FAILED(res))
2474         goto done;
2475
2476     len = sizeof(buf);
2477     if (RegQueryValueW(hkey, NULL, buf, &len))
2478     {
2479         res = REGDB_E_KEYMISSING;
2480         goto done;
2481     }
2482     res = CLSIDFromString(buf, pClsidNew);
2483 done:
2484     if (hkey) RegCloseKey(hkey);
2485     return res;
2486 }
2487
2488 /******************************************************************************
2489  *              OleSetAutoConvert        [OLE32.@]
2490  */
2491 HRESULT WINAPI OleSetAutoConvert(REFCLSID clsidOld, REFCLSID clsidNew)
2492 {
2493     static const WCHAR wszAutoConvertTo[] = {'A','u','t','o','C','o','n','v','e','r','t','T','o',0};
2494     HKEY hkey = NULL;
2495     WCHAR szClsidNew[CHARS_IN_GUID];
2496     HRESULT res = S_OK;
2497
2498     TRACE("(%s,%s)\n", debugstr_guid(clsidOld), debugstr_guid(clsidNew));
2499
2500     res = COM_OpenKeyForCLSID(clsidOld, NULL, KEY_READ | KEY_WRITE, &hkey);
2501     if (FAILED(res))
2502         goto done;
2503     StringFromGUID2(clsidNew, szClsidNew, CHARS_IN_GUID);
2504     if (RegSetValueW(hkey, wszAutoConvertTo, REG_SZ, szClsidNew, (strlenW(szClsidNew)+1) * sizeof(WCHAR)))
2505     {
2506         res = REGDB_E_WRITEREGDB;
2507         goto done;
2508     }
2509
2510 done:
2511     if (hkey) RegCloseKey(hkey);
2512     return res;
2513 }
2514
2515 /******************************************************************************
2516  *              OleDoAutoConvert        [OLE32.@]
2517  */
2518 HRESULT WINAPI OleDoAutoConvert(LPSTORAGE pStg, LPCLSID pClsidNew)
2519 {
2520     FIXME("(%p,%p) : stub\n",pStg,pClsidNew);
2521     return E_NOTIMPL;
2522 }
2523
2524 /******************************************************************************
2525  *              OleIsRunning        [OLE32.@]
2526  */
2527 BOOL WINAPI OleIsRunning(LPOLEOBJECT pObject)
2528 {
2529     IRunnableObject *pRunnable;
2530     HRESULT hr;
2531     BOOL running;
2532
2533     TRACE("(%p)\n", pObject);
2534
2535     hr = IOleObject_QueryInterface(pObject, &IID_IRunnableObject, (void **)&pRunnable);
2536     if (FAILED(hr))
2537         return TRUE;
2538     running = IRunnableObject_IsRunning(pRunnable);
2539     IRunnableObject_Release(pRunnable);
2540     return running;
2541 }
2542
2543 /***********************************************************************
2544  *           OleNoteObjectVisible                           [OLE32.@]
2545  */
2546 HRESULT WINAPI OleNoteObjectVisible(LPUNKNOWN pUnknown, BOOL bVisible)
2547 {
2548     TRACE("(%p, %s)\n", pUnknown, bVisible ? "TRUE" : "FALSE");
2549     return CoLockObjectExternal(pUnknown, bVisible, TRUE);
2550 }
2551
2552
2553 /***********************************************************************
2554  *           OLE_FreeClipDataArray   [internal]
2555  *
2556  * NOTES:
2557  *  frees the data associated with an array of CLIPDATAs
2558  */
2559 static void OLE_FreeClipDataArray(ULONG count, CLIPDATA * pClipDataArray)
2560 {
2561     ULONG i;
2562     for (i = 0; i < count; i++)
2563         if (pClipDataArray[i].pClipData)
2564             CoTaskMemFree(pClipDataArray[i].pClipData);
2565 }
2566
2567 /***********************************************************************
2568  *           PropSysAllocString                     [OLE32.@]
2569  * NOTES:
2570  *  Basically a copy of SysAllocStringLen.
2571  */
2572 BSTR WINAPI PropSysAllocString(LPCOLESTR str)
2573 {
2574     DWORD  bufferSize;
2575     DWORD* newBuffer;
2576     WCHAR* stringBuffer;
2577     int len;
2578
2579     if (!str) return 0;
2580
2581     len = lstrlenW(str);
2582     /*
2583      * Find the length of the buffer passed-in, in bytes.
2584      */
2585     bufferSize = len * sizeof (WCHAR);
2586
2587     /*
2588      * Allocate a new buffer to hold the string.
2589      * Don't forget to keep an empty spot at the beginning of the
2590      * buffer for the character count and an extra character at the
2591      * end for the NULL.
2592      */
2593     newBuffer = HeapAlloc(GetProcessHeap(), 0,
2594                           bufferSize + sizeof(WCHAR) + sizeof(DWORD));
2595
2596     /*
2597      * If the memory allocation failed, return a null pointer.
2598      */
2599     if (newBuffer==0)
2600       return 0;
2601
2602     /*
2603      * Copy the length of the string in the placeholder.
2604      */
2605     *newBuffer = bufferSize;
2606
2607     /*
2608      * Skip the byte count.
2609      */
2610     newBuffer++;
2611
2612     memcpy(newBuffer, str, bufferSize);
2613
2614     /*
2615      * Make sure that there is a nul character at the end of the
2616      * string.
2617      */
2618     stringBuffer = (WCHAR*)newBuffer;
2619     stringBuffer[len] = '\0';
2620
2621     return stringBuffer;
2622 }
2623
2624 /***********************************************************************
2625  *           PropSysFreeString                      [OLE32.@]
2626  * NOTES
2627  *  Copy of SysFreeString.
2628  */
2629 void WINAPI PropSysFreeString(LPOLESTR str)
2630 {
2631     DWORD* bufferPointer;
2632
2633     /* NULL is a valid parameter */
2634     if(!str) return;
2635
2636     /*
2637      * We have to be careful when we free a BSTR pointer, it points to
2638      * the beginning of the string but it skips the byte count contained
2639      * before the string.
2640      */
2641     bufferPointer = (DWORD*)str;
2642
2643     bufferPointer--;
2644
2645     /*
2646      * Free the memory from its "real" origin.
2647      */
2648     HeapFree(GetProcessHeap(), 0, bufferPointer);
2649 }
2650
2651 /******************************************************************************
2652  * Check if a PROPVARIANT's type is valid.
2653  */
2654 static inline HRESULT PROPVARIANT_ValidateType(VARTYPE vt)
2655 {
2656     switch (vt)
2657     {
2658     case VT_EMPTY:
2659     case VT_NULL:
2660     case VT_I2:
2661     case VT_I4:
2662     case VT_R4:
2663     case VT_R8:
2664     case VT_CY:
2665     case VT_DATE:
2666     case VT_BSTR:
2667     case VT_ERROR:
2668     case VT_BOOL:
2669     case VT_DECIMAL:
2670     case VT_UI1:
2671     case VT_UI2:
2672     case VT_UI4:
2673     case VT_I8:
2674     case VT_UI8:
2675     case VT_LPSTR:
2676     case VT_LPWSTR:
2677     case VT_FILETIME:
2678     case VT_BLOB:
2679     case VT_STREAM:
2680     case VT_STORAGE:
2681     case VT_STREAMED_OBJECT:
2682     case VT_STORED_OBJECT:
2683     case VT_BLOB_OBJECT:
2684     case VT_CF:
2685     case VT_CLSID:
2686     case VT_I2|VT_VECTOR:
2687     case VT_I4|VT_VECTOR:
2688     case VT_R4|VT_VECTOR:
2689     case VT_R8|VT_VECTOR:
2690     case VT_CY|VT_VECTOR:
2691     case VT_DATE|VT_VECTOR:
2692     case VT_BSTR|VT_VECTOR:
2693     case VT_ERROR|VT_VECTOR:
2694     case VT_BOOL|VT_VECTOR:
2695     case VT_VARIANT|VT_VECTOR:
2696     case VT_UI1|VT_VECTOR:
2697     case VT_UI2|VT_VECTOR:
2698     case VT_UI4|VT_VECTOR:
2699     case VT_I8|VT_VECTOR:
2700     case VT_UI8|VT_VECTOR:
2701     case VT_LPSTR|VT_VECTOR:
2702     case VT_LPWSTR|VT_VECTOR:
2703     case VT_FILETIME|VT_VECTOR:
2704     case VT_CF|VT_VECTOR:
2705     case VT_CLSID|VT_VECTOR:
2706         return S_OK;
2707     }
2708     WARN("Bad type %d\n", vt);
2709     return STG_E_INVALIDPARAMETER;
2710 }
2711
2712 /***********************************************************************
2713  *           PropVariantClear                       [OLE32.@]
2714  */
2715 HRESULT WINAPI PropVariantClear(PROPVARIANT * pvar) /* [in/out] */
2716 {
2717     HRESULT hr;
2718
2719     TRACE("(%p)\n", pvar);
2720
2721     if (!pvar)
2722         return S_OK;
2723
2724     hr = PROPVARIANT_ValidateType(pvar->vt);
2725     if (FAILED(hr))
2726         return hr;
2727
2728     switch(pvar->vt)
2729     {
2730     case VT_EMPTY:
2731     case VT_NULL:
2732     case VT_I2:
2733     case VT_I4:
2734     case VT_R4:
2735     case VT_R8:
2736     case VT_CY:
2737     case VT_DATE:
2738     case VT_ERROR:
2739     case VT_BOOL:
2740     case VT_DECIMAL:
2741     case VT_UI1:
2742     case VT_UI2:
2743     case VT_UI4:
2744     case VT_I8:
2745     case VT_UI8:
2746     case VT_FILETIME:
2747         break;
2748     case VT_STREAM:
2749     case VT_STREAMED_OBJECT:
2750     case VT_STORAGE:
2751     case VT_STORED_OBJECT:
2752         if (pvar->u.pStream)
2753             IUnknown_Release(pvar->u.pStream);
2754         break;
2755     case VT_CLSID:
2756     case VT_LPSTR:
2757     case VT_LPWSTR:
2758         /* pick an arbitrary typed pointer - we don't care about the type
2759          * as we are just freeing it */
2760         CoTaskMemFree(pvar->u.puuid);
2761         break;
2762     case VT_BLOB:
2763     case VT_BLOB_OBJECT:
2764         CoTaskMemFree(pvar->u.blob.pBlobData);
2765         break;
2766     case VT_BSTR:
2767         if (pvar->u.bstrVal)
2768             PropSysFreeString(pvar->u.bstrVal);
2769         break;
2770     case VT_CF:
2771         if (pvar->u.pclipdata)
2772         {
2773             OLE_FreeClipDataArray(1, pvar->u.pclipdata);
2774             CoTaskMemFree(pvar->u.pclipdata);
2775         }
2776         break;
2777     default:
2778         if (pvar->vt & VT_VECTOR)
2779         {
2780             ULONG i;
2781
2782             switch (pvar->vt & ~VT_VECTOR)
2783             {
2784             case VT_VARIANT:
2785                 FreePropVariantArray(pvar->u.capropvar.cElems, pvar->u.capropvar.pElems);
2786                 break;
2787             case VT_CF:
2788                 OLE_FreeClipDataArray(pvar->u.caclipdata.cElems, pvar->u.caclipdata.pElems);
2789                 break;
2790             case VT_BSTR:
2791                 for (i = 0; i < pvar->u.cabstr.cElems; i++)
2792                     PropSysFreeString(pvar->u.cabstr.pElems[i]);
2793                 break;
2794             case VT_LPSTR:
2795                 for (i = 0; i < pvar->u.calpstr.cElems; i++)
2796                     CoTaskMemFree(pvar->u.calpstr.pElems[i]);
2797                 break;
2798             case VT_LPWSTR:
2799                 for (i = 0; i < pvar->u.calpwstr.cElems; i++)
2800                     CoTaskMemFree(pvar->u.calpwstr.pElems[i]);
2801                 break;
2802             }
2803             if (pvar->vt & ~VT_VECTOR)
2804             {
2805                 /* pick an arbitrary VT_VECTOR structure - they all have the same
2806                  * memory layout */
2807                 CoTaskMemFree(pvar->u.capropvar.pElems);
2808             }
2809         }
2810         else
2811             WARN("Invalid/unsupported type %d\n", pvar->vt);
2812     }
2813
2814     ZeroMemory(pvar, sizeof(*pvar));
2815
2816     return S_OK;
2817 }
2818
2819 /***********************************************************************
2820  *           PropVariantCopy                        [OLE32.@]
2821  */
2822 HRESULT WINAPI PropVariantCopy(PROPVARIANT *pvarDest,      /* [out] */
2823                                const PROPVARIANT *pvarSrc) /* [in] */
2824 {
2825     ULONG len;
2826     HRESULT hr;
2827
2828     TRACE("(%p, %p vt %04x)\n", pvarDest, pvarSrc, pvarSrc->vt);
2829
2830     hr = PROPVARIANT_ValidateType(pvarSrc->vt);
2831     if (FAILED(hr))
2832         return hr;
2833
2834     /* this will deal with most cases */
2835     *pvarDest = *pvarSrc;
2836
2837     switch(pvarSrc->vt)
2838     {
2839     case VT_EMPTY:
2840     case VT_NULL:
2841     case VT_I1:
2842     case VT_UI1:
2843     case VT_I2:
2844     case VT_UI2:
2845     case VT_BOOL:
2846     case VT_DECIMAL:
2847     case VT_I4:
2848     case VT_UI4:
2849     case VT_R4:
2850     case VT_ERROR:
2851     case VT_I8:
2852     case VT_UI8:
2853     case VT_R8:
2854     case VT_CY:
2855     case VT_DATE:
2856     case VT_FILETIME:
2857         break;
2858     case VT_STREAM:
2859     case VT_STREAMED_OBJECT:
2860     case VT_STORAGE:
2861     case VT_STORED_OBJECT:
2862         IUnknown_AddRef((LPUNKNOWN)pvarDest->u.pStream);
2863         break;
2864     case VT_CLSID:
2865         pvarDest->u.puuid = CoTaskMemAlloc(sizeof(CLSID));
2866         *pvarDest->u.puuid = *pvarSrc->u.puuid;
2867         break;
2868     case VT_LPSTR:
2869         len = strlen(pvarSrc->u.pszVal);
2870         pvarDest->u.pszVal = CoTaskMemAlloc((len+1)*sizeof(CHAR));
2871         CopyMemory(pvarDest->u.pszVal, pvarSrc->u.pszVal, (len+1)*sizeof(CHAR));
2872         break;
2873     case VT_LPWSTR:
2874         len = lstrlenW(pvarSrc->u.pwszVal);
2875         pvarDest->u.pwszVal = CoTaskMemAlloc((len+1)*sizeof(WCHAR));
2876         CopyMemory(pvarDest->u.pwszVal, pvarSrc->u.pwszVal, (len+1)*sizeof(WCHAR));
2877         break;
2878     case VT_BLOB:
2879     case VT_BLOB_OBJECT:
2880         if (pvarSrc->u.blob.pBlobData)
2881         {
2882             len = pvarSrc->u.blob.cbSize;
2883             pvarDest->u.blob.pBlobData = CoTaskMemAlloc(len);
2884             CopyMemory(pvarDest->u.blob.pBlobData, pvarSrc->u.blob.pBlobData, len);
2885         }
2886         break;
2887     case VT_BSTR:
2888         pvarDest->u.bstrVal = PropSysAllocString(pvarSrc->u.bstrVal);
2889         break;
2890     case VT_CF:
2891         if (pvarSrc->u.pclipdata)
2892         {
2893             len = pvarSrc->u.pclipdata->cbSize - sizeof(pvarSrc->u.pclipdata->ulClipFmt);
2894             pvarDest->u.pclipdata = CoTaskMemAlloc(sizeof (CLIPDATA));
2895             pvarDest->u.pclipdata->cbSize = pvarSrc->u.pclipdata->cbSize;
2896             pvarDest->u.pclipdata->ulClipFmt = pvarSrc->u.pclipdata->ulClipFmt;
2897             pvarDest->u.pclipdata->pClipData = CoTaskMemAlloc(len);
2898             CopyMemory(pvarDest->u.pclipdata->pClipData, pvarSrc->u.pclipdata->pClipData, len);
2899         }
2900         break;
2901     default:
2902         if (pvarSrc->vt & VT_VECTOR)
2903         {
2904             int elemSize;
2905             ULONG i;
2906
2907             switch(pvarSrc->vt & ~VT_VECTOR)
2908             {
2909             case VT_I1:       elemSize = sizeof(pvarSrc->u.cVal); break;
2910             case VT_UI1:      elemSize = sizeof(pvarSrc->u.bVal); break;
2911             case VT_I2:       elemSize = sizeof(pvarSrc->u.iVal); break;
2912             case VT_UI2:      elemSize = sizeof(pvarSrc->u.uiVal); break;
2913             case VT_BOOL:     elemSize = sizeof(pvarSrc->u.boolVal); break;
2914             case VT_I4:       elemSize = sizeof(pvarSrc->u.lVal); break;
2915             case VT_UI4:      elemSize = sizeof(pvarSrc->u.ulVal); break;
2916             case VT_R4:       elemSize = sizeof(pvarSrc->u.fltVal); break;
2917             case VT_R8:       elemSize = sizeof(pvarSrc->u.dblVal); break;
2918             case VT_ERROR:    elemSize = sizeof(pvarSrc->u.scode); break;
2919             case VT_I8:       elemSize = sizeof(pvarSrc->u.hVal); break;
2920             case VT_UI8:      elemSize = sizeof(pvarSrc->u.uhVal); break;
2921             case VT_CY:       elemSize = sizeof(pvarSrc->u.cyVal); break;
2922             case VT_DATE:     elemSize = sizeof(pvarSrc->u.date); break;
2923             case VT_FILETIME: elemSize = sizeof(pvarSrc->u.filetime); break;
2924             case VT_CLSID:    elemSize = sizeof(*pvarSrc->u.puuid); break;
2925             case VT_CF:       elemSize = sizeof(*pvarSrc->u.pclipdata); break;
2926             case VT_BSTR:     elemSize = sizeof(pvarSrc->u.bstrVal); break;
2927             case VT_LPSTR:    elemSize = sizeof(pvarSrc->u.pszVal); break;
2928             case VT_LPWSTR:   elemSize = sizeof(pvarSrc->u.pwszVal); break;
2929             case VT_VARIANT:  elemSize = sizeof(*pvarSrc->u.pvarVal); break;
2930
2931             default:
2932                 FIXME("Invalid element type: %ul\n", pvarSrc->vt & ~VT_VECTOR);
2933                 return E_INVALIDARG;
2934             }
2935             len = pvarSrc->u.capropvar.cElems;
2936             pvarDest->u.capropvar.pElems = CoTaskMemAlloc(len * elemSize);
2937             if (pvarSrc->vt == (VT_VECTOR | VT_VARIANT))
2938             {
2939                 for (i = 0; i < len; i++)
2940                     PropVariantCopy(&pvarDest->u.capropvar.pElems[i], &pvarSrc->u.capropvar.pElems[i]);
2941             }
2942             else if (pvarSrc->vt == (VT_VECTOR | VT_CF))
2943             {
2944                 FIXME("Copy clipformats\n");
2945             }
2946             else if (pvarSrc->vt == (VT_VECTOR | VT_BSTR))
2947             {
2948                 for (i = 0; i < len; i++)
2949                     pvarDest->u.cabstr.pElems[i] = PropSysAllocString(pvarSrc->u.cabstr.pElems[i]);
2950             }
2951             else if (pvarSrc->vt == (VT_VECTOR | VT_LPSTR))
2952             {
2953                 size_t strLen;
2954                 for (i = 0; i < len; i++)
2955                 {
2956                     strLen = lstrlenA(pvarSrc->u.calpstr.pElems[i]) + 1;
2957                     pvarDest->u.calpstr.pElems[i] = CoTaskMemAlloc(strLen);
2958                     memcpy(pvarDest->u.calpstr.pElems[i],
2959                      pvarSrc->u.calpstr.pElems[i], strLen);
2960                 }
2961             }
2962             else if (pvarSrc->vt == (VT_VECTOR | VT_LPWSTR))
2963             {
2964                 size_t strLen;
2965                 for (i = 0; i < len; i++)
2966                 {
2967                     strLen = (lstrlenW(pvarSrc->u.calpwstr.pElems[i]) + 1) *
2968                      sizeof(WCHAR);
2969                     pvarDest->u.calpstr.pElems[i] = CoTaskMemAlloc(strLen);
2970                     memcpy(pvarDest->u.calpstr.pElems[i],
2971                      pvarSrc->u.calpstr.pElems[i], strLen);
2972                 }
2973             }
2974             else
2975                 CopyMemory(pvarDest->u.capropvar.pElems, pvarSrc->u.capropvar.pElems, len * elemSize);
2976         }
2977         else
2978             WARN("Invalid/unsupported type %d\n", pvarSrc->vt);
2979     }
2980
2981     return S_OK;
2982 }
2983
2984 /***********************************************************************
2985  *           FreePropVariantArray                           [OLE32.@]
2986  */
2987 HRESULT WINAPI FreePropVariantArray(ULONG cVariants, /* [in] */
2988                                     PROPVARIANT *rgvars)    /* [in/out] */
2989 {
2990     ULONG i;
2991
2992     TRACE("(%u, %p)\n", cVariants, rgvars);
2993
2994     if (!rgvars)
2995         return E_INVALIDARG;
2996
2997     for(i = 0; i < cVariants; i++)
2998         PropVariantClear(&rgvars[i]);
2999
3000     return S_OK;
3001 }
3002
3003 /******************************************************************************
3004  * DllDebugObjectRPCHook (OLE32.@)
3005  * turns on and off internal debugging,  pointer is only used on macintosh
3006  */
3007
3008 BOOL WINAPI DllDebugObjectRPCHook(BOOL b, void *dummy)
3009 {
3010   FIXME("stub\n");
3011   return TRUE;
3012 }