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