1 /*
2 * Class Monikers
3 *
4 * Copyright 1999 Noomen Hamza
5 * Copyright 2005-2007 Robert Shearman
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #include <assert.h>
23 #include <stdarg.h>
24 #include <string.h>
25
26 #define COBJMACROS
27 #define NONAMELESSUNION
28 #define NONAMELESSSTRUCT
29
30 #include "winerror.h"
31 #include "windef.h"
32 #include "winbase.h"
33 #include "winuser.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 #define CHARS_IN_GUID 39
42
43 /* ClassMoniker data structure */
44 typedef struct ClassMoniker
45 {
46 const IMonikerVtbl* lpVtbl; /* VTable relative to the IMoniker interface.*/
47 const IROTDataVtbl* lpVtblRotData; /* VTable relative to the IROTData interface.*/
48 LONG ref; /* reference counter for this object */
49 CLSID clsid; /* clsid identified by this moniker */
50 IUnknown *pMarshal; /* custom marshaler */
51 } ClassMoniker;
52
53 static inline IMoniker *impl_from_IROTData( IROTData *iface )
54 {
55 return (IMoniker *)((char*)iface - FIELD_OFFSET(ClassMoniker, lpVtblRotData));
56 }
57
58 /*******************************************************************************
59 * ClassMoniker_QueryInterface
60 *******************************************************************************/
61 static HRESULT WINAPI ClassMoniker_QueryInterface(IMoniker* iface,REFIID riid,void** ppvObject)
62 {
63 ClassMoniker *This = (ClassMoniker *)iface;
64
65 TRACE("(%p,%p,%p)\n",This,riid,ppvObject);
66
67 /* Perform a sanity check on the parameters.*/
68 if (!ppvObject)
69 return E_POINTER;
70
71 /* Initialize the return parameter */
72 *ppvObject = 0;
73
74 /* Compare the riid with the interface IDs implemented by this object.*/
75 if (IsEqualIID(&IID_IUnknown, riid) ||
76 IsEqualIID(&IID_IPersist, riid) ||
77 IsEqualIID(&IID_IPersistStream, riid) ||
78 IsEqualIID(&IID_IMoniker, riid))
79 {
80 *ppvObject = iface;
81 }
82 else if (IsEqualIID(&IID_IROTData, riid))
83 *ppvObject = &This->lpVtblRotData;
84 else if (IsEqualIID(&IID_IMarshal, riid))
85 {
86 HRESULT hr = S_OK;
87 if (!This->pMarshal)
88 hr = MonikerMarshal_Create(iface, &This->pMarshal);
89 if (hr != S_OK)
90 return hr;
91 return IUnknown_QueryInterface(This->pMarshal, riid, ppvObject);
92 }
93
94 /* Check that we obtained an interface.*/
95 if (!*ppvObject)
96 return E_NOINTERFACE;
97
98 /* Query Interface always increases the reference count by one when it is successful */
99 IMoniker_AddRef(iface);
100
101 return S_OK;
102 }
103
104 /******************************************************************************
105 * ClassMoniker_AddRef
106 ******************************************************************************/
107 static ULONG WINAPI ClassMoniker_AddRef(IMoniker* iface)
108 {
109 ClassMoniker *This = (ClassMoniker *)iface;
110
111 TRACE("(%p)\n",This);
112
113 return InterlockedIncrement(&This->ref);
114 }
115
116 /******************************************************************************
117 * ClassMoniker_Destroy (local function)
118 *******************************************************************************/
119 static HRESULT ClassMoniker_Destroy(ClassMoniker* This)
120 {
121 TRACE("(%p)\n",This);
122
123 if (This->pMarshal) IUnknown_Release(This->pMarshal);
124
125 HeapFree(GetProcessHeap(),0,This);
126
127 return S_OK;
128 }
129
130 /******************************************************************************
131 * ClassMoniker_Release
132 ******************************************************************************/
133 static ULONG WINAPI ClassMoniker_Release(IMoniker* iface)
134 {
135 ClassMoniker *This = (ClassMoniker *)iface;
136 ULONG ref;
137
138 TRACE("(%p)\n",This);
139
140 ref = InterlockedDecrement(&This->ref);
141
142 /* destroy the object if there's no more reference on it */
143 if (ref == 0) ClassMoniker_Destroy(This);
144
145 return ref;
146 }
147
148 /******************************************************************************
149 * ClassMoniker_GetClassID
150 ******************************************************************************/
151 static HRESULT WINAPI ClassMoniker_GetClassID(IMoniker* iface,CLSID *pClassID)
152 {
153 TRACE("(%p,%p),stub!\n",iface,pClassID);
154
155 if (pClassID==NULL)
156 return E_POINTER;
157
158 *pClassID = CLSID_ClassMoniker;
159
160 return S_OK;
161 }
162
163 /******************************************************************************
164 * ClassMoniker_IsDirty
165 ******************************************************************************/
166 static HRESULT WINAPI ClassMoniker_IsDirty(IMoniker* iface)
167 {
168 /* Note that the OLE-provided implementations of the IPersistStream::IsDirty
169 method in the OLE-provided moniker interfaces always return S_FALSE because
170 their internal state never changes. */
171
172 TRACE("(%p)\n",iface);
173
174 return S_FALSE;
175 }
176
177 /******************************************************************************
178 * ClassMoniker_Load
179 ******************************************************************************/
180 static HRESULT WINAPI ClassMoniker_Load(IMoniker* iface,IStream* pStm)
181 {
182 ClassMoniker *This = (ClassMoniker *)iface;
183 HRESULT hr;
184 DWORD zero;
185
186 TRACE("(%p)\n", pStm);
187
188 hr = IStream_Read(pStm, &This->clsid, sizeof(This->clsid), NULL);
189 if (hr != S_OK) return STG_E_READFAULT;
190
191 hr = IStream_Read(pStm, &zero, sizeof(zero), NULL);
192 if ((hr != S_OK) || (zero != 0)) return STG_E_READFAULT;
193
194 return S_OK;
195 }
196
197 /******************************************************************************
198 * ClassMoniker_Save
199 ******************************************************************************/
200 static HRESULT WINAPI ClassMoniker_Save(IMoniker* iface,
201 IStream* pStm,/* pointer to the stream where the object is to be saved */
202 BOOL fClearDirty)/* Specifies whether to clear the dirty flag */
203 {
204 ClassMoniker *This = (ClassMoniker *)iface;
205 HRESULT hr;
206 DWORD zero = 0;
207
208 TRACE("(%p, %s)\n", pStm, fClearDirty ? "TRUE" : "FALSE");
209
210 hr = IStream_Write(pStm, &This->clsid, sizeof(This->clsid), NULL);
211 if (FAILED(hr)) return hr;
212
213 hr = IStream_Write(pStm, &zero, sizeof(zero), NULL);
214
215 return hr;
216 }
217
218 /******************************************************************************
219 * ClassMoniker_GetSizeMax
220 ******************************************************************************/
221 static HRESULT WINAPI ClassMoniker_GetSizeMax(IMoniker* iface,
222 ULARGE_INTEGER* pcbSize)/* Pointer to size of stream needed to save object */
223 {
224 TRACE("(%p)\n", pcbSize);
225
226 pcbSize->QuadPart = sizeof(CLSID) + sizeof(DWORD);
227
228 return S_OK;
229 }
230
231 /******************************************************************************
232 * ClassMoniker_BindToObject
233 ******************************************************************************/
234 static HRESULT WINAPI ClassMoniker_BindToObject(IMoniker* iface,
235 IBindCtx* pbc,
236 IMoniker* pmkToLeft,
237 REFIID riid,
238 VOID** ppvResult)
239 {
240 ClassMoniker *This = (ClassMoniker *)iface;
241 BIND_OPTS2 bindopts;
242 IClassActivator *pActivator;
243 HRESULT hr;
244
245 TRACE("(%p,%p,%p,%p)\n", pbc, pmkToLeft, riid, ppvResult);
246
247 bindopts.cbStruct = sizeof(bindopts);
248 IBindCtx_GetBindOptions(pbc, (BIND_OPTS *)&bindopts);
249
250 if (!pmkToLeft)
251 return CoGetClassObject(&This->clsid, bindopts.dwClassContext, NULL,
252 riid, ppvResult);
253 else
254 {
255 hr = IMoniker_BindToObject(pmkToLeft, pbc, NULL, &IID_IClassActivator,
256 (void **)&pActivator);
257 if (FAILED(hr)) return hr;
258
259 hr = IClassActivator_GetClassObject(pActivator, &This->clsid,
260 bindopts.dwClassContext,
261 bindopts.locale, riid, ppvResult);
262
263 IClassActivator_Release(pActivator);
264
265 return hr;
266 }
267 }
268
269 /******************************************************************************
270 * ClassMoniker_BindToStorage
271 ******************************************************************************/
272 static HRESULT WINAPI ClassMoniker_BindToStorage(IMoniker* iface,
273 IBindCtx* pbc,
274 IMoniker* pmkToLeft,
275 REFIID riid,
276 VOID** ppvResult)
277 {
278 TRACE("(%p,%p,%p,%p)\n",pbc, pmkToLeft, riid, ppvResult);
279 return ClassMoniker_BindToObject(iface, pbc, pmkToLeft, riid, ppvResult);
280 }
281
282 /******************************************************************************
283 * ClassMoniker_Reduce
284 ******************************************************************************/
285 static HRESULT WINAPI ClassMoniker_Reduce(IMoniker* iface,
286 IBindCtx* pbc,
287 DWORD dwReduceHowFar,
288 IMoniker** ppmkToLeft,
289 IMoniker** ppmkReduced)
290 {
291 TRACE("(%p,%p,%d,%p,%p)\n",iface,pbc,dwReduceHowFar,ppmkToLeft,ppmkReduced);
292
293 if (!ppmkReduced)
294 return E_POINTER;
295
296 ClassMoniker_AddRef(iface);
297
298 *ppmkReduced = iface;
299
300 return MK_S_REDUCED_TO_SELF;
301 }
302 /******************************************************************************
303 * ClassMoniker_ComposeWith
304 ******************************************************************************/
305 static HRESULT WINAPI ClassMoniker_ComposeWith(IMoniker* iface,
306 IMoniker* pmkRight,
307 BOOL fOnlyIfNotGeneric,
308 IMoniker** ppmkComposite)
309 {
310 HRESULT res=S_OK;
311 DWORD mkSys,mkSys2;
312 IEnumMoniker* penumMk=0;
313 IMoniker *pmostLeftMk=0;
314 IMoniker* tempMkComposite=0;
315
316 TRACE("(%p,%d,%p)\n", pmkRight, fOnlyIfNotGeneric, ppmkComposite);
317
318 if ((ppmkComposite==NULL)||(pmkRight==NULL))
319 return E_POINTER;
320
321 *ppmkComposite=0;
322
323 IMoniker_IsSystemMoniker(pmkRight,&mkSys);
324
325 /* If pmkRight is an anti-moniker, the returned moniker is NULL */
326 if(mkSys==MKSYS_ANTIMONIKER)
327 return res;
328
329 else
330 /* if pmkRight is a composite whose leftmost component is an anti-moniker, */
331 /* the returned moniker is the composite after the leftmost anti-moniker is removed. */
332
333 if(mkSys==MKSYS_GENERICCOMPOSITE){
334
335 res=IMoniker_Enum(pmkRight,TRUE,&penumMk);
336
337 if (FAILED(res))
338 return res;
339
340 res=IEnumMoniker_Next(penumMk,1,&pmostLeftMk,NULL);
341
342 IMoniker_IsSystemMoniker(pmostLeftMk,&mkSys2);
343
344 if(mkSys2==MKSYS_ANTIMONIKER){
345
346 IMoniker_Release(pmostLeftMk);
347
348 tempMkComposite=iface;
349 IMoniker_AddRef(iface);
350
351 while(IEnumMoniker_Next(penumMk,1,&pmostLeftMk,NULL)==S_OK){
352
353 res=CreateGenericComposite(tempMkComposite,pmostLeftMk,ppmkComposite);
354
355 IMoniker_Release(tempMkComposite);
356 IMoniker_Release(pmostLeftMk);
357
358 tempMkComposite=*ppmkComposite;
359 IMoniker_AddRef(tempMkComposite);
360 }
361 return res;
362 }
363 else
364 return CreateGenericComposite(iface,pmkRight,ppmkComposite);
365 }
366 /* If pmkRight is not an anti-moniker, the method combines the two monikers into a generic
367 composite if fOnlyIfNotGeneric is FALSE; if fOnlyIfNotGeneric is TRUE, the method returns
368 a NULL moniker and a return value of MK_E_NEEDGENERIC */
369 else
370 if (!fOnlyIfNotGeneric)
371 return CreateGenericComposite(iface,pmkRight,ppmkComposite);
372
373 else
374 return MK_E_NEEDGENERIC;
375 }
376
377 /******************************************************************************
378 * ClassMoniker_Enum
379 ******************************************************************************/
380 static HRESULT WINAPI ClassMoniker_Enum(IMoniker* iface,BOOL fForward, IEnumMoniker** ppenumMoniker)
381 {
382 TRACE("(%p,%d,%p)\n",iface,fForward,ppenumMoniker);
383
384 if (ppenumMoniker == NULL)
385 return E_POINTER;
386
387 *ppenumMoniker = NULL;
388
389 return S_OK;
390 }
391
392 /******************************************************************************
393 * ClassMoniker_IsEqual
394 ******************************************************************************/
395 static HRESULT WINAPI ClassMoniker_IsEqual(IMoniker* iface,IMoniker* pmkOtherMoniker)
396 {
397
398 CLSID clsid;
399 LPOLESTR dispName1,dispName2;
400 IBindCtx* bind;
401 HRESULT res = S_FALSE;
402
403 TRACE("(%p,%p)\n",iface,pmkOtherMoniker);
404
405 if (!pmkOtherMoniker) return S_FALSE;
406
407
408 /* check if both are ClassMoniker */
409 if(FAILED (IMoniker_GetClassID(pmkOtherMoniker,&clsid))) return S_FALSE;
410 if(!IsEqualCLSID(&clsid,&CLSID_ClassMoniker)) return S_FALSE;
411
412 /* check if both displaynames are the same */
413 if(SUCCEEDED ((res = CreateBindCtx(0,&bind)))) {
414 if(SUCCEEDED (IMoniker_GetDisplayName(iface,bind,NULL,&dispName1))) {
415 if(SUCCEEDED (IMoniker_GetDisplayName(pmkOtherMoniker,bind,NULL,&dispName2))) {
416 if(lstrcmpW(dispName1,dispName2)==0) res = S_OK;
417 CoTaskMemFree(dispName2);
418 }
419 CoTaskMemFree(dispName1);
420 }
421 }
422 return res;
423 }
424
425 /******************************************************************************
426 * ClassMoniker_Hash
427 ******************************************************************************/
428 static HRESULT WINAPI ClassMoniker_Hash(IMoniker* iface,DWORD* pdwHash)
429 {
430 ClassMoniker *This = (ClassMoniker *)iface;
431
432 TRACE("(%p)\n", pdwHash);
433
434 *pdwHash = This->clsid.Data1;
435
436 return S_OK;
437 }
438
439 /******************************************************************************
440 * ClassMoniker_IsRunning
441 ******************************************************************************/
442 static HRESULT WINAPI ClassMoniker_IsRunning(IMoniker* iface,
443 IBindCtx* pbc,
444 IMoniker* pmkToLeft,
445 IMoniker* pmkNewlyRunning)
446 {
447 TRACE("(%p, %p, %p)\n", pbc, pmkToLeft, pmkNewlyRunning);
448
449 /* as in native */
450 return E_NOTIMPL;
451 }
452
453 /******************************************************************************
454 * ClassMoniker_GetTimeOfLastChange
455 ******************************************************************************/
456 static HRESULT WINAPI ClassMoniker_GetTimeOfLastChange(IMoniker* iface,
457 IBindCtx* pbc,
458 IMoniker* pmkToLeft,
459 FILETIME* pItemTime)
460 {
461 TRACE("(%p, %p, %p)\n", pbc, pmkToLeft, pItemTime);
462
463 return MK_E_UNAVAILABLE;
464 }
465
466 /******************************************************************************
467 * ClassMoniker_Inverse
468 ******************************************************************************/
469 static HRESULT WINAPI ClassMoniker_Inverse(IMoniker* iface,IMoniker** ppmk)
470 {
471 TRACE("(%p)\n",ppmk);
472
473 if (!ppmk)
474 return E_POINTER;
475
476 return CreateAntiMoniker(ppmk);
477 }
478
479 /******************************************************************************
480 * ClassMoniker_CommonPrefixWith
481 ******************************************************************************/
482 static HRESULT WINAPI ClassMoniker_CommonPrefixWith(IMoniker* iface,IMoniker* pmkOther,IMoniker** ppmkPrefix)
483 {
484 DWORD mkSys;
485
486 TRACE("(%p, %p)\n", pmkOther, ppmkPrefix);
487
488 *ppmkPrefix = NULL;
489
490 IMoniker_IsSystemMoniker(pmkOther, &mkSys);
491
492 /* If the other moniker is an class moniker that is equal to this moniker, this method sets *ppmkPrefix */
493 /* to this moniker and returns MK_S_US */
494
495 if (mkSys == MKSYS_CLASSMONIKER)
496 {
497 if (IMoniker_IsEqual(iface, pmkOther) == S_OK)
498 {
499 *ppmkPrefix = iface;
500
501 IMoniker_AddRef(iface);
502
503 return MK_S_US;
504 }
505 else
506 return MK_E_NOPREFIX;
507 }
508 else
509 /* otherwise, the method calls the MonikerCommonPrefixWith function. This function correctly handles */
510 /* the case where the other moniker is a generic composite. */
511 return MonikerCommonPrefixWith(iface, pmkOther, ppmkPrefix);
512 }
513
514 /******************************************************************************
515 * ClassMoniker_RelativePathTo
516 ******************************************************************************/
517 static HRESULT WINAPI ClassMoniker_RelativePathTo(IMoniker* iface,IMoniker* pmOther, IMoniker** ppmkRelPath)
518 {
519 TRACE("(%p, %p)\n",pmOther,ppmkRelPath);
520
521 if (!ppmkRelPath)
522 return E_POINTER;
523
524 *ppmkRelPath = NULL;
525
526 return MK_E_NOTBINDABLE;
527 }
528
529 /******************************************************************************
530 * ClassMoniker_GetDisplayName
531 ******************************************************************************/
532 static HRESULT WINAPI ClassMoniker_GetDisplayName(IMoniker* iface,
533 IBindCtx* pbc,
534 IMoniker* pmkToLeft,
535 LPOLESTR *ppszDisplayName)
536 {
537 ClassMoniker *This = (ClassMoniker *)iface;
538 static const WCHAR wszClsidPrefix[] = {'c','l','s','i','d',':',0};
539
540 TRACE("(%p, %p, %p)\n", pbc, pmkToLeft, ppszDisplayName);
541
542 if (!ppszDisplayName)
543 return E_POINTER;
544
545 if (pmkToLeft)
546 return E_INVALIDARG;
547
548 *ppszDisplayName = CoTaskMemAlloc(sizeof(wszClsidPrefix) + (CHARS_IN_GUID-2) * sizeof(WCHAR));
549
550 StringFromGUID2(&This->clsid, *ppszDisplayName+sizeof(wszClsidPrefix)/sizeof(WCHAR)-2, CHARS_IN_GUID);
551
552 /* note: this overwrites the opening curly bracket of the CLSID string generated above */
553 memcpy(*ppszDisplayName, wszClsidPrefix, sizeof(wszClsidPrefix)-sizeof(WCHAR));
554
555 /* note: this overwrites the closing curly bracket of the CLSID string generated above */
556 (*ppszDisplayName)[sizeof(wszClsidPrefix)/sizeof(WCHAR)-2+CHARS_IN_GUID-2] = ':';
557 (*ppszDisplayName)[sizeof(wszClsidPrefix)/sizeof(WCHAR)-2+CHARS_IN_GUID-1] = '\0';
558
559 TRACE("string is %s\n", debugstr_w(*ppszDisplayName));
560 return S_OK;
561 }
562
563 /******************************************************************************
564 * ClassMoniker_ParseDisplayName
565 ******************************************************************************/
566 static HRESULT WINAPI ClassMoniker_ParseDisplayName(IMoniker* iface,
567 IBindCtx* pbc,
568 IMoniker* pmkToLeft,
569 LPOLESTR pszDisplayName,
570 ULONG* pchEaten,
571 IMoniker** ppmkOut)
572 {
573 FIXME("(%p, %p, %s, %p, %p)\n", pbc, pmkToLeft, debugstr_w(pszDisplayName), pchEaten, ppmkOut);
574 return E_NOTIMPL;
575 }
576
577 /******************************************************************************
578 * ClassMoniker_IsSystemMoniker
579 ******************************************************************************/
580 static HRESULT WINAPI ClassMoniker_IsSystemMoniker(IMoniker* iface,DWORD* pwdMksys)
581 {
582 TRACE("(%p,%p)\n",iface,pwdMksys);
583
584 if (!pwdMksys)
585 return E_POINTER;
586
587 *pwdMksys = MKSYS_CLASSMONIKER;
588
589 return S_OK;
590 }
591
592 /*******************************************************************************
593 * ClassMonikerIROTData_QueryInterface
594 *******************************************************************************/
595 static HRESULT WINAPI ClassMonikerROTData_QueryInterface(IROTData *iface,REFIID riid,VOID** ppvObject)
596 {
597
598 IMoniker *This = impl_from_IROTData(iface);
599
600 TRACE("(%p,%p,%p)\n",iface,riid,ppvObject);
601
602 return ClassMoniker_QueryInterface(This, riid, ppvObject);
603 }
604
605 /***********************************************************************
606 * ClassMonikerIROTData_AddRef
607 */
608 static ULONG WINAPI ClassMonikerROTData_AddRef(IROTData *iface)
609 {
610 IMoniker *This = impl_from_IROTData(iface);
611
612 TRACE("(%p)\n",iface);
613
614 return ClassMoniker_AddRef(This);
615 }
616
617 /***********************************************************************
618 * ClassMonikerIROTData_Release
619 */
620 static ULONG WINAPI ClassMonikerROTData_Release(IROTData* iface)
621 {
622 IMoniker *This = impl_from_IROTData(iface);
623
624 TRACE("(%p)\n",iface);
625
626 return ClassMoniker_Release(This);
627 }
628
629 /******************************************************************************
630 * ClassMonikerIROTData_GetComparisonData
631 ******************************************************************************/
632 static HRESULT WINAPI ClassMonikerROTData_GetComparisonData(IROTData* iface,
633 BYTE* pbData,
634 ULONG cbMax,
635 ULONG* pcbData)
636 {
637 ClassMoniker *This = (ClassMoniker *)impl_from_IROTData(iface);
638
639 TRACE("(%p, %u, %p)\n", pbData, cbMax, pcbData);
640
641 *pcbData = 2*sizeof(CLSID);
642 if (cbMax < *pcbData)
643 return E_OUTOFMEMORY;
644
645 /* write CLSID of the moniker */
646 memcpy(pbData, &CLSID_ClassMoniker, sizeof(CLSID));
647 /* write CLSID the moniker represents */
648 memcpy(pbData+sizeof(CLSID), &This->clsid, sizeof(CLSID));
649
650 return S_OK;
651 }
652
653 /********************************************************************************/
654 /* Virtual function table for the ClassMoniker class which include IPersist,*/
655 /* IPersistStream and IMoniker functions. */
656 static const IMonikerVtbl ClassMonikerVtbl =
657 {
658 ClassMoniker_QueryInterface,
659 ClassMoniker_AddRef,
660 ClassMoniker_Release,
661 ClassMoniker_GetClassID,
662 ClassMoniker_IsDirty,
663 ClassMoniker_Load,
664 ClassMoniker_Save,
665 ClassMoniker_GetSizeMax,
666 ClassMoniker_BindToObject,
667 ClassMoniker_BindToStorage,
668 ClassMoniker_Reduce,
669 ClassMoniker_ComposeWith,
670 ClassMoniker_Enum,
671 ClassMoniker_IsEqual,
672 ClassMoniker_Hash,
673 ClassMoniker_IsRunning,
674 ClassMoniker_GetTimeOfLastChange,
675 ClassMoniker_Inverse,
676 ClassMoniker_CommonPrefixWith,
677 ClassMoniker_RelativePathTo,
678 ClassMoniker_GetDisplayName,
679 ClassMoniker_ParseDisplayName,
680 ClassMoniker_IsSystemMoniker
681 };
682
683 /********************************************************************************/
684 /* Virtual function table for the IROTData class. */
685 static const IROTDataVtbl ROTDataVtbl =
686 {
687 ClassMonikerROTData_QueryInterface,
688 ClassMonikerROTData_AddRef,
689 ClassMonikerROTData_Release,
690 ClassMonikerROTData_GetComparisonData
691 };
692
693 /******************************************************************************
694 * ClassMoniker_Construct (local function)
695 *******************************************************************************/
696 static HRESULT ClassMoniker_Construct(ClassMoniker* This, REFCLSID rclsid)
697 {
698 TRACE("(%p,%s)\n",This,debugstr_guid(rclsid));
699
700 /* Initialize the virtual function table. */
701 This->lpVtbl = &ClassMonikerVtbl;
702 This->lpVtblRotData = &ROTDataVtbl;
703 This->ref = 0;
704 This->clsid = *rclsid;
705 This->pMarshal = NULL;
706
707 return S_OK;
708 }
709
710 /******************************************************************************
711 * CreateClassMoniker [OLE32.@]
712 ******************************************************************************/
713 HRESULT WINAPI CreateClassMoniker(REFCLSID rclsid, IMoniker **ppmk)
714 {
715 ClassMoniker* newClassMoniker;
716 HRESULT hr;
717
718 TRACE("(%s,%p)\n", debugstr_guid(rclsid), ppmk);
719
720 newClassMoniker = HeapAlloc(GetProcessHeap(), 0, sizeof(ClassMoniker));
721
722 if (!newClassMoniker)
723 return STG_E_INSUFFICIENTMEMORY;
724
725 hr = ClassMoniker_Construct(newClassMoniker, rclsid);
726
727 if (FAILED(hr))
728 {
729 HeapFree(GetProcessHeap(), 0, newClassMoniker);
730 return hr;
731 }
732
733 return ClassMoniker_QueryInterface((IMoniker *)newClassMoniker, &IID_IMoniker, (void**)ppmk);
734 }
735
736 HRESULT ClassMoniker_CreateFromDisplayName(LPBC pbc, LPCOLESTR szDisplayName,
737 LPDWORD pchEaten, LPMONIKER *ppmk)
738 {
739 HRESULT hr;
740 LPCWSTR s = strchrW(szDisplayName, ':');
741 LPCWSTR end;
742 CLSID clsid;
743 BYTE table[256];
744 int i;
745
746 if (!s)
747 return MK_E_SYNTAX;
748
749 s++;
750
751 for (end = s; *end && (*end != ':'); end++)
752 ;
753
754 TRACE("parsing %s\n", debugstr_wn(s, end - s));
755
756 /* validate the CLSID string */
757 if (s[0] == '{')
758 {
759 if ((end - s != 38) || (s[37] != '}'))
760 return MK_E_SYNTAX;
761 s++;
762 }
763 else
764 {
765 if (end - s != 36)
766 return MK_E_SYNTAX;
767 }
768
769 for (i=0; i<36; i++)
770 {
771 if ((i == 8)||(i == 13)||(i == 18)||(i == 23))
772 {
773 if (s[i] != '-')
774 return MK_E_SYNTAX;
775 continue;
776 }
777 if (!(((s[i] >= '') && (s[i] <= '9')) ||
778 ((s[i] >= 'a') && (s[i] <= 'f')) ||
779 ((s[i] >= 'A') && (s[i] <= 'F'))))
780 return MK_E_SYNTAX;
781 }
782
783 /* quick lookup table */
784 memset(table, 0, 256);
785
786 for (i = 0; i < 10; i++)
787 table['' + i] = i;
788 for (i = 0; i < 6; i++)
789 {
790 table['A' + i] = i+10;
791 table['a' + i] = i+10;
792 }
793
794 /* in form XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX */
795
796 clsid.Data1 = (table[s[0]] << 28 | table[s[1]] << 24 | table[s[2]] << 20 | table[s[3]] << 16 |
797 table[s[4]] << 12 | table[s[5]] << 8 | table[s[6]] << 4 | table[s[7]]);
798 clsid.Data2 = table[s[9]] << 12 | table[s[10]] << 8 | table[s[11]] << 4 | table[s[12]];
799 clsid.Data3 = table[s[14]] << 12 | table[s[15]] << 8 | table[s[16]] << 4 | table[s[17]];
800
801 /* these are just sequential bytes */
802 clsid.Data4[0] = table[s[19]] << 4 | table[s[20]];
803 clsid.Data4[1] = table[s[21]] << 4 | table[s[22]];
804 clsid.Data4[2] = table[s[24]] << 4 | table[s[25]];
805 clsid.Data4[3] = table[s[26]] << 4 | table[s[27]];
806 clsid.Data4[4] = table[s[28]] << 4 | table[s[29]];
807 clsid.Data4[5] = table[s[30]] << 4 | table[s[31]];
808 clsid.Data4[6] = table[s[32]] << 4 | table[s[33]];
809 clsid.Data4[7] = table[s[34]] << 4 | table[s[35]];
810
811 hr = CreateClassMoniker(&clsid, ppmk);
812 if (SUCCEEDED(hr))
813 *pchEaten = (*end == ':' ? end + 1 : end) - szDisplayName;
814 return hr;
815 }
816
817 static HRESULT WINAPI ClassMonikerCF_QueryInterface(LPCLASSFACTORY iface,
818 REFIID riid, LPVOID *ppv)
819 {
820 *ppv = NULL;
821 if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IClassFactory))
822 {
823 *ppv = iface;
824 IUnknown_AddRef(iface);
825 return S_OK;
826 }
827 return E_NOINTERFACE;
828 }
829
830 static ULONG WINAPI ClassMonikerCF_AddRef(LPCLASSFACTORY iface)
831 {
832 return 2; /* non-heap based object */
833 }
834
835 static ULONG WINAPI ClassMonikerCF_Release(LPCLASSFACTORY iface)
836 {
837 return 1; /* non-heap based object */
838 }
839
840 static HRESULT WINAPI ClassMonikerCF_CreateInstance(LPCLASSFACTORY iface,
841 LPUNKNOWN pUnk, REFIID riid, LPVOID *ppv)
842 {
843 HRESULT hr;
844 IMoniker *pmk;
845
846 TRACE("(%p, %s, %p)\n", pUnk, debugstr_guid(riid), ppv);
847
848 *ppv = NULL;
849
850 if (pUnk)
851 return CLASS_E_NOAGGREGATION;
852
853 hr = CreateClassMoniker(&CLSID_NULL, &pmk);
854 if (FAILED(hr)) return hr;
855
856 hr = IMoniker_QueryInterface(pmk, riid, ppv);
857 IMoniker_Release(pmk);
858
859 return hr;
860 }
861
862 static HRESULT WINAPI ClassMonikerCF_LockServer(LPCLASSFACTORY iface, BOOL fLock)
863 {
864 FIXME("(%d), stub!\n",fLock);
865 return S_OK;
866 }
867
868 static const IClassFactoryVtbl ClassMonikerCFVtbl =
869 {
870 ClassMonikerCF_QueryInterface,
871 ClassMonikerCF_AddRef,
872 ClassMonikerCF_Release,
873 ClassMonikerCF_CreateInstance,
874 ClassMonikerCF_LockServer
875 };
876 static const IClassFactoryVtbl *ClassMonikerCF = &ClassMonikerCFVtbl;
877
878 HRESULT ClassMonikerCF_Create(REFIID riid, LPVOID *ppv)
879 {
880 return IClassFactory_QueryInterface((IClassFactory *)&ClassMonikerCF, riid, ppv);
881 }
882
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.