dlls/ole32/itemmoniker.c

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