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