dlls/ole32/antimoniker.c

   1 /***************************************************************************************
   2  *                            AntiMonikers implementation
   3  *
   4  *               Copyright 1999  Noomen Hamza
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  ***************************************************************************************/
  20
  21 #include <assert.h>
  22 #include <stdarg.h>
  23 #include <string.h>
  24
  25 #define NONAMELESSUNION
  26 #define NONAMELESSSTRUCT
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "winerror.h"
  30 #include "wine/unicode.h"
  31 #include "objbase.h"
  32 #include "wine/debug.h"
  33 #include "moniker.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  36
  37 const CLSID CLSID_AntiMoniker = {
  38   0x305, 0, 0, {0xC0, 0, 0, 0, 0, 0, 0, 0x46}
  39 };
  40
  41 /* AntiMoniker data structure */
  42 typedef struct AntiMonikerImpl{
  43
  44     ICOM_VTABLE(IMoniker)*  lpvtbl1;  /* VTable relative to the IMoniker interface.*/
  45
  46     /* The ROT (RunningObjectTable implementation) uses the IROTData interface to test whether
  47      * two monikers are equal. That's whay IROTData interface is implemented by monikers.
  48      */
  49     ICOM_VTABLE(IROTData)*  lpvtbl2;  /* VTable relative to the IROTData interface.*/
  50
  51     ULONG ref; /* reference counter for this object */
  52
  53 } AntiMonikerImpl;
  54
  55 /********************************************************************************/
  56 /* AntiMoniker prototype functions :                                            */
  57
  58 /* IUnknown prototype functions */
  59 static HRESULT WINAPI AntiMonikerImpl_QueryInterface(IMoniker* iface,REFIID riid,void** ppvObject);
  60 static ULONG   WINAPI AntiMonikerImpl_AddRef(IMoniker* iface);
  61 static ULONG   WINAPI AntiMonikerImpl_Release(IMoniker* iface);
  62
  63 /* IPersist prototype functions */
  64 static HRESULT WINAPI AntiMonikerImpl_GetClassID(IMoniker* iface, CLSID *pClassID);
  65
  66 /* IPersistStream prototype functions */
  67 static HRESULT WINAPI AntiMonikerImpl_IsDirty(IMoniker* iface);
  68 static HRESULT WINAPI AntiMonikerImpl_Load(IMoniker* iface, IStream* pStm);
  69 static HRESULT WINAPI AntiMonikerImpl_Save(IMoniker* iface, IStream* pStm, BOOL fClearDirty);
  70 static HRESULT WINAPI AntiMonikerImpl_GetSizeMax(IMoniker* iface, ULARGE_INTEGER* pcbSize);
  71
  72 /* IMoniker prototype functions */
  73 static HRESULT WINAPI AntiMonikerImpl_BindToObject(IMoniker* iface,IBindCtx* pbc, IMoniker* pmkToLeft, REFIID riid, VOID** ppvResult);
  74 static HRESULT WINAPI AntiMonikerImpl_BindToStorage(IMoniker* iface,IBindCtx* pbc, IMoniker* pmkToLeft, REFIID riid, VOID** ppvResult);
  75 static HRESULT WINAPI AntiMonikerImpl_Reduce(IMoniker* iface,IBindCtx* pbc, DWORD dwReduceHowFar,IMoniker** ppmkToLeft, IMoniker** ppmkReduced);
  76 static HRESULT WINAPI AntiMonikerImpl_ComposeWith(IMoniker* iface,IMoniker* pmkRight,BOOL fOnlyIfNotGeneric, IMoniker** ppmkComposite);
  77 static HRESULT WINAPI AntiMonikerImpl_Enum(IMoniker* iface,BOOL fForward, IEnumMoniker** ppenumMoniker);
  78 static HRESULT WINAPI AntiMonikerImpl_IsEqual(IMoniker* iface,IMoniker* pmkOtherMoniker);
  79 static HRESULT WINAPI AntiMonikerImpl_Hash(IMoniker* iface,DWORD* pdwHash);
  80 static HRESULT WINAPI AntiMonikerImpl_IsRunning(IMoniker* iface,IBindCtx* pbc, IMoniker* pmkToLeft, IMoniker* pmkNewlyRunning);
  81 static HRESULT WINAPI AntiMonikerImpl_GetTimeOfLastChange(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft, FILETIME* pAntiTime);
  82 static HRESULT WINAPI AntiMonikerImpl_Inverse(IMoniker* iface,IMoniker** ppmk);
  83 static HRESULT WINAPI AntiMonikerImpl_CommonPrefixWith(IMoniker* iface,IMoniker* pmkOther, IMoniker** ppmkPrefix);
  84 static HRESULT WINAPI AntiMonikerImpl_RelativePathTo(IMoniker* iface,IMoniker* pmOther, IMoniker** ppmkRelPath);
  85 static HRESULT WINAPI AntiMonikerImpl_GetDisplayName(IMoniker* iface,IBindCtx* pbc, IMoniker* pmkToLeft, LPOLESTR *ppszDisplayName);
  86 static HRESULT WINAPI AntiMonikerImpl_ParseDisplayName(IMoniker* iface,IBindCtx* pbc, IMoniker* pmkToLeft, LPOLESTR pszDisplayName, ULONG* pchEaten, IMoniker** ppmkOut);
  87 static HRESULT WINAPI AntiMonikerImpl_IsSystemMoniker(IMoniker* iface,DWORD* pwdMksys);
  88
  89 /********************************************************************************/
  90 /* IROTData prototype functions                                                 */
  91
  92 /* IUnknown prototype functions */
  93 static HRESULT WINAPI AntiMonikerROTDataImpl_QueryInterface(IROTData* iface,REFIID riid,VOID** ppvObject);
  94 static ULONG   WINAPI AntiMonikerROTDataImpl_AddRef(IROTData* iface);
  95 static ULONG   WINAPI AntiMonikerROTDataImpl_Release(IROTData* iface);
  96
  97 /* IROTData prototype function */
  98 static HRESULT WINAPI AntiMonikerROTDataImpl_GetComparaisonData(IROTData* iface,BYTE* pbData,ULONG cbMax,ULONG* pcbData);
  99
 100 /* Local function used by AntiMoniker implementation */
 101 HRESULT WINAPI AntiMonikerImpl_Construct(AntiMonikerImpl* iface);
 102 HRESULT WINAPI AntiMonikerImpl_Destroy(AntiMonikerImpl* iface);
 103
 104 /********************************************************************************/
 105 /* Virtual function table for the AntiMonikerImpl class which  include IPersist,*/
 106 /* IPersistStream and IMoniker functions.                                       */
 107 static ICOM_VTABLE(IMoniker) VT_AntiMonikerImpl =
 108 {
 109     ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
 110     AntiMonikerImpl_QueryInterface,
 111     AntiMonikerImpl_AddRef,
 112     AntiMonikerImpl_Release,
 113     AntiMonikerImpl_GetClassID,
 114     AntiMonikerImpl_IsDirty,
 115     AntiMonikerImpl_Load,
 116     AntiMonikerImpl_Save,
 117     AntiMonikerImpl_GetSizeMax,
 118     AntiMonikerImpl_BindToObject,
 119     AntiMonikerImpl_BindToStorage,
 120     AntiMonikerImpl_Reduce,
 121     AntiMonikerImpl_ComposeWith,
 122     AntiMonikerImpl_Enum,
 123     AntiMonikerImpl_IsEqual,
 124     AntiMonikerImpl_Hash,
 125     AntiMonikerImpl_IsRunning,
 126     AntiMonikerImpl_GetTimeOfLastChange,
 127     AntiMonikerImpl_Inverse,
 128     AntiMonikerImpl_CommonPrefixWith,
 129     AntiMonikerImpl_RelativePathTo,
 130     AntiMonikerImpl_GetDisplayName,
 131     AntiMonikerImpl_ParseDisplayName,
 132     AntiMonikerImpl_IsSystemMoniker
 133 };
 134
 135 /********************************************************************************/
 136 /* Virtual function table for the IROTData class.                               */
 137 static ICOM_VTABLE(IROTData) VT_ROTDataImpl =
 138 {
 139     ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
 140     AntiMonikerROTDataImpl_QueryInterface,
 141     AntiMonikerROTDataImpl_AddRef,
 142     AntiMonikerROTDataImpl_Release,
 143     AntiMonikerROTDataImpl_GetComparaisonData
 144 };
 145
 146 /*******************************************************************************
 147  *        AntiMoniker_QueryInterface
 148  *******************************************************************************/
 149 HRESULT WINAPI AntiMonikerImpl_QueryInterface(IMoniker* iface,REFIID riid,void** ppvObject)
 150 {
 151     ICOM_THIS(AntiMonikerImpl,iface);
 152
 153   TRACE("(%p,%p,%p)\n",This,riid,ppvObject);
 154
 155   /* Perform a sanity check on the parameters.*/
 156     if ( (This==0) || (ppvObject==0) )
 157         return E_INVALIDARG;
 158
 159   /* Initialize the return parameter */
 160   *ppvObject = 0;
 161
 162   /* Compare the riid with the interface IDs implemented by this object.*/
 163   if (IsEqualIID(&IID_IUnknown, riid) ||
 164       IsEqualIID(&IID_IPersist, riid) ||
 165       IsEqualIID(&IID_IPersistStream, riid) ||
 166       IsEqualIID(&IID_IMoniker, riid)
 167      )
 168       *ppvObject = iface;
 169     else if (IsEqualIID(&IID_IROTData, riid))
 170         *ppvObject = (IROTData*)&(This->lpvtbl2);
 171
 172   /* Check that we obtained an interface.*/
 173     if ((*ppvObject)==0)
 174         return E_NOINTERFACE;
 175
 176    /* Query Interface always increases the reference count by one when it is successful */
 177   AntiMonikerImpl_AddRef(iface);
 178
 179   return S_OK;
 180 }
 181
 182 /******************************************************************************
 183  *        AntiMoniker_AddRef
 184  ******************************************************************************/
 185 ULONG WINAPI AntiMonikerImpl_AddRef(IMoniker* iface)
 186 {
 187     ICOM_THIS(AntiMonikerImpl,iface);
 188
 189     TRACE("(%p)\n",This);
 190
 191     return ++(This->ref);
 192 }
 193
 194 /******************************************************************************
 195  *        AntiMoniker_Release
 196  ******************************************************************************/
 197 ULONG WINAPI AntiMonikerImpl_Release(IMoniker* iface)
 198 {
 199     ICOM_THIS(AntiMonikerImpl,iface);
 200
 201     TRACE("(%p)\n",This);
 202
 203     This->ref--;
 204
 205     /* destroy the object if there's no more reference on it */
 206     if (This->ref==0){
 207
 208         AntiMonikerImpl_Destroy(This);
 209
 210         return 0;
 211     }
 212     return This->ref;
 213 }
 214
 215 /******************************************************************************
 216  *        AntiMoniker_GetClassID
 217  ******************************************************************************/
 218 HRESULT WINAPI AntiMonikerImpl_GetClassID(IMoniker* iface,CLSID *pClassID)
 219 {
 220     TRACE("(%p,%p),stub!\n",iface,pClassID);
 221
 222     if (pClassID==NULL)
 223         return E_POINTER;
 224
 225     *pClassID = CLSID_AntiMoniker;
 226
 227     return S_OK;
 228 }
 229
 230 /******************************************************************************
 231  *        AntiMoniker_IsDirty
 232  ******************************************************************************/
 233 HRESULT WINAPI AntiMonikerImpl_IsDirty(IMoniker* iface)
 234 {
 235     /* Note that the OLE-provided implementations of the IPersistStream::IsDirty
 236        method in the OLE-provided moniker interfaces always return S_FALSE because
 237        their internal state never changes. */
 238
 239     TRACE("(%p)\n",iface);
 240
 241     return S_FALSE;
 242 }
 243
 244 /******************************************************************************
 245  *        AntiMoniker_Load
 246  ******************************************************************************/
 247 HRESULT WINAPI AntiMonikerImpl_Load(IMoniker* iface,IStream* pStm)
 248 {
 249     DWORD constant=1,dwbuffer;
 250     HRESULT res;
 251
 252     /* data read by this function is only a DWORD constant (must be 1) ! */
 253     res=IStream_Read(pStm,&dwbuffer,sizeof(DWORD),NULL);
 254
 255     if (SUCCEEDED(res)&& dwbuffer!=constant)
 256         return E_FAIL;
 257
 258     return res;
 259 }
 260
 261 /******************************************************************************
 262  *        AntiMoniker_Save
 263  ******************************************************************************/
 264 HRESULT WINAPI AntiMonikerImpl_Save(IMoniker* iface,IStream* pStm,BOOL fClearDirty)
 265 {
 266     DWORD constant=1;
 267     HRESULT res;
 268
 269     /* data written by this function is only a DWORD constant set to 1 ! */
 270     res=IStream_Write(pStm,&constant,sizeof(constant),NULL);
 271
 272     return res;
 273 }
 274
 275 /******************************************************************************
 276  *        AntiMoniker_GetSizeMax
 277  ******************************************************************************/
 278 HRESULT WINAPI AntiMonikerImpl_GetSizeMax(IMoniker* iface,
 279                                           ULARGE_INTEGER* pcbSize)/* Pointer to size of stream needed to save object */
 280 {
 281     TRACE("(%p,%p)\n",iface,pcbSize);
 282
 283     if (pcbSize!=NULL)
 284         return E_POINTER;
 285
 286     /* for more details see AntiMonikerImpl_Save coments */
 287
 288     /* Normaly the sizemax must be the  size of DWORD ! but I tested this function it ususlly return 16 bytes */
 289     /* more than the number of bytes used by AntiMoniker::Save function */
 290     pcbSize->s.LowPart =  sizeof(DWORD)+16;
 291
 292     pcbSize->s.HighPart=0;
 293
 294     return S_OK;
 295 }
 296
 297 /******************************************************************************
 298  *         AntiMoniker_Construct (local function)
 299  *******************************************************************************/
 300 HRESULT WINAPI AntiMonikerImpl_Construct(AntiMonikerImpl* This)
 301 {
 302
 303     TRACE("(%p)\n",This);
 304
 305     /* Initialize the virtual fgunction table. */
 306     This->lpvtbl1      = &VT_AntiMonikerImpl;
 307     This->lpvtbl2      = &VT_ROTDataImpl;
 308     This->ref          = 0;
 309
 310     return S_OK;
 311 }
 312
 313 /******************************************************************************
 314  *        AntiMoniker_Destroy (local function)
 315  *******************************************************************************/
 316 HRESULT WINAPI AntiMonikerImpl_Destroy(AntiMonikerImpl* This)
 317 {
 318     TRACE("(%p)\n",This);
 319
 320     return HeapFree(GetProcessHeap(),0,This);
 321 }
 322
 323 /******************************************************************************
 324  *                  AntiMoniker_BindToObject
 325  ******************************************************************************/
 326 HRESULT WINAPI AntiMonikerImpl_BindToObject(IMoniker* iface,
 327                                             IBindCtx* pbc,
 328                                             IMoniker* pmkToLeft,
 329                                             REFIID riid,
 330                                             VOID** ppvResult)
 331 {
 332     TRACE("(%p,%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,riid,ppvResult);
 333     return E_NOTIMPL;
 334 }
 335
 336 /******************************************************************************
 337  *        AntiMoniker_BindToStorage
 338  ******************************************************************************/
 339 HRESULT WINAPI AntiMonikerImpl_BindToStorage(IMoniker* iface,
 340                                              IBindCtx* pbc,
 341                                              IMoniker* pmkToLeft,
 342                                              REFIID riid,
 343                                              VOID** ppvResult)
 344 {
 345     TRACE("(%p,%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,riid,ppvResult);
 346     return E_NOTIMPL;
 347 }
 348
 349 /******************************************************************************
 350  *        AntiMoniker_Reduce
 351  ******************************************************************************/
 352 HRESULT WINAPI AntiMonikerImpl_Reduce(IMoniker* iface,
 353                                       IBindCtx* pbc,
 354                                       DWORD dwReduceHowFar,
 355                                       IMoniker** ppmkToLeft,
 356                                       IMoniker** ppmkReduced)
 357 {
 358     TRACE("(%p,%p,%ld,%p,%p)\n",iface,pbc,dwReduceHowFar,ppmkToLeft,ppmkReduced);
 359
 360     if (ppmkReduced==NULL)
 361         return E_POINTER;
 362
 363     AntiMonikerImpl_AddRef(iface);
 364
 365     *ppmkReduced=iface;
 366
 367     return MK_S_REDUCED_TO_SELF;
 368 }
 369 /******************************************************************************
 370  *        AntiMoniker_ComposeWith
 371  ******************************************************************************/
 372 HRESULT WINAPI AntiMonikerImpl_ComposeWith(IMoniker* iface,
 373                                            IMoniker* pmkRight,
 374                                            BOOL fOnlyIfNotGeneric,
 375                                            IMoniker** ppmkComposite)
 376 {
 377
 378     TRACE("(%p,%p,%d,%p)\n",iface,pmkRight,fOnlyIfNotGeneric,ppmkComposite);
 379
 380     if ((ppmkComposite==NULL)||(pmkRight==NULL))
 381         return E_POINTER;
 382
 383     *ppmkComposite=0;
 384
 385     if (fOnlyIfNotGeneric)
 386         return MK_E_NEEDGENERIC;
 387     else
 388         return CreateGenericComposite(iface,pmkRight,ppmkComposite);
 389 }
 390
 391 /******************************************************************************
 392  *        AntiMoniker_Enum
 393  ******************************************************************************/
 394 HRESULT WINAPI AntiMonikerImpl_Enum(IMoniker* iface,BOOL fForward, IEnumMoniker** ppenumMoniker)
 395 {
 396     TRACE("(%p,%d,%p)\n",iface,fForward,ppenumMoniker);
 397
 398     if (ppenumMoniker == NULL)
 399         return E_POINTER;
 400
 401     *ppenumMoniker = NULL;
 402
 403     return S_OK;
 404 }
 405
 406 /******************************************************************************
 407  *        AntiMoniker_IsEqual
 408  ******************************************************************************/
 409 HRESULT WINAPI AntiMonikerImpl_IsEqual(IMoniker* iface,IMoniker* pmkOtherMoniker)
 410 {
 411     DWORD mkSys;
 412
 413     TRACE("(%p,%p)\n",iface,pmkOtherMoniker);
 414
 415     if (pmkOtherMoniker==NULL)
 416         return S_FALSE;
 417
 418     IMoniker_IsSystemMoniker(pmkOtherMoniker,&mkSys);
 419
 420     if (mkSys==MKSYS_ANTIMONIKER)
 421         return S_OK;
 422     else
 423         return S_FALSE;
 424 }
 425
 426 /******************************************************************************
 427  *        AntiMoniker_Hash
 428  ******************************************************************************/
 429 HRESULT WINAPI AntiMonikerImpl_Hash(IMoniker* iface,DWORD* pdwHash)
 430 {
 431     if (pdwHash==NULL)
 432         return E_POINTER;
 433
 434     *pdwHash=0;
 435
 436     return S_OK;
 437 }
 438
 439 /******************************************************************************
 440  *        AntiMoniker_IsRunning
 441  ******************************************************************************/
 442 HRESULT WINAPI AntiMonikerImpl_IsRunning(IMoniker* iface,
 443                                          IBindCtx* pbc,
 444                                          IMoniker* pmkToLeft,
 445                                          IMoniker* pmkNewlyRunning)
 446 {
 447     IRunningObjectTable* rot;
 448     HRESULT res;
 449
 450     TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pmkNewlyRunning);
 451
 452     if (pbc==NULL)
 453         return E_INVALIDARG;
 454
 455     res=IBindCtx_GetRunningObjectTable(pbc,&rot);
 456
 457     if (FAILED(res))
 458     return res;
 459
 460     res = IRunningObjectTable_IsRunning(rot,iface);
 461
 462     IRunningObjectTable_Release(rot);
 463
 464     return res;
 465 }
 466
 467 /******************************************************************************
 468  *        AntiMoniker_GetTimeOfLastChange
 469  ******************************************************************************/
 470 HRESULT WINAPI AntiMonikerImpl_GetTimeOfLastChange(IMoniker* iface,
 471                                                    IBindCtx* pbc,
 472                                                    IMoniker* pmkToLeft,
 473                                                    FILETIME* pAntiTime)
 474 {
 475     TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pAntiTime);
 476     return E_NOTIMPL;
 477 }
 478
 479 /******************************************************************************
 480  *        AntiMoniker_Inverse
 481  ******************************************************************************/
 482 HRESULT WINAPI AntiMonikerImpl_Inverse(IMoniker* iface,IMoniker** ppmk)
 483 {
 484     TRACE("(%p,%p)\n",iface,ppmk);
 485
 486     if (ppmk==NULL)
 487         return E_POINTER;
 488
 489     *ppmk=0;
 490
 491     return MK_E_NOINVERSE;
 492 }
 493
 494 /******************************************************************************
 495  *        AntiMoniker_CommonPrefixWith
 496  ******************************************************************************/
 497 HRESULT WINAPI AntiMonikerImpl_CommonPrefixWith(IMoniker* iface,IMoniker* pmkOther,IMoniker** ppmkPrefix)
 498 {
 499     DWORD mkSys;
 500
 501     IMoniker_IsSystemMoniker(pmkOther,&mkSys);
 502
 503     if(mkSys==MKSYS_ITEMMONIKER){
 504
 505         IMoniker_AddRef(iface);
 506
 507         *ppmkPrefix=iface;
 508
 509         IMoniker_AddRef(iface);
 510
 511         return MK_S_US;
 512     }
 513     else
 514         return MonikerCommonPrefixWith(iface,pmkOther,ppmkPrefix);
 515 }
 516
 517 /******************************************************************************
 518  *        AntiMoniker_RelativePathTo
 519  ******************************************************************************/
 520 HRESULT WINAPI AntiMonikerImpl_RelativePathTo(IMoniker* iface,IMoniker* pmOther, IMoniker** ppmkRelPath)
 521 {
 522     TRACE("(%p,%p,%p)\n",iface,pmOther,ppmkRelPath);
 523
 524     if (ppmkRelPath==NULL)
 525         return E_POINTER;
 526
 527     IMoniker_AddRef(pmOther);
 528
 529     *ppmkRelPath=pmOther;
 530
 531     return MK_S_HIM;
 532 }
 533
 534 /******************************************************************************
 535  *        AntiMoniker_GetDisplayName
 536  ******************************************************************************/
 537 HRESULT WINAPI AntiMonikerImpl_GetDisplayName(IMoniker* iface,
 538                                               IBindCtx* pbc,
 539                                               IMoniker* pmkToLeft,
 540                                               LPOLESTR *ppszDisplayName)
 541 {
 542     WCHAR back[]={'\\','.','.',0};
 543
 544     TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,ppszDisplayName);
 545
 546     if (ppszDisplayName==NULL)
 547         return E_POINTER;
 548
 549     if (pmkToLeft!=NULL){
 550         FIXME("() pmkToLeft!=NULL not implemented \n");
 551         return E_NOTIMPL;
 552     }
 553
 554     *ppszDisplayName=CoTaskMemAlloc(sizeof(back));
 555
 556     if (*ppszDisplayName==NULL)
 557         return E_OUTOFMEMORY;
 558
 559     strcpyW(*ppszDisplayName,back);
 560
 561     return S_OK;
 562 }
 563
 564 /******************************************************************************
 565  *        AntiMoniker_ParseDisplayName
 566  ******************************************************************************/
 567 HRESULT WINAPI AntiMonikerImpl_ParseDisplayName(IMoniker* iface,
 568                                                 IBindCtx* pbc,
 569                                                 IMoniker* pmkToLeft,
 570                                                 LPOLESTR pszDisplayName,
 571                                                 ULONG* pchEaten,
 572                                                 IMoniker** ppmkOut)
 573 {
 574     TRACE("(%p,%p,%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pszDisplayName,pchEaten,ppmkOut);
 575     return E_NOTIMPL;
 576 }
 577
 578 /******************************************************************************
 579  *        AntiMoniker_IsSystemMoniker
 580  ******************************************************************************/
 581 HRESULT WINAPI AntiMonikerImpl_IsSystemMoniker(IMoniker* iface,DWORD* pwdMksys)
 582 {
 583     TRACE("(%p,%p)\n",iface,pwdMksys);
 584
 585     if (!pwdMksys)
 586         return E_POINTER;
 587
 588     (*pwdMksys)=MKSYS_ANTIMONIKER;
 589
 590     return S_OK;
 591 }
 592
 593 /*******************************************************************************
 594  *        AntiMonikerIROTData_QueryInterface
 595  *******************************************************************************/
 596 HRESULT WINAPI AntiMonikerROTDataImpl_QueryInterface(IROTData *iface,REFIID riid,VOID** ppvObject)
 597 {
 598
 599     ICOM_THIS_From_IROTData(IMoniker, iface);
 600
 601     TRACE("(%p,%p,%p)\n",iface,riid,ppvObject);
 602
 603     return AntiMonikerImpl_QueryInterface(This, riid, ppvObject);
 604 }
 605
 606 /***********************************************************************
 607  *        AntiMonikerIROTData_AddRef
 608  */
 609 ULONG   WINAPI AntiMonikerROTDataImpl_AddRef(IROTData *iface)
 610 {
 611     ICOM_THIS_From_IROTData(IMoniker, iface);
 612
 613     TRACE("(%p)\n",iface);
 614
 615     return AntiMonikerImpl_AddRef(This);
 616 }
 617
 618 /***********************************************************************
 619  *        AntiMonikerIROTData_Release
 620  */
 621 ULONG   WINAPI AntiMonikerROTDataImpl_Release(IROTData* iface)
 622 {
 623     ICOM_THIS_From_IROTData(IMoniker, iface);
 624
 625     TRACE("(%p)\n",iface);
 626
 627     return AntiMonikerImpl_Release(This);
 628 }
 629
 630 /******************************************************************************
 631  *        AntiMonikerIROTData_GetComparaisonData
 632  ******************************************************************************/
 633 HRESULT WINAPI AntiMonikerROTDataImpl_GetComparaisonData(IROTData* iface,
 634                                                          BYTE* pbData,
 635                                                          ULONG cbMax,
 636                                                          ULONG* pcbData)
 637 {
 638     FIXME("(),stub!\n");
 639     return E_NOTIMPL;
 640 }
 641
 642 /******************************************************************************
 643  *        CreateAntiMoniker     [OLE32.@]
 644  ******************************************************************************/
 645 HRESULT WINAPI CreateAntiMoniker(LPMONIKER * ppmk)
 646 {
 647     AntiMonikerImpl* newAntiMoniker = 0;
 648     HRESULT        hr = S_OK;
 649     IID riid=IID_IMoniker;
 650
 651     TRACE("(%p)\n",ppmk);
 652
 653     newAntiMoniker = HeapAlloc(GetProcessHeap(), 0, sizeof(AntiMonikerImpl));
 654
 655     if (newAntiMoniker == 0)
 656         return STG_E_INSUFFICIENTMEMORY;
 657
 658     hr = AntiMonikerImpl_Construct(newAntiMoniker);
 659
 660     if (FAILED(hr)){
 661
 662         HeapFree(GetProcessHeap(),0,newAntiMoniker);
 663         return hr;
 664     }
 665
 666     hr = AntiMonikerImpl_QueryInterface((IMoniker*)newAntiMoniker,&riid,(void**)ppmk);
 667
 668     return hr;
 669 }