1 /*
2 * AntiMonikers 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 "windef.h"
30 #include "winbase.h"
31 #include "winerror.h"
32 #include "objbase.h"
33 #include "wine/debug.h"
34 #include "moniker.h"
35
36 WINE_DEFAULT_DEBUG_CHANNEL(ole);
37
38 /* AntiMoniker data structure */
39 typedef struct AntiMonikerImpl{
40
41 const IMonikerVtbl* lpvtbl1; /* VTable relative to the IMoniker interface.*/
42
43 /* The ROT (RunningObjectTable implementation) uses the IROTData interface to test whether
44 * two monikers are equal. That's whay IROTData interface is implemented by monikers.
45 */
46 const IROTDataVtbl* lpvtbl2; /* VTable relative to the IROTData interface.*/
47
48 LONG ref; /* reference counter for this object */
49
50 IUnknown *pMarshal; /* custom marshaler */
51 } AntiMonikerImpl;
52
53 static inline IMoniker *impl_from_IROTData( IROTData *iface )
54 {
55 return (IMoniker *)((char*)iface - FIELD_OFFSET(AntiMonikerImpl, lpvtbl2));
56 }
57
58
59 /*******************************************************************************
60 * AntiMoniker_QueryInterface
61 *******************************************************************************/
62 static HRESULT WINAPI
63 AntiMonikerImpl_QueryInterface(IMoniker* iface,REFIID riid,void** ppvObject)
64 {
65 AntiMonikerImpl *This = (AntiMonikerImpl *)iface;
66
67 TRACE("(%p,%p,%p)\n",This,riid,ppvObject);
68
69 /* Perform a sanity check on the parameters.*/
70 if ( (This==0) || (ppvObject==0) )
71 return E_INVALIDARG;
72
73 /* Initialize the return parameter */
74 *ppvObject = 0;
75
76 /* Compare the riid with the interface IDs implemented by this object.*/
77 if (IsEqualIID(&IID_IUnknown, riid) ||
78 IsEqualIID(&IID_IPersist, riid) ||
79 IsEqualIID(&IID_IPersistStream, riid) ||
80 IsEqualIID(&IID_IMoniker, riid))
81 *ppvObject = iface;
82 else if (IsEqualIID(&IID_IROTData, riid))
83 *ppvObject = &This->lpvtbl2;
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)==0)
96 return E_NOINTERFACE;
97
98 /* always increase the reference count by one when it is successful */
99 IMoniker_AddRef(iface);
100
101 return S_OK;
102 }
103
104 /******************************************************************************
105 * AntiMoniker_AddRef
106 ******************************************************************************/
107 static ULONG WINAPI
108 AntiMonikerImpl_AddRef(IMoniker* iface)
109 {
110 AntiMonikerImpl *This = (AntiMonikerImpl *)iface;
111
112 TRACE("(%p)\n",This);
113
114 return InterlockedIncrement(&This->ref);
115 }
116
117 /******************************************************************************
118 * AntiMoniker_Release
119 ******************************************************************************/
120 static ULONG WINAPI
121 AntiMonikerImpl_Release(IMoniker* iface)
122 {
123 AntiMonikerImpl *This = (AntiMonikerImpl *)iface;
124 ULONG ref;
125
126 TRACE("(%p)\n",This);
127
128 ref = InterlockedDecrement(&This->ref);
129
130 /* destroy the object if there's no more reference on it */
131 if (ref == 0)
132 {
133 if (This->pMarshal) IUnknown_Release(This->pMarshal);
134 HeapFree(GetProcessHeap(),0,This);
135 }
136
137 return ref;
138 }
139
140 /******************************************************************************
141 * AntiMoniker_GetClassID
142 ******************************************************************************/
143 static HRESULT WINAPI
144 AntiMonikerImpl_GetClassID(IMoniker* iface,CLSID *pClassID)
145 {
146 TRACE("(%p,%p)\n",iface,pClassID);
147
148 if (pClassID==NULL)
149 return E_POINTER;
150
151 *pClassID = CLSID_AntiMoniker;
152
153 return S_OK;
154 }
155
156 /******************************************************************************
157 * AntiMoniker_IsDirty
158 ******************************************************************************/
159 static HRESULT WINAPI
160 AntiMonikerImpl_IsDirty(IMoniker* iface)
161 {
162 /* Note that the OLE-provided implementations of the IPersistStream::IsDirty
163 method in the OLE-provided moniker interfaces always return S_FALSE because
164 their internal state never changes. */
165
166 TRACE("(%p)\n",iface);
167
168 return S_FALSE;
169 }
170
171 /******************************************************************************
172 * AntiMoniker_Load
173 ******************************************************************************/
174 static HRESULT WINAPI
175 AntiMonikerImpl_Load(IMoniker* iface,IStream* pStm)
176 {
177 DWORD constant=1,dwbuffer;
178 HRESULT res;
179
180 /* data read by this function is only a DWORD constant (must be 1) ! */
181 res=IStream_Read(pStm,&dwbuffer,sizeof(DWORD),NULL);
182
183 if (SUCCEEDED(res)&& dwbuffer!=constant)
184 return E_FAIL;
185
186 return res;
187 }
188
189 /******************************************************************************
190 * AntiMoniker_Save
191 ******************************************************************************/
192 static HRESULT WINAPI
193 AntiMonikerImpl_Save(IMoniker* iface,IStream* pStm,BOOL fClearDirty)
194 {
195 DWORD constant=1;
196 HRESULT res;
197
198 /* data written by this function is only a DWORD constant set to 1 ! */
199 res=IStream_Write(pStm,&constant,sizeof(constant),NULL);
200
201 return res;
202 }
203
204 /******************************************************************************
205 * AntiMoniker_GetSizeMax
206 *
207 * PARAMS
208 * pcbSize [out] Pointer to size of stream needed to save object
209 ******************************************************************************/
210 static HRESULT WINAPI
211 AntiMonikerImpl_GetSizeMax(IMoniker* iface, ULARGE_INTEGER* pcbSize)
212 {
213 TRACE("(%p,%p)\n",iface,pcbSize);
214
215 if (!pcbSize)
216 return E_POINTER;
217
218 /* for more details see AntiMonikerImpl_Save comments */
219
220 /*
221 * Normally the sizemax must be sizeof DWORD, but
222 * I tested this function it usually return 16 bytes
223 * more than the number of bytes used by AntiMoniker::Save function
224 */
225 pcbSize->u.LowPart = sizeof(DWORD)+16;
226
227 pcbSize->u.HighPart=0;
228
229 return S_OK;
230 }
231
232 /******************************************************************************
233 * AntiMoniker_BindToObject
234 ******************************************************************************/
235 static HRESULT WINAPI
236 AntiMonikerImpl_BindToObject(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft,
237 REFIID riid, VOID** ppvResult)
238 {
239 TRACE("(%p,%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,riid,ppvResult);
240 return E_NOTIMPL;
241 }
242
243 /******************************************************************************
244 * AntiMoniker_BindToStorage
245 ******************************************************************************/
246 static HRESULT WINAPI
247 AntiMonikerImpl_BindToStorage(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft,
248 REFIID riid, VOID** ppvResult)
249 {
250 TRACE("(%p,%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,riid,ppvResult);
251 return E_NOTIMPL;
252 }
253
254 /******************************************************************************
255 * AntiMoniker_Reduce
256 ******************************************************************************/
257 static HRESULT WINAPI
258 AntiMonikerImpl_Reduce(IMoniker* iface, IBindCtx* pbc, DWORD dwReduceHowFar,
259 IMoniker** ppmkToLeft, IMoniker** ppmkReduced)
260 {
261 TRACE("(%p,%p,%d,%p,%p)\n",iface,pbc,dwReduceHowFar,ppmkToLeft,ppmkReduced);
262
263 if (ppmkReduced==NULL)
264 return E_POINTER;
265
266 AntiMonikerImpl_AddRef(iface);
267
268 *ppmkReduced=iface;
269
270 return MK_S_REDUCED_TO_SELF;
271 }
272 /******************************************************************************
273 * AntiMoniker_ComposeWith
274 ******************************************************************************/
275 static HRESULT WINAPI
276 AntiMonikerImpl_ComposeWith(IMoniker* iface, IMoniker* pmkRight,
277 BOOL fOnlyIfNotGeneric, IMoniker** ppmkComposite)
278 {
279
280 TRACE("(%p,%p,%d,%p)\n",iface,pmkRight,fOnlyIfNotGeneric,ppmkComposite);
281
282 if ((ppmkComposite==NULL)||(pmkRight==NULL))
283 return E_POINTER;
284
285 *ppmkComposite=0;
286
287 if (fOnlyIfNotGeneric)
288 return MK_E_NEEDGENERIC;
289 else
290 return CreateGenericComposite(iface,pmkRight,ppmkComposite);
291 }
292
293 /******************************************************************************
294 * AntiMoniker_Enum
295 ******************************************************************************/
296 static HRESULT WINAPI
297 AntiMonikerImpl_Enum(IMoniker* iface,BOOL fForward, IEnumMoniker** ppenumMoniker)
298 {
299 TRACE("(%p,%d,%p)\n",iface,fForward,ppenumMoniker);
300
301 if (ppenumMoniker == NULL)
302 return E_POINTER;
303
304 *ppenumMoniker = NULL;
305
306 return S_OK;
307 }
308
309 /******************************************************************************
310 * AntiMoniker_IsEqual
311 ******************************************************************************/
312 static HRESULT WINAPI
313 AntiMonikerImpl_IsEqual(IMoniker* iface,IMoniker* pmkOtherMoniker)
314 {
315 DWORD mkSys;
316
317 TRACE("(%p,%p)\n",iface,pmkOtherMoniker);
318
319 if (pmkOtherMoniker==NULL)
320 return S_FALSE;
321
322 IMoniker_IsSystemMoniker(pmkOtherMoniker,&mkSys);
323
324 if (mkSys==MKSYS_ANTIMONIKER)
325 return S_OK;
326 else
327 return S_FALSE;
328 }
329
330 /******************************************************************************
331 * AntiMoniker_Hash
332 ******************************************************************************/
333 static HRESULT WINAPI AntiMonikerImpl_Hash(IMoniker* iface,DWORD* pdwHash)
334 {
335 if (pdwHash==NULL)
336 return E_POINTER;
337
338 *pdwHash = 0x80000001;
339
340 return S_OK;
341 }
342
343 /******************************************************************************
344 * AntiMoniker_IsRunning
345 ******************************************************************************/
346 static HRESULT WINAPI
347 AntiMonikerImpl_IsRunning(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft,
348 IMoniker* pmkNewlyRunning)
349 {
350 IRunningObjectTable* rot;
351 HRESULT res;
352
353 TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pmkNewlyRunning);
354
355 if (pbc==NULL)
356 return E_INVALIDARG;
357
358 res=IBindCtx_GetRunningObjectTable(pbc,&rot);
359
360 if (FAILED(res))
361 return res;
362
363 res = IRunningObjectTable_IsRunning(rot,iface);
364
365 IRunningObjectTable_Release(rot);
366
367 return res;
368 }
369
370 /******************************************************************************
371 * AntiMoniker_GetTimeOfLastChange
372 ******************************************************************************/
373 static HRESULT WINAPI AntiMonikerImpl_GetTimeOfLastChange(IMoniker* iface,
374 IBindCtx* pbc,
375 IMoniker* pmkToLeft,
376 FILETIME* pAntiTime)
377 {
378 TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pAntiTime);
379 return E_NOTIMPL;
380 }
381
382 /******************************************************************************
383 * AntiMoniker_Inverse
384 ******************************************************************************/
385 static HRESULT WINAPI
386 AntiMonikerImpl_Inverse(IMoniker* iface,IMoniker** ppmk)
387 {
388 TRACE("(%p,%p)\n",iface,ppmk);
389
390 if (ppmk==NULL)
391 return E_POINTER;
392
393 *ppmk=0;
394
395 return MK_E_NOINVERSE;
396 }
397
398 /******************************************************************************
399 * AntiMoniker_CommonPrefixWith
400 ******************************************************************************/
401 static HRESULT WINAPI
402 AntiMonikerImpl_CommonPrefixWith(IMoniker* iface,IMoniker* pmkOther,IMoniker** ppmkPrefix)
403 {
404 DWORD mkSys;
405
406 IMoniker_IsSystemMoniker(pmkOther,&mkSys);
407
408 if(mkSys==MKSYS_ANTIMONIKER){
409
410 IMoniker_AddRef(iface);
411
412 *ppmkPrefix=iface;
413
414 IMoniker_AddRef(iface);
415
416 return MK_S_US;
417 }
418 else
419 return MonikerCommonPrefixWith(iface,pmkOther,ppmkPrefix);
420 }
421
422 /******************************************************************************
423 * AntiMoniker_RelativePathTo
424 ******************************************************************************/
425 static HRESULT WINAPI
426 AntiMonikerImpl_RelativePathTo(IMoniker* iface,IMoniker* pmOther, IMoniker** ppmkRelPath)
427 {
428 TRACE("(%p,%p,%p)\n",iface,pmOther,ppmkRelPath);
429
430 if (ppmkRelPath==NULL)
431 return E_POINTER;
432
433 IMoniker_AddRef(pmOther);
434
435 *ppmkRelPath=pmOther;
436
437 return MK_S_HIM;
438 }
439
440 /******************************************************************************
441 * AntiMoniker_GetDisplayName
442 ******************************************************************************/
443 static HRESULT WINAPI
444 AntiMonikerImpl_GetDisplayName(IMoniker* iface, IBindCtx* pbc,
445 IMoniker* pmkToLeft, LPOLESTR *ppszDisplayName)
446 {
447 static const WCHAR back[]={'\\','.','.',0};
448
449 TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,ppszDisplayName);
450
451 if (ppszDisplayName==NULL)
452 return E_POINTER;
453
454 if (pmkToLeft!=NULL){
455 FIXME("() pmkToLeft!=NULL not implemented\n");
456 return E_NOTIMPL;
457 }
458
459 *ppszDisplayName=CoTaskMemAlloc(sizeof(back));
460
461 if (*ppszDisplayName==NULL)
462 return E_OUTOFMEMORY;
463
464 lstrcpyW(*ppszDisplayName,back);
465
466 return S_OK;
467 }
468
469 /******************************************************************************
470 * AntiMoniker_ParseDisplayName
471 ******************************************************************************/
472 static HRESULT WINAPI
473 AntiMonikerImpl_ParseDisplayName(IMoniker* iface, IBindCtx* pbc,
474 IMoniker* pmkToLeft, LPOLESTR pszDisplayName,
475 ULONG* pchEaten, IMoniker** ppmkOut)
476 {
477 TRACE("(%p,%p,%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pszDisplayName,pchEaten,ppmkOut);
478 return E_NOTIMPL;
479 }
480
481 /******************************************************************************
482 * AntiMoniker_IsSystemMoniker
483 ******************************************************************************/
484 static HRESULT WINAPI
485 AntiMonikerImpl_IsSystemMoniker(IMoniker* iface,DWORD* pwdMksys)
486 {
487 TRACE("(%p,%p)\n",iface,pwdMksys);
488
489 if (!pwdMksys)
490 return E_POINTER;
491
492 (*pwdMksys)=MKSYS_ANTIMONIKER;
493
494 return S_OK;
495 }
496
497 /*******************************************************************************
498 * AntiMonikerIROTData_QueryInterface
499 *******************************************************************************/
500 static HRESULT WINAPI
501 AntiMonikerROTDataImpl_QueryInterface(IROTData *iface,REFIID riid,VOID** ppvObject)
502 {
503 IMoniker *This = impl_from_IROTData(iface);
504
505 TRACE("(%p,%p,%p)\n",iface,riid,ppvObject);
506
507 return AntiMonikerImpl_QueryInterface(This, riid, ppvObject);
508 }
509
510 /***********************************************************************
511 * AntiMonikerIROTData_AddRef
512 */
513 static ULONG WINAPI AntiMonikerROTDataImpl_AddRef(IROTData *iface)
514 {
515 IMoniker *This = impl_from_IROTData(iface);
516
517 TRACE("(%p)\n",iface);
518
519 return AntiMonikerImpl_AddRef(This);
520 }
521
522 /***********************************************************************
523 * AntiMonikerIROTData_Release
524 */
525 static ULONG WINAPI AntiMonikerROTDataImpl_Release(IROTData* iface)
526 {
527 IMoniker *This = impl_from_IROTData(iface);
528
529 TRACE("(%p)\n",iface);
530
531 return AntiMonikerImpl_Release(This);
532 }
533
534 /******************************************************************************
535 * AntiMonikerIROTData_GetComparisonData
536 ******************************************************************************/
537 static HRESULT WINAPI
538 AntiMonikerROTDataImpl_GetComparisonData(IROTData* iface, BYTE* pbData,
539 ULONG cbMax, ULONG* pcbData)
540 {
541 DWORD constant = 1;
542
543 TRACE("(%p, %u, %p)\n", pbData, cbMax, pcbData);
544
545 *pcbData = sizeof(CLSID) + sizeof(DWORD);
546 if (cbMax < *pcbData)
547 return E_OUTOFMEMORY;
548
549 memcpy(pbData, &CLSID_AntiMoniker, sizeof(CLSID));
550 memcpy(pbData+sizeof(CLSID), &constant, sizeof(DWORD));
551
552 return S_OK;
553 }
554
555 /********************************************************************************/
556 /* Virtual function table for the AntiMonikerImpl class which include IPersist,*/
557 /* IPersistStream and IMoniker functions. */
558 static const IMonikerVtbl VT_AntiMonikerImpl =
559 {
560 AntiMonikerImpl_QueryInterface,
561 AntiMonikerImpl_AddRef,
562 AntiMonikerImpl_Release,
563 AntiMonikerImpl_GetClassID,
564 AntiMonikerImpl_IsDirty,
565 AntiMonikerImpl_Load,
566 AntiMonikerImpl_Save,
567 AntiMonikerImpl_GetSizeMax,
568 AntiMonikerImpl_BindToObject,
569 AntiMonikerImpl_BindToStorage,
570 AntiMonikerImpl_Reduce,
571 AntiMonikerImpl_ComposeWith,
572 AntiMonikerImpl_Enum,
573 AntiMonikerImpl_IsEqual,
574 AntiMonikerImpl_Hash,
575 AntiMonikerImpl_IsRunning,
576 AntiMonikerImpl_GetTimeOfLastChange,
577 AntiMonikerImpl_Inverse,
578 AntiMonikerImpl_CommonPrefixWith,
579 AntiMonikerImpl_RelativePathTo,
580 AntiMonikerImpl_GetDisplayName,
581 AntiMonikerImpl_ParseDisplayName,
582 AntiMonikerImpl_IsSystemMoniker
583 };
584
585 /********************************************************************************/
586 /* Virtual function table for the IROTData class. */
587 static const IROTDataVtbl VT_ROTDataImpl =
588 {
589 AntiMonikerROTDataImpl_QueryInterface,
590 AntiMonikerROTDataImpl_AddRef,
591 AntiMonikerROTDataImpl_Release,
592 AntiMonikerROTDataImpl_GetComparisonData
593 };
594
595 /******************************************************************************
596 * AntiMoniker_Construct (local function)
597 *******************************************************************************/
598 static HRESULT AntiMonikerImpl_Construct(AntiMonikerImpl* This)
599 {
600
601 TRACE("(%p)\n",This);
602
603 /* Initialize the virtual function table. */
604 This->lpvtbl1 = &VT_AntiMonikerImpl;
605 This->lpvtbl2 = &VT_ROTDataImpl;
606 This->ref = 0;
607 This->pMarshal = NULL;
608
609 return S_OK;
610 }
611
612 /******************************************************************************
613 * CreateAntiMoniker [OLE32.@]
614 ******************************************************************************/
615 HRESULT WINAPI CreateAntiMoniker(LPMONIKER * ppmk)
616 {
617 AntiMonikerImpl* newAntiMoniker = 0;
618 HRESULT hr = S_OK;
619 IID riid=IID_IMoniker;
620
621 TRACE("(%p)\n",ppmk);
622
623 newAntiMoniker = HeapAlloc(GetProcessHeap(), 0, sizeof(AntiMonikerImpl));
624
625 if (newAntiMoniker == 0)
626 return STG_E_INSUFFICIENTMEMORY;
627
628 hr = AntiMonikerImpl_Construct(newAntiMoniker);
629 if (FAILED(hr))
630 {
631 HeapFree(GetProcessHeap(),0,newAntiMoniker);
632 return hr;
633 }
634
635 hr = AntiMonikerImpl_QueryInterface((IMoniker*)newAntiMoniker,&riid,(void**)ppmk);
636
637 return hr;
638 }
639
640 static HRESULT WINAPI AntiMonikerCF_QueryInterface(LPCLASSFACTORY iface,
641 REFIID riid, LPVOID *ppv)
642 {
643 *ppv = NULL;
644 if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IClassFactory))
645 {
646 *ppv = iface;
647 IUnknown_AddRef(iface);
648 return S_OK;
649 }
650 return E_NOINTERFACE;
651 }
652
653 static ULONG WINAPI AntiMonikerCF_AddRef(LPCLASSFACTORY iface)
654 {
655 return 2; /* non-heap based object */
656 }
657
658 static ULONG WINAPI AntiMonikerCF_Release(LPCLASSFACTORY iface)
659 {
660 return 1; /* non-heap based object */
661 }
662
663 static HRESULT WINAPI AntiMonikerCF_CreateInstance(LPCLASSFACTORY iface,
664 LPUNKNOWN pUnk, REFIID riid, LPVOID *ppv)
665 {
666 IMoniker *pMoniker;
667 HRESULT hr;
668
669 TRACE("(%p, %s, %p)\n", pUnk, debugstr_guid(riid), ppv);
670
671 *ppv = NULL;
672
673 if (pUnk)
674 return CLASS_E_NOAGGREGATION;
675
676 hr = CreateAntiMoniker(&pMoniker);
677 if (FAILED(hr))
678 return hr;
679
680 hr = IMoniker_QueryInterface(pMoniker, riid, ppv);
681
682 if (FAILED(hr))
683 IMoniker_Release(pMoniker);
684
685 return hr;
686 }
687
688 static HRESULT WINAPI AntiMonikerCF_LockServer(LPCLASSFACTORY iface, BOOL fLock)
689 {
690 FIXME("(%d), stub!\n",fLock);
691 return S_OK;
692 }
693
694 static const IClassFactoryVtbl AntiMonikerCFVtbl =
695 {
696 AntiMonikerCF_QueryInterface,
697 AntiMonikerCF_AddRef,
698 AntiMonikerCF_Release,
699 AntiMonikerCF_CreateInstance,
700 AntiMonikerCF_LockServer
701 };
702 static const IClassFactoryVtbl *AntiMonikerCF = &AntiMonikerCFVtbl;
703
704 HRESULT AntiMonikerCF_Create(REFIID riid, LPVOID *ppv)
705 {
706 return IClassFactory_QueryInterface((IClassFactory *)&AntiMonikerCF, riid, ppv);
707 }
708
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.