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