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