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

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

Wine resync
File size: 35.2 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 lstrcpyW(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=lstrlenW(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 lstrcpyW(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 = S_FALSE;
615
616 TRACE("(%p,%p)\n",iface,pmkOtherMoniker);
617
618 if (!pmkOtherMoniker) return S_FALSE;
619
620
621 /* check if both are ItemMoniker */
622 if(FAILED (IMoniker_GetClassID(pmkOtherMoniker,&clsid))) return S_FALSE;
623 if(!IsEqualCLSID(&clsid,&CLSID_ItemMoniker)) return S_FALSE;
624
625 /* check if both displaynames are the same */
626 if(SUCCEEDED ((res = CreateBindCtx(0,&bind)))) {
627 if(SUCCEEDED (IMoniker_GetDisplayName(iface,bind,NULL,&dispName1))) {
628 if(SUCCEEDED (IMoniker_GetDisplayName(pmkOtherMoniker,bind,NULL,&dispName2))) {
629 if(lstrcmpW(dispName1,dispName2)==0) res = S_OK;
630 CoTaskMemFree(dispName2);
631 }
632 CoTaskMemFree(dispName1);
633 }
634 }
635 return res;
636}
637
638/******************************************************************************
639 * ItemMoniker_Hash
640 ******************************************************************************/
641HRESULT WINAPI ItemMonikerImpl_Hash(IMoniker* iface,DWORD* pdwHash)
642{
643 ICOM_THIS(ItemMonikerImpl,iface);
644
645 int h = 0,i,skip,len;
646 int off = 0;
647 LPOLESTR val;
648
649 if (pdwHash==NULL)
650 return E_POINTER;
651
652 val = This->itemName;
653 len = lstrlenW(val);
654
655 if (len < 16) {
656 for (i = len ; i > 0; i--) {
657 h = (h * 37) + val[off++];
658 }
659 } else {
660 /* only sample some characters */
661 skip = len / 8;
662 for (i = len ; i > 0; i -= skip, off += skip) {
663 h = (h * 39) + val[off];
664 }
665 }
666
667 *pdwHash=h;
668
669 return S_OK;
670}
671
672/******************************************************************************
673 * ItemMoniker_IsRunning
674 ******************************************************************************/
675HRESULT WINAPI ItemMonikerImpl_IsRunning(IMoniker* iface,
676 IBindCtx* pbc,
677 IMoniker* pmkToLeft,
678 IMoniker* pmkNewlyRunning)
679{
680 IRunningObjectTable* rot;
681 HRESULT res;
682 IOleItemContainer *poic=0;
683 ICOM_THIS(ItemMonikerImpl,iface);
684
685 TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pmkNewlyRunning);
686
687 /* If pmkToLeft is NULL, this method returns TRUE if pmkNewlyRunning is non-NULL and is equal to this */
688 /* moniker. Otherwise, the method checks the ROT to see whether this moniker is running. */
689 if (pmkToLeft==NULL)
690 if ((pmkNewlyRunning!=NULL)&&(IMoniker_IsEqual(pmkNewlyRunning,iface)==S_OK))
691 return S_OK;
692 else {
693 if (pbc==NULL)
694 return E_POINTER;
695
696 res=IBindCtx_GetRunningObjectTable(pbc,&rot);
697
698 if (FAILED(res))
699 return res;
700
701 res = IRunningObjectTable_IsRunning(rot,iface);
702
703 IRunningObjectTable_Release(rot);
704 }
705 else{
706
707 /* If pmkToLeft is non-NULL, the method calls IMoniker::BindToObject on the pmkToLeft parameter, */
708 /* requesting an IOleItemContainer interface pointer. The method then calls IOleItemContainer::IsRunning,*/
709 /* passing the string contained within this moniker. */
710
711 res=IMoniker_BindToObject(pmkToLeft,pbc,NULL,&IID_IOleItemContainer,(void**)&poic);
712
713 if (SUCCEEDED(res)){
714
715 res=IOleItemContainer_IsRunning(poic,This->itemName);
716
717 IOleItemContainer_Release(poic);
718 }
719 }
720
721 return res;
722}
723
724/******************************************************************************
725 * ItemMoniker_GetTimeOfLastChange
726 ******************************************************************************/
727HRESULT WINAPI ItemMonikerImpl_GetTimeOfLastChange(IMoniker* iface,
728 IBindCtx* pbc,
729 IMoniker* pmkToLeft,
730 FILETIME* pItemTime)
731{
732 IRunningObjectTable* rot;
733 HRESULT res;
734 IMoniker *compositeMk;
735
736 TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pItemTime);
737
738 if (pItemTime==NULL)
739 return E_INVALIDARG;
740
741 /* If pmkToLeft is NULL, this method returns MK_E_NOTBINDABLE */
742 if (pmkToLeft==NULL)
743
744 return MK_E_NOTBINDABLE;
745 else {
746
747 /* Otherwise, the method creates a composite of pmkToLeft and this moniker and uses the ROT to access */
748 /* the time of last change. If the object is not in the ROT, the method calls */
749 /* IMoniker::GetTimeOfLastChange on the pmkToLeft parameter. */
750
751 res=CreateGenericComposite(pmkToLeft,iface,&compositeMk);
752
753 res=IBindCtx_GetRunningObjectTable(pbc,&rot);
754
755 if (IRunningObjectTable_GetTimeOfLastChange(rot,compositeMk,pItemTime)!=S_OK)
756
757 res=IMoniker_GetTimeOfLastChange(pmkToLeft,pbc,NULL,pItemTime);
758
759 IMoniker_Release(compositeMk);
760 }
761
762 return res;
763}
764
765/******************************************************************************
766 * ItemMoniker_Inverse
767 ******************************************************************************/
768HRESULT WINAPI ItemMonikerImpl_Inverse(IMoniker* iface,IMoniker** ppmk)
769{
770 TRACE("(%p,%p)\n",iface,ppmk);
771
772 if (ppmk==NULL)
773 return E_POINTER;
774
775 return CreateAntiMoniker(ppmk);
776}
777
778/******************************************************************************
779 * ItemMoniker_CommonPrefixWith
780 ******************************************************************************/
781HRESULT WINAPI ItemMonikerImpl_CommonPrefixWith(IMoniker* iface,IMoniker* pmkOther,IMoniker** ppmkPrefix)
782{
783 DWORD mkSys;
784 IMoniker_IsSystemMoniker(pmkOther,&mkSys);
785 /* If the other moniker is an item moniker that is equal to this moniker, this method sets *ppmkPrefix */
786 /* to this moniker and returns MK_S_US */
787
788 if((mkSys==MKSYS_ITEMMONIKER) && (IMoniker_IsEqual(iface,pmkOther)==S_OK) ){
789
790 *ppmkPrefix=iface;
791
792 IMoniker_AddRef(iface);
793
794 return MK_S_US;
795 }
796 else
797 /* otherwise, the method calls the MonikerCommonPrefixWith function. This function correctly handles */
798 /* the case where the other moniker is a generic composite. */
799 return MonikerCommonPrefixWith(iface,pmkOther,ppmkPrefix);
800}
801
802/******************************************************************************
803 * ItemMoniker_RelativePathTo
804 ******************************************************************************/
805HRESULT WINAPI ItemMonikerImpl_RelativePathTo(IMoniker* iface,IMoniker* pmOther, IMoniker** ppmkRelPath)
806{
807 TRACE("(%p,%p,%p)\n",iface,pmOther,ppmkRelPath);
808
809 if (ppmkRelPath==NULL)
810 return E_POINTER;
811
812 *ppmkRelPath=0;
813
814 return MK_E_NOTBINDABLE;
815}
816
817/******************************************************************************
818 * ItemMoniker_GetDisplayName
819 ******************************************************************************/
820HRESULT WINAPI ItemMonikerImpl_GetDisplayName(IMoniker* iface,
821 IBindCtx* pbc,
822 IMoniker* pmkToLeft,
823 LPOLESTR *ppszDisplayName)
824{
825 ICOM_THIS(ItemMonikerImpl,iface);
826
827 TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,ppszDisplayName);
828
829 if (ppszDisplayName==NULL)
830 return E_POINTER;
831
832 if (pmkToLeft!=NULL){
833 return E_INVALIDARG;
834 }
835
836 *ppszDisplayName=CoTaskMemAlloc(sizeof(WCHAR)*(lstrlenW(This->itemDelimiter)+lstrlenW(This->itemName)+1));
837
838 if (*ppszDisplayName==NULL)
839 return E_OUTOFMEMORY;
840
841 lstrcpyW(*ppszDisplayName,This->itemDelimiter);
842 lstrcatW(*ppszDisplayName,This->itemName);
843
844 return S_OK;
845}
846
847/******************************************************************************
848 * ItemMoniker_ParseDisplayName
849 ******************************************************************************/
850HRESULT WINAPI ItemMonikerImpl_ParseDisplayName(IMoniker* iface,
851 IBindCtx* pbc,
852 IMoniker* pmkToLeft,
853 LPOLESTR pszDisplayName,
854 ULONG* pchEaten,
855 IMoniker** ppmkOut)
856{
857 IOleItemContainer* poic=0;
858 IParseDisplayName* ppdn=0;
859 LPOLESTR displayName;
860 HRESULT res;
861 ICOM_THIS(ItemMonikerImpl,iface);
862
863 /* If pmkToLeft is NULL, this method returns MK_E_SYNTAX */
864 if (pmkToLeft==NULL)
865
866 return MK_E_SYNTAX;
867
868 else{
869 /* Otherwise, the method calls IMoniker::BindToObject on the pmkToLeft parameter, requesting an */
870 /* IParseDisplayName interface pointer to the object identified by the moniker, and passes the display */
871 /* name to IParseDisplayName::ParseDisplayName */
872 res=IMoniker_BindToObject(pmkToLeft,pbc,NULL,&IID_IOleItemContainer,(void**)&poic);
873
874 if (SUCCEEDED(res)){
875
876 res=IOleItemContainer_GetObject(poic,This->itemName,BINDSPEED_MODERATE,pbc,&IID_IParseDisplayName,(void**)&ppdn);
877
878 res=IMoniker_GetDisplayName(iface,pbc,NULL,&displayName);
879
880 res=IParseDisplayName_ParseDisplayName(ppdn,pbc,displayName,pchEaten,ppmkOut);
881
882 IOleItemContainer_Release(poic);
883 IParseDisplayName_Release(ppdn);
884 }
885 }
886 return res;
887}
888
889/******************************************************************************
890 * ItemMoniker_IsSystemMoniker
891 ******************************************************************************/
892HRESULT WINAPI ItemMonikerImpl_IsSystemMoniker(IMoniker* iface,DWORD* pwdMksys)
893{
894 TRACE("(%p,%p)\n",iface,pwdMksys);
895
896 if (!pwdMksys)
897 return E_POINTER;
898
899 (*pwdMksys)=MKSYS_ITEMMONIKER;
900
901 return S_OK;
902}
903
904/*******************************************************************************
905 * ItemMonikerIROTData_QueryInterface
906 *******************************************************************************/
907HRESULT WINAPI ItemMonikerROTDataImpl_QueryInterface(IROTData *iface,REFIID riid,VOID** ppvObject)
908{
909
910 ICOM_THIS_From_IROTData(IMoniker, iface);
911
912 TRACE("(%p,%p,%p)\n",iface,riid,ppvObject);
913
914 return ItemMonikerImpl_QueryInterface(This, riid, ppvObject);
915}
916
917/***********************************************************************
918 * ItemMonikerIROTData_AddRef
919 */
920ULONG WINAPI ItemMonikerROTDataImpl_AddRef(IROTData *iface)
921{
922 ICOM_THIS_From_IROTData(IMoniker, iface);
923
924 TRACE("(%p)\n",iface);
925
926 return ItemMonikerImpl_AddRef(This);
927}
928
929/***********************************************************************
930 * ItemMonikerIROTData_Release
931 */
932ULONG WINAPI ItemMonikerROTDataImpl_Release(IROTData* iface)
933{
934 ICOM_THIS_From_IROTData(IMoniker, iface);
935
936 TRACE("(%p)\n",iface);
937
938 return ItemMonikerImpl_Release(This);
939}
940
941/******************************************************************************
942 * ItemMonikerIROTData_GetComparaisonData
943 ******************************************************************************/
944HRESULT WINAPI ItemMonikerROTDataImpl_GetComparaisonData(IROTData* iface,
945 BYTE* pbData,
946 ULONG cbMax,
947 ULONG* pcbData)
948{
949 FIXME("(),stub!\n");
950 return E_NOTIMPL;
951}
952
953/******************************************************************************
954 * CreateItemMoniker16 [OLE2.28]
955 ******************************************************************************/
956HRESULT WINAPI CreateItemMoniker16(LPCOLESTR16 lpszDelim,LPCOLESTR lpszItem,LPMONIKER* ppmk)
957{
958
959 FIXME("(%s,%p),stub!\n",lpszDelim,ppmk);
960 *ppmk = NULL;
961 return E_NOTIMPL;
962}
963
964/******************************************************************************
965 * CreateItemMoniker [OLE32.58]
966 ******************************************************************************/
967HRESULT WINAPI CreateItemMoniker(LPCOLESTR lpszDelim,LPCOLESTR lpszItem, LPMONIKER * ppmk)
968{
969 ItemMonikerImpl* newItemMoniker = 0;
970 HRESULT hr = S_OK;
971 IID riid=IID_IMoniker;
972
973 TRACE("(%p,%p,%p)\n",lpszDelim,lpszItem,ppmk);
974
975 newItemMoniker = HeapAlloc(GetProcessHeap(), 0, sizeof(ItemMonikerImpl));
976
977 if (newItemMoniker == 0)
978 return STG_E_INSUFFICIENTMEMORY;
979
980 hr = ItemMonikerImpl_Construct(newItemMoniker,lpszDelim,lpszItem);
981
982 if (FAILED(hr)){
983
984 HeapFree(GetProcessHeap(),0,newItemMoniker);
985 return hr;
986 }
987
988 return ItemMonikerImpl_QueryInterface((IMoniker*)newItemMoniker,&riid,(void**)ppmk);
989}
Note: See TracBrowser for help on using the repository browser.