1 /***************************************************************************************
2 * ItemMonikers implementation
4 * Copyright 1999 Noomen Hamza
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.
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.
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 ***************************************************************************************/
25 #define NONAMELESSUNION
26 #define NONAMELESSSTRUCT
32 #include "wine/debug.h"
34 #include "wine/unicode.h"
37 WINE_DEFAULT_DEBUG_CHANNEL(ole
);
39 const CLSID CLSID_ItemMoniker
= {
40 0x304, 0, 0, {0xC0, 0, 0, 0, 0, 0, 0, 0x46}
43 /* ItemMoniker data structure */
44 typedef struct ItemMonikerImpl
{
46 IMonikerVtbl
* lpvtbl1
; /* VTable relative to the IMoniker interface.*/
48 /* The ROT (RunningObjectTable implementation) uses the IROTData interface to test whether
49 * two monikers are equal. That's whay IROTData interface is implemented by monikers.
51 IROTDataVtbl
* lpvtbl2
; /* VTable relative to the IROTData interface.*/
53 ULONG ref
; /* reference counter for this object */
55 LPOLESTR itemName
; /* item name identified by this ItemMoniker */
57 LPOLESTR itemDelimiter
; /* Delimiter string */
61 /********************************************************************************/
62 /* ItemMoniker prototype functions : */
64 /* IUnknown prototype functions */
65 static HRESULT WINAPI
ItemMonikerImpl_QueryInterface(IMoniker
* iface
,REFIID riid
,void** ppvObject
);
66 static ULONG WINAPI
ItemMonikerImpl_AddRef(IMoniker
* iface
);
67 static ULONG WINAPI
ItemMonikerImpl_Release(IMoniker
* iface
);
69 /* IPersist prototype functions */
70 static HRESULT WINAPI
ItemMonikerImpl_GetClassID(IMoniker
* iface
, CLSID
*pClassID
);
72 /* IPersistStream prototype functions */
73 static HRESULT WINAPI
ItemMonikerImpl_IsDirty(IMoniker
* iface
);
74 static HRESULT WINAPI
ItemMonikerImpl_Load(IMoniker
* iface
, IStream
* pStm
);
75 static HRESULT WINAPI
ItemMonikerImpl_Save(IMoniker
* iface
, IStream
* pStm
, BOOL fClearDirty
);
76 static HRESULT WINAPI
ItemMonikerImpl_GetSizeMax(IMoniker
* iface
, ULARGE_INTEGER
* pcbSize
);
78 /* IMoniker prototype functions */
79 static HRESULT WINAPI
ItemMonikerImpl_BindToObject(IMoniker
* iface
,IBindCtx
* pbc
, IMoniker
* pmkToLeft
, REFIID riid
, VOID
** ppvResult
);
80 static HRESULT WINAPI
ItemMonikerImpl_BindToStorage(IMoniker
* iface
,IBindCtx
* pbc
, IMoniker
* pmkToLeft
, REFIID riid
, VOID
** ppvResult
);
81 static HRESULT WINAPI
ItemMonikerImpl_Reduce(IMoniker
* iface
,IBindCtx
* pbc
, DWORD dwReduceHowFar
,IMoniker
** ppmkToLeft
, IMoniker
** ppmkReduced
);
82 static HRESULT WINAPI
ItemMonikerImpl_ComposeWith(IMoniker
* iface
,IMoniker
* pmkRight
,BOOL fOnlyIfNotGeneric
, IMoniker
** ppmkComposite
);
83 static HRESULT WINAPI
ItemMonikerImpl_Enum(IMoniker
* iface
,BOOL fForward
, IEnumMoniker
** ppenumMoniker
);
84 static HRESULT WINAPI
ItemMonikerImpl_IsEqual(IMoniker
* iface
,IMoniker
* pmkOtherMoniker
);
85 static HRESULT WINAPI
ItemMonikerImpl_Hash(IMoniker
* iface
,DWORD
* pdwHash
);
86 static HRESULT WINAPI
ItemMonikerImpl_IsRunning(IMoniker
* iface
,IBindCtx
* pbc
, IMoniker
* pmkToLeft
, IMoniker
* pmkNewlyRunning
);
87 static HRESULT WINAPI
ItemMonikerImpl_GetTimeOfLastChange(IMoniker
* iface
, IBindCtx
* pbc
, IMoniker
* pmkToLeft
, FILETIME
* pItemTime
);
88 static HRESULT WINAPI
ItemMonikerImpl_Inverse(IMoniker
* iface
,IMoniker
** ppmk
);
89 static HRESULT WINAPI
ItemMonikerImpl_CommonPrefixWith(IMoniker
* iface
,IMoniker
* pmkOther
, IMoniker
** ppmkPrefix
);
90 static HRESULT WINAPI
ItemMonikerImpl_RelativePathTo(IMoniker
* iface
,IMoniker
* pmOther
, IMoniker
** ppmkRelPath
);
91 static HRESULT WINAPI
ItemMonikerImpl_GetDisplayName(IMoniker
* iface
,IBindCtx
* pbc
, IMoniker
* pmkToLeft
, LPOLESTR
*ppszDisplayName
);
92 static HRESULT WINAPI
ItemMonikerImpl_ParseDisplayName(IMoniker
* iface
,IBindCtx
* pbc
, IMoniker
* pmkToLeft
, LPOLESTR pszDisplayName
, ULONG
* pchEaten
, IMoniker
** ppmkOut
);
93 static HRESULT WINAPI
ItemMonikerImpl_IsSystemMoniker(IMoniker
* iface
,DWORD
* pwdMksys
);
95 /* Local function used by ItemMoniker implementation */
96 HRESULT WINAPI
ItemMonikerImpl_Construct(ItemMonikerImpl
* iface
, LPCOLESTR lpszDelim
,LPCOLESTR lpszPathName
);
97 HRESULT WINAPI
ItemMonikerImpl_Destroy(ItemMonikerImpl
* iface
);
99 /********************************************************************************/
100 /* IROTData prototype functions */
102 /* IUnknown prototype functions */
103 static HRESULT WINAPI
ItemMonikerROTDataImpl_QueryInterface(IROTData
* iface
,REFIID riid
,VOID
** ppvObject
);
104 static ULONG WINAPI
ItemMonikerROTDataImpl_AddRef(IROTData
* iface
);
105 static ULONG WINAPI
ItemMonikerROTDataImpl_Release(IROTData
* iface
);
107 /* IROTData prototype function */
108 static HRESULT WINAPI
ItemMonikerROTDataImpl_GetComparaisonData(IROTData
* iface
,BYTE
* pbData
,ULONG cbMax
,ULONG
* pcbData
);
110 /********************************************************************************/
111 /* Virtual function table for the ItemMonikerImpl class which include IPersist,*/
112 /* IPersistStream and IMoniker functions. */
113 static IMonikerVtbl VT_ItemMonikerImpl
=
115 ItemMonikerImpl_QueryInterface
,
116 ItemMonikerImpl_AddRef
,
117 ItemMonikerImpl_Release
,
118 ItemMonikerImpl_GetClassID
,
119 ItemMonikerImpl_IsDirty
,
120 ItemMonikerImpl_Load
,
121 ItemMonikerImpl_Save
,
122 ItemMonikerImpl_GetSizeMax
,
123 ItemMonikerImpl_BindToObject
,
124 ItemMonikerImpl_BindToStorage
,
125 ItemMonikerImpl_Reduce
,
126 ItemMonikerImpl_ComposeWith
,
127 ItemMonikerImpl_Enum
,
128 ItemMonikerImpl_IsEqual
,
129 ItemMonikerImpl_Hash
,
130 ItemMonikerImpl_IsRunning
,
131 ItemMonikerImpl_GetTimeOfLastChange
,
132 ItemMonikerImpl_Inverse
,
133 ItemMonikerImpl_CommonPrefixWith
,
134 ItemMonikerImpl_RelativePathTo
,
135 ItemMonikerImpl_GetDisplayName
,
136 ItemMonikerImpl_ParseDisplayName
,
137 ItemMonikerImpl_IsSystemMoniker
140 /********************************************************************************/
141 /* Virtual function table for the IROTData class. */
142 static IROTDataVtbl VT_ROTDataImpl
=
144 ItemMonikerROTDataImpl_QueryInterface
,
145 ItemMonikerROTDataImpl_AddRef
,
146 ItemMonikerROTDataImpl_Release
,
147 ItemMonikerROTDataImpl_GetComparaisonData
150 /*******************************************************************************
151 * ItemMoniker_QueryInterface
152 *******************************************************************************/
153 HRESULT WINAPI
ItemMonikerImpl_QueryInterface(IMoniker
* iface
,REFIID riid
,void** ppvObject
)
155 ItemMonikerImpl
*This
= (ItemMonikerImpl
*)iface
;
157 TRACE("(%p,%p,%p)\n",This
,riid
,ppvObject
);
159 /* Perform a sanity check on the parameters.*/
160 if ( (This
==0) || (ppvObject
==0) )
163 /* Initialize the return parameter */
166 /* Compare the riid with the interface IDs implemented by this object.*/
167 if (IsEqualIID(&IID_IUnknown
, riid
) ||
168 IsEqualIID(&IID_IPersist
, riid
) ||
169 IsEqualIID(&IID_IPersistStream
, riid
) ||
170 IsEqualIID(&IID_IMoniker
, riid
)
174 else if (IsEqualIID(&IID_IROTData
, riid
))
175 *ppvObject
= (IROTData
*)&(This
->lpvtbl2
);
177 /* Check that we obtained an interface.*/
179 return E_NOINTERFACE
;
181 /* Query Interface always increases the reference count by one when it is successful */
182 ItemMonikerImpl_AddRef(iface
);
187 /******************************************************************************
189 ******************************************************************************/
190 ULONG WINAPI
ItemMonikerImpl_AddRef(IMoniker
* iface
)
192 ItemMonikerImpl
*This
= (ItemMonikerImpl
*)iface
;
194 TRACE("(%p)\n",This
);
196 return ++(This
->ref
);
199 /******************************************************************************
200 * ItemMoniker_Release
201 ******************************************************************************/
202 ULONG WINAPI
ItemMonikerImpl_Release(IMoniker
* iface
)
204 ItemMonikerImpl
*This
= (ItemMonikerImpl
*)iface
;
206 TRACE("(%p)\n",This
);
210 /* destroy the object if there's no more reference on it */
213 ItemMonikerImpl_Destroy(This
);
220 /******************************************************************************
221 * ItemMoniker_GetClassID
222 ******************************************************************************/
223 HRESULT WINAPI
ItemMonikerImpl_GetClassID(IMoniker
* iface
,CLSID
*pClassID
)
225 TRACE("(%p,%p),stub!\n",iface
,pClassID
);
230 *pClassID
= CLSID_ItemMoniker
;
235 /******************************************************************************
236 * ItemMoniker_IsDirty
237 ******************************************************************************/
238 HRESULT WINAPI
ItemMonikerImpl_IsDirty(IMoniker
* iface
)
240 /* Note that the OLE-provided implementations of the IPersistStream::IsDirty
241 method in the OLE-provided moniker interfaces always return S_FALSE because
242 their internal state never changes. */
244 TRACE("(%p)\n",iface
);
249 /******************************************************************************
251 ******************************************************************************/
252 HRESULT WINAPI
ItemMonikerImpl_Load(IMoniker
* iface
,IStream
* pStm
)
255 ItemMonikerImpl
*This
= (ItemMonikerImpl
*)iface
;
257 DWORD delimiterLength
,nameLength
,lenW
;
258 CHAR
*itemNameA
,*itemDelimiterA
;
261 /* for more details about data read by this function see coments of ItemMonikerImpl_Save function */
263 /* read item delimiter string length + 1 */
264 res
=IStream_Read(pStm
,&delimiterLength
,sizeof(DWORD
),&bread
);
265 if (bread
!= sizeof(DWORD
))
268 /* read item delimiter string */
269 if (!(itemDelimiterA
=HeapAlloc(GetProcessHeap(),0,delimiterLength
)))
270 return E_OUTOFMEMORY
;
271 res
=IStream_Read(pStm
,itemDelimiterA
,delimiterLength
,&bread
);
272 if (bread
!= delimiterLength
)
274 HeapFree( GetProcessHeap(), 0, itemDelimiterA
);
278 lenW
= MultiByteToWideChar( CP_ACP
, 0, itemDelimiterA
, -1, NULL
, 0 );
279 This
->itemDelimiter
=HeapReAlloc(GetProcessHeap(),0,This
->itemDelimiter
,lenW
*sizeof(WCHAR
));
280 if (!This
->itemDelimiter
)
282 HeapFree( GetProcessHeap(), 0, itemDelimiterA
);
283 return E_OUTOFMEMORY
;
285 MultiByteToWideChar( CP_ACP
, 0, itemDelimiterA
, -1, This
->itemDelimiter
, lenW
);
286 HeapFree( GetProcessHeap(), 0, itemDelimiterA
);
288 /* read item name string length + 1*/
289 res
=IStream_Read(pStm
,&nameLength
,sizeof(DWORD
),&bread
);
290 if (bread
!= sizeof(DWORD
))
293 /* read item name string */
294 if (!(itemNameA
=HeapAlloc(GetProcessHeap(),0,nameLength
)))
295 return E_OUTOFMEMORY
;
296 res
=IStream_Read(pStm
,itemNameA
,nameLength
,&bread
);
297 if (bread
!= nameLength
)
299 HeapFree( GetProcessHeap(), 0, itemNameA
);
303 lenW
= MultiByteToWideChar( CP_ACP
, 0, itemNameA
, -1, NULL
, 0 );
304 This
->itemName
=HeapReAlloc(GetProcessHeap(),0,This
->itemName
,lenW
*sizeof(WCHAR
));
307 HeapFree( GetProcessHeap(), 0, itemNameA
);
308 return E_OUTOFMEMORY
;
310 MultiByteToWideChar( CP_ACP
, 0, itemNameA
, -1, This
->itemName
, lenW
);
311 HeapFree( GetProcessHeap(), 0, itemNameA
);
316 /******************************************************************************
318 ******************************************************************************/
319 HRESULT WINAPI
ItemMonikerImpl_Save(IMoniker
* iface
,
320 IStream
* pStm
,/* pointer to the stream where the object is to be saved */
321 BOOL fClearDirty
)/* Specifies whether to clear the dirty flag */
323 ItemMonikerImpl
*This
= (ItemMonikerImpl
*)iface
;
325 CHAR
*itemNameA
,*itemDelimiterA
;
327 /* data written by this function are : 1) DWORD : size of item delimiter string ('\0' included ) */
328 /* 2) String (type A): item delimiter string ('\0' included) */
329 /* 3) DWORD : size of item name string ('\0' included) */
330 /* 4) String (type A): item name string ('\0' included) */
332 DWORD nameLength
= WideCharToMultiByte( CP_ACP
, 0, This
->itemName
, -1, NULL
, 0, NULL
, NULL
);
333 DWORD delimiterLength
= WideCharToMultiByte( CP_ACP
, 0, This
->itemDelimiter
, -1, NULL
, 0, NULL
, NULL
);
334 itemNameA
=HeapAlloc(GetProcessHeap(),0,nameLength
);
335 itemDelimiterA
=HeapAlloc(GetProcessHeap(),0,delimiterLength
);
336 WideCharToMultiByte( CP_ACP
, 0, This
->itemName
, -1, itemNameA
, nameLength
, NULL
, NULL
);
337 WideCharToMultiByte( CP_ACP
, 0, This
->itemDelimiter
, -1, itemDelimiterA
, delimiterLength
, NULL
, NULL
);
339 res
=IStream_Write(pStm
,&delimiterLength
,sizeof(DWORD
),NULL
);
340 res
=IStream_Write(pStm
,itemDelimiterA
,delimiterLength
* sizeof(CHAR
),NULL
);
341 res
=IStream_Write(pStm
,&nameLength
,sizeof(DWORD
),NULL
);
342 res
=IStream_Write(pStm
,itemNameA
,nameLength
* sizeof(CHAR
),NULL
);
347 /******************************************************************************
348 * ItemMoniker_GetSizeMax
349 ******************************************************************************/
350 HRESULT WINAPI
ItemMonikerImpl_GetSizeMax(IMoniker
* iface
,
351 ULARGE_INTEGER
* pcbSize
)/* Pointer to size of stream needed to save object */
353 ItemMonikerImpl
*This
= (ItemMonikerImpl
*)iface
;
354 DWORD delimiterLength
=lstrlenW(This
->itemDelimiter
)+1;
355 DWORD nameLength
=lstrlenW(This
->itemName
)+1;
357 TRACE("(%p,%p)\n",iface
,pcbSize
);
362 /* for more details see ItemMonikerImpl_Save coments */
364 pcbSize
->u
.LowPart
= sizeof(DWORD
) + /* DWORD which contains delimiter length */
365 delimiterLength
+ /* item delimiter string */
366 sizeof(DWORD
) + /* DWORD which contains item name length */
367 nameLength
+ /* item name string */
368 34; /* this constant was added ! because when I tested this function it usually */
369 /* returns 34 bytes more than the number of bytes used by IMoniker::Save function */
370 pcbSize
->u
.HighPart
=0;
375 /******************************************************************************
376 * ItemMoniker_Construct (local function)
377 *******************************************************************************/
378 HRESULT WINAPI
ItemMonikerImpl_Construct(ItemMonikerImpl
* This
, LPCOLESTR lpszDelim
,LPCOLESTR lpszItem
)
381 int sizeStr1
=lstrlenW(lpszItem
), sizeStr2
;
382 static const OLECHAR emptystr
[1];
385 TRACE("(%p,%p)\n",This
,lpszItem
);
387 /* Initialize the virtual fgunction table. */
388 This
->lpvtbl1
= &VT_ItemMonikerImpl
;
389 This
->lpvtbl2
= &VT_ROTDataImpl
;
392 This
->itemName
=HeapAlloc(GetProcessHeap(),0,sizeof(WCHAR
)*(sizeStr1
+1));
394 return E_OUTOFMEMORY
;
395 lstrcpyW(This
->itemName
,lpszItem
);
398 FIXME("lpszDelim is NULL. Using empty string which is possibly wrong.\n");
400 delim
= lpszDelim
? lpszDelim
: emptystr
;
402 sizeStr2
=lstrlenW(delim
);
403 This
->itemDelimiter
=HeapAlloc(GetProcessHeap(),0,sizeof(WCHAR
)*(sizeStr2
+1));
404 if (!This
->itemDelimiter
) {
405 HeapFree(GetProcessHeap(),0,This
->itemName
);
406 return E_OUTOFMEMORY
;
408 lstrcpyW(This
->itemDelimiter
,delim
);
412 /******************************************************************************
413 * ItemMoniker_Destroy (local function)
414 *******************************************************************************/
415 HRESULT WINAPI
ItemMonikerImpl_Destroy(ItemMonikerImpl
* This
)
417 TRACE("(%p)\n",This
);
420 HeapFree(GetProcessHeap(),0,This
->itemName
);
422 if (This
->itemDelimiter
)
423 HeapFree(GetProcessHeap(),0,This
->itemDelimiter
);
425 HeapFree(GetProcessHeap(),0,This
);
430 /******************************************************************************
431 * ItemMoniker_BindToObject
432 ******************************************************************************/
433 HRESULT WINAPI
ItemMonikerImpl_BindToObject(IMoniker
* iface
,
439 ItemMonikerImpl
*This
= (ItemMonikerImpl
*)iface
;
442 IID refid
=IID_IOleItemContainer
;
443 IOleItemContainer
*poic
=0;
445 TRACE("(%p,%p,%p,%p,%p)\n",iface
,pbc
,pmkToLeft
,riid
,ppvResult
);
455 res
=IMoniker_BindToObject(pmkToLeft
,pbc
,NULL
,&refid
,(void**)&poic
);
459 res
=IOleItemContainer_GetObject(poic
,This
->itemName
,BINDSPEED_MODERATE
,pbc
,riid
,ppvResult
);
461 IOleItemContainer_Release(poic
);
467 /******************************************************************************
468 * ItemMoniker_BindToStorage
469 ******************************************************************************/
470 HRESULT WINAPI
ItemMonikerImpl_BindToStorage(IMoniker
* iface
,
476 ItemMonikerImpl
*This
= (ItemMonikerImpl
*)iface
;
479 IOleItemContainer
*poic
=0;
481 TRACE("(%p,%p,%p,%p,%p)\n",iface
,pbc
,pmkToLeft
,riid
,ppvResult
);
488 res
=IMoniker_BindToObject(pmkToLeft
,pbc
,NULL
,&IID_IOleItemContainer
,(void**)&poic
);
492 res
=IOleItemContainer_GetObjectStorage(poic
,This
->itemName
,pbc
,riid
,ppvResult
);
494 IOleItemContainer_Release(poic
);
500 /******************************************************************************
502 ******************************************************************************/
503 HRESULT WINAPI
ItemMonikerImpl_Reduce(IMoniker
* iface
,
505 DWORD dwReduceHowFar
,
506 IMoniker
** ppmkToLeft
,
507 IMoniker
** ppmkReduced
)
509 TRACE("(%p,%p,%ld,%p,%p)\n",iface
,pbc
,dwReduceHowFar
,ppmkToLeft
,ppmkReduced
);
511 if (ppmkReduced
==NULL
)
514 ItemMonikerImpl_AddRef(iface
);
518 return MK_S_REDUCED_TO_SELF
;
520 /******************************************************************************
521 * ItemMoniker_ComposeWith
522 ******************************************************************************/
523 HRESULT WINAPI
ItemMonikerImpl_ComposeWith(IMoniker
* iface
,
525 BOOL fOnlyIfNotGeneric
,
526 IMoniker
** ppmkComposite
)
530 IEnumMoniker
* penumMk
=0;
531 IMoniker
*pmostLeftMk
=0;
532 IMoniker
* tempMkComposite
=0;
534 TRACE("(%p,%p,%d,%p)\n",iface
,pmkRight
,fOnlyIfNotGeneric
,ppmkComposite
);
536 if ((ppmkComposite
==NULL
)||(pmkRight
==NULL
))
541 IMoniker_IsSystemMoniker(pmkRight
,&mkSys
);
543 /* If pmkRight is an anti-moniker, the returned moniker is NULL */
544 if(mkSys
==MKSYS_ANTIMONIKER
)
548 /* if pmkRight is a composite whose leftmost component is an anti-moniker, */
549 /* the returned moniker is the composite after the leftmost anti-moniker is removed. */
551 if(mkSys
==MKSYS_GENERICCOMPOSITE
){
553 res
=IMoniker_Enum(pmkRight
,TRUE
,&penumMk
);
558 res
=IEnumMoniker_Next(penumMk
,1,&pmostLeftMk
,NULL
);
560 IMoniker_IsSystemMoniker(pmostLeftMk
,&mkSys2
);
562 if(mkSys2
==MKSYS_ANTIMONIKER
){
564 IMoniker_Release(pmostLeftMk
);
566 tempMkComposite
=iface
;
567 IMoniker_AddRef(iface
);
569 while(IEnumMoniker_Next(penumMk
,1,&pmostLeftMk
,NULL
)==S_OK
){
571 res
=CreateGenericComposite(tempMkComposite
,pmostLeftMk
,ppmkComposite
);
573 IMoniker_Release(tempMkComposite
);
574 IMoniker_Release(pmostLeftMk
);
576 tempMkComposite
=*ppmkComposite
;
577 IMoniker_AddRef(tempMkComposite
);
582 return CreateGenericComposite(iface
,pmkRight
,ppmkComposite
);
584 /* If pmkRight is not an anti-moniker, the method combines the two monikers into a generic
585 composite if fOnlyIfNotGeneric is FALSE; if fOnlyIfNotGeneric is TRUE, the method returns
586 a NULL moniker and a return value of MK_E_NEEDGENERIC */
588 if (!fOnlyIfNotGeneric
)
589 return CreateGenericComposite(iface
,pmkRight
,ppmkComposite
);
592 return MK_E_NEEDGENERIC
;
595 /******************************************************************************
597 ******************************************************************************/
598 HRESULT WINAPI
ItemMonikerImpl_Enum(IMoniker
* iface
,BOOL fForward
, IEnumMoniker
** ppenumMoniker
)
600 TRACE("(%p,%d,%p)\n",iface
,fForward
,ppenumMoniker
);
602 if (ppenumMoniker
== NULL
)
605 *ppenumMoniker
= NULL
;
610 /******************************************************************************
611 * ItemMoniker_IsEqual
612 ******************************************************************************/
613 HRESULT WINAPI
ItemMonikerImpl_IsEqual(IMoniker
* iface
,IMoniker
* pmkOtherMoniker
)
617 LPOLESTR dispName1
,dispName2
;
619 HRESULT res
= S_FALSE
;
621 TRACE("(%p,%p)\n",iface
,pmkOtherMoniker
);
623 if (!pmkOtherMoniker
) return S_FALSE
;
626 /* check if both are ItemMoniker */
627 if(FAILED (IMoniker_GetClassID(pmkOtherMoniker
,&clsid
))) return S_FALSE
;
628 if(!IsEqualCLSID(&clsid
,&CLSID_ItemMoniker
)) return S_FALSE
;
630 /* check if both displaynames are the same */
631 if(SUCCEEDED ((res
= CreateBindCtx(0,&bind
)))) {
632 if(SUCCEEDED (IMoniker_GetDisplayName(iface
,bind
,NULL
,&dispName1
))) {
633 if(SUCCEEDED (IMoniker_GetDisplayName(pmkOtherMoniker
,bind
,NULL
,&dispName2
))) {
634 if(lstrcmpW(dispName1
,dispName2
)==0) res
= S_OK
;
635 CoTaskMemFree(dispName2
);
637 CoTaskMemFree(dispName1
);
643 /******************************************************************************
645 ******************************************************************************/
646 HRESULT WINAPI
ItemMonikerImpl_Hash(IMoniker
* iface
,DWORD
* pdwHash
)
648 ItemMonikerImpl
*This
= (ItemMonikerImpl
*)iface
;
650 int h
= 0,i
,skip
,len
;
657 val
= This
->itemName
;
661 for (i
= len
; i
> 0; i
--) {
662 h
= (h
* 37) + val
[off
++];
665 /* only sample some characters */
667 for (i
= len
; i
> 0; i
-= skip
, off
+= skip
) {
668 h
= (h
* 39) + val
[off
];
677 /******************************************************************************
678 * ItemMoniker_IsRunning
679 ******************************************************************************/
680 HRESULT WINAPI
ItemMonikerImpl_IsRunning(IMoniker
* iface
,
683 IMoniker
* pmkNewlyRunning
)
685 IRunningObjectTable
* rot
;
687 IOleItemContainer
*poic
=0;
688 ItemMonikerImpl
*This
= (ItemMonikerImpl
*)iface
;
690 TRACE("(%p,%p,%p,%p)\n",iface
,pbc
,pmkToLeft
,pmkNewlyRunning
);
692 /* If pmkToLeft is NULL, this method returns TRUE if pmkNewlyRunning is non-NULL and is equal to this */
693 /* moniker. Otherwise, the method checks the ROT to see whether this moniker is running. */
695 if ((pmkNewlyRunning
!=NULL
)&&(IMoniker_IsEqual(pmkNewlyRunning
,iface
)==S_OK
))
701 res
=IBindCtx_GetRunningObjectTable(pbc
,&rot
);
706 res
= IRunningObjectTable_IsRunning(rot
,iface
);
708 IRunningObjectTable_Release(rot
);
712 /* If pmkToLeft is non-NULL, the method calls IMoniker::BindToObject on the pmkToLeft parameter, */
713 /* requesting an IOleItemContainer interface pointer. The method then calls IOleItemContainer::IsRunning,*/
714 /* passing the string contained within this moniker. */
716 res
=IMoniker_BindToObject(pmkToLeft
,pbc
,NULL
,&IID_IOleItemContainer
,(void**)&poic
);
720 res
=IOleItemContainer_IsRunning(poic
,This
->itemName
);
722 IOleItemContainer_Release(poic
);
729 /******************************************************************************
730 * ItemMoniker_GetTimeOfLastChange
731 ******************************************************************************/
732 HRESULT WINAPI
ItemMonikerImpl_GetTimeOfLastChange(IMoniker
* iface
,
737 IRunningObjectTable
* rot
;
739 IMoniker
*compositeMk
;
741 TRACE("(%p,%p,%p,%p)\n",iface
,pbc
,pmkToLeft
,pItemTime
);
746 /* If pmkToLeft is NULL, this method returns MK_E_NOTBINDABLE */
749 return MK_E_NOTBINDABLE
;
752 /* Otherwise, the method creates a composite of pmkToLeft and this moniker and uses the ROT to access */
753 /* the time of last change. If the object is not in the ROT, the method calls */
754 /* IMoniker::GetTimeOfLastChange on the pmkToLeft parameter. */
756 res
=CreateGenericComposite(pmkToLeft
,iface
,&compositeMk
);
758 res
=IBindCtx_GetRunningObjectTable(pbc
,&rot
);
760 if (IRunningObjectTable_GetTimeOfLastChange(rot
,compositeMk
,pItemTime
)!=S_OK
)
762 res
=IMoniker_GetTimeOfLastChange(pmkToLeft
,pbc
,NULL
,pItemTime
);
764 IMoniker_Release(compositeMk
);
770 /******************************************************************************
771 * ItemMoniker_Inverse
772 ******************************************************************************/
773 HRESULT WINAPI
ItemMonikerImpl_Inverse(IMoniker
* iface
,IMoniker
** ppmk
)
775 TRACE("(%p,%p)\n",iface
,ppmk
);
780 return CreateAntiMoniker(ppmk
);
783 /******************************************************************************
784 * ItemMoniker_CommonPrefixWith
785 ******************************************************************************/
786 HRESULT WINAPI
ItemMonikerImpl_CommonPrefixWith(IMoniker
* iface
,IMoniker
* pmkOther
,IMoniker
** ppmkPrefix
)
789 IMoniker_IsSystemMoniker(pmkOther
,&mkSys
);
790 /* If the other moniker is an item moniker that is equal to this moniker, this method sets *ppmkPrefix */
791 /* to this moniker and returns MK_S_US */
793 if((mkSys
==MKSYS_ITEMMONIKER
) && (IMoniker_IsEqual(iface
,pmkOther
)==S_OK
) ){
797 IMoniker_AddRef(iface
);
802 /* otherwise, the method calls the MonikerCommonPrefixWith function. This function correctly handles */
803 /* the case where the other moniker is a generic composite. */
804 return MonikerCommonPrefixWith(iface
,pmkOther
,ppmkPrefix
);
807 /******************************************************************************
808 * ItemMoniker_RelativePathTo
809 ******************************************************************************/
810 HRESULT WINAPI
ItemMonikerImpl_RelativePathTo(IMoniker
* iface
,IMoniker
* pmOther
, IMoniker
** ppmkRelPath
)
812 TRACE("(%p,%p,%p)\n",iface
,pmOther
,ppmkRelPath
);
814 if (ppmkRelPath
==NULL
)
819 return MK_E_NOTBINDABLE
;
822 /******************************************************************************
823 * ItemMoniker_GetDisplayName
824 ******************************************************************************/
825 HRESULT WINAPI
ItemMonikerImpl_GetDisplayName(IMoniker
* iface
,
828 LPOLESTR
*ppszDisplayName
)
830 ItemMonikerImpl
*This
= (ItemMonikerImpl
*)iface
;
832 TRACE("(%p,%p,%p,%p)\n",iface
,pbc
,pmkToLeft
,ppszDisplayName
);
834 if (ppszDisplayName
==NULL
)
837 if (pmkToLeft
!=NULL
){
841 *ppszDisplayName
=CoTaskMemAlloc(sizeof(WCHAR
)*(lstrlenW(This
->itemDelimiter
)+lstrlenW(This
->itemName
)+1));
843 if (*ppszDisplayName
==NULL
)
844 return E_OUTOFMEMORY
;
846 lstrcpyW(*ppszDisplayName
,This
->itemDelimiter
);
847 lstrcatW(*ppszDisplayName
,This
->itemName
);
852 /******************************************************************************
853 * ItemMoniker_ParseDisplayName
854 ******************************************************************************/
855 HRESULT WINAPI
ItemMonikerImpl_ParseDisplayName(IMoniker
* iface
,
858 LPOLESTR pszDisplayName
,
862 IOleItemContainer
* poic
=0;
863 IParseDisplayName
* ppdn
=0;
864 LPOLESTR displayName
;
866 ItemMonikerImpl
*This
= (ItemMonikerImpl
*)iface
;
868 /* If pmkToLeft is NULL, this method returns MK_E_SYNTAX */
874 /* Otherwise, the method calls IMoniker::BindToObject on the pmkToLeft parameter, requesting an */
875 /* IParseDisplayName interface pointer to the object identified by the moniker, and passes the display */
876 /* name to IParseDisplayName::ParseDisplayName */
877 res
=IMoniker_BindToObject(pmkToLeft
,pbc
,NULL
,&IID_IOleItemContainer
,(void**)&poic
);
881 res
=IOleItemContainer_GetObject(poic
,This
->itemName
,BINDSPEED_MODERATE
,pbc
,&IID_IParseDisplayName
,(void**)&ppdn
);
883 res
=IMoniker_GetDisplayName(iface
,pbc
,NULL
,&displayName
);
885 res
=IParseDisplayName_ParseDisplayName(ppdn
,pbc
,displayName
,pchEaten
,ppmkOut
);
887 IOleItemContainer_Release(poic
);
888 IParseDisplayName_Release(ppdn
);
894 /******************************************************************************
895 * ItemMoniker_IsSystemMoniker
896 ******************************************************************************/
897 HRESULT WINAPI
ItemMonikerImpl_IsSystemMoniker(IMoniker
* iface
,DWORD
* pwdMksys
)
899 TRACE("(%p,%p)\n",iface
,pwdMksys
);
904 (*pwdMksys
)=MKSYS_ITEMMONIKER
;
909 /*******************************************************************************
910 * ItemMonikerIROTData_QueryInterface
911 *******************************************************************************/
912 HRESULT WINAPI
ItemMonikerROTDataImpl_QueryInterface(IROTData
*iface
,REFIID riid
,VOID
** ppvObject
)
915 ICOM_THIS_From_IROTData(IMoniker
, iface
);
917 TRACE("(%p,%p,%p)\n",iface
,riid
,ppvObject
);
919 return ItemMonikerImpl_QueryInterface(This
, riid
, ppvObject
);
922 /***********************************************************************
923 * ItemMonikerIROTData_AddRef
925 ULONG WINAPI
ItemMonikerROTDataImpl_AddRef(IROTData
*iface
)
927 ICOM_THIS_From_IROTData(IMoniker
, iface
);
929 TRACE("(%p)\n",iface
);
931 return ItemMonikerImpl_AddRef(This
);
934 /***********************************************************************
935 * ItemMonikerIROTData_Release
937 ULONG WINAPI
ItemMonikerROTDataImpl_Release(IROTData
* iface
)
939 ICOM_THIS_From_IROTData(IMoniker
, iface
);
941 TRACE("(%p)\n",iface
);
943 return ItemMonikerImpl_Release(This
);
946 /******************************************************************************
947 * ItemMonikerIROTData_GetComparaisonData
948 ******************************************************************************/
949 HRESULT WINAPI
ItemMonikerROTDataImpl_GetComparaisonData(IROTData
* iface
,
958 /******************************************************************************
959 * CreateItemMoniker [OLE32.@]
960 ******************************************************************************/
961 HRESULT WINAPI
CreateItemMoniker(LPCOLESTR lpszDelim
,LPCOLESTR lpszItem
, LPMONIKER
* ppmk
)
963 ItemMonikerImpl
* newItemMoniker
= 0;
965 IID riid
=IID_IMoniker
;
967 TRACE("(%p,%p,%p)\n",lpszDelim
,lpszItem
,ppmk
);
969 newItemMoniker
= HeapAlloc(GetProcessHeap(), 0, sizeof(ItemMonikerImpl
));
971 if (newItemMoniker
== 0)
972 return STG_E_INSUFFICIENTMEMORY
;
974 hr
= ItemMonikerImpl_Construct(newItemMoniker
,lpszDelim
,lpszItem
);
978 HeapFree(GetProcessHeap(),0,newItemMoniker
);
982 return ItemMonikerImpl_QueryInterface((IMoniker
*)newItemMoniker
,&riid
,(void**)ppmk
);