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