ReactOS  0.4.14-dev-317-g96040ec
antimoniker.c
Go to the documentation of this file.
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 
28 #include "windef.h"
29 #include "winbase.h"
30 #include "winerror.h"
31 #include "objbase.h"
32 #include "wine/debug.h"
33 #include "moniker.h"
34 
36 
37 /* AntiMoniker data structure */
38 typedef struct AntiMonikerImpl{
42  IUnknown *pMarshal; /* custom marshaler */
44 
46 {
47  return CONTAINING_RECORD(iface, AntiMonikerImpl, IMoniker_iface);
48 }
49 
51 {
52  return CONTAINING_RECORD(iface, AntiMonikerImpl, IROTData_iface);
53 }
54 
55 
56 /*******************************************************************************
57  * AntiMoniker_QueryInterface
58  *******************************************************************************/
59 static HRESULT WINAPI
61 {
63 
64  TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppvObject);
65 
66  /* Perform a sanity check on the parameters.*/
67  if ( ppvObject==0 )
68  return E_INVALIDARG;
69 
70  /* Initialize the return parameter */
71  *ppvObject = 0;
72 
73  /* Compare the riid with the interface IDs implemented by this object.*/
74  if (IsEqualIID(&IID_IUnknown, riid) ||
77  IsEqualIID(&IID_IMoniker, riid))
78  *ppvObject = iface;
79  else if (IsEqualIID(&IID_IROTData, riid))
80  *ppvObject = &This->IROTData_iface;
81  else if (IsEqualIID(&IID_IMarshal, riid))
82  {
83  HRESULT hr = S_OK;
84  if (!This->pMarshal)
85  hr = MonikerMarshal_Create(iface, &This->pMarshal);
86  if (hr != S_OK)
87  return hr;
88  return IUnknown_QueryInterface(This->pMarshal, riid, ppvObject);
89  }
90 
91  /* Check that we obtained an interface.*/
92  if ((*ppvObject)==0)
93  return E_NOINTERFACE;
94 
95  /* always increase the reference count by one when it is successful */
96  IMoniker_AddRef(iface);
97 
98  return S_OK;
99 }
100 
101 /******************************************************************************
102  * AntiMoniker_AddRef
103  ******************************************************************************/
104 static ULONG WINAPI
106 {
108 
109  TRACE("(%p)\n",This);
110 
111  return InterlockedIncrement(&This->ref);
112 }
113 
114 /******************************************************************************
115  * AntiMoniker_Release
116  ******************************************************************************/
117 static ULONG WINAPI
119 {
121  ULONG ref;
122 
123  TRACE("(%p)\n",This);
124 
125  ref = InterlockedDecrement(&This->ref);
126 
127  /* destroy the object if there are no more references to it */
128  if (ref == 0)
129  {
130  if (This->pMarshal) IUnknown_Release(This->pMarshal);
132  }
133 
134  return ref;
135 }
136 
137 /******************************************************************************
138  * AntiMoniker_GetClassID
139  ******************************************************************************/
140 static HRESULT WINAPI
142 {
143  TRACE("(%p,%p)\n",iface,pClassID);
144 
145  if (pClassID==NULL)
146  return E_POINTER;
147 
148  *pClassID = CLSID_AntiMoniker;
149 
150  return S_OK;
151 }
152 
153 /******************************************************************************
154  * AntiMoniker_IsDirty
155  ******************************************************************************/
156 static HRESULT WINAPI
158 {
159  /* Note that the OLE-provided implementations of the IPersistStream::IsDirty
160  method in the OLE-provided moniker interfaces always return S_FALSE because
161  their internal state never changes. */
162 
163  TRACE("(%p)\n",iface);
164 
165  return S_FALSE;
166 }
167 
168 /******************************************************************************
169  * AntiMoniker_Load
170  ******************************************************************************/
171 static HRESULT WINAPI
173 {
174  DWORD constant=1,dwbuffer;
175  HRESULT res;
176 
177  /* data read by this function is only a DWORD constant (must be 1) ! */
178  res=IStream_Read(pStm,&dwbuffer,sizeof(DWORD),NULL);
179 
180  if (SUCCEEDED(res)&& dwbuffer!=constant)
181  return E_FAIL;
182 
183  return res;
184 }
185 
186 /******************************************************************************
187  * AntiMoniker_Save
188  ******************************************************************************/
189 static HRESULT WINAPI
190 AntiMonikerImpl_Save(IMoniker* iface,IStream* pStm,BOOL fClearDirty)
191 {
192  static const DWORD constant = 1;
193  /* data written by this function is only a DWORD constant set to 1 ! */
194  return IStream_Write(pStm,&constant,sizeof(constant),NULL);
195 }
196 
197 /******************************************************************************
198  * AntiMoniker_GetSizeMax
199  *
200  * PARAMS
201  * pcbSize [out] Pointer to size of stream needed to save object
202  ******************************************************************************/
203 static HRESULT WINAPI
205 {
206  TRACE("(%p,%p)\n",iface,pcbSize);
207 
208  if (!pcbSize)
209  return E_POINTER;
210 
211  /* for more details see AntiMonikerImpl_Save comments */
212 
213  /*
214  * Normally the sizemax must be sizeof DWORD, but
215  * I tested this function it usually return 16 bytes
216  * more than the number of bytes used by AntiMoniker::Save function
217  */
218  pcbSize->u.LowPart = sizeof(DWORD)+16;
219 
220  pcbSize->u.HighPart=0;
221 
222  return S_OK;
223 }
224 
225 /******************************************************************************
226  * AntiMoniker_BindToObject
227  ******************************************************************************/
228 static HRESULT WINAPI
230  REFIID riid, VOID** ppvResult)
231 {
232  TRACE("(%p,%p,%p,%s,%p)\n",iface,pbc,pmkToLeft,debugstr_guid(riid),ppvResult);
233  return E_NOTIMPL;
234 }
235 
236 /******************************************************************************
237  * AntiMoniker_BindToStorage
238  ******************************************************************************/
239 static HRESULT WINAPI
241  REFIID riid, VOID** ppvResult)
242 {
243  TRACE("(%p,%p,%p,%s,%p)\n",iface,pbc,pmkToLeft,debugstr_guid(riid),ppvResult);
244  return E_NOTIMPL;
245 }
246 
247 /******************************************************************************
248  * AntiMoniker_Reduce
249  ******************************************************************************/
250 static HRESULT WINAPI
251 AntiMonikerImpl_Reduce(IMoniker* iface, IBindCtx* pbc, DWORD dwReduceHowFar,
252  IMoniker** ppmkToLeft, IMoniker** ppmkReduced)
253 {
254  TRACE("(%p,%p,%d,%p,%p)\n",iface,pbc,dwReduceHowFar,ppmkToLeft,ppmkReduced);
255 
256  if (ppmkReduced==NULL)
257  return E_POINTER;
258 
259  AntiMonikerImpl_AddRef(iface);
260 
261  *ppmkReduced=iface;
262 
263  return MK_S_REDUCED_TO_SELF;
264 }
265 /******************************************************************************
266  * AntiMoniker_ComposeWith
267  ******************************************************************************/
268 static HRESULT WINAPI
270  BOOL fOnlyIfNotGeneric, IMoniker** ppmkComposite)
271 {
272 
273  TRACE("(%p,%p,%d,%p)\n",iface,pmkRight,fOnlyIfNotGeneric,ppmkComposite);
274 
275  if ((ppmkComposite==NULL)||(pmkRight==NULL))
276  return E_POINTER;
277 
278  *ppmkComposite=0;
279 
280  if (fOnlyIfNotGeneric)
281  return MK_E_NEEDGENERIC;
282  else
283  return CreateGenericComposite(iface,pmkRight,ppmkComposite);
284 }
285 
286 /******************************************************************************
287  * AntiMoniker_Enum
288  ******************************************************************************/
289 static HRESULT WINAPI
290 AntiMonikerImpl_Enum(IMoniker* iface,BOOL fForward, IEnumMoniker** ppenumMoniker)
291 {
292  TRACE("(%p,%d,%p)\n",iface,fForward,ppenumMoniker);
293 
294  if (ppenumMoniker == NULL)
295  return E_POINTER;
296 
297  *ppenumMoniker = NULL;
298 
299  return S_OK;
300 }
301 
302 /******************************************************************************
303  * AntiMoniker_IsEqual
304  ******************************************************************************/
305 static HRESULT WINAPI
306 AntiMonikerImpl_IsEqual(IMoniker* iface,IMoniker* pmkOtherMoniker)
307 {
308  DWORD mkSys;
309 
310  TRACE("(%p,%p)\n",iface,pmkOtherMoniker);
311 
312  if (pmkOtherMoniker==NULL)
313  return S_FALSE;
314 
315  IMoniker_IsSystemMoniker(pmkOtherMoniker,&mkSys);
316 
317  if (mkSys==MKSYS_ANTIMONIKER)
318  return S_OK;
319  else
320  return S_FALSE;
321 }
322 
323 /******************************************************************************
324  * AntiMoniker_Hash
325  ******************************************************************************/
327 {
328  if (pdwHash==NULL)
329  return E_POINTER;
330 
331  *pdwHash = 0x80000001;
332 
333  return S_OK;
334 }
335 
336 /******************************************************************************
337  * AntiMoniker_IsRunning
338  ******************************************************************************/
339 static HRESULT WINAPI
341  IMoniker* pmkNewlyRunning)
342 {
344  HRESULT res;
345 
346  TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pmkNewlyRunning);
347 
348  if (pbc==NULL)
349  return E_INVALIDARG;
350 
351  res=IBindCtx_GetRunningObjectTable(pbc,&rot);
352 
353  if (FAILED(res))
354  return res;
355 
356  res = IRunningObjectTable_IsRunning(rot,iface);
357 
358  IRunningObjectTable_Release(rot);
359 
360  return res;
361 }
362 
363 /******************************************************************************
364  * AntiMoniker_GetTimeOfLastChange
365  ******************************************************************************/
367  IBindCtx* pbc,
368  IMoniker* pmkToLeft,
369  FILETIME* pAntiTime)
370 {
371  TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pAntiTime);
372  return E_NOTIMPL;
373 }
374 
375 /******************************************************************************
376  * AntiMoniker_Inverse
377  ******************************************************************************/
378 static HRESULT WINAPI
380 {
381  TRACE("(%p,%p)\n",iface,ppmk);
382 
383  if (ppmk==NULL)
384  return E_POINTER;
385 
386  *ppmk=0;
387 
388  return MK_E_NOINVERSE;
389 }
390 
391 /******************************************************************************
392  * AntiMoniker_CommonPrefixWith
393  ******************************************************************************/
394 static HRESULT WINAPI
396 {
397  DWORD mkSys;
398 
399  IMoniker_IsSystemMoniker(pmkOther,&mkSys);
400 
401  if(mkSys==MKSYS_ANTIMONIKER){
402 
403  IMoniker_AddRef(iface);
404 
405  *ppmkPrefix=iface;
406 
407  IMoniker_AddRef(iface);
408 
409  return MK_S_US;
410  }
411  else
412  return MonikerCommonPrefixWith(iface,pmkOther,ppmkPrefix);
413 }
414 
415 /******************************************************************************
416  * AntiMoniker_RelativePathTo
417  ******************************************************************************/
418 static HRESULT WINAPI
420 {
421  TRACE("(%p,%p,%p)\n",iface,pmOther,ppmkRelPath);
422 
423  if (ppmkRelPath==NULL)
424  return E_POINTER;
425 
426  IMoniker_AddRef(pmOther);
427 
428  *ppmkRelPath=pmOther;
429 
430  return MK_S_HIM;
431 }
432 
433 /******************************************************************************
434  * AntiMoniker_GetDisplayName
435  ******************************************************************************/
436 static HRESULT WINAPI
438  IMoniker* pmkToLeft, LPOLESTR *ppszDisplayName)
439 {
440  static const WCHAR back[]={'\\','.','.',0};
441 
442  TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,ppszDisplayName);
443 
444  if (ppszDisplayName==NULL)
445  return E_POINTER;
446 
447  if (pmkToLeft!=NULL){
448  FIXME("() pmkToLeft!=NULL not implemented\n");
449  return E_NOTIMPL;
450  }
451 
452  *ppszDisplayName=CoTaskMemAlloc(sizeof(back));
453 
454  if (*ppszDisplayName==NULL)
455  return E_OUTOFMEMORY;
456 
457  lstrcpyW(*ppszDisplayName,back);
458 
459  return S_OK;
460 }
461 
462 /******************************************************************************
463  * AntiMoniker_ParseDisplayName
464  ******************************************************************************/
465 static HRESULT WINAPI
467  IMoniker* pmkToLeft, LPOLESTR pszDisplayName,
468  ULONG* pchEaten, IMoniker** ppmkOut)
469 {
470  TRACE("(%p,%p,%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pszDisplayName,pchEaten,ppmkOut);
471  return E_NOTIMPL;
472 }
473 
474 /******************************************************************************
475  * AntiMoniker_IsSystemMoniker
476  ******************************************************************************/
477 static HRESULT WINAPI
479 {
480  TRACE("(%p,%p)\n",iface,pwdMksys);
481 
482  if (!pwdMksys)
483  return E_POINTER;
484 
485  (*pwdMksys)=MKSYS_ANTIMONIKER;
486 
487  return S_OK;
488 }
489 
490 /*******************************************************************************
491  * AntiMonikerIROTData_QueryInterface
492  *******************************************************************************/
493 static HRESULT WINAPI
495 {
497 
498  TRACE("(%p,%s,%p)\n",iface,debugstr_guid(riid),ppvObject);
499 
500  return AntiMonikerImpl_QueryInterface(&This->IMoniker_iface, riid, ppvObject);
501 }
502 
503 /***********************************************************************
504  * AntiMonikerIROTData_AddRef
505  */
507 {
509 
510  TRACE("(%p)\n",iface);
511 
512  return AntiMonikerImpl_AddRef(&This->IMoniker_iface);
513 }
514 
515 /***********************************************************************
516  * AntiMonikerIROTData_Release
517  */
519 {
521 
522  TRACE("(%p)\n",iface);
523 
524  return AntiMonikerImpl_Release(&This->IMoniker_iface);
525 }
526 
527 /******************************************************************************
528  * AntiMonikerIROTData_GetComparisonData
529  ******************************************************************************/
530 static HRESULT WINAPI
532  ULONG cbMax, ULONG* pcbData)
533 {
534  DWORD constant = 1;
535 
536  TRACE("(%p, %u, %p)\n", pbData, cbMax, pcbData);
537 
538  *pcbData = sizeof(CLSID) + sizeof(DWORD);
539  if (cbMax < *pcbData)
540  return E_OUTOFMEMORY;
541 
542  memcpy(pbData, &CLSID_AntiMoniker, sizeof(CLSID));
543  memcpy(pbData+sizeof(CLSID), &constant, sizeof(DWORD));
544 
545  return S_OK;
546 }
547 
548 /********************************************************************************/
549 /* Virtual function table for the AntiMonikerImpl class which include IPersist,*/
550 /* IPersistStream and IMoniker functions. */
551 static const IMonikerVtbl VT_AntiMonikerImpl =
552 {
576 };
577 
578 /********************************************************************************/
579 /* Virtual function table for the IROTData class. */
580 static const IROTDataVtbl VT_ROTDataImpl =
581 {
586 };
587 
588 /******************************************************************************
589  * AntiMoniker_Construct (local function)
590  *******************************************************************************/
592 {
593 
594  TRACE("(%p)\n",This);
595 
596  /* Initialize the virtual function table. */
597  This->IMoniker_iface.lpVtbl = &VT_AntiMonikerImpl;
598  This->IROTData_iface.lpVtbl = &VT_ROTDataImpl;
599  This->ref = 0;
600  This->pMarshal = NULL;
601 
602  return S_OK;
603 }
604 
605 /******************************************************************************
606  * CreateAntiMoniker [OLE32.@]
607  ******************************************************************************/
609 {
610  AntiMonikerImpl* newAntiMoniker;
611  HRESULT hr;
612 
613  TRACE("(%p)\n",ppmk);
614 
615  newAntiMoniker = HeapAlloc(GetProcessHeap(), 0, sizeof(AntiMonikerImpl));
616 
617  if (newAntiMoniker == 0)
619 
620  hr = AntiMonikerImpl_Construct(newAntiMoniker);
621  if (FAILED(hr))
622  {
623  HeapFree(GetProcessHeap(),0,newAntiMoniker);
624  return hr;
625  }
626 
627  return AntiMonikerImpl_QueryInterface(&newAntiMoniker->IMoniker_iface, &IID_IMoniker,
628  (void**)ppmk);
629 }
630 
632  IUnknown *pUnk, REFIID riid, void **ppv)
633 {
634  IMoniker *pMoniker;
635  HRESULT hr;
636 
637  TRACE("(%p, %s, %p)\n", pUnk, debugstr_guid(riid), ppv);
638 
639  *ppv = NULL;
640 
641  if (pUnk)
642  return CLASS_E_NOAGGREGATION;
643 
644  hr = CreateAntiMoniker(&pMoniker);
645  if (FAILED(hr))
646  return hr;
647 
648  hr = IMoniker_QueryInterface(pMoniker, riid, ppv);
649 
650  if (FAILED(hr))
651  IMoniker_Release(pMoniker);
652 
653  return hr;
654 }
IMoniker IMoniker_iface
Definition: antimoniker.c:39
#define REFIID
Definition: guiddef.h:118
#define MK_S_REDUCED_TO_SELF
Definition: winerror.h:2773
#define E_NOINTERFACE
Definition: winerror.h:2364
static HRESULT WINAPI AntiMonikerImpl_Load(IMoniker *iface, IStream *pStm)
Definition: antimoniker.c:172
HRESULT WINAPI MonikerCommonPrefixWith(IMoniker *pmkThis, IMoniker *pmkOther, IMoniker **ppmkCommon)
WINE_DEFAULT_DEBUG_CHANNEL(ole)
HRESULT hr
Definition: shlfolder.c:183
static const IMonikerVtbl VT_AntiMonikerImpl
Definition: antimoniker.c:551
#define MK_E_NOINVERSE
Definition: winerror.h:2793
REFIID riid
Definition: precomp.h:44
static HRESULT WINAPI AntiMonikerImpl_GetTimeOfLastChange(IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft, FILETIME *pAntiTime)
Definition: antimoniker.c:366
const GUID IID_IPersist
Definition: proxy.cpp:14
REFIID LPVOID * ppv
Definition: atlbase.h:39
static HRESULT WINAPI AntiMonikerImpl_Reduce(IMoniker *iface, IBindCtx *pbc, DWORD dwReduceHowFar, IMoniker **ppmkToLeft, IMoniker **ppmkReduced)
Definition: antimoniker.c:251
#define STG_E_INSUFFICIENTMEMORY
Definition: winerror.h:2570
IUnknown * pMarshal
Definition: antimoniker.c:42
struct _ULARGE_INTEGER::@3770 u
static LPOLESTR
Definition: stg_prop.c:27
#define E_FAIL
Definition: ddrawi.h:102
#define DWORD
Definition: nt_native.h:44
Definition: send.c:47
struct AntiMonikerImpl AntiMonikerImpl
HRESULT WINAPI AntiMoniker_CreateInstance(IClassFactory *iface, IUnknown *pUnk, REFIID riid, void **ppv)
Definition: antimoniker.c:631
static HRESULT WINAPI AntiMonikerImpl_Inverse(IMoniker *iface, IMoniker **ppmk)
Definition: antimoniker.c:379
static HRESULT WINAPI AntiMonikerImpl_GetClassID(IMoniker *iface, CLSID *pClassID)
Definition: antimoniker.c:141
static HRESULT WINAPI AntiMonikerImpl_BindToObject(IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft, REFIID riid, VOID **ppvResult)
Definition: antimoniker.c:229
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
unsigned int BOOL
Definition: ntddk_ex.h:94
long LONG
Definition: pedump.c:60
static HRESULT WINAPI AntiMonikerImpl_Enum(IMoniker *iface, BOOL fForward, IEnumMoniker **ppenumMoniker)
Definition: antimoniker.c:290
GLenum GLint ref
Definition: glext.h:6028
#define FIXME(fmt,...)
Definition: debug.h:110
GLfloat rot
Definition: 3dtext.c:36
static HRESULT WINAPI AntiMonikerImpl_RelativePathTo(IMoniker *iface, IMoniker *pmOther, IMoniker **ppmkRelPath)
Definition: antimoniker.c:419
#define S_FALSE
Definition: winerror.h:2357
#define E_INVALIDARG
Definition: ddrawi.h:101
smooth NULL
Definition: ftsmooth.c:416
static HRESULT WINAPI AntiMonikerImpl_IsEqual(IMoniker *iface, IMoniker *pmkOtherMoniker)
Definition: antimoniker.c:306
#define MK_E_NEEDGENERIC
Definition: winerror.h:2783
#define debugstr_guid
Definition: kernel32.h:35
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
static AntiMonikerImpl * impl_from_IROTData(IROTData *iface)
Definition: antimoniker.c:50
static HRESULT WINAPI AntiMonikerImpl_Save(IMoniker *iface, IStream *pStm, BOOL fClearDirty)
Definition: antimoniker.c:190
IROTData IROTData_iface
Definition: antimoniker.c:40
static ULONG WINAPI AntiMonikerImpl_Release(IMoniker *iface)
Definition: antimoniker.c:118
#define TRACE(s)
Definition: solgame.cpp:4
#define GetProcessHeap()
Definition: compat.h:395
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
__wchar_t WCHAR
Definition: xmlstorage.h:180
LONG HRESULT
Definition: typedefs.h:77
const GUID IID_IUnknown
static HRESULT WINAPI AntiMonikerImpl_GetDisplayName(IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft, LPOLESTR *ppszDisplayName)
Definition: antimoniker.c:437
#define WINAPI
Definition: msvc.h:8
static HRESULT WINAPI AntiMonikerImpl_IsDirty(IMoniker *iface)
Definition: antimoniker.c:157
static HRESULT WINAPI AntiMonikerImpl_IsRunning(IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft, IMoniker *pmkNewlyRunning)
Definition: antimoniker.c:340
unsigned long DWORD
Definition: ntddk_ex.h:95
const GUID IID_IPersistStream
Definition: proxy.cpp:13
HRESULT WINAPI CreateAntiMoniker(IMoniker **ppmk)
Definition: antimoniker.c:608
#define InterlockedDecrement
Definition: armddk.h:52
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
unsigned char BYTE
Definition: mem.h:68
static HRESULT WINAPI AntiMonikerImpl_IsSystemMoniker(IMoniker *iface, DWORD *pwdMksys)
Definition: antimoniker.c:478
REFIID LPVOID * ppvObject
Definition: precomp.h:44
static ULONG WINAPI AntiMonikerROTDataImpl_Release(IROTData *iface)
Definition: antimoniker.c:518
#define CLASS_E_NOAGGREGATION
Definition: winerror.h:2662
static AntiMonikerImpl * impl_from_IMoniker(IMoniker *iface)
Definition: antimoniker.c:45
static HRESULT WINAPI AntiMonikerImpl_QueryInterface(IMoniker *iface, REFIID riid, void **ppvObject)
Definition: antimoniker.c:60
static ULONG WINAPI AntiMonikerImpl_AddRef(IMoniker *iface)
Definition: antimoniker.c:105
static HRESULT WINAPI AntiMonikerImpl_BindToStorage(IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft, REFIID riid, VOID **ppvResult)
Definition: antimoniker.c:240
#define S_OK
Definition: intsafe.h:59
#define MK_S_US
Definition: winerror.h:2776
#define InterlockedIncrement
Definition: armddk.h:53
#define lstrcpyW
Definition: compat.h:406
static HRESULT WINAPI AntiMonikerImpl_Hash(IMoniker *iface, DWORD *pdwHash)
Definition: antimoniker.c:326
static HRESULT WINAPI AntiMonikerROTDataImpl_GetComparisonData(IROTData *iface, BYTE *pbData, ULONG cbMax, ULONG *pcbData)
Definition: antimoniker.c:531
#define E_NOTIMPL
Definition: ddrawi.h:99
HRESULT MonikerMarshal_Create(IMoniker *inner, IUnknown **outer)
Definition: moniker.c:1677
static ULONG WINAPI AntiMonikerROTDataImpl_AddRef(IROTData *iface)
Definition: antimoniker.c:506
static HRESULT WINAPI AntiMonikerImpl_GetSizeMax(IMoniker *iface, ULARGE_INTEGER *pcbSize)
Definition: antimoniker.c:204
GLuint res
Definition: glext.h:9613
unsigned int ULONG
Definition: retypes.h:1
static HRESULT AntiMonikerImpl_Construct(AntiMonikerImpl *This)
Definition: antimoniker.c:591
static HRESULT WINAPI AntiMonikerROTDataImpl_QueryInterface(IROTData *iface, REFIID riid, VOID **ppvObject)
Definition: antimoniker.c:494
HRESULT WINAPI CreateGenericComposite(IMoniker *pmkFirst, IMoniker *pmkRest, IMoniker **ppmkComposite)
#define E_POINTER
Definition: winerror.h:2365
static HRESULT WINAPI AntiMonikerImpl_CommonPrefixWith(IMoniker *iface, IMoniker *pmkOther, IMoniker **ppmkPrefix)
Definition: antimoniker.c:395
static void *static void *static LPDIRECTPLAY IUnknown * pUnk
Definition: dplayx.c:30
LPVOID WINAPI CoTaskMemAlloc(SIZE_T size)
Definition: ifs.c:404
#define HeapFree(x, y, z)
Definition: compat.h:394
#define IsEqualIID(riid1, riid2)
Definition: guiddef.h:95
static HRESULT WINAPI AntiMonikerImpl_ComposeWith(IMoniker *iface, IMoniker *pmkRight, BOOL fOnlyIfNotGeneric, IMoniker **ppmkComposite)
Definition: antimoniker.c:269
#define SUCCEEDED(hr)
Definition: intsafe.h:57
_In_ DWORD _Out_writes_bytes_to_opt_ pcbData void _Inout_ DWORD * pcbData
Definition: wincrypt.h:4953
static const IROTDataVtbl VT_ROTDataImpl
Definition: antimoniker.c:580
static HRESULT WINAPI AntiMonikerImpl_ParseDisplayName(IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft, LPOLESTR pszDisplayName, ULONG *pchEaten, IMoniker **ppmkOut)
Definition: antimoniker.c:466
_In_ HCRYPTHASH _In_ BOOL _In_ DWORD _Inout_updates_bytes_to_ pdwDataLen BYTE * pbData
Definition: wincrypt.h:4201
#define MK_S_HIM
Definition: winerror.h:2775