reactos/lib/ole32/antimoniker.c

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