source: trunk/src/ole32/antimoniker.c@ 7721

Last change on this file since 7721 was 7508, checked in by sandervl, 24 years ago

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