dlls/ole32/ole2stubs.c

   1 /*
   2  * Temporary place for ole2 stubs.
   3  *
   4  * Copyright (C) 1999 Corel Corporation
   5  * Move these functions to dlls/ole32/ole2impl.c when you implement them.
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 #define NONAMELESSUNION
  23 #define NONAMELESSSTRUCT
  24 #include <stdarg.h>
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winuser.h"
  29 #include "ole2.h"
  30 #include "objidl.h"
  31 #include "wine/debug.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  34
  35 /******************************************************************************
  36  *               OleCreateLinkToFile        [OLE32.96]
  37  */
  38 HRESULT WINAPI  OleCreateLinkToFile(LPCOLESTR lpszFileName, REFIID riid,
  39                         DWORD renderopt, LPFORMATETC lpFormatEtc,
  40                         LPOLECLIENTSITE pClientSite, LPSTORAGE pStg, LPVOID* ppvObj)
  41 {
  42     FIXME("(%p,%p,%li,%p,%p,%p,%p), stub!\n",lpszFileName, riid, renderopt, lpFormatEtc, pClientSite, pStg, ppvObj);
  43     return E_NOTIMPL;
  44 }
  45
  46
  47 /******************************************************************************
  48  *              OleDuplicateData        [OLE32.102]
  49  */
  50 HRESULT WINAPI OleDuplicateData(HANDLE hSrc, CLIPFORMAT cfFormat,
  51                                   UINT uiFlags)
  52 {
  53     FIXME("(%p,%x,%x), stub!\n", hSrc, cfFormat, uiFlags);
  54     return E_NOTIMPL;
  55 }
  56
  57
  58 /***********************************************************************
  59  *             OleTranslateAccelerator [OLE32.130]
  60  */
  61 HRESULT WINAPI OleTranslateAccelerator (LPOLEINPLACEFRAME lpFrame,
  62                    LPOLEINPLACEFRAMEINFO lpFrameInfo, LPMSG lpmsg)
  63 {
  64     FIXME("(%p,%p,%p),stub!\n", lpFrame, lpFrameInfo, lpmsg);
  65     return S_OK;
  66 }
  67
  68 /******************************************************************************
  69  *              SetConvertStg        [OLE32.142]
  70  */
  71 HRESULT WINAPI SetConvertStg(LPSTORAGE pStg, BOOL fConvert)
  72 {
  73   FIXME("(%p,%x), stub!\n", pStg, fConvert);
  74   return E_NOTIMPL;
  75 }
  76
  77 /******************************************************************************
  78  *              OleCreate        [OLE32.89]
  79  *
  80  */
  81 HRESULT WINAPI OleCreate(
  82         REFCLSID rclsid,
  83         REFIID riid,
  84         DWORD renderopt,
  85         LPFORMATETC pFormatEtc,
  86         LPOLECLIENTSITE pClientSite,
  87         LPSTORAGE pStg,
  88         LPVOID* ppvObj)
  89 {
  90   HRESULT hres, hres1;
  91   IUnknown * pUnk = NULL;
  92
  93   FIXME("\n\t%s\n\t%s stub!\n", debugstr_guid(rclsid), debugstr_guid(riid));
  94
  95   if (SUCCEEDED((hres = CoCreateInstance(rclsid, 0, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER|CLSCTX_LOCAL_SERVER , riid, (LPVOID*)&pUnk))))
  96   {
  97     if (pClientSite)
  98     {
  99       IOleObject * pOE;
 100       IPersistStorage * pPS;
 101       if (SUCCEEDED((hres = IUnknown_QueryInterface( pUnk, &IID_IOleObject, (LPVOID*)&pOE))))
 102       {
 103         TRACE("trying to set clientsite %p\n", pClientSite);
 104         hres1 = IOleObject_SetClientSite(pOE, pClientSite);
 105         TRACE("-- result 0x%08lx\n", hres1);
 106         IOleObject_Release(pOE);
 107       }
 108       if (SUCCEEDED((hres = IUnknown_QueryInterface( pUnk, &IID_IPersistStorage, (LPVOID*)&pPS))))
 109       {
 110         TRACE("trying to set stg %p\n", pStg);
 111         hres1 = IPersistStorage_InitNew(pPS, pStg);
 112         TRACE("-- result 0x%08lx\n", hres1);
 113         IPersistStorage_Release(pPS);
 114       }
 115     }
 116   }
 117
 118   *ppvObj = pUnk;
 119
 120   TRACE("-- %p \n", pUnk);
 121   return hres;
 122 }
 123
 124 /******************************************************************************
 125  *              OleCreateLink        [OLE32.94]
 126  */
 127 HRESULT WINAPI OleCreateLink(LPMONIKER pmkLinkSrc, REFIID riid, DWORD renderopt, LPFORMATETC lpFormatEtc,
 128                 LPOLECLIENTSITE pClientSite, LPSTORAGE pStg, LPVOID* ppvObj)
 129 {
 130   FIXME("(not shown), stub!\n");
 131   return E_NOTIMPL;
 132 }
 133
 134 /******************************************************************************
 135  *              OleCreateFromFile        [OLE32.93]
 136  */
 137 HRESULT WINAPI OleCreateFromFile(REFCLSID rclsid, LPCOLESTR lpszFileName, REFIID riid,
 138             DWORD renderopt, LPFORMATETC lpFormatEtc, LPOLECLIENTSITE pClientSite, LPSTORAGE pStg, LPVOID* ppvObj)
 139 {
 140   FIXME("(not shown), stub!\n");
 141   return E_NOTIMPL;
 142 }
 143
 144
 145 /******************************************************************************
 146  *              OleGetIconOfClass        [OLE32.106]
 147  */
 148 HGLOBAL WINAPI OleGetIconOfClass(REFCLSID rclsid, LPOLESTR lpszLabel, BOOL fUseTypeAsLabel)
 149 {
 150   FIXME("(%p,%p,%x), stub!\n", rclsid, lpszLabel, fUseTypeAsLabel);
 151   return NULL;
 152 }
 153
 154
 155 /******************************************************************************
 156  *              OleCreateStaticFromData        [OLE32.98]
 157  */
 158 HRESULT     WINAPI OleCreateStaticFromData(LPDATAOBJECT pSrcDataObj, REFIID iid,
 159                 DWORD renderopt, LPFORMATETC pFormatEtc, LPOLECLIENTSITE pClientSite,
 160                 LPSTORAGE pStg, LPVOID* ppvObj)
 161 {
 162   FIXME("(not shown), stub!\n");
 163   return E_NOTIMPL;
 164 }
 165
 166 /******************************************************************************
 167  *              OleCreateLinkFromData        [OLE32.95]
 168  */
 169
 170 HRESULT WINAPI  OleCreateLinkFromData(LPDATAOBJECT pSrcDataObj, REFIID riid,
 171                 DWORD renderopt, LPFORMATETC pFormatEtc,
 172                 LPOLECLIENTSITE pClientSite, LPSTORAGE pStg,
 173                 LPVOID* ppvObj)
 174 {
 175   FIXME("(not shown), stub!\n");
 176   return E_NOTIMPL;
 177 }
 178
 179 /******************************************************************************
 180  *              OleIsRunning        [OLE32.111]
 181  */
 182 BOOL WINAPI OleIsRunning(LPOLEOBJECT pObject)
 183 {
 184   FIXME("(%p), stub!\n", pObject);
 185   return TRUE;
 186 }
 187
 188 /***********************************************************************
 189  *           OleRegEnumVerbs    [OLE32.120]
 190  */
 191 HRESULT WINAPI OleRegEnumVerbs (REFCLSID clsid, LPENUMOLEVERB* ppenum)
 192 {
 193     FIXME("(%p,%p), stub!\n", clsid, ppenum);
 194     return OLEOBJ_E_NOVERBS;
 195 }
 196
 197 /***********************************************************************
 198  *           OleRegEnumFormatEtc    [OLE32.119]
 199  */
 200 HRESULT     WINAPI OleRegEnumFormatEtc (
 201   REFCLSID clsid,
 202   DWORD    dwDirection,
 203   LPENUMFORMATETC* ppenumFormatetc)
 204 {
 205     FIXME("(%p, %ld, %p), stub!\n", clsid, dwDirection, ppenumFormatetc);
 206
 207     return E_NOTIMPL;
 208 }
 209
 210 /***********************************************************************
 211  *           OLE_FreeClipDataArray   [internal]
 212  *
 213  * NOTES:
 214  *  frees the data associated with an array of CLIPDATAs
 215  */
 216 static void OLE_FreeClipDataArray(ULONG count, CLIPDATA * pClipDataArray)
 217 {
 218     ULONG i;
 219     for (i = 0; i < count; i++)
 220     {
 221         if (pClipDataArray[i].pClipData)
 222         {
 223             CoTaskMemFree(pClipDataArray[i].pClipData);
 224         }
 225     }
 226 }
 227
 228 HRESULT WINAPI FreePropVariantArray(ULONG,PROPVARIANT*);
 229
 230 /***********************************************************************
 231  *           PropVariantClear                       [OLE32.166]
 232  */
 233 HRESULT WINAPI PropVariantClear(PROPVARIANT * pvar) /* [in/out] */
 234 {
 235         TRACE("(%p)\n", pvar);
 236
 237         if (!pvar)
 238             return S_OK;
 239
 240         switch(pvar->vt)
 241         {
 242             case VT_STREAM:
 243             case VT_STREAMED_OBJECT:
 244             case VT_STORAGE:
 245             case VT_STORED_OBJECT:
 246                 IUnknown_Release((LPUNKNOWN)pvar->u.pStream);
 247                 break;
 248             case VT_CLSID:
 249             case VT_LPSTR:
 250             case VT_LPWSTR:
 251                 CoTaskMemFree(pvar->u.puuid); /* pick an arbitary typed pointer - we don't care about the type as we are just freeing it */
 252                 break;
 253             case VT_BLOB:
 254             case VT_BLOB_OBJECT:
 255                 CoTaskMemFree(pvar->u.blob.pBlobData);
 256                 break;
 257             case VT_BSTR:
 258                 FIXME("Need to load OLEAUT32 for SysFreeString\n");
 259                 /* SysFreeString(pvar->u.bstrVal); */
 260                 break;
 261             case VT_CF:
 262                 if (pvar->u.pclipdata)
 263                 {
 264                         OLE_FreeClipDataArray(1, pvar->u.pclipdata);
 265                         CoTaskMemFree(pvar->u.pclipdata);
 266                 }
 267                 break;
 268             default:
 269                 if (pvar->vt & VT_ARRAY)
 270                 {
 271                     FIXME("Need to call SafeArrayDestroy\n");
 272 /*                  SafeArrayDestroy(pvar->u.caub); */
 273                 }
 274                 switch (pvar->vt & VT_VECTOR)
 275                 {
 276                 case VT_VARIANT:
 277                         FreePropVariantArray(pvar->u.capropvar.cElems, pvar->u.capropvar.pElems);
 278                         break;
 279                 case VT_CF:
 280                         OLE_FreeClipDataArray(pvar->u.caclipdata.cElems, pvar->u.caclipdata.pElems);
 281                         break;
 282                 case VT_BSTR:
 283                 case VT_LPSTR:
 284                 case VT_LPWSTR:
 285                         FIXME("Freeing of vector sub-type not supported yet\n");
 286                 }
 287                 if (pvar->vt & VT_VECTOR)
 288                 {
 289                         CoTaskMemFree(pvar->u.capropvar.pElems); /* pick an arbitary VT_VECTOR structure - they all have the same memory layout */
 290                 }
 291         }
 292
 293         ZeroMemory(pvar, sizeof(*pvar));
 294
 295         return S_OK;
 296 }
 297
 298 /***********************************************************************
 299  *           PropVariantCopy                        [OLE32.246]
 300  */
 301 HRESULT WINAPI PropVariantCopy(PROPVARIANT *pvarDest,      /* [out] FIXME: PROPVARIANT * */
 302                                const PROPVARIANT *pvarSrc) /* [in] FIXME: const PROPVARIANT * */
 303 {
 304         ULONG len;
 305         TRACE("(%p, %p): stub:\n", pvarDest, pvarSrc);
 306
 307         /* this will deal with most cases */
 308         CopyMemory(pvarDest, pvarSrc, sizeof(*pvarDest));
 309
 310         switch(pvarSrc->vt)
 311         {
 312         case VT_STREAM:
 313         case VT_STREAMED_OBJECT:
 314         case VT_STORAGE:
 315         case VT_STORED_OBJECT:
 316                 IUnknown_AddRef((LPUNKNOWN)pvarDest->u.pStream);
 317                 break;
 318         case VT_CLSID:
 319                 pvarDest->u.puuid = CoTaskMemAlloc(sizeof(CLSID));
 320                 CopyMemory(pvarDest->u.puuid, pvarSrc->u.puuid, sizeof(CLSID));
 321                 break;
 322         case VT_LPSTR:
 323                 len = strlen(pvarSrc->u.pszVal);
 324                 pvarDest->u.pszVal = CoTaskMemAlloc(len);
 325                 CopyMemory(pvarDest->u.pszVal, pvarSrc->u.pszVal, len);
 326                 break;
 327         case VT_LPWSTR:
 328                 len = lstrlenW(pvarSrc->u.pwszVal);
 329                 pvarDest->u.pwszVal = CoTaskMemAlloc(len);
 330                 CopyMemory(pvarDest->u.pwszVal, pvarSrc->u.pwszVal, len);
 331                 break;
 332         case VT_BLOB:
 333         case VT_BLOB_OBJECT:
 334                 if (pvarSrc->u.blob.pBlobData)
 335                 {
 336                         len = pvarSrc->u.blob.cbSize;
 337                         pvarDest->u.blob.pBlobData = CoTaskMemAlloc(len);
 338                         CopyMemory(pvarDest->u.blob.pBlobData, pvarSrc->u.blob.pBlobData, len);
 339                 }
 340                 break;
 341         case VT_BSTR:
 342                 FIXME("Need to copy BSTR\n");
 343                 break;
 344         case VT_CF:
 345                 if (pvarSrc->u.pclipdata)
 346                 {
 347                         len = pvarSrc->u.pclipdata->cbSize - sizeof(pvarSrc->u.pclipdata->ulClipFmt);
 348                         CoTaskMemAlloc(len);
 349                         CopyMemory(pvarDest->u.pclipdata->pClipData, pvarSrc->u.pclipdata->pClipData, len);
 350                 }
 351                 break;
 352         default:
 353                 if (pvarSrc->vt & VT_ARRAY)
 354                 {
 355                     FIXME("Need to call SafeArrayCopy\n");
 356 /*                  SafeArrayCopy(...); */
 357                 }
 358                 if (pvarSrc->vt & VT_VECTOR)
 359                 {
 360                         int elemSize;
 361                         switch(pvarSrc->vt & VT_VECTOR)
 362                         {
 363                         case VT_I1:
 364                                 elemSize = sizeof(pvarSrc->u.cVal);
 365                                 break;
 366                         case VT_UI1:
 367                                 elemSize = sizeof(pvarSrc->u.bVal);
 368                                 break;
 369                         case VT_I2:
 370                                 elemSize = sizeof(pvarSrc->u.iVal);
 371                                 break;
 372                         case VT_UI2:
 373                                 elemSize = sizeof(pvarSrc->u.uiVal);
 374                                 break;
 375                         case VT_BOOL:
 376                                 elemSize = sizeof(pvarSrc->u.boolVal);
 377                                 break;
 378                         case VT_I4:
 379                                 elemSize = sizeof(pvarSrc->u.lVal);
 380                                 break;
 381                         case VT_UI4:
 382                                 elemSize = sizeof(pvarSrc->u.ulVal);
 383                                 break;
 384                         case VT_R4:
 385                                 elemSize = sizeof(pvarSrc->u.fltVal);
 386                                 break;
 387                         case VT_R8:
 388                                 elemSize = sizeof(pvarSrc->u.dblVal);
 389                                 break;
 390                         case VT_ERROR:
 391                                 elemSize = sizeof(pvarSrc->u.scode);
 392                                 break;
 393                         case VT_I8:
 394                                 elemSize = sizeof(pvarSrc->u.hVal);
 395                                 break;
 396                         case VT_UI8:
 397                                 elemSize = sizeof(pvarSrc->u.uhVal);
 398                                 break;
 399                         case VT_CY:
 400                                 elemSize = sizeof(pvarSrc->u.cyVal);
 401                                 break;
 402                         case VT_DATE:
 403                                 elemSize = sizeof(pvarSrc->u.date);
 404                                 break;
 405                         case VT_FILETIME:
 406                                 elemSize = sizeof(pvarSrc->u.filetime);
 407                                 break;
 408                         case VT_CLSID:
 409                                 elemSize = sizeof(*pvarSrc->u.puuid);
 410                                 break;
 411                         case VT_CF:
 412                                 elemSize = sizeof(*pvarSrc->u.pclipdata);
 413                                 break;
 414                         case VT_BSTR:
 415                         case VT_LPSTR:
 416                         case VT_LPWSTR:
 417                         case VT_VARIANT:
 418                         default:
 419                                 FIXME("Invalid element type: %ul\n", pvarSrc->vt & VT_VECTOR);
 420                                 return E_INVALIDARG;
 421                         }
 422                         len = pvarSrc->u.capropvar.cElems;
 423                         pvarDest->u.capropvar.pElems = CoTaskMemAlloc(len * elemSize);
 424                         if (pvarSrc->vt == (VT_VECTOR | VT_VARIANT))
 425                         {
 426                                 ULONG i;
 427                                 for (i = 0; i < len; i++)
 428                                         PropVariantCopy(&pvarDest->u.capropvar.pElems[i], &pvarSrc->u.capropvar.pElems[i]);
 429                         }
 430                         else if (pvarSrc->vt == (VT_VECTOR | VT_CF))
 431                         {
 432                                 FIXME("Copy clipformats\n");
 433                         }
 434                         else if (pvarSrc->vt == (VT_VECTOR | VT_BSTR))
 435                         {
 436                                 FIXME("Copy BSTRs\n");
 437                         }
 438                         else if (pvarSrc->vt == (VT_VECTOR | VT_LPSTR))
 439                         {
 440                                 FIXME("Copy LPSTRs\n");
 441                         }
 442                         else if (pvarSrc->vt == (VT_VECTOR | VT_LPSTR))
 443                         {
 444                                 FIXME("Copy LPWSTRs\n");
 445                         }
 446                         else
 447                                 CopyMemory(pvarDest->u.capropvar.pElems, pvarSrc->u.capropvar.pElems, len * elemSize);
 448                 }
 449         }
 450
 451         return S_OK;
 452 }
 453
 454 /***********************************************************************
 455  *           FreePropVariantArray                           [OLE32.195]
 456  */
 457 HRESULT WINAPI FreePropVariantArray(ULONG cVariants, /* [in] */
 458                                     PROPVARIANT *rgvars)    /* [in/out] */
 459 {
 460         ULONG i;
 461
 462         TRACE("(%lu, %p)\n", cVariants, rgvars);
 463
 464         for(i = 0; i < cVariants; i++)
 465                 PropVariantClear(&rgvars[i]);
 466
 467         return S_OK;
 468 }
 469
 470 /***********************************************************************
 471  *           CoIsOle1Class                              [OLE32.29]
 472  */
 473 BOOL WINAPI CoIsOle1Class(REFCLSID clsid)
 474 {
 475   FIXME("%s\n", debugstr_guid(clsid));
 476   return FALSE;
 477 }
 478
 479 /***********************************************************************
 480  *           DllGetClassObject                          [OLE2.4]
 481  */
 482 HRESULT WINAPI DllGetClassObject16(REFCLSID rclsid, REFIID iid, LPVOID *ppv)
 483 {
 484   FIXME("(%s, %s, %p): stub\n", debugstr_guid(rclsid), debugstr_guid(iid), ppv);
 485   return E_NOTIMPL;
 486 }
 487
 488 /***********************************************************************
 489  *           OleSetClipboard                            [OLE2.49]
 490  */
 491 HRESULT WINAPI OleSetClipboard16(IDataObject* pDataObj)
 492 {
 493   FIXME("(%p): stub\n", pDataObj);
 494   return S_OK;
 495 }
 496
 497 /***********************************************************************
 498  *           OleGetClipboard                            [OLE2.50]
 499  */
 500 HRESULT WINAPI OleGetClipboard16(IDataObject** ppDataObj)
 501 {
 502   FIXME("(%p): stub\n", ppDataObj);
 503   return E_NOTIMPL;
 504 }