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