source: trunk/src/ole32/itemmoniker.c@ 8441

Last change on this file since 8441 was 8441, checked in by sandervl, 23 years ago

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