ole/itemmoniker.c

   1 /***************************************************************************************
   2  *                            ItemMonikers implementation
   3  *
   4  *           Copyright 1999  Noomen Hamza
   5  ***************************************************************************************/
   6
   7 #include <assert.h>
   8 #include "winerror.h"
   9 #include "debug.h"
  10 #include "heap.h"
  11 #include "winuser.h"
  12 #include "file.h"
  13 #include "winreg.h"
  14 #include "objbase.h"
  15 #include "wine/obj_inplace.h"
  16
  17 DEFAULT_DEBUG_CHANNEL(ole)
  18
  19 /* ItemMoniker data structure */
  20 typedef struct ItemMonikerImpl{
  21
  22     ICOM_VTABLE(IMoniker)*  lpvtbl1;  /* VTable relative to the IMoniker interface.*/
  23
  24     /* The ROT (RunningObjectTable implementation) uses the IROTData interface to test whether
  25      * two monikers are equal. That's whay IROTData interface is implemented by monikers.
  26      */
  27     ICOM_VTABLE(IROTData)*  lpvtbl2;  /* VTable relative to the IROTData interface.*/
  28
  29     ULONG ref; /* reference counter for this object */
  30
  31     LPOLESTR itemName; /* item name identified by this ItemMoniker */
  32
  33     LPOLESTR itemDelimiter; /* Delimiter string */
  34
  35 } ItemMonikerImpl;
  36
  37 /********************************************************************************/
  38 /* ItemMoniker prototype functions :                                            */
  39
  40 /* IUnknown prototype functions */
  41 static HRESULT WINAPI ItemMonikerImpl_QueryInterface(IMoniker* iface,REFIID riid,void** ppvObject);
  42 static ULONG   WINAPI ItemMonikerImpl_AddRef(IMoniker* iface);
  43 static ULONG   WINAPI ItemMonikerImpl_Release(IMoniker* iface);
  44
  45 /* IPersist prototype functions */
  46 static HRESULT WINAPI ItemMonikerImpl_GetClassID(const IMoniker* iface, CLSID *pClassID);
  47
  48 /* IPersistStream prototype functions */
  49 static HRESULT WINAPI ItemMonikerImpl_IsDirty(IMoniker* iface);
  50 static HRESULT WINAPI ItemMonikerImpl_Load(IMoniker* iface, IStream* pStm);
  51 static HRESULT WINAPI ItemMonikerImpl_Save(IMoniker* iface, IStream* pStm, BOOL fClearDirty);
  52 static HRESULT WINAPI ItemMonikerImpl_GetSizeMax(IMoniker* iface, ULARGE_INTEGER* pcbSize);
  53
  54 /* IMoniker prototype functions */
  55 static HRESULT WINAPI ItemMonikerImpl_BindToObject(IMoniker* iface,IBindCtx* pbc, IMoniker* pmkToLeft, REFIID riid, VOID** ppvResult);
  56 static HRESULT WINAPI ItemMonikerImpl_BindToStorage(IMoniker* iface,IBindCtx* pbc, IMoniker* pmkToLeft, REFIID riid, VOID** ppvResult);
  57 static HRESULT WINAPI ItemMonikerImpl_Reduce(IMoniker* iface,IBindCtx* pbc, DWORD dwReduceHowFar,IMoniker** ppmkToLeft, IMoniker** ppmkReduced);
  58 static HRESULT WINAPI ItemMonikerImpl_ComposeWith(IMoniker* iface,IMoniker* pmkRight,BOOL fOnlyIfNotGeneric, IMoniker** ppmkComposite);
  59 static HRESULT WINAPI ItemMonikerImpl_Enum(IMoniker* iface,BOOL fForward, IEnumMoniker** ppenumMoniker);
  60 static HRESULT WINAPI ItemMonikerImpl_IsEqual(IMoniker* iface,IMoniker* pmkOtherMoniker);
  61 static HRESULT WINAPI ItemMonikerImpl_Hash(IMoniker* iface,DWORD* pdwHash);
  62 static HRESULT WINAPI ItemMonikerImpl_IsRunning(IMoniker* iface,IBindCtx* pbc, IMoniker* pmkToLeft, IMoniker* pmkNewlyRunning);
  63 static HRESULT WINAPI ItemMonikerImpl_GetTimeOfLastChange(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft, FILETIME* pItemTime);
  64 static HRESULT WINAPI ItemMonikerImpl_Inverse(IMoniker* iface,IMoniker** ppmk);
  65 static HRESULT WINAPI ItemMonikerImpl_CommonPrefixWith(IMoniker* iface,IMoniker* pmkOther, IMoniker** ppmkPrefix);
  66 static HRESULT WINAPI ItemMonikerImpl_RelativePathTo(IMoniker* iface,IMoniker* pmOther, IMoniker** ppmkRelPath);
  67 static HRESULT WINAPI ItemMonikerImpl_GetDisplayName(IMoniker* iface,IBindCtx* pbc, IMoniker* pmkToLeft, LPOLESTR *ppszDisplayName);
  68 static HRESULT WINAPI ItemMonikerImpl_ParseDisplayName(IMoniker* iface,IBindCtx* pbc, IMoniker* pmkToLeft, LPOLESTR pszDisplayName, ULONG* pchEaten, IMoniker** ppmkOut);
  69 static HRESULT WINAPI ItemMonikerImpl_IsSystemMoniker(IMoniker* iface,DWORD* pwdMksys);
  70
  71 /* Local function used by ItemMoniker implementation */
  72 HRESULT WINAPI ItemMonikerImpl_Construct(ItemMonikerImpl* iface, LPCOLESTR lpszDelim,LPCOLESTR lpszPathName);
  73 HRESULT WINAPI ItemMonikerImpl_Destroy(ItemMonikerImpl* iface);
  74
  75 /********************************************************************************/
  76 /* IROTData prototype functions                                                 */
  77
  78 /* IUnknown prototype functions */
  79 static HRESULT WINAPI ItemMonikerROTDataImpl_QueryInterface(IROTData* iface,REFIID riid,VOID** ppvObject);
  80 static ULONG   WINAPI ItemMonikerROTDataImpl_AddRef(IROTData* iface);
  81 static ULONG   WINAPI ItemMonikerROTDataImpl_Release(IROTData* iface);
  82
  83 /* IROTData prototype function */
  84 static HRESULT WINAPI ItemMonikerROTDataImpl_GetComparaisonData(IROTData* iface,BYTE* pbData,ULONG cbMax,ULONG* pcbData);
  85
  86 /********************************************************************************/
  87 /* Virtual function table for the ItemMonikerImpl class witch  include Ipersist,*/
  88 /* IPersistStream and IMoniker functions.                                       */
  89 static ICOM_VTABLE(IMoniker) VT_ItemMonikerImpl =
  90     {
  91     ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
  92     ItemMonikerImpl_QueryInterface,
  93     ItemMonikerImpl_AddRef,
  94     ItemMonikerImpl_Release,
  95     ItemMonikerImpl_GetClassID,
  96     ItemMonikerImpl_IsDirty,
  97     ItemMonikerImpl_Load,
  98     ItemMonikerImpl_Save,
  99     ItemMonikerImpl_GetSizeMax,
 100     ItemMonikerImpl_BindToObject,
 101     ItemMonikerImpl_BindToStorage,
 102     ItemMonikerImpl_Reduce,
 103     ItemMonikerImpl_ComposeWith,
 104     ItemMonikerImpl_Enum,
 105     ItemMonikerImpl_IsEqual,
 106     ItemMonikerImpl_Hash,
 107     ItemMonikerImpl_IsRunning,
 108     ItemMonikerImpl_GetTimeOfLastChange,
 109     ItemMonikerImpl_Inverse,
 110     ItemMonikerImpl_CommonPrefixWith,
 111     ItemMonikerImpl_RelativePathTo,
 112     ItemMonikerImpl_GetDisplayName,
 113     ItemMonikerImpl_ParseDisplayName,
 114     ItemMonikerImpl_IsSystemMoniker
 115 };
 116
 117 /********************************************************************************/
 118 /* Virtual function table for the IROTData class.                               */
 119 static ICOM_VTABLE(IROTData) VT_ROTDataImpl =
 120 {
 121     ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
 122     ItemMonikerROTDataImpl_QueryInterface,
 123     ItemMonikerROTDataImpl_AddRef,
 124     ItemMonikerROTDataImpl_Release,
 125     ItemMonikerROTDataImpl_GetComparaisonData
 126 };
 127
 128 /*******************************************************************************
 129  *        ItemMoniker_QueryInterface
 130  *******************************************************************************/
 131 HRESULT WINAPI ItemMonikerImpl_QueryInterface(IMoniker* iface,REFIID riid,void** ppvObject)
 132 {
 133     ICOM_THIS(ItemMonikerImpl,iface);
 134
 135   TRACE(ole,"(%p,%p,%p)\n",This,riid,ppvObject);
 136
 137   /* Perform a sanity check on the parameters.*/
 138     if ( (This==0) || (ppvObject==0) )
 139         return E_INVALIDARG;
 140
 141   /* Initialize the return parameter */
 142   *ppvObject = 0;
 143
 144   /* Compare the riid with the interface IDs implemented by this object.*/
 145   if (IsEqualIID(&IID_IUnknown, riid) ||
 146       IsEqualIID(&IID_IPersist, riid) ||
 147       IsEqualIID(&IID_IPersistStream, riid) ||
 148       IsEqualIID(&IID_IMoniker, riid)
 149      )
 150       *ppvObject = iface;
 151
 152     else if (IsEqualIID(&IID_IROTData, riid))
 153         *ppvObject = (IROTData*)&(This->lpvtbl2);
 154
 155   /* Check that we obtained an interface.*/
 156     if ((*ppvObject)==0)
 157         return E_NOINTERFACE;
 158
 159    /* Query Interface always increases the reference count by one when it is successful */
 160   ItemMonikerImpl_AddRef(iface);
 161
 162   return S_OK;
 163 }
 164
 165 /******************************************************************************
 166  *        ItemMoniker_AddRef
 167  ******************************************************************************/
 168 ULONG WINAPI ItemMonikerImpl_AddRef(IMoniker* iface)
 169 {
 170     ICOM_THIS(ItemMonikerImpl,iface);
 171
 172     TRACE(ole,"(%p)\n",This);
 173
 174     return ++(This->ref);
 175 }
 176
 177 /******************************************************************************
 178  *        ItemMoniker_Release
 179  ******************************************************************************/
 180 ULONG WINAPI ItemMonikerImpl_Release(IMoniker* iface)
 181 {
 182     ICOM_THIS(ItemMonikerImpl,iface);
 183
 184     TRACE(ole,"(%p)\n",This);
 185
 186     This->ref--;
 187
 188     /* destroy the object if there's no more reference on it */
 189     if (This->ref==0){
 190
 191         ItemMonikerImpl_Destroy(This);
 192
 193         return 0;
 194     }
 195     return This->ref;;
 196 }
 197
 198 /******************************************************************************
 199  *        ItemMoniker_GetClassID
 200  ******************************************************************************/
 201 HRESULT WINAPI ItemMonikerImpl_GetClassID(const IMoniker* iface,CLSID *pClassID)
 202 {
 203     TRACE(ole,"(%p,%p),stub!\n",iface,pClassID);
 204
 205     if (pClassID==NULL)
 206         return E_POINTER;
 207
 208     *pClassID = CLSID_ItemMoniker;
 209
 210     return S_OK;
 211 }
 212
 213 /******************************************************************************
 214  *        ItemMoniker_IsDirty
 215  ******************************************************************************/
 216 HRESULT WINAPI ItemMonikerImpl_IsDirty(IMoniker* iface)
 217 {
 218     /* Note that the OLE-provided implementations of the IPersistStream::IsDirty
 219        method in the OLE-provided moniker interfaces always return S_FALSE because
 220        their internal state never changes. */
 221
 222     TRACE(ole,"(%p)\n",iface);
 223
 224     return S_FALSE;
 225 }
 226
 227 /******************************************************************************
 228  *        ItemMoniker_Load
 229  ******************************************************************************/
 230 HRESULT WINAPI ItemMonikerImpl_Load(IMoniker* iface,IStream* pStm)
 231 {
 232
 233     ICOM_THIS(ItemMonikerImpl,iface);
 234     HRESULT res;
 235     DWORD delimiterLength,nameLength;
 236     CHAR *itemNameA,*itemDelimiterA;
 237     ULONG bread;
 238
 239     /* for more details about data read by this function see coments of ItemMonikerImpl_Save function */
 240
 241     /* read item delimiter string length + 1 */
 242     res=IStream_Read(pStm,&delimiterLength,sizeof(DWORD),&bread);
 243     if (bread != sizeof(DWORD))
 244         return E_FAIL;
 245
 246     /* read item delimiter string */
 247     itemDelimiterA=HeapAlloc(GetProcessHeap(),0,delimiterLength);
 248     res=IStream_Read(pStm,itemDelimiterA,delimiterLength,&bread);
 249     if (bread != delimiterLength)
 250         return E_FAIL;
 251
 252     This->itemDelimiter=HeapReAlloc(GetProcessHeap(),0,This->itemDelimiter,delimiterLength*sizeof(WCHAR));
 253     if (!This->itemDelimiter)
 254         return E_OUTOFMEMORY;
 255
 256     lstrcpyAtoW(This->itemDelimiter,itemDelimiterA);
 257
 258     /* read item name string length + 1*/
 259     res=IStream_Read(pStm,&nameLength,sizeof(DWORD),&bread);
 260     if (bread != sizeof(DWORD))
 261         return E_FAIL;
 262
 263     /* read item name string */
 264     itemNameA=HeapAlloc(GetProcessHeap(),0,nameLength);
 265     res=IStream_Read(pStm,itemNameA,nameLength,&bread);
 266     if (bread != nameLength)
 267         return E_FAIL;
 268
 269     This->itemName=HeapReAlloc(GetProcessHeap(),0,This->itemName,nameLength*sizeof(WCHAR));
 270     if (!This->itemName)
 271         return E_OUTOFMEMORY;
 272
 273     lstrcpyAtoW(This->itemName,itemNameA);
 274
 275     return res;
 276 }
 277
 278 /******************************************************************************
 279  *        ItemMoniker_Save
 280  ******************************************************************************/
 281 HRESULT WINAPI ItemMonikerImpl_Save(IMoniker* iface,
 282                                     IStream* pStm,/* pointer to the stream where the object is to be saved */
 283                                     BOOL fClearDirty)/* Specifies whether to clear the dirty flag */
 284 {
 285     ICOM_THIS(ItemMonikerImpl,iface);
 286     HRESULT res;
 287     DWORD delimiterLength=lstrlenW(This->itemDelimiter)+1;
 288     DWORD nameLength=lstrlenW(This->itemName)+1;
 289     CHAR *itemNameA,*itemDelimiterA;
 290
 291     /* data writen by this function are : 1) DWORD : size of item delimiter string ('\0' included ) */
 292     /*                                    2) String (type A): item delimiter string ('\0' included)          */
 293     /*                                    3) DWORD : size of item name string ('\0' included)       */
 294     /*                                    4) String (type A): item name string ('\0' included)               */
 295
 296     itemNameA=HeapAlloc(GetProcessHeap(),0,nameLength);
 297     itemDelimiterA=HeapAlloc(GetProcessHeap(),0,delimiterLength);
 298     lstrcpyWtoA(itemNameA,This->itemName);
 299     lstrcpyWtoA(itemDelimiterA,This->itemDelimiter);
 300
 301     res=IStream_Write(pStm,&delimiterLength,sizeof(DWORD),NULL);
 302     res=IStream_Write(pStm,itemDelimiterA,delimiterLength * sizeof(CHAR),NULL);
 303     res=IStream_Write(pStm,&nameLength,sizeof(DWORD),NULL);
 304     res=IStream_Write(pStm,itemNameA,nameLength * sizeof(CHAR),NULL);
 305
 306     return res;
 307 }
 308
 309 /******************************************************************************
 310  *        ItemMoniker_GetSizeMax
 311  ******************************************************************************/
 312 HRESULT WINAPI ItemMonikerImpl_GetSizeMax(IMoniker* iface,
 313                                           ULARGE_INTEGER* pcbSize)/* Pointer to size of stream needed to save object */
 314 {
 315     ICOM_THIS(ItemMonikerImpl,iface);
 316     DWORD delimiterLength=lstrlenW(This->itemDelimiter)+1;
 317     DWORD nameLength=lstrlenW(This->itemName)+1;
 318
 319     TRACE(ole,"(%p,%p)\n",iface,pcbSize);
 320
 321     if (pcbSize!=NULL)
 322         return E_POINTER;
 323
 324     /* for more details see ItemMonikerImpl_Save coments */
 325
 326     pcbSize->LowPart =  sizeof(DWORD) + /* DWORD witch contains delimiter length */
 327                         delimiterLength + /* item delimiter string */
 328                         sizeof(DWORD) + /* DWORD witch contains item name length */
 329                         nameLength + /* item name string */
 330                         34; /* this constant was added ! because when I tested this function it usually */
 331                             /*  returns 34 bytes more than the number of bytes used by IMoniker::Save function */
 332     pcbSize->HighPart=0;
 333
 334     return S_OK;
 335 }
 336
 337 /******************************************************************************
 338  *         ItemMoniker_Construct (local function)
 339  *******************************************************************************/
 340 HRESULT WINAPI ItemMonikerImpl_Construct(ItemMonikerImpl* This, LPCOLESTR lpszDelim,LPCOLESTR lpszItem)
 341 {
 342
 343     int sizeStr1=lstrlenW(lpszItem);
 344     int sizeStr2=lstrlenW(lpszDelim);
 345
 346     TRACE(ole,"(%p,%p)\n",This,lpszItem);
 347
 348     /* Initialize the virtual fgunction table. */
 349     This->lpvtbl1      = &VT_ItemMonikerImpl;
 350     This->lpvtbl2      = &VT_ROTDataImpl;
 351     This->ref          = 0;
 352
 353     This->itemName=HeapAlloc(GetProcessHeap(),0,sizeof(WCHAR)*(sizeStr1+1));
 354     This->itemDelimiter=HeapAlloc(GetProcessHeap(),0,sizeof(WCHAR)*(sizeStr2+1));
 355
 356     if ((This->itemName==NULL)||(This->itemDelimiter==NULL))
 357         return E_OUTOFMEMORY;
 358
 359     lstrcpyW(This->itemName,lpszItem);
 360     lstrcpyW(This->itemDelimiter,lpszDelim);
 361
 362     return S_OK;
 363 }
 364
 365 /******************************************************************************
 366  *        ItemMoniker_Destroy (local function)
 367  *******************************************************************************/
 368 HRESULT WINAPI ItemMonikerImpl_Destroy(ItemMonikerImpl* This)
 369 {
 370     TRACE(ole,"(%p)\n",This);
 371
 372     if (This->itemName)
 373         HeapFree(GetProcessHeap(),0,This->itemName);
 374
 375     if (This->itemDelimiter)
 376         HeapFree(GetProcessHeap(),0,This->itemDelimiter);
 377
 378     HeapFree(GetProcessHeap(),0,This);
 379
 380     return S_OK;
 381 }
 382
 383 /******************************************************************************
 384  *                  ItemMoniker_BindToObject
 385  ******************************************************************************/
 386 HRESULT WINAPI ItemMonikerImpl_BindToObject(IMoniker* iface,
 387                                             IBindCtx* pbc,
 388                                             IMoniker* pmkToLeft,
 389                                             REFIID riid,
 390                                             VOID** ppvResult)
 391 {
 392     ICOM_THIS(ItemMonikerImpl,iface);
 393
 394     HRESULT   res;
 395     IID    refid=IID_IOleItemContainer;
 396     IOleItemContainer *poic=0;
 397
 398     TRACE(ole,"(%p,%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,riid,ppvResult);
 399
 400     if(ppvResult ==NULL)
 401         return E_POINTER;
 402
 403     if(pmkToLeft==NULL)
 404         return E_INVALIDARG;
 405
 406     *ppvResult=0;
 407
 408     res=IMoniker_BindToObject(pmkToLeft,pbc,NULL,&refid,(void**)&poic);
 409
 410     if (SUCCEEDED(res)){
 411
 412         res=IOleItemContainer_GetObject(poic,This->itemName,BINDSPEED_MODERATE,pbc,riid,ppvResult);
 413
 414         IOleItemContainer_Release(poic);
 415     }
 416
 417     return res;
 418 }
 419
 420 /******************************************************************************
 421  *        ItemMoniker_BindToStorage
 422  ******************************************************************************/
 423 HRESULT WINAPI ItemMonikerImpl_BindToStorage(IMoniker* iface,
 424                                              IBindCtx* pbc,
 425                                              IMoniker* pmkToLeft,
 426                                              REFIID riid,
 427                                              VOID** ppvResult)
 428 {
 429     ICOM_THIS(ItemMonikerImpl,iface);
 430
 431     HRESULT   res;
 432     IOleItemContainer *poic=0;
 433
 434     TRACE(ole,"(%p,%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,riid,ppvResult);
 435
 436     *ppvResult=0;
 437
 438     if(pmkToLeft==NULL)
 439         return E_INVALIDARG;
 440
 441     res=IMoniker_BindToObject(pmkToLeft,pbc,NULL,&IID_IOleItemContainer,(void**)&poic);
 442
 443     if (SUCCEEDED(res)){
 444
 445         res=IOleItemContainer_GetObjectStorage(poic,This->itemName,pbc,riid,ppvResult);
 446
 447         IOleItemContainer_Release(poic);
 448     }
 449
 450     return res;
 451 }
 452
 453 /******************************************************************************
 454  *        ItemMoniker_Reduce
 455  ******************************************************************************/
 456 HRESULT WINAPI ItemMonikerImpl_Reduce(IMoniker* iface,
 457                                       IBindCtx* pbc,
 458                                       DWORD dwReduceHowFar,
 459                                       IMoniker** ppmkToLeft,
 460                                       IMoniker** ppmkReduced)
 461 {
 462     TRACE(ole,"(%p,%p,%ld,%p,%p)\n",iface,pbc,dwReduceHowFar,ppmkToLeft,ppmkReduced);
 463
 464     if (ppmkReduced==NULL)
 465         return E_POINTER;
 466
 467     ItemMonikerImpl_AddRef(iface);
 468
 469     *ppmkReduced=iface;
 470
 471     return MK_S_REDUCED_TO_SELF;
 472 }
 473 /******************************************************************************
 474  *        ItemMoniker_ComposeWith
 475  ******************************************************************************/
 476 HRESULT WINAPI ItemMonikerImpl_ComposeWith(IMoniker* iface,
 477                                            IMoniker* pmkRight,
 478                                            BOOL fOnlyIfNotGeneric,
 479                                            IMoniker** ppmkComposite)
 480 {
 481     HRESULT res=S_OK;
 482     DWORD mkSys,mkSys2;
 483     IEnumMoniker* penumMk=0;
 484     IMoniker *pmostLeftMk=0;
 485     IMoniker* tempMkComposite=0;
 486
 487     TRACE(ole,"(%p,%p,%d,%p)\n",iface,pmkRight,fOnlyIfNotGeneric,ppmkComposite);
 488
 489     if ((ppmkComposite==NULL)||(pmkRight==NULL))
 490         return E_POINTER;
 491
 492     *ppmkComposite=0;
 493
 494     IMoniker_IsSystemMoniker(pmkRight,&mkSys);
 495
 496     /* If pmkRight is an anti-moniker, the returned moniker is NULL */
 497     if(mkSys==MKSYS_ANTIMONIKER)
 498         return res;
 499
 500     else
 501         /* if pmkRight is a composite whose leftmost component is an anti-moniker,           */
 502         /* the returned moniker is the composite after the leftmost anti-moniker is removed. */
 503
 504          if(mkSys==MKSYS_GENERICCOMPOSITE){
 505
 506             res=IMoniker_Enum(pmkRight,TRUE,&penumMk);
 507
 508             if (FAILED(res))
 509                 return res;
 510
 511             res=IEnumMoniker_Next(penumMk,1,&pmostLeftMk,NULL);
 512
 513             IMoniker_IsSystemMoniker(pmostLeftMk,&mkSys2);
 514
 515             if(mkSys2==MKSYS_ANTIMONIKER){
 516
 517                 IMoniker_Release(pmostLeftMk);
 518
 519                 tempMkComposite=iface;
 520                 IMoniker_AddRef(iface);
 521
 522                 while(IEnumMoniker_Next(penumMk,1,&pmostLeftMk,NULL)==S_OK){
 523
 524                     res=CreateGenericComposite(tempMkComposite,pmostLeftMk,ppmkComposite);
 525
 526                     IMoniker_Release(tempMkComposite);
 527                     IMoniker_Release(pmostLeftMk);
 528
 529                     tempMkComposite=*ppmkComposite;
 530                     IMoniker_AddRef(tempMkComposite);
 531 }
 532                 return res;
 533             }
 534             else
 535                 return CreateGenericComposite(iface,pmkRight,ppmkComposite);
 536          }
 537          /* If pmkRight is not an anti-moniker, the method combines the two monikers into a generic
 538           composite if fOnlyIfNotGeneric is FALSE; if fOnlyIfNotGeneric is TRUE, the method returns
 539           a NULL moniker and a return value of MK_E_NEEDGENERIC */
 540           else
 541             if (!fOnlyIfNotGeneric)
 542                 return CreateGenericComposite(iface,pmkRight,ppmkComposite);
 543
 544             else
 545                 return MK_E_NEEDGENERIC;
 546 }
 547
 548 /******************************************************************************
 549  *        ItemMoniker_Enum
 550  ******************************************************************************/
 551 HRESULT WINAPI ItemMonikerImpl_Enum(IMoniker* iface,BOOL fForward, IEnumMoniker** ppenumMoniker)
 552 {
 553     TRACE(ole,"(%p,%d,%p)\n",iface,fForward,ppenumMoniker);
 554
 555     if (ppenumMoniker == NULL)
 556         return E_POINTER;
 557
 558     *ppenumMoniker = NULL;
 559
 560     return S_OK;
 561 }
 562
 563 /******************************************************************************
 564  *        ItemMoniker_IsEqual
 565  ******************************************************************************/
 566 HRESULT WINAPI ItemMonikerImpl_IsEqual(IMoniker* iface,IMoniker* pmkOtherMoniker)
 567 {
 568
 569     CLSID clsid;
 570     LPOLESTR dispName1,dispName2;
 571     IBindCtx* bind;
 572     HRESULT res;
 573
 574     TRACE(ole,"(%p,%p)\n",iface,pmkOtherMoniker);
 575
 576     if (pmkOtherMoniker==NULL)
 577         return S_FALSE;
 578
 579     /* This method returns S_OK if both monikers are item monikers and their display names are */
 580     /* identical (using a case-insensitive comparison); otherwise, the method returns S_FALSE. */
 581
 582     IMoniker_GetClassID(pmkOtherMoniker,&clsid);
 583
 584     if (!IsEqualCLSID(&clsid,&CLSID_ItemMoniker))
 585         return S_FALSE;
 586
 587     res=CreateBindCtx(0,&bind);
 588     if (FAILED(res))
 589         return res;
 590
 591     IMoniker_GetDisplayName(iface,bind,NULL,&dispName1);
 592     IMoniker_GetDisplayName(pmkOtherMoniker,bind,NULL,&dispName2);
 593
 594     if (lstrcmpW(dispName1,dispName2)!=0)
 595         return S_FALSE;
 596
 597     return S_OK;
 598 }
 599
 600 /******************************************************************************
 601  *        ItemMoniker_Hash
 602  ******************************************************************************/
 603 HRESULT WINAPI ItemMonikerImpl_Hash(IMoniker* iface,DWORD* pdwHash)
 604 {
 605     ICOM_THIS(ItemMonikerImpl,iface);
 606
 607     int  h = 0,i,skip,len;
 608     int  off = 0;
 609     LPOLESTR val;
 610
 611     if (pdwHash==NULL)
 612         return E_POINTER;
 613
 614     val =  This->itemName;
 615     len = lstrlenW(val);
 616
 617     if (len < 16) {
 618         for (i = len ; i > 0; i--) {
 619             h = (h * 37) + val[off++];
 620 }
 621     } else {
 622         /* only sample some characters */
 623         skip = len / 8;
 624         for (i = len ; i > 0; i -= skip, off += skip) {
 625             h = (h * 39) + val[off];
 626         }
 627     }
 628
 629     *pdwHash=h;
 630
 631     return S_OK;
 632 }
 633
 634 /******************************************************************************
 635  *        ItemMoniker_IsRunning
 636  ******************************************************************************/
 637 HRESULT WINAPI ItemMonikerImpl_IsRunning(IMoniker* iface,
 638                                          IBindCtx* pbc,
 639                                          IMoniker* pmkToLeft,
 640                                          IMoniker* pmkNewlyRunning)
 641 {
 642     IRunningObjectTable* rot;
 643     HRESULT res;
 644     IOleItemContainer *poic=0;
 645     ICOM_THIS(ItemMonikerImpl,iface);
 646
 647     TRACE(ole,"(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pmkNewlyRunning);
 648
 649     /* If pmkToLeft is NULL, this method returns TRUE if pmkNewlyRunning is non-NULL and is equal to this */
 650     /* moniker. Otherwise, the method checks the ROT to see whether this moniker is running.              */
 651     if (pmkToLeft==NULL)
 652         if ((pmkNewlyRunning!=NULL)&&(IMoniker_IsEqual(pmkNewlyRunning,iface)==S_OK))
 653             return S_OK;
 654         else {
 655             if (pbc==NULL)
 656                 return E_POINTER;
 657
 658             res=IBindCtx_GetRunningObjectTable(pbc,&rot);
 659
 660             if (FAILED(res))
 661                 return res;
 662
 663             res = IRunningObjectTable_IsRunning(rot,iface);
 664
 665             IRunningObjectTable_Release(rot);
 666         }
 667     else{
 668
 669         /* If pmkToLeft is non-NULL, the method calls IMoniker::BindToObject on the pmkToLeft parameter,         */
 670         /* requesting an IOleItemContainer interface pointer. The method then calls IOleItemContainer::IsRunning,*/
 671         /* passing the string contained within this moniker. */
 672
 673         res=IMoniker_BindToObject(pmkToLeft,pbc,NULL,&IID_IOleItemContainer,(void**)&poic);
 674
 675         if (SUCCEEDED(res)){
 676
 677             res=IOleItemContainer_IsRunning(poic,This->itemName);
 678
 679             IOleItemContainer_Release(poic);
 680         }
 681     }
 682
 683     return res;
 684 }
 685
 686 /******************************************************************************
 687  *        ItemMoniker_GetTimeOfLastChange
 688  ******************************************************************************/
 689 HRESULT WINAPI ItemMonikerImpl_GetTimeOfLastChange(IMoniker* iface,
 690                                                    IBindCtx* pbc,
 691                                                    IMoniker* pmkToLeft,
 692                                                    FILETIME* pItemTime)
 693 {
 694     IRunningObjectTable* rot;
 695     HRESULT res;
 696     IMoniker *compositeMk;
 697
 698     TRACE(ole,"(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pItemTime);
 699
 700     if (pItemTime==NULL)
 701         return E_INVALIDARG;
 702
 703     /* If pmkToLeft is NULL, this method returns MK_E_NOTBINDABLE */
 704     if (pmkToLeft==NULL)
 705
 706         return MK_E_NOTBINDABLE;
 707     else {
 708
 709         /* Otherwise, the method creates a composite of pmkToLeft and this moniker and uses the ROT to access  */
 710         /* the time of last change. If the object is not in the ROT, the method calls                          */
 711         /* IMoniker::GetTimeOfLastChange on the pmkToLeft parameter.                                            */
 712
 713         res=CreateGenericComposite(pmkToLeft,iface,&compositeMk);
 714
 715         res=IBindCtx_GetRunningObjectTable(pbc,&rot);
 716
 717         if (IRunningObjectTable_GetTimeOfLastChange(rot,compositeMk,pItemTime)!=S_OK)
 718
 719             res=IMoniker_GetTimeOfLastChange(pmkToLeft,pbc,NULL,pItemTime);
 720
 721         IMoniker_Release(compositeMk);
 722 }
 723
 724     return res;
 725 }
 726
 727 /******************************************************************************
 728  *        ItemMoniker_Inverse
 729  ******************************************************************************/
 730 HRESULT WINAPI ItemMonikerImpl_Inverse(IMoniker* iface,IMoniker** ppmk)
 731 {
 732     TRACE(ole,"(%p,%p)\n",iface,ppmk);
 733
 734     if (ppmk==NULL)
 735         return E_POINTER;
 736
 737     return CreateAntiMoniker(ppmk);
 738 }
 739
 740 /******************************************************************************
 741  *        ItemMoniker_CommonPrefixWith
 742  ******************************************************************************/
 743 HRESULT WINAPI ItemMonikerImpl_CommonPrefixWith(IMoniker* iface,IMoniker* pmkOther,IMoniker** ppmkPrefix)
 744 {
 745     DWORD mkSys;
 746     IMoniker_IsSystemMoniker(pmkOther,&mkSys);
 747     /* If the other moniker is an item moniker that is equal to this moniker, this method sets *ppmkPrefix */
 748     /* to this moniker and returns MK_S_US */
 749
 750     if((mkSys==MKSYS_ITEMMONIKER) && (IMoniker_IsEqual(iface,pmkOther)==S_OK) ){
 751
 752         *ppmkPrefix=iface;
 753
 754         IMoniker_AddRef(iface);
 755
 756         return MK_S_US;
 757     }
 758     else
 759         /* otherwise, the method calls the MonikerCommonPrefixWith function. This function correctly handles */
 760         /* the case where the other moniker is a generic composite. */
 761         return MonikerCommonPrefixWith(iface,pmkOther,ppmkPrefix);
 762 }
 763
 764 /******************************************************************************
 765  *        ItemMoniker_RelativePathTo
 766  ******************************************************************************/
 767 HRESULT WINAPI ItemMonikerImpl_RelativePathTo(IMoniker* iface,IMoniker* pmOther, IMoniker** ppmkRelPath)
 768 {
 769     TRACE(ole,"(%p,%p,%p)\n",iface,pmOther,ppmkRelPath);
 770
 771     if (ppmkRelPath==NULL)
 772         return E_POINTER;
 773
 774     *ppmkRelPath=0;
 775
 776     return MK_E_NOTBINDABLE;
 777 }
 778
 779 /******************************************************************************
 780  *        ItemMoniker_GetDisplayName
 781  ******************************************************************************/
 782 HRESULT WINAPI ItemMonikerImpl_GetDisplayName(IMoniker* iface,
 783                                               IBindCtx* pbc,
 784                                               IMoniker* pmkToLeft,
 785                                               LPOLESTR *ppszDisplayName)
 786 {
 787     ICOM_THIS(ItemMonikerImpl,iface);
 788
 789     TRACE(ole,"(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,ppszDisplayName);
 790
 791     if (ppszDisplayName==NULL)
 792         return E_POINTER;
 793
 794     if (pmkToLeft!=NULL){
 795         return E_INVALIDARG;
 796     }
 797
 798     *ppszDisplayName=CoTaskMemAlloc(sizeof(WCHAR)*(lstrlenW(This->itemDelimiter)+lstrlenW(This->itemName)+1));
 799
 800     if (*ppszDisplayName==NULL)
 801         return E_OUTOFMEMORY;
 802
 803     lstrcpyW(*ppszDisplayName,This->itemDelimiter);
 804     lstrcatW(*ppszDisplayName,This->itemName);
 805
 806     return S_OK;
 807 }
 808
 809 /******************************************************************************
 810  *        ItemMoniker_ParseDisplayName
 811  ******************************************************************************/
 812 HRESULT WINAPI ItemMonikerImpl_ParseDisplayName(IMoniker* iface,
 813                                                 IBindCtx* pbc,
 814                                                 IMoniker* pmkToLeft,
 815                                                 LPOLESTR pszDisplayName,
 816                                                 ULONG* pchEaten,
 817                                                 IMoniker** ppmkOut)
 818 {
 819     IOleItemContainer* poic=0;
 820     IParseDisplayName* ppdn=0;
 821     LPOLESTR displayName;
 822     HRESULT res;
 823     ICOM_THIS(ItemMonikerImpl,iface);
 824
 825     /* If pmkToLeft is NULL, this method returns MK_E_SYNTAX */
 826     if (pmkToLeft==NULL)
 827
 828         return MK_E_SYNTAX;
 829
 830     else{
 831         /* Otherwise, the method calls IMoniker::BindToObject on the pmkToLeft parameter, requesting an */
 832         /* IParseDisplayName interface pointer to the object identified by the moniker, and passes the display */        /* name to IParseDisplayName::ParseDisplayName */
 833         res=IMoniker_BindToObject(pmkToLeft,pbc,NULL,&IID_IOleItemContainer,(void**)&poic);
 834
 835         if (SUCCEEDED(res)){
 836
 837             res=IOleItemContainer_GetObject(poic,This->itemName,BINDSPEED_MODERATE,pbc,&IID_IParseDisplayName,(void**)&ppdn);
 838
 839             res=IMoniker_GetDisplayName(iface,pbc,NULL,&displayName);
 840
 841             res=IParseDisplayName_ParseDisplayName(ppdn,pbc,displayName,pchEaten,ppmkOut);
 842
 843             IOleItemContainer_Release(poic);
 844             IParseDisplayName_Release(ppdn);
 845         }
 846 }
 847     return res;
 848 }
 849
 850 /******************************************************************************
 851  *        ItemMoniker_IsSystemMonker
 852  ******************************************************************************/
 853 HRESULT WINAPI ItemMonikerImpl_IsSystemMoniker(IMoniker* iface,DWORD* pwdMksys)
 854 {
 855     TRACE(ole,"(%p,%p)\n",iface,pwdMksys);
 856
 857     if (!pwdMksys)
 858         return E_POINTER;
 859
 860     (*pwdMksys)=MKSYS_ITEMMONIKER;
 861
 862     return S_OK;
 863 }
 864
 865 /*******************************************************************************
 866  *        ItemMonikerIROTData_QueryInterface
 867  *******************************************************************************/
 868 HRESULT WINAPI ItemMonikerROTDataImpl_QueryInterface(IROTData *iface,REFIID riid,VOID** ppvObject)
 869 {
 870
 871     ICOM_THIS_From_IROTData(IMoniker, iface);
 872
 873     TRACE(ole,"(%p,%p,%p)\n",iface,riid,ppvObject);
 874
 875     return ItemMonikerImpl_QueryInterface(This, riid, ppvObject);
 876 }
 877
 878 /***********************************************************************
 879  *        ItemMonikerIROTData_AddRef
 880  */
 881 ULONG   WINAPI ItemMonikerROTDataImpl_AddRef(IROTData *iface)
 882 {
 883     ICOM_THIS_From_IROTData(IMoniker, iface);
 884
 885     TRACE(ole,"(%p)\n",iface);
 886
 887     return ItemMonikerImpl_AddRef(This);
 888 }
 889
 890 /***********************************************************************
 891  *        ItemMonikerIROTData_Release
 892  */
 893 ULONG   WINAPI ItemMonikerROTDataImpl_Release(IROTData* iface)
 894 {
 895     ICOM_THIS_From_IROTData(IMoniker, iface);
 896
 897     TRACE(ole,"(%p)\n",iface);
 898
 899     return ItemMonikerImpl_Release(This);
 900 }
 901
 902 /******************************************************************************
 903  *        ItemMonikerIROTData_GetComparaisonData
 904  ******************************************************************************/
 905 HRESULT WINAPI ItemMonikerROTDataImpl_GetComparaisonData(IROTData* iface,
 906                                                          BYTE* pbData,
 907                                                          ULONG cbMax,
 908                                                          ULONG* pcbData)
 909 {
 910     FIXME(ole,"(),stub!\n");
 911     return E_NOTIMPL;
 912 }
 913
 914 /******************************************************************************
 915  *        CreateItemMoniker16   [OLE2.28]
 916  ******************************************************************************/
 917 HRESULT WINAPI CreateItemMoniker16(LPCOLESTR16 lpszDelim,LPCOLESTR  lpszItem,LPMONIKER* ppmk)
 918 {
 919
 920     FIXME(ole,"(%s,%p),stub!\n",lpszDelim,ppmk);
 921     *ppmk = NULL;
 922     return E_NOTIMPL;
 923 }
 924
 925 /******************************************************************************
 926  *        CreateItemMoniker     [OLE.55]
 927  ******************************************************************************/
 928 HRESULT WINAPI CreateItemMoniker(LPCOLESTR lpszDelim,LPCOLESTR  lpszItem, LPMONIKER * ppmk)
 929 {
 930     ItemMonikerImpl* newItemMoniker = 0;
 931     HRESULT        hr = S_OK;
 932     IID riid=IID_IMoniker;
 933
 934     TRACE(ole,"(%p,%p,%p)\n",lpszDelim,lpszItem,ppmk);
 935
 936     newItemMoniker = HeapAlloc(GetProcessHeap(), 0, sizeof(ItemMonikerImpl));
 937
 938     if (newItemMoniker == 0)
 939         return STG_E_INSUFFICIENTMEMORY;
 940
 941     hr = ItemMonikerImpl_Construct(newItemMoniker,lpszDelim,lpszItem);
 942
 943     if (FAILED(hr)){
 944
 945         HeapFree(GetProcessHeap(),0,newItemMoniker);
 946     return hr;
 947     }
 948
 949     return ItemMonikerImpl_QueryInterface((IMoniker*)newItemMoniker,&riid,(void**)ppmk);
 950 }