ReactOS 0.4.16-dev-41-ge8c7597
Classes | Macros | Typedefs | Functions | Variables
compositemoniker.c File Reference
#include <assert.h>
#include <stdarg.h>
#include <string.h>
#include "windef.h"
#include "winbase.h"
#include "winuser.h"
#include "winerror.h"
#include "wine/debug.h"
#include "ole2.h"
#include "moniker.h"
Include dependency graph for compositemoniker.c:

Go to the source code of this file.

Classes

struct  CompositeMonikerImpl
 
struct  EnumMonikerImpl
 

Macros

#define COBJMACROS
 
#define BLOCK_TAB_SIZE   5 /* represent the first size table and its increment block size */
 

Typedefs

typedef struct CompositeMonikerImpl CompositeMonikerImpl
 
typedef struct EnumMonikerImpl EnumMonikerImpl
 

Functions

 WINE_DEFAULT_DEBUG_CHANNEL (ole)
 
static CompositeMonikerImpl * impl_from_IMoniker (IMoniker *iface)
 
static CompositeMonikerImpl * impl_from_IROTData (IROTData *iface)
 
static CompositeMonikerImpl * impl_from_IMarshal (IMarshal *iface)
 
static EnumMonikerImpl * impl_from_IEnumMoniker (IEnumMoniker *iface)
 
static HRESULT EnumMonikerImpl_CreateEnumMoniker (IMoniker **tabMoniker, ULONG tabSize, ULONG currentPos, BOOL leftToRight, IEnumMoniker **ppmk)
 
static HRESULT WINAPI CompositeMonikerImpl_QueryInterface (IMoniker *iface, REFIID riid, void **ppvObject)
 
static ULONG WINAPI CompositeMonikerImpl_AddRef (IMoniker *iface)
 
static void CompositeMonikerImpl_ReleaseMonikersInTable (CompositeMonikerImpl *This)
 
static ULONG WINAPI CompositeMonikerImpl_Release (IMoniker *iface)
 
static HRESULT WINAPI CompositeMonikerImpl_GetClassID (IMoniker *iface, CLSID *pClassID)
 
static HRESULT WINAPI CompositeMonikerImpl_IsDirty (IMoniker *iface)
 
static HRESULT WINAPI CompositeMonikerImpl_Load (IMoniker *iface, IStream *pStm)
 
static HRESULT WINAPI CompositeMonikerImpl_Save (IMoniker *iface, IStream *pStm, BOOL fClearDirty)
 
static HRESULT WINAPI CompositeMonikerImpl_GetSizeMax (IMoniker *iface, ULARGE_INTEGER *pcbSize)
 
static HRESULT WINAPI CompositeMonikerImpl_BindToObject (IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft, REFIID riid, VOID **ppvResult)
 
static HRESULT WINAPI CompositeMonikerImpl_BindToStorage (IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft, REFIID riid, VOID **ppvResult)
 
static HRESULT WINAPI CompositeMonikerImpl_Reduce (IMoniker *iface, IBindCtx *pbc, DWORD dwReduceHowFar, IMoniker **ppmkToLeft, IMoniker **ppmkReduced)
 
static HRESULT WINAPI CompositeMonikerImpl_ComposeWith (IMoniker *iface, IMoniker *pmkRight, BOOL fOnlyIfNotGeneric, IMoniker **ppmkComposite)
 
static HRESULT WINAPI CompositeMonikerImpl_Enum (IMoniker *iface, BOOL fForward, IEnumMoniker **ppenumMoniker)
 
static HRESULT WINAPI CompositeMonikerImpl_IsEqual (IMoniker *iface, IMoniker *pmkOtherMoniker)
 
static HRESULT WINAPI CompositeMonikerImpl_Hash (IMoniker *iface, DWORD *pdwHash)
 
static HRESULT WINAPI CompositeMonikerImpl_IsRunning (IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft, IMoniker *pmkNewlyRunning)
 
static HRESULT WINAPI CompositeMonikerImpl_GetTimeOfLastChange (IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft, FILETIME *pCompositeTime)
 
static HRESULT WINAPI CompositeMonikerImpl_Inverse (IMoniker *iface, IMoniker **ppmk)
 
static HRESULT WINAPI CompositeMonikerImpl_CommonPrefixWith (IMoniker *iface, IMoniker *pmkOther, IMoniker **ppmkPrefix)
 
static VOID GetAfterCommonPrefix (IMoniker *pGenMk, IMoniker *commonMk, IMoniker **restMk)
 
static HRESULT WINAPI CompositeMonikerImpl_RelativePathTo (IMoniker *iface, IMoniker *pmkOther, IMoniker **ppmkRelPath)
 
static HRESULT WINAPI CompositeMonikerImpl_GetDisplayName (IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft, LPOLESTR *ppszDisplayName)
 
static HRESULT WINAPI CompositeMonikerImpl_ParseDisplayName (IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft, LPOLESTR pszDisplayName, ULONG *pchEaten, IMoniker **ppmkOut)
 
static HRESULT WINAPI CompositeMonikerImpl_IsSystemMoniker (IMoniker *iface, DWORD *pwdMksys)
 
static HRESULT WINAPI CompositeMonikerROTDataImpl_QueryInterface (IROTData *iface, REFIID riid, VOID **ppvObject)
 
static ULONG WINAPI CompositeMonikerROTDataImpl_AddRef (IROTData *iface)
 
static ULONG WINAPI CompositeMonikerROTDataImpl_Release (IROTData *iface)
 
static HRESULT WINAPI CompositeMonikerROTDataImpl_GetComparisonData (IROTData *iface, BYTE *pbData, ULONG cbMax, ULONG *pcbData)
 
static HRESULT WINAPI CompositeMonikerMarshalImpl_QueryInterface (IMarshal *iface, REFIID riid, LPVOID *ppv)
 
static ULONG WINAPI CompositeMonikerMarshalImpl_AddRef (IMarshal *iface)
 
static ULONG WINAPI CompositeMonikerMarshalImpl_Release (IMarshal *iface)
 
static HRESULT WINAPI CompositeMonikerMarshalImpl_GetUnmarshalClass (IMarshal *iface, REFIID riid, void *pv, DWORD dwDestContext, void *pvDestContext, DWORD mshlflags, CLSID *pCid)
 
static HRESULT WINAPI CompositeMonikerMarshalImpl_GetMarshalSizeMax (IMarshal *iface, REFIID riid, void *pv, DWORD dwDestContext, void *pvDestContext, DWORD mshlflags, DWORD *pSize)
 
static HRESULT WINAPI CompositeMonikerMarshalImpl_MarshalInterface (IMarshal *iface, IStream *pStm, REFIID riid, void *pv, DWORD dwDestContext, void *pvDestContext, DWORD mshlflags)
 
static HRESULT WINAPI CompositeMonikerMarshalImpl_UnmarshalInterface (IMarshal *iface, IStream *pStm, REFIID riid, void **ppv)
 
static HRESULT WINAPI CompositeMonikerMarshalImpl_ReleaseMarshalData (IMarshal *iface, IStream *pStm)
 
static HRESULT WINAPI CompositeMonikerMarshalImpl_DisconnectObject (IMarshal *iface, DWORD dwReserved)
 
static HRESULT WINAPI EnumMonikerImpl_QueryInterface (IEnumMoniker *iface, REFIID riid, void **ppvObject)
 
static ULONG WINAPI EnumMonikerImpl_AddRef (IEnumMoniker *iface)
 
static ULONG WINAPI EnumMonikerImpl_Release (IEnumMoniker *iface)
 
static HRESULT WINAPI EnumMonikerImpl_Next (IEnumMoniker *iface, ULONG celt, IMoniker **rgelt, ULONG *pceltFethed)
 
static HRESULT WINAPI EnumMonikerImpl_Skip (IEnumMoniker *iface, ULONG celt)
 
static HRESULT WINAPI EnumMonikerImpl_Reset (IEnumMoniker *iface)
 
static HRESULT WINAPI EnumMonikerImpl_Clone (IEnumMoniker *iface, IEnumMoniker **ppenum)
 
static HRESULT CompositeMonikerImpl_Construct (IMoniker **ppMoniker, IMoniker *pmkFirst, IMoniker *pmkRest)
 
HRESULT WINAPI CreateGenericComposite (IMoniker *pmkFirst, IMoniker *pmkRest, IMoniker **ppmkComposite)
 
HRESULT WINAPI MonikerCommonPrefixWith (IMoniker *pmkThis, IMoniker *pmkOther, IMoniker **ppmkCommon)
 
HRESULT WINAPI CompositeMoniker_CreateInstance (IClassFactory *iface, IUnknown *pUnk, REFIID riid, void **ppv)
 

Variables

static const IEnumMonikerVtbl VT_EnumMonikerImpl
 
static const IMonikerVtbl VT_CompositeMonikerImpl
 
static const IROTDataVtbl VT_ROTDataImpl
 
static const IMarshalVtbl VT_MarshalImpl
 

Macro Definition Documentation

◆ BLOCK_TAB_SIZE

#define BLOCK_TAB_SIZE   5 /* represent the first size table and its increment block size */

Definition at line 37 of file compositemoniker.c.

◆ COBJMACROS

#define COBJMACROS

Definition at line 25 of file compositemoniker.c.

Typedef Documentation

◆ CompositeMonikerImpl

typedef struct CompositeMonikerImpl CompositeMonikerImpl

◆ EnumMonikerImpl

typedef struct EnumMonikerImpl EnumMonikerImpl

Function Documentation

◆ CompositeMoniker_CreateInstance()

HRESULT WINAPI CompositeMoniker_CreateInstance ( IClassFactory *  iface,
IUnknown *  pUnk,
REFIID  riid,
void **  ppv 
)

Definition at line 1999 of file compositemoniker.c.

2001{
2002 IMoniker* pMoniker;
2003 HRESULT hr;
2004
2005 TRACE("(%p, %s, %p)\n", pUnk, debugstr_guid(riid), ppv);
2006
2007 *ppv = NULL;
2008
2009 if (pUnk)
2010 return CLASS_E_NOAGGREGATION;
2011
2012 hr = CompositeMonikerImpl_Construct(&pMoniker, NULL, NULL);
2013
2014 if (SUCCEEDED(hr))
2015 {
2016 hr = IMoniker_QueryInterface(pMoniker, riid, ppv);
2017 IMoniker_Release(pMoniker);
2018 }
2019
2020 return hr;
2021}
CompositeMonikerImpl_Construct
static HRESULT CompositeMonikerImpl_Construct(IMoniker **ppMoniker, IMoniker *pmkFirst, IMoniker *pmkRest)
Definition: compositemoniker.c:1758
NULL
#define NULL
Definition: types.h:112
pUnk
static void *static void *static LPDIRECTPLAY IUnknown * pUnk
Definition: dplayx.c:30
riid
REFIID riid
Definition: atlbase.h:39
ppv
REFIID LPVOID * ppv
Definition: atlbase.h:39
SUCCEEDED
#define SUCCEEDED(hr)
Definition: intsafe.h:50
debugstr_guid
#define debugstr_guid
Definition: kernel32.h:35
hr
HRESULT hr
Definition: shlfolder.c:183
TRACE
#define TRACE(s)
Definition: solgame.cpp:4
CLASS_E_NOAGGREGATION
#define CLASS_E_NOAGGREGATION
Definition: winerror.h:2662

◆ CompositeMonikerImpl_AddRef()

static ULONG WINAPI CompositeMonikerImpl_AddRef ( IMoniker *  iface)
static

Definition at line 124 of file compositemoniker.c.

125{
126 CompositeMonikerImpl *This = impl_from_IMoniker(iface);
127
128 TRACE("(%p)\n",This);
129
130 return InterlockedIncrement(&This->ref);
131}
InterlockedIncrement
#define InterlockedIncrement
Definition: armddk.h:53
impl_from_IMoniker
static CompositeMonikerImpl * impl_from_IMoniker(IMoniker *iface)
Definition: compositemoniker.c:50

Referenced by CompositeMonikerMarshalImpl_AddRef().

◆ CompositeMonikerImpl_BindToObject()

static HRESULT WINAPI CompositeMonikerImpl_BindToObject ( IMoniker *  iface,
IBindCtx *  pbc,
IMoniker *  pmkToLeft,
REFIID  riid,
VOID **  ppvResult 
)
static

Definition at line 330 of file compositemoniker.c.

332{
333 HRESULT res;
334 IRunningObjectTable *prot;
335 IMoniker *tempMk,*antiMk,*rightMostMk;
336 IEnumMoniker *enumMoniker;
337
338 TRACE("(%p,%p,%p,%s,%p)\n",iface,pbc,pmkToLeft,debugstr_guid(riid),ppvResult);
339
340 if (ppvResult==NULL)
341 return E_POINTER;
342
343 *ppvResult=0;
344 /* If pmkToLeft is NULL, this method looks for the moniker in the ROT, and if found, queries the retrieved */
345 /* object for the requested interface pointer. */
346 if(pmkToLeft==NULL){
347
348 res=IBindCtx_GetRunningObjectTable(pbc,&prot);
349
350 if (SUCCEEDED(res)){
351
352 /* if the requested class was loaded before ! we don't need to reload it */
353 res = IRunningObjectTable_GetObject(prot,iface,(IUnknown**)ppvResult);
354
355 if (res==S_OK)
356 return res;
357 }
358 }
359 else{
360 /* If pmkToLeft is not NULL, the method recursively calls IMoniker::BindToObject on the rightmost */
361 /* component of the composite, passing the rest of the composite as the pmkToLeft parameter for that call */
362
363 IMoniker_Enum(iface,FALSE,&enumMoniker);
364 IEnumMoniker_Next(enumMoniker,1,&rightMostMk,NULL);
365 IEnumMoniker_Release(enumMoniker);
366
367 res=CreateAntiMoniker(&antiMk);
368 res=IMoniker_ComposeWith(iface,antiMk,0,&tempMk);
369 IMoniker_Release(antiMk);
370
371 res=IMoniker_BindToObject(rightMostMk,pbc,tempMk,riid,ppvResult);
372
373 IMoniker_Release(tempMk);
374 IMoniker_Release(rightMostMk);
375 }
376
377 return res;
378}
CreateAntiMoniker
HRESULT WINAPI CreateAntiMoniker(IMoniker **ppmk)
Definition: antimoniker.c:608
FALSE
#define FALSE
Definition: types.h:117
res
GLuint res
Definition: glext.h:9613
S_OK
#define S_OK
Definition: intsafe.h:52
E_POINTER
#define E_POINTER
Definition: winerror.h:2365

◆ CompositeMonikerImpl_BindToStorage()

static HRESULT WINAPI CompositeMonikerImpl_BindToStorage ( IMoniker *  iface,
IBindCtx *  pbc,
IMoniker *  pmkToLeft,
REFIID  riid,
VOID **  ppvResult 
)
static

Definition at line 384 of file compositemoniker.c.

386{
387 HRESULT res;
388 IMoniker *tempMk,*antiMk,*rightMostMk,*leftMk;
389 IEnumMoniker *enumMoniker;
390
391 TRACE("(%p,%p,%p,%s,%p)\n",iface,pbc,pmkToLeft,debugstr_guid(riid),ppvResult);
392
393 *ppvResult=0;
394
395 /* This method recursively calls BindToStorage on the rightmost component of the composite, */
396 /* passing the rest of the composite as the pmkToLeft parameter for that call. */
397
398 if (pmkToLeft)
399 {
400 res = IMoniker_ComposeWith(pmkToLeft, iface, FALSE, &leftMk);
401 if (FAILED(res)) return res;
402 }
403 else
404 leftMk = iface;
405
406 IMoniker_Enum(iface, FALSE, &enumMoniker);
407 IEnumMoniker_Next(enumMoniker, 1, &rightMostMk, NULL);
408 IEnumMoniker_Release(enumMoniker);
409
410 res = CreateAntiMoniker(&antiMk);
411 if (FAILED(res)) return res;
412 res = IMoniker_ComposeWith(leftMk, antiMk, 0, &tempMk);
413 if (FAILED(res)) return res;
414 IMoniker_Release(antiMk);
415
416 res = IMoniker_BindToStorage(rightMostMk, pbc, tempMk, riid, ppvResult);
417
418 IMoniker_Release(tempMk);
419
420 IMoniker_Release(rightMostMk);
421
422 if (pmkToLeft)
423 IMoniker_Release(leftMk);
424
425 return res;
426}
FAILED
#define FAILED(hr)
Definition: intsafe.h:51

◆ CompositeMonikerImpl_CommonPrefixWith()

static HRESULT WINAPI CompositeMonikerImpl_CommonPrefixWith ( IMoniker *  iface,
IMoniker *  pmkOther,
IMoniker **  ppmkPrefix 
)
static

Definition at line 825 of file compositemoniker.c.

827{
828 DWORD mkSys;
829 HRESULT res1,res2;
830 IMoniker *tempMk1,*tempMk2,*mostLeftMk1,*mostLeftMk2;
831 IEnumMoniker *enumMoniker1,*enumMoniker2;
832 ULONG i,nbCommonMk=0;
833
834 /* If the other moniker is a composite, this method compares the components of each composite from left */
835 /* to right. The returned common prefix moniker might also be a composite moniker, depending on how many */
836 /* of the leftmost components were common to both monikers. */
837
838 if (ppmkPrefix==NULL)
839 return E_POINTER;
840
841 *ppmkPrefix=0;
842
843 if (pmkOther==NULL)
844 return MK_E_NOPREFIX;
845
846 IMoniker_IsSystemMoniker(pmkOther,&mkSys);
847
848 if(mkSys==MKSYS_GENERICCOMPOSITE){
849
850 IMoniker_Enum(iface,TRUE,&enumMoniker1);
851 IMoniker_Enum(pmkOther,TRUE,&enumMoniker2);
852
853 while(1){
854
855 res1=IEnumMoniker_Next(enumMoniker1,1,&mostLeftMk1,NULL);
856 res2=IEnumMoniker_Next(enumMoniker2,1,&mostLeftMk2,NULL);
857
858 if ((res1==S_FALSE) && (res2==S_FALSE)){
859
860 /* If the monikers are equal, the method returns MK_S_US and sets ppmkPrefix to this moniker.*/
861 *ppmkPrefix=iface;
862 IMoniker_AddRef(iface);
863 return MK_S_US;
864 }
865 else if ((res1==S_OK) && (res2==S_OK)){
866
867 if (IMoniker_IsEqual(mostLeftMk1,mostLeftMk2)==S_OK)
868
869 nbCommonMk++;
870
871 else
872 break;
873
874 }
875 else if (res1==S_OK){
876
877 /* If the other moniker is a prefix of this moniker, the method returns MK_S_HIM and sets */
878 /* ppmkPrefix to the other moniker. */
879 *ppmkPrefix=pmkOther;
880 return MK_S_HIM;
881 }
882 else{
883 /* If this moniker is a prefix of the other, this method returns MK_S_ME and sets ppmkPrefix */
884 /* to this moniker. */
885 *ppmkPrefix=iface;
886 return MK_S_ME;
887 }
888 }
889
890 IEnumMoniker_Release(enumMoniker1);
891 IEnumMoniker_Release(enumMoniker2);
892
893 /* If there is no common prefix, this method returns MK_E_NOPREFIX and sets ppmkPrefix to NULL. */
894 if (nbCommonMk==0)
895 return MK_E_NOPREFIX;
896
897 IEnumMoniker_Reset(enumMoniker1);
898
899 IEnumMoniker_Next(enumMoniker1,1,&tempMk1,NULL);
900
901 /* if we have more than one common moniker the result will be a composite moniker */
902 if (nbCommonMk>1){
903
904 /* initialize the common prefix moniker with the composite of two first moniker (from the left)*/
905 IEnumMoniker_Next(enumMoniker1,1,&tempMk2,NULL);
906 CreateGenericComposite(tempMk1,tempMk2,ppmkPrefix);
907 IMoniker_Release(tempMk1);
908 IMoniker_Release(tempMk2);
909
910 /* compose all common monikers in a composite moniker */
911 for(i=0;i<nbCommonMk;i++){
912
913 IEnumMoniker_Next(enumMoniker1,1,&tempMk1,NULL);
914
915 CreateGenericComposite(*ppmkPrefix,tempMk1,&tempMk2);
916
917 IMoniker_Release(*ppmkPrefix);
918
919 IMoniker_Release(tempMk1);
920
921 *ppmkPrefix=tempMk2;
922 }
923 return S_OK;
924 }
925 else{
926 /* if we have only one common moniker the result will be a simple moniker which is the most-left one*/
927 *ppmkPrefix=tempMk1;
928
929 return S_OK;
930 }
931 }
932 else{
933 /* If the other moniker is not a composite, the method simply compares it to the leftmost component
934 of this moniker.*/
935
936 IMoniker_Enum(iface,TRUE,&enumMoniker1);
937
938 IEnumMoniker_Next(enumMoniker1,1,&mostLeftMk1,NULL);
939
940 if (IMoniker_IsEqual(pmkOther,mostLeftMk1)==S_OK){
941
942 *ppmkPrefix=pmkOther;
943
944 return MK_S_HIM;
945 }
946 else
947 return MK_E_NOPREFIX;
948 }
949}
CreateGenericComposite
HRESULT WINAPI CreateGenericComposite(IMoniker *pmkFirst, IMoniker *pmkRest, IMoniker **ppmkComposite)
Definition: compositemoniker.c:1952
TRUE
#define TRUE
Definition: types.h:120
DWORD
unsigned long DWORD
Definition: ntddk_ex.h:95
i
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
ULONG
uint32_t ULONG
Definition: typedefs.h:59
S_FALSE
#define S_FALSE
Definition: winerror.h:2357
MK_E_NOPREFIX
#define MK_E_NOPREFIX
Definition: winerror.h:2795
MK_S_ME
#define MK_S_ME
Definition: winerror.h:2774
MK_S_HIM
#define MK_S_HIM
Definition: winerror.h:2775
MK_S_US
#define MK_S_US
Definition: winerror.h:2776

◆ CompositeMonikerImpl_ComposeWith()

static HRESULT WINAPI CompositeMonikerImpl_ComposeWith ( IMoniker *  iface,
IMoniker *  pmkRight,
BOOL  fOnlyIfNotGeneric,
IMoniker **  ppmkComposite 
)
static

Definition at line 504 of file compositemoniker.c.

506{
507 TRACE("(%p,%p,%d,%p)\n",iface,pmkRight,fOnlyIfNotGeneric,ppmkComposite);
508
509 if ((ppmkComposite==NULL)||(pmkRight==NULL))
510 return E_POINTER;
511
512 *ppmkComposite=0;
513
514 /* If fOnlyIfNotGeneric is TRUE, this method sets *pmkComposite to NULL and returns MK_E_NEEDGENERIC; */
515 /* otherwise, the method returns the result of combining the two monikers by calling the */
516 /* CreateGenericComposite function */
517
518 if (fOnlyIfNotGeneric)
519 return MK_E_NEEDGENERIC;
520
521 return CreateGenericComposite(iface,pmkRight,ppmkComposite);
522}
MK_E_NEEDGENERIC
#define MK_E_NEEDGENERIC
Definition: winerror.h:2783

◆ CompositeMonikerImpl_Construct()

static HRESULT CompositeMonikerImpl_Construct ( IMoniker **  ppMoniker,
IMoniker *  pmkFirst,
IMoniker *  pmkRest 
)
static

Definition at line 1758 of file compositemoniker.c.

1759{
1760 DWORD mkSys;
1761 IEnumMoniker *enumMoniker;
1762 IMoniker *tempMk;
1763 HRESULT res;
1764 CompositeMonikerImpl *This;
1765 int i;
1766
1767 This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
1768
1769 if (!This)
1770 return E_OUTOFMEMORY;
1771
1772 TRACE("(%p,%p,%p)\n",This,pmkFirst,pmkRest);
1773
1774 /* Initialize the virtual function table. */
1775 This->IMoniker_iface.lpVtbl = &VT_CompositeMonikerImpl;
1776 This->IROTData_iface.lpVtbl = &VT_ROTDataImpl;
1777 This->IMarshal_iface.lpVtbl = &VT_MarshalImpl;
1778 This->ref = 1;
1779
1780 This->tabSize=BLOCK_TAB_SIZE;
1781 This->tabLastIndex=0;
1782
1783 This->tabMoniker=HeapAlloc(GetProcessHeap(),0,This->tabSize*sizeof(This->tabMoniker[0]));
1784 if (This->tabMoniker==NULL) {
1785 HeapFree(GetProcessHeap(), 0, This);
1786 return E_OUTOFMEMORY;
1787 }
1788
1789 if (!pmkFirst && !pmkRest)
1790 {
1791 *ppMoniker = &This->IMoniker_iface;
1792 return S_OK;
1793 }
1794
1795 IMoniker_IsSystemMoniker(pmkFirst,&mkSys);
1796
1797 /* put the first moniker contents in the beginning of the table */
1798 if (mkSys!=MKSYS_GENERICCOMPOSITE){
1799
1800 This->tabMoniker[(This->tabLastIndex)++]=pmkFirst;
1801 IMoniker_AddRef(pmkFirst);
1802 }
1803 else{
1804
1805 IMoniker_Enum(pmkFirst,TRUE,&enumMoniker);
1806
1807 while(IEnumMoniker_Next(enumMoniker,1,&This->tabMoniker[This->tabLastIndex],NULL)==S_OK){
1808
1809
1810 if (++This->tabLastIndex==This->tabSize){
1811 IMoniker **tab_moniker = This->tabMoniker;
1812
1813 This->tabSize+=BLOCK_TAB_SIZE;
1814 This->tabMoniker=HeapReAlloc(GetProcessHeap(),0,This->tabMoniker,This->tabSize*sizeof(This->tabMoniker[0]));
1815
1816 if (This->tabMoniker==NULL){
1817 for (i = 0; i < This->tabLastIndex; i++)
1818 IMoniker_Release(tab_moniker[i]);
1819 HeapFree(GetProcessHeap(), 0, tab_moniker);
1820 HeapFree(GetProcessHeap(), 0, This);
1821 return E_OUTOFMEMORY;
1822 }
1823 }
1824 }
1825
1826 IEnumMoniker_Release(enumMoniker);
1827 }
1828
1829 /* put the rest moniker contents after the first one and make simplification if needed */
1830
1831 IMoniker_IsSystemMoniker(pmkRest,&mkSys);
1832
1833 if (mkSys!=MKSYS_GENERICCOMPOSITE){
1834
1835 /* add a simple moniker to the moniker table */
1836
1837 res=IMoniker_ComposeWith(This->tabMoniker[This->tabLastIndex-1],pmkRest,TRUE,&tempMk);
1838
1839 if (res==MK_E_NEEDGENERIC){
1840
1841 /* there's no simplification in this case */
1842 This->tabMoniker[This->tabLastIndex]=pmkRest;
1843
1844 This->tabLastIndex++;
1845
1846 IMoniker_AddRef(pmkRest);
1847 }
1848 else if (tempMk==NULL){
1849
1850 /* we have an antimoniker after a simple moniker so we can make a simplification in this case */
1851 IMoniker_Release(This->tabMoniker[This->tabLastIndex-1]);
1852
1853 This->tabLastIndex--;
1854 }
1855 else if (SUCCEEDED(res)){
1856
1857 /* the non-generic composition was successful so we can make a simplification in this case */
1858 IMoniker_Release(This->tabMoniker[This->tabLastIndex-1]);
1859
1860 This->tabMoniker[This->tabLastIndex-1]=tempMk;
1861 } else{
1862 for (i = 0; i < This->tabLastIndex; i++)
1863 IMoniker_Release(This->tabMoniker[i]);
1864 HeapFree(GetProcessHeap(), 0, This->tabMoniker);
1865 HeapFree(GetProcessHeap(), 0, This);
1866 return res;
1867 }
1868
1869 /* resize tabMoniker if needed */
1870 if (This->tabLastIndex==This->tabSize){
1871 IMoniker **tab_moniker = This->tabMoniker;
1872
1873 This->tabSize+=BLOCK_TAB_SIZE;
1874
1875 This->tabMoniker=HeapReAlloc(GetProcessHeap(),0,This->tabMoniker,This->tabSize*sizeof(IMoniker));
1876
1877 if (This->tabMoniker==NULL){
1878 for (i = 0; i < This->tabLastIndex; i++)
1879 IMoniker_Release(tab_moniker[i]);
1880 HeapFree(GetProcessHeap(), 0, tab_moniker);
1881 HeapFree(GetProcessHeap(), 0, This);
1882 return E_OUTOFMEMORY;
1883 }
1884 }
1885 }
1886 else{
1887
1888 /* add a composite moniker to the moniker table (do the same thing
1889 * for each moniker within the composite moniker as a simple moniker
1890 * (see above for how to add a simple moniker case) )
1891 */
1892 IMoniker_Enum(pmkRest,TRUE,&enumMoniker);
1893
1894 while(IEnumMoniker_Next(enumMoniker,1,&This->tabMoniker[This->tabLastIndex],NULL)==S_OK){
1895
1896 res=IMoniker_ComposeWith(This->tabMoniker[This->tabLastIndex-1],This->tabMoniker[This->tabLastIndex],TRUE,&tempMk);
1897
1898 if (res==MK_E_NEEDGENERIC){
1899
1900 This->tabLastIndex++;
1901 }
1902 else if (tempMk==NULL){
1903
1904 IMoniker_Release(This->tabMoniker[This->tabLastIndex-1]);
1905 IMoniker_Release(This->tabMoniker[This->tabLastIndex]);
1906 This->tabLastIndex--;
1907 }
1908 else{
1909
1910 IMoniker_Release(This->tabMoniker[This->tabLastIndex-1]);
1911
1912 This->tabMoniker[This->tabLastIndex-1]=tempMk;
1913 }
1914
1915 if (This->tabLastIndex==This->tabSize){
1916 IMoniker **tab_moniker = This->tabMoniker;
1917
1918 This->tabSize+=BLOCK_TAB_SIZE;
1919
1920 This->tabMoniker=HeapReAlloc(GetProcessHeap(),0,This->tabMoniker,This->tabSize*sizeof(This->tabMoniker[0]));
1921
1922 if (This->tabMoniker==NULL){
1923 for (i = 0; i < This->tabLastIndex; i++)
1924 IMoniker_Release(tab_moniker[i]);
1925 HeapFree(GetProcessHeap(), 0, tab_moniker);
1926 HeapFree(GetProcessHeap(), 0, This);
1927 return E_OUTOFMEMORY;
1928 }
1929 }
1930 }
1931
1932 IEnumMoniker_Release(enumMoniker);
1933 }
1934
1935 /* only one moniker, then just return it */
1936 if (This->tabLastIndex == 1)
1937 {
1938 *ppMoniker = This->tabMoniker[0];
1939 IMoniker_AddRef(*ppMoniker);
1940 IMoniker_Release(&This->IMoniker_iface);
1941 }
1942 else
1943 *ppMoniker = &This->IMoniker_iface;
1944
1945 return S_OK;
1946}
BLOCK_TAB_SIZE
#define BLOCK_TAB_SIZE
Definition: compositemoniker.c:37
VT_CompositeMonikerImpl
static const IMonikerVtbl VT_CompositeMonikerImpl
Definition: compositemoniker.c:1704
VT_MarshalImpl
static const IMarshalVtbl VT_MarshalImpl
Definition: compositemoniker.c:1741
VT_ROTDataImpl
static const IROTDataVtbl VT_ROTDataImpl
Definition: compositemoniker.c:1733
E_OUTOFMEMORY
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
GetProcessHeap
#define GetProcessHeap()
Definition: compat.h:736
HeapAlloc
#define HeapAlloc
Definition: compat.h:733
HeapReAlloc
#define HeapReAlloc
Definition: compat.h:734
HeapFree
#define HeapFree(x, y, z)
Definition: compat.h:735

Referenced by CompositeMoniker_CreateInstance(), and CreateGenericComposite().

◆ CompositeMonikerImpl_Enum()

static HRESULT WINAPI CompositeMonikerImpl_Enum ( IMoniker *  iface,
BOOL  fForward,
IEnumMoniker **  ppenumMoniker 
)
static

Definition at line 528 of file compositemoniker.c.

529{
530 CompositeMonikerImpl *This = impl_from_IMoniker(iface);
531
532 TRACE("(%p,%d,%p)\n",iface,fForward,ppenumMoniker);
533
534 if (ppenumMoniker == NULL)
535 return E_POINTER;
536
537 return EnumMonikerImpl_CreateEnumMoniker(This->tabMoniker,This->tabLastIndex,0,fForward,ppenumMoniker);
538}
EnumMonikerImpl_CreateEnumMoniker
static HRESULT EnumMonikerImpl_CreateEnumMoniker(IMoniker **tabMoniker, ULONG tabSize, ULONG currentPos, BOOL leftToRight, IEnumMoniker **ppmk)
Definition: compositemoniker.c:1654

◆ CompositeMonikerImpl_GetClassID()

static HRESULT WINAPI CompositeMonikerImpl_GetClassID ( IMoniker *  iface,
CLSID *  pClassID 
)
static

Definition at line 172 of file compositemoniker.c.

173{
174 TRACE("(%p,%p)\n",iface,pClassID);
175
176 if (pClassID==NULL)
177 return E_POINTER;
178
179 *pClassID = CLSID_CompositeMoniker;
180
181 return S_OK;
182}

◆ CompositeMonikerImpl_GetDisplayName()

static HRESULT WINAPI CompositeMonikerImpl_GetDisplayName ( IMoniker *  iface,
IBindCtx *  pbc,
IMoniker *  pmkToLeft,
LPOLESTR *  ppszDisplayName 
)
static

Definition at line 1107 of file compositemoniker.c.

1109{
1110 ULONG lengthStr=1;
1111 IEnumMoniker *enumMoniker;
1112 IMoniker* tempMk;
1113 LPOLESTR tempStr;
1114
1115 TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,ppszDisplayName);
1116
1117 if (ppszDisplayName==NULL)
1118 return E_POINTER;
1119
1120 *ppszDisplayName=CoTaskMemAlloc(sizeof(WCHAR));
1121
1122 if (*ppszDisplayName==NULL)
1123 return E_OUTOFMEMORY;
1124
1125 /* This method returns the concatenation of the display names returned by each component moniker of */
1126 /* the composite */
1127
1128 **ppszDisplayName=0;
1129
1130 IMoniker_Enum(iface,TRUE,&enumMoniker);
1131
1132 while(IEnumMoniker_Next(enumMoniker,1,&tempMk,NULL)==S_OK){
1133
1134 IMoniker_GetDisplayName(tempMk,pbc,NULL,&tempStr);
1135
1136 lengthStr+=lstrlenW(tempStr);
1137
1138 *ppszDisplayName=CoTaskMemRealloc(*ppszDisplayName,lengthStr * sizeof(WCHAR));
1139
1140 if (*ppszDisplayName==NULL)
1141 return E_OUTOFMEMORY;
1142
1143 lstrcatW(*ppszDisplayName,tempStr);
1144
1145 CoTaskMemFree(tempStr);
1146 IMoniker_Release(tempMk);
1147 }
1148
1149 IEnumMoniker_Release(enumMoniker);
1150
1151 return S_OK;
1152}
lstrlenW
#define lstrlenW
Definition: compat.h:750
CoTaskMemRealloc
LPVOID WINAPI CoTaskMemRealloc(LPVOID pvOld, SIZE_T size)
Definition: ifs.c:460
CoTaskMemFree
VOID WINAPI CoTaskMemFree(LPVOID ptr)
Definition: ifs.c:442
CoTaskMemAlloc
LPVOID WINAPI CoTaskMemAlloc(SIZE_T size)
Definition: ifs.c:426
lstrcatW
LPWSTR WINAPI lstrcatW(LPWSTR lpString1, LPCWSTR lpString2)
Definition: lstring.c:274
LPOLESTR
static LPOLESTR
Definition: stg_prop.c:27
WCHAR
__wchar_t WCHAR
Definition: xmlstorage.h:180

◆ CompositeMonikerImpl_GetSizeMax()

static HRESULT WINAPI CompositeMonikerImpl_GetSizeMax ( IMoniker *  iface,
ULARGE_INTEGER *  pcbSize 
)
static

Definition at line 293 of file compositemoniker.c.

294{
295 IEnumMoniker *enumMk;
296 IMoniker *pmk;
297 ULARGE_INTEGER ptmpSize;
298
299 /* The sizeMax of this object is calculated by calling GetSizeMax on
300 * each moniker within this object then summing all returned values
301 */
302
303 TRACE("(%p,%p)\n",iface,pcbSize);
304
305 if (!pcbSize)
306 return E_POINTER;
307
308 pcbSize->QuadPart = sizeof(DWORD);
309
310 IMoniker_Enum(iface,TRUE,&enumMk);
311
312 while(IEnumMoniker_Next(enumMk,1,&pmk,NULL)==S_OK){
313
314 IMoniker_GetSizeMax(pmk,&ptmpSize);
315
316 IMoniker_Release(pmk);
317
318 pcbSize->QuadPart = ptmpSize.QuadPart + sizeof(CLSID);
319 }
320
321 IEnumMoniker_Release(enumMk);
322
323 return S_OK;
324}
CLSID
IID CLSID
Definition: mstsclib_i.c:62
DWORD
#define DWORD
Definition: nt_native.h:44
_ULARGE_INTEGER
Definition: ms-dtyp.idl:184
_ULARGE_INTEGER::QuadPart
ULONGLONG QuadPart
Definition: ms-dtyp.idl:185

◆ CompositeMonikerImpl_GetTimeOfLastChange()

static HRESULT WINAPI CompositeMonikerImpl_GetTimeOfLastChange ( IMoniker *  iface,
IBindCtx *  pbc,
IMoniker *  pmkToLeft,
FILETIME *  pCompositeTime 
)
static

Definition at line 709 of file compositemoniker.c.

711{
712 HRESULT res;
713 IMoniker *tempMk,*antiMk,*rightMostMk,*leftMk;
714 IEnumMoniker *enumMoniker;
715
716 TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pCompositeTime);
717
718 if (pCompositeTime==NULL)
719 return E_INVALIDARG;
720
721 /* This method creates a composite of pmkToLeft (if non-NULL) and this moniker and uses the ROT to */
722 /* retrieve the time of last change. If the object is not in the ROT, the method recursively calls */
723 /* IMoniker::GetTimeOfLastChange on the rightmost component of the composite, passing the remainder */
724 /* of the composite as the pmkToLeft parameter for that call. */
725 if (pmkToLeft)
726 {
727 IRunningObjectTable* rot;
728
729 res = IMoniker_ComposeWith(pmkToLeft, iface, FALSE, &leftMk);
730 if (FAILED(res))
731 return res;
732
733 res = IBindCtx_GetRunningObjectTable(pbc,&rot);
734 if (FAILED(res))
735 {
736 IMoniker_Release(leftMk);
737 return res;
738 }
739
740 if (IRunningObjectTable_GetTimeOfLastChange(rot,leftMk,pCompositeTime)==S_OK)
741 {
742 IMoniker_Release(leftMk);
743 return res;
744 }
745 }
746 else
747 leftMk = iface;
748
749 IMoniker_Enum(iface, FALSE, &enumMoniker);
750 IEnumMoniker_Next(enumMoniker, 1, &rightMostMk, NULL);
751 IEnumMoniker_Release(enumMoniker);
752
753 res = CreateAntiMoniker(&antiMk);
754 res = IMoniker_ComposeWith(leftMk, antiMk, 0, &tempMk);
755 IMoniker_Release(antiMk);
756
757 res = IMoniker_GetTimeOfLastChange(rightMostMk, pbc, tempMk, pCompositeTime);
758
759 IMoniker_Release(tempMk);
760 IMoniker_Release(rightMostMk);
761
762 if (pmkToLeft)
763 IMoniker_Release(leftMk);
764
765 return res;
766}
rot
GLfloat rot
Definition: 3dtext.c:36
E_INVALIDARG
#define E_INVALIDARG
Definition: ddrawi.h:101

◆ CompositeMonikerImpl_Hash()

static HRESULT WINAPI CompositeMonikerImpl_Hash ( IMoniker *  iface,
DWORD *  pdwHash 
)
static

Definition at line 595 of file compositemoniker.c.

596{
597 IEnumMoniker *enumMoniker;
598 IMoniker *tempMk;
599 HRESULT res;
600 DWORD tempHash;
601
602 TRACE("(%p,%p)\n",iface,pdwHash);
603
604 if (pdwHash==NULL)
605 return E_POINTER;
606
607 res = IMoniker_Enum(iface,TRUE,&enumMoniker);
608 if(FAILED(res))
609 return res;
610
611 *pdwHash = 0;
612
613 while(IEnumMoniker_Next(enumMoniker,1,&tempMk,NULL)==S_OK){
614 res = IMoniker_Hash(tempMk, &tempHash);
615 if(FAILED(res))
616 break;
617 *pdwHash = *pdwHash ^ tempHash;
618
619 IMoniker_Release(tempMk);
620 }
621
622 IEnumMoniker_Release(enumMoniker);
623
624 return res;
625}

◆ CompositeMonikerImpl_Inverse()

static HRESULT WINAPI CompositeMonikerImpl_Inverse ( IMoniker *  iface,
IMoniker **  ppmk 
)
static

Definition at line 772 of file compositemoniker.c.

773{
774 HRESULT res;
775 IMoniker *tempMk,*antiMk,*rightMostMk,*tempInvMk,*rightMostInvMk;
776 IEnumMoniker *enumMoniker;
777
778 TRACE("(%p,%p)\n",iface,ppmk);
779
780 if (ppmk==NULL)
781 return E_POINTER;
782
783 /* This method returns a composite moniker that consists of the inverses of each of the components */
784 /* of the original composite, stored in reverse order */
785
786 *ppmk = NULL;
787
788 res=CreateAntiMoniker(&antiMk);
789 if (FAILED(res))
790 return res;
791
792 res=IMoniker_ComposeWith(iface,antiMk,FALSE,&tempMk);
793 IMoniker_Release(antiMk);
794 if (FAILED(res))
795 return res;
796
797 if (tempMk==NULL)
798
799 return IMoniker_Inverse(iface,ppmk);
800
801 else{
802
803 IMoniker_Enum(iface,FALSE,&enumMoniker);
804 IEnumMoniker_Next(enumMoniker,1,&rightMostMk,NULL);
805 IEnumMoniker_Release(enumMoniker);
806
807 IMoniker_Inverse(rightMostMk,&rightMostInvMk);
808 CompositeMonikerImpl_Inverse(tempMk,&tempInvMk);
809
810 res=CreateGenericComposite(rightMostInvMk,tempInvMk,ppmk);
811
812 IMoniker_Release(tempMk);
813 IMoniker_Release(rightMostMk);
814 IMoniker_Release(tempInvMk);
815 IMoniker_Release(rightMostInvMk);
816
817 return res;
818 }
819}
CompositeMonikerImpl_Inverse
static HRESULT WINAPI CompositeMonikerImpl_Inverse(IMoniker *iface, IMoniker **ppmk)
Definition: compositemoniker.c:772

Referenced by CompositeMonikerImpl_Inverse().

◆ CompositeMonikerImpl_IsDirty()

static HRESULT WINAPI CompositeMonikerImpl_IsDirty ( IMoniker *  iface)
static

Definition at line 188 of file compositemoniker.c.

189{
190 /* Note that the OLE-provided implementations of the IPersistStream::IsDirty
191 method in the OLE-provided moniker interfaces always return S_FALSE because
192 their internal state never changes. */
193
194 TRACE("(%p)\n",iface);
195
196 return S_FALSE;
197}

◆ CompositeMonikerImpl_IsEqual()

static HRESULT WINAPI CompositeMonikerImpl_IsEqual ( IMoniker *  iface,
IMoniker *  pmkOtherMoniker 
)
static

Definition at line 544 of file compositemoniker.c.

545{
546 IEnumMoniker *enumMoniker1,*enumMoniker2;
547 IMoniker *tempMk1,*tempMk2;
548 HRESULT res1,res2,res;
549 BOOL done;
550
551 TRACE("(%p,%p)\n",iface,pmkOtherMoniker);
552
553 if (pmkOtherMoniker==NULL)
554 return S_FALSE;
555
556 /* This method returns S_OK if the components of both monikers are equal when compared in the */
557 /* left-to-right order.*/
558 IMoniker_Enum(pmkOtherMoniker,TRUE,&enumMoniker1);
559
560 if (enumMoniker1==NULL)
561 return S_FALSE;
562
563 IMoniker_Enum(iface,TRUE,&enumMoniker2);
564
565 do {
566
567 res1=IEnumMoniker_Next(enumMoniker1,1,&tempMk1,NULL);
568 res2=IEnumMoniker_Next(enumMoniker2,1,&tempMk2,NULL);
569
570 if((res1==S_OK)&&(res2==S_OK)){
571 done = (res = IMoniker_IsEqual(tempMk1,tempMk2)) == S_FALSE;
572 }
573 else
574 {
575 res = (res1==S_FALSE) && (res2==S_FALSE);
576 done = TRUE;
577 }
578
579 if (res1==S_OK)
580 IMoniker_Release(tempMk1);
581
582 if (res2==S_OK)
583 IMoniker_Release(tempMk2);
584 } while (!done);
585
586 IEnumMoniker_Release(enumMoniker1);
587 IEnumMoniker_Release(enumMoniker2);
588
589 return res;
590}
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94

◆ CompositeMonikerImpl_IsRunning()

static HRESULT WINAPI CompositeMonikerImpl_IsRunning ( IMoniker *  iface,
IBindCtx *  pbc,
IMoniker *  pmkToLeft,
IMoniker *  pmkNewlyRunning 
)
static

Definition at line 631 of file compositemoniker.c.

633{
634 IRunningObjectTable* rot;
635 HRESULT res;
636 IMoniker *tempMk,*antiMk,*rightMostMk;
637 IEnumMoniker *enumMoniker;
638
639 TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pmkNewlyRunning);
640
641 /* If pmkToLeft is non-NULL, this method composes pmkToLeft with this moniker and calls IsRunning on the result.*/
642 if (pmkToLeft!=NULL){
643
644 CreateGenericComposite(pmkToLeft,iface,&tempMk);
645
646 res = IMoniker_IsRunning(tempMk,pbc,NULL,pmkNewlyRunning);
647
648 IMoniker_Release(tempMk);
649
650 return res;
651 }
652 else
653 /* If pmkToLeft is NULL, this method returns S_OK if pmkNewlyRunning is non-NULL and is equal */
654 /* to this moniker */
655
656 if (pmkNewlyRunning!=NULL)
657
658 if (IMoniker_IsEqual(iface,pmkNewlyRunning)==S_OK)
659 return S_OK;
660
661 else
662 return S_FALSE;
663
664 else{
665
666 if (pbc==NULL)
667 return E_INVALIDARG;
668
669 /* If pmkToLeft and pmkNewlyRunning are both NULL, this method checks the ROT to see whether */
670 /* the moniker is running. If so, the method returns S_OK; otherwise, it recursively calls */
671 /* IMoniker::IsRunning on the rightmost component of the composite, passing the remainder of */
672 /* the composite as the pmkToLeft parameter for that call. */
673
674 res=IBindCtx_GetRunningObjectTable(pbc,&rot);
675
676 if (FAILED(res))
677 return res;
678
679 res = IRunningObjectTable_IsRunning(rot,iface);
680 IRunningObjectTable_Release(rot);
681
682 if(res==S_OK)
683 return S_OK;
684
685 else{
686
687 IMoniker_Enum(iface,FALSE,&enumMoniker);
688 IEnumMoniker_Next(enumMoniker,1,&rightMostMk,NULL);
689 IEnumMoniker_Release(enumMoniker);
690
691 res=CreateAntiMoniker(&antiMk);
692 res=IMoniker_ComposeWith(iface,antiMk,0,&tempMk);
693 IMoniker_Release(antiMk);
694
695 res=IMoniker_IsRunning(rightMostMk,pbc,tempMk,pmkNewlyRunning);
696
697 IMoniker_Release(tempMk);
698 IMoniker_Release(rightMostMk);
699
700 return res;
701 }
702 }
703}

◆ CompositeMonikerImpl_IsSystemMoniker()

static HRESULT WINAPI CompositeMonikerImpl_IsSystemMoniker ( IMoniker *  iface,
DWORD *  pwdMksys 
)
static

Definition at line 1184 of file compositemoniker.c.

1185{
1186 TRACE("(%p,%p)\n",iface,pwdMksys);
1187
1188 if (!pwdMksys)
1189 return E_POINTER;
1190
1191 (*pwdMksys)=MKSYS_GENERICCOMPOSITE;
1192
1193 return S_OK;
1194}

◆ CompositeMonikerImpl_Load()

static HRESULT WINAPI CompositeMonikerImpl_Load ( IMoniker *  iface,
IStream *  pStm 
)
static

Definition at line 203 of file compositemoniker.c.

204{
205 CompositeMonikerImpl *This = impl_from_IMoniker(iface);
206 HRESULT res;
207 DWORD moniker_count;
208 DWORD i;
209
210 TRACE("(%p,%p)\n",iface,pStm);
211
212 /* this function call OleLoadFromStream function for each moniker within this object */
213
214 res=IStream_Read(pStm,&moniker_count,sizeof(DWORD),NULL);
215 if (res != S_OK)
216 {
217 ERR("couldn't reading moniker count from stream\n");
218 return E_FAIL;
219 }
220
221 CompositeMonikerImpl_ReleaseMonikersInTable(This);
222
223 for (i = 0; i < moniker_count; i++)
224 {
225 res=OleLoadFromStream(pStm,&IID_IMoniker,(void**)&This->tabMoniker[This->tabLastIndex]);
226 if (FAILED(res))
227 {
228 ERR("couldn't load moniker from stream, res = 0x%08x\n", res);
229 break;
230 }
231
232 /* resize the table if needed */
233 if (++This->tabLastIndex==This->tabSize){
234
235 This->tabSize+=BLOCK_TAB_SIZE;
236 This->tabMoniker=HeapReAlloc(GetProcessHeap(),0,This->tabMoniker,This->tabSize*sizeof(This->tabMoniker[0]));
237
238 if (This->tabMoniker==NULL)
239 return E_OUTOFMEMORY;
240 }
241 }
242
243 return res;
244}
ERR
#define ERR(fmt,...)
Definition: precomp.h:57
CompositeMonikerImpl_ReleaseMonikersInTable
static void CompositeMonikerImpl_ReleaseMonikersInTable(CompositeMonikerImpl *This)
Definition: compositemoniker.c:133
E_FAIL
#define E_FAIL
Definition: ddrawi.h:102
OleLoadFromStream
HRESULT WINAPI OleLoadFromStream(IStream *pStm, REFIID iidInterface, void **ppvObj)
Definition: storage32.c:9129

◆ CompositeMonikerImpl_ParseDisplayName()

static HRESULT WINAPI CompositeMonikerImpl_ParseDisplayName ( IMoniker *  iface,
IBindCtx *  pbc,
IMoniker *  pmkToLeft,
LPOLESTR  pszDisplayName,
ULONG *  pchEaten,
IMoniker **  ppmkOut 
)
static

Definition at line 1158 of file compositemoniker.c.

1161{
1162 IEnumMoniker *enumMoniker;
1163 IMoniker *tempMk,*rightMostMk,*antiMk;
1164 /* This method recursively calls IMoniker::ParseDisplayName on the rightmost component of the composite,*/
1165 /* passing everything else as the pmkToLeft parameter for that call. */
1166
1167 /* get the most right moniker */
1168 IMoniker_Enum(iface,FALSE,&enumMoniker);
1169 IEnumMoniker_Next(enumMoniker,1,&rightMostMk,NULL);
1170 IEnumMoniker_Release(enumMoniker);
1171
1172 /* get the left moniker */
1173 CreateAntiMoniker(&antiMk);
1174 IMoniker_ComposeWith(iface,antiMk,0,&tempMk);
1175 IMoniker_Release(antiMk);
1176
1177 return IMoniker_ParseDisplayName(rightMostMk,pbc,tempMk,pszDisplayName,pchEaten,ppmkOut);
1178}

◆ CompositeMonikerImpl_QueryInterface()

static HRESULT WINAPI CompositeMonikerImpl_QueryInterface ( IMoniker *  iface,
REFIID  riid,
void **  ppvObject 
)
static

Definition at line 85 of file compositemoniker.c.

86{
87 CompositeMonikerImpl *This = impl_from_IMoniker(iface);
88
89 TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppvObject);
90
91 /* Perform a sanity check on the parameters.*/
92 if ( ppvObject==0 )
93 return E_INVALIDARG;
94
95 /* Initialize the return parameter */
96 *ppvObject = 0;
97
98 /* Compare the riid with the interface IDs implemented by this object.*/
99 if (IsEqualIID(&IID_IUnknown, riid) ||
100 IsEqualIID(&IID_IPersist, riid) ||
101 IsEqualIID(&IID_IPersistStream, riid) ||
102 IsEqualIID(&IID_IMoniker, riid)
103 )
104 *ppvObject = iface;
105 else if (IsEqualIID(&IID_IROTData, riid))
106 *ppvObject = &This->IROTData_iface;
107 else if (IsEqualIID(&IID_IMarshal, riid))
108 *ppvObject = &This->IMarshal_iface;
109
110 /* Check that we obtained an interface.*/
111 if ((*ppvObject)==0)
112 return E_NOINTERFACE;
113
114 /* Query Interface always increases the reference count by one when it is successful */
115 IMoniker_AddRef(iface);
116
117 return S_OK;
118}
IID_IUnknown
const GUID IID_IUnknown
Definition: classfactory.cpp:11
IID_IPersist
const GUID IID_IPersist
Definition: proxy.cpp:14
IID_IPersistStream
const GUID IID_IPersistStream
Definition: proxy.cpp:13
IsEqualIID
#define IsEqualIID(riid1, riid2)
Definition: guiddef.h:95
ppvObject
_In_ void _In_ PCCERT_CONTEXT _In_opt_ LPFILETIME _In_ DWORD _In_ DWORD _Outptr_opt_ void ** ppvObject
Definition: wincrypt.h:6082
E_NOINTERFACE
#define E_NOINTERFACE
Definition: winerror.h:2364

Referenced by CompositeMonikerMarshalImpl_QueryInterface(), and CompositeMonikerROTDataImpl_QueryInterface().

◆ CompositeMonikerImpl_Reduce()

static HRESULT WINAPI CompositeMonikerImpl_Reduce ( IMoniker *  iface,
IBindCtx *  pbc,
DWORD  dwReduceHowFar,
IMoniker **  ppmkToLeft,
IMoniker **  ppmkReduced 
)
static

Definition at line 432 of file compositemoniker.c.

434{
435 HRESULT res;
436 IMoniker *tempMk,*antiMk,*rightMostMk,*leftReducedComposedMk,*rightMostReducedMk;
437 IEnumMoniker *enumMoniker;
438
439 TRACE("(%p,%p,%d,%p,%p)\n",iface,pbc,dwReduceHowFar,ppmkToLeft,ppmkReduced);
440
441 if (ppmkReduced==NULL)
442 return E_POINTER;
443
444 /* This method recursively calls Reduce for each of its component monikers. */
445
446 if (ppmkToLeft==NULL){
447
448 IMoniker_Enum(iface,FALSE,&enumMoniker);
449 IEnumMoniker_Next(enumMoniker,1,&rightMostMk,NULL);
450 IEnumMoniker_Release(enumMoniker);
451
452 CreateAntiMoniker(&antiMk);
453 IMoniker_ComposeWith(iface,antiMk,0,&tempMk);
454 IMoniker_Release(antiMk);
455
456 res = IMoniker_Reduce(rightMostMk,pbc,dwReduceHowFar,&tempMk, ppmkReduced);
457 IMoniker_Release(tempMk);
458 IMoniker_Release(rightMostMk);
459
460 return res;
461 }
462 else if (*ppmkToLeft==NULL)
463
464 return IMoniker_Reduce(iface,pbc,dwReduceHowFar,NULL,ppmkReduced);
465
466 else{
467
468 /* separate the composite moniker in to left and right moniker */
469 IMoniker_Enum(iface,FALSE,&enumMoniker);
470 IEnumMoniker_Next(enumMoniker,1,&rightMostMk,NULL);
471 IEnumMoniker_Release(enumMoniker);
472
473 CreateAntiMoniker(&antiMk);
474 IMoniker_ComposeWith(iface,antiMk,0,&tempMk);
475 IMoniker_Release(antiMk);
476
477 /* If any of the components reduces itself, the method returns S_OK and passes back a composite */
478 /* of the reduced components */
479 if (IMoniker_Reduce(rightMostMk,pbc,dwReduceHowFar,NULL,&rightMostReducedMk) &&
480 IMoniker_Reduce(rightMostMk,pbc,dwReduceHowFar,&tempMk,&leftReducedComposedMk) ){
481 IMoniker_Release(tempMk);
482 IMoniker_Release(rightMostMk);
483
484 return CreateGenericComposite(leftReducedComposedMk,rightMostReducedMk,ppmkReduced);
485 }
486 else{
487 /* If no reduction occurred, the method passes back the same moniker and returns MK_S_REDUCED_TO_SELF.*/
488 IMoniker_Release(tempMk);
489 IMoniker_Release(rightMostMk);
490
491 IMoniker_AddRef(iface);
492
493 *ppmkReduced=iface;
494
495 return MK_S_REDUCED_TO_SELF;
496 }
497 }
498}
MK_S_REDUCED_TO_SELF
#define MK_S_REDUCED_TO_SELF
Definition: winerror.h:2773

◆ CompositeMonikerImpl_RelativePathTo()

static HRESULT WINAPI CompositeMonikerImpl_RelativePathTo ( IMoniker *  iface,
IMoniker *  pmkOther,
IMoniker **  ppmkRelPath 
)
static

Definition at line 1045 of file compositemoniker.c.

1047{
1048 HRESULT res;
1049 IMoniker *restOtherMk=0,*restThisMk=0,*invRestThisMk=0,*commonMk=0;
1050
1051 TRACE("(%p,%p,%p)\n",iface,pmkOther,ppmkRelPath);
1052
1053 if (ppmkRelPath==NULL)
1054 return E_POINTER;
1055
1056 *ppmkRelPath=0;
1057
1058 /* This method finds the common prefix of the two monikers and creates two monikers that consist */
1059 /* of the remainder when the common prefix is removed. Then it creates the inverse for the remainder */
1060 /* of this moniker and composes the remainder of the other moniker on the right of it. */
1061
1062 /* finds the common prefix of the two monikers */
1063 res=IMoniker_CommonPrefixWith(iface,pmkOther,&commonMk);
1064
1065 /* if there's no common prefix or the two moniker are equal the relative is the other moniker */
1066 if ((res== MK_E_NOPREFIX)||(res==MK_S_US)){
1067
1068 *ppmkRelPath=pmkOther;
1069 IMoniker_AddRef(pmkOther);
1070 return MK_S_HIM;
1071 }
1072
1073 GetAfterCommonPrefix(iface,commonMk,&restThisMk);
1074 GetAfterCommonPrefix(pmkOther,commonMk,&restOtherMk);
1075
1076 /* if other is a prefix of this moniker the relative path is the inverse of the remainder path of this */
1077 /* moniker when the common prefix is removed */
1078 if (res==MK_S_HIM){
1079
1080 IMoniker_Inverse(restThisMk,ppmkRelPath);
1081 IMoniker_Release(restThisMk);
1082 }
1083 /* if this moniker is a prefix of other moniker the relative path is the remainder path of other moniker */
1084 /* when the common prefix is removed */
1085 else if (res==MK_S_ME){
1086
1087 *ppmkRelPath=restOtherMk;
1088 IMoniker_AddRef(restOtherMk);
1089 }
1090 /* the relative path is the inverse for the remainder of this moniker and the remainder of the other */
1091 /* moniker on the right of it. */
1092 else if (res==S_OK){
1093
1094 IMoniker_Inverse(restThisMk,&invRestThisMk);
1095 IMoniker_Release(restThisMk);
1096 CreateGenericComposite(invRestThisMk,restOtherMk,ppmkRelPath);
1097 IMoniker_Release(invRestThisMk);
1098 IMoniker_Release(restOtherMk);
1099 }
1100 return S_OK;
1101}
GetAfterCommonPrefix
static VOID GetAfterCommonPrefix(IMoniker *pGenMk, IMoniker *commonMk, IMoniker **restMk)
Definition: compositemoniker.c:955

◆ CompositeMonikerImpl_Release()

static ULONG WINAPI CompositeMonikerImpl_Release ( IMoniker *  iface)
static

Definition at line 147 of file compositemoniker.c.

148{
149 CompositeMonikerImpl *This = impl_from_IMoniker(iface);
150 ULONG ref;
151
152 TRACE("(%p)\n",This);
153
154 ref = InterlockedDecrement(&This->ref);
155
156 /* destroy the object if there are no more references to it */
157 if (ref == 0){
158
159 /* release all the components before destroying this object */
160 CompositeMonikerImpl_ReleaseMonikersInTable(This);
161
162 HeapFree(GetProcessHeap(),0,This->tabMoniker);
163 HeapFree(GetProcessHeap(),0,This);
164 }
165 return ref;
166}
InterlockedDecrement
#define InterlockedDecrement
Definition: armddk.h:52
ref
Definition: send.c:48

Referenced by CompositeMonikerMarshalImpl_Release().

◆ CompositeMonikerImpl_ReleaseMonikersInTable()

static void CompositeMonikerImpl_ReleaseMonikersInTable ( CompositeMonikerImpl *  This)
static

Definition at line 133 of file compositemoniker.c.

134{
135 ULONG i;
136
137 for (i = 0; i < This->tabLastIndex; i++)
138 IMoniker_Release(This->tabMoniker[i]);
139
140 This->tabLastIndex = 0;
141}

Referenced by CompositeMonikerImpl_Load(), CompositeMonikerImpl_Release(), and CompositeMonikerMarshalImpl_UnmarshalInterface().

◆ CompositeMonikerImpl_Save()

static HRESULT WINAPI CompositeMonikerImpl_Save ( IMoniker *  iface,
IStream *  pStm,
BOOL  fClearDirty 
)
static

Definition at line 250 of file compositemoniker.c.

251{
252 CompositeMonikerImpl *This = impl_from_IMoniker(iface);
253 HRESULT res;
254 IEnumMoniker *enumMk;
255 IMoniker *pmk;
256 DWORD moniker_count = This->tabLastIndex;
257
258 TRACE("(%p,%p,%d)\n",iface,pStm,fClearDirty);
259
260 /* This function calls OleSaveToStream function for each moniker within
261 * this object.
262 * When I tested this function in windows, I usually found this constant
263 * at the beginning of the stream. I don't known why (there's no
264 * indication in the specification) !
265 */
266 res=IStream_Write(pStm,&moniker_count,sizeof(moniker_count),NULL);
267 if (FAILED(res)) return res;
268
269 IMoniker_Enum(iface,TRUE,&enumMk);
270
271 while(IEnumMoniker_Next(enumMk,1,&pmk,NULL)==S_OK){
272
273 res=OleSaveToStream((IPersistStream*)pmk,pStm);
274
275 IMoniker_Release(pmk);
276
277 if (FAILED(res)){
278
279 IEnumMoniker_Release(enumMk);
280 return res;
281 }
282 }
283
284 IEnumMoniker_Release(enumMk);
285
286 return S_OK;
287}
OleSaveToStream
HRESULT WINAPI OleSaveToStream(IPersistStream *pPStm, IStream *pStm)
Definition: storage32.c:9164

◆ CompositeMonikerMarshalImpl_AddRef()

static ULONG WINAPI CompositeMonikerMarshalImpl_AddRef ( IMarshal *  iface)
static

Definition at line 1336 of file compositemoniker.c.

1337{
1338 CompositeMonikerImpl *This = impl_from_IMarshal(iface);
1339
1340 TRACE("(%p)\n",iface);
1341
1342 return CompositeMonikerImpl_AddRef(&This->IMoniker_iface);
1343}
impl_from_IMarshal
static CompositeMonikerImpl * impl_from_IMarshal(IMarshal *iface)
Definition: compositemoniker.c:60
CompositeMonikerImpl_AddRef
static ULONG WINAPI CompositeMonikerImpl_AddRef(IMoniker *iface)
Definition: compositemoniker.c:124

◆ CompositeMonikerMarshalImpl_DisconnectObject()

static HRESULT WINAPI CompositeMonikerMarshalImpl_DisconnectObject ( IMarshal *  iface,
DWORD  dwReserved 
)
static

Definition at line 1492 of file compositemoniker.c.

1494{
1495 TRACE("(0x%x)\n", dwReserved);
1496 /* can't disconnect a state-based marshal as nothing on server side to
1497 * disconnect from */
1498 return S_OK;
1499}
dwReserved
_In_ HANDLE _In_ DWORD _In_ DWORD _Inout_opt_ LPOVERLAPPED _In_opt_ LPTRANSMIT_FILE_BUFFERS _In_ DWORD dwReserved
Definition: mswsock.h:95

◆ CompositeMonikerMarshalImpl_GetMarshalSizeMax()

static HRESULT WINAPI CompositeMonikerMarshalImpl_GetMarshalSizeMax ( IMarshal *  iface,
REFIID  riid,
void *  pv,
DWORD  dwDestContext,
void *  pvDestContext,
DWORD  mshlflags,
DWORD *  pSize 
)
static

Definition at line 1366 of file compositemoniker.c.

1369{
1370 CompositeMonikerImpl *This = impl_from_IMarshal(iface);
1371 IEnumMoniker *pEnumMk;
1372 IMoniker *pmk;
1373 HRESULT hr;
1374 ULARGE_INTEGER size;
1375
1376 TRACE("(%s, %p, %x, %p, %x, %p)\n", debugstr_guid(riid), pv,
1377 dwDestContext, pvDestContext, mshlflags, pSize);
1378
1379 *pSize = 0x10; /* to match native */
1380
1381 hr = IMoniker_Enum(&This->IMoniker_iface, TRUE, &pEnumMk);
1382 if (FAILED(hr)) return hr;
1383
1384 hr = IMoniker_GetSizeMax(&This->IMoniker_iface, &size);
1385
1386 while (IEnumMoniker_Next(pEnumMk, 1, &pmk, NULL) == S_OK)
1387 {
1388 ULONG size;
1389
1390 hr = CoGetMarshalSizeMax(&size, &IID_IMoniker, (IUnknown *)pmk, dwDestContext, pvDestContext, mshlflags);
1391 if (SUCCEEDED(hr))
1392 *pSize += size;
1393
1394 IMoniker_Release(pmk);
1395
1396 if (FAILED(hr))
1397 {
1398 IEnumMoniker_Release(pEnumMk);
1399 return hr;
1400 }
1401 }
1402
1403 IEnumMoniker_Release(pEnumMk);
1404
1405 return S_OK;
1406}
CoGetMarshalSizeMax
HRESULT WINAPI CoGetMarshalSizeMax(ULONG *pulSize, REFIID riid, IUnknown *pUnk, DWORD dwDestContext, void *pvDestContext, DWORD mshlFlags)
Definition: marshal.c:1800
size
GLsizeiptr size
Definition: glext.h:5919

◆ CompositeMonikerMarshalImpl_GetUnmarshalClass()

static HRESULT WINAPI CompositeMonikerMarshalImpl_GetUnmarshalClass ( IMarshal *  iface,
REFIID  riid,
void *  pv,
DWORD  dwDestContext,
void *  pvDestContext,
DWORD  mshlflags,
CLSID *  pCid 
)
static

Definition at line 1354 of file compositemoniker.c.

1357{
1358 CompositeMonikerImpl *This = impl_from_IMarshal(iface);
1359
1360 TRACE("(%s, %p, %x, %p, %x, %p)\n", debugstr_guid(riid), pv,
1361 dwDestContext, pvDestContext, mshlflags, pCid);
1362
1363 return IMoniker_GetClassID(&This->IMoniker_iface, pCid);
1364}

◆ CompositeMonikerMarshalImpl_MarshalInterface()

static HRESULT WINAPI CompositeMonikerMarshalImpl_MarshalInterface ( IMarshal *  iface,
IStream *  pStm,
REFIID  riid,
void *  pv,
DWORD  dwDestContext,
void *  pvDestContext,
DWORD  mshlflags 
)
static

Definition at line 1408 of file compositemoniker.c.

1411{
1412 CompositeMonikerImpl *This = impl_from_IMarshal(iface);
1413 IEnumMoniker *pEnumMk;
1414 IMoniker *pmk;
1415 HRESULT hr;
1416 ULONG i = 0;
1417
1418 TRACE("(%p, %s, %p, %x, %p, %x)\n", pStm, debugstr_guid(riid), pv,
1419 dwDestContext, pvDestContext, mshlflags);
1420
1421 hr = IMoniker_Enum(&This->IMoniker_iface, TRUE, &pEnumMk);
1422 if (FAILED(hr)) return hr;
1423
1424 while (IEnumMoniker_Next(pEnumMk, 1, &pmk, NULL) == S_OK)
1425 {
1426 hr = CoMarshalInterface(pStm, &IID_IMoniker, (IUnknown *)pmk, dwDestContext, pvDestContext, mshlflags);
1427
1428 IMoniker_Release(pmk);
1429
1430 if (FAILED(hr))
1431 {
1432 IEnumMoniker_Release(pEnumMk);
1433 return hr;
1434 }
1435 i++;
1436 }
1437
1438 if (i != 2)
1439 FIXME("moniker count of %d not supported\n", i);
1440
1441 IEnumMoniker_Release(pEnumMk);
1442
1443 return S_OK;
1444}
FIXME
#define FIXME(fmt,...)
Definition: precomp.h:53
CoMarshalInterface
HRESULT WINAPI CoMarshalInterface(IStream *pStream, REFIID riid, IUnknown *pUnk, DWORD dwDestContext, void *pvDestContext, DWORD mshlFlags)
Definition: marshal.c:1876

◆ CompositeMonikerMarshalImpl_QueryInterface()

static HRESULT WINAPI CompositeMonikerMarshalImpl_QueryInterface ( IMarshal *  iface,
REFIID  riid,
LPVOID *  ppv 
)
static

Definition at line 1327 of file compositemoniker.c.

1328{
1329 CompositeMonikerImpl *This = impl_from_IMarshal(iface);
1330
1331 TRACE("(%p,%s,%p)\n",iface,debugstr_guid(riid),ppv);
1332
1333 return CompositeMonikerImpl_QueryInterface(&This->IMoniker_iface, riid, ppv);
1334}
CompositeMonikerImpl_QueryInterface
static HRESULT WINAPI CompositeMonikerImpl_QueryInterface(IMoniker *iface, REFIID riid, void **ppvObject)
Definition: compositemoniker.c:85

◆ CompositeMonikerMarshalImpl_Release()

static ULONG WINAPI CompositeMonikerMarshalImpl_Release ( IMarshal *  iface)
static

Definition at line 1345 of file compositemoniker.c.

1346{
1347 CompositeMonikerImpl *This = impl_from_IMarshal(iface);
1348
1349 TRACE("(%p)\n",iface);
1350
1351 return CompositeMonikerImpl_Release(&This->IMoniker_iface);
1352}
CompositeMonikerImpl_Release
static ULONG WINAPI CompositeMonikerImpl_Release(IMoniker *iface)
Definition: compositemoniker.c:147

◆ CompositeMonikerMarshalImpl_ReleaseMarshalData()

static HRESULT WINAPI CompositeMonikerMarshalImpl_ReleaseMarshalData ( IMarshal *  iface,
IStream *  pStm 
)
static

Definition at line 1484 of file compositemoniker.c.

1485{
1486 TRACE("(%p)\n", pStm);
1487 /* can't release a state-based marshal as nothing on server side to
1488 * release */
1489 return S_OK;
1490}

◆ CompositeMonikerMarshalImpl_UnmarshalInterface()

static HRESULT WINAPI CompositeMonikerMarshalImpl_UnmarshalInterface ( IMarshal *  iface,
IStream *  pStm,
REFIID  riid,
void **  ppv 
)
static

Definition at line 1446 of file compositemoniker.c.

1448{
1449 CompositeMonikerImpl *This = impl_from_IMarshal(iface);
1450 HRESULT hr;
1451
1452 TRACE("(%p, %s, %p)\n", pStm, debugstr_guid(riid), ppv);
1453
1454 CompositeMonikerImpl_ReleaseMonikersInTable(This);
1455
1456 /* resize the table if needed */
1457 if (This->tabLastIndex + 2 > This->tabSize)
1458 {
1459 This->tabSize += max(BLOCK_TAB_SIZE, 2);
1460 This->tabMoniker=HeapReAlloc(GetProcessHeap(),0,This->tabMoniker,This->tabSize*sizeof(This->tabMoniker[0]));
1461
1462 if (This->tabMoniker==NULL)
1463 return E_OUTOFMEMORY;
1464 }
1465
1466 hr = CoUnmarshalInterface(pStm, &IID_IMoniker, (void**)&This->tabMoniker[This->tabLastIndex]);
1467 if (FAILED(hr))
1468 {
1469 ERR("couldn't unmarshal moniker, hr = 0x%08x\n", hr);
1470 return hr;
1471 }
1472 This->tabLastIndex++;
1473 hr = CoUnmarshalInterface(pStm, &IID_IMoniker, (void**)&This->tabMoniker[This->tabLastIndex]);
1474 if (FAILED(hr))
1475 {
1476 ERR("couldn't unmarshal moniker, hr = 0x%08x\n", hr);
1477 return hr;
1478 }
1479 This->tabLastIndex++;
1480
1481 return IMoniker_QueryInterface(&This->IMoniker_iface, riid, ppv);
1482}
CoUnmarshalInterface
HRESULT WINAPI CoUnmarshalInterface(IStream *pStream, REFIID riid, LPVOID *ppv)
Definition: marshal.c:1981
max
#define max(a, b)
Definition: svc.c:63

◆ CompositeMonikerROTDataImpl_AddRef()

static ULONG WINAPI CompositeMonikerROTDataImpl_AddRef ( IROTData *  iface)
static

Definition at line 1214 of file compositemoniker.c.

1215{
1216 CompositeMonikerImpl *This = impl_from_IROTData(iface);
1217
1218 TRACE("(%p)\n",iface);
1219
1220 return IMoniker_AddRef(&This->IMoniker_iface);
1221}
impl_from_IROTData
static CompositeMonikerImpl * impl_from_IROTData(IROTData *iface)
Definition: compositemoniker.c:55

◆ CompositeMonikerROTDataImpl_GetComparisonData()

static HRESULT WINAPI CompositeMonikerROTDataImpl_GetComparisonData ( IROTData *  iface,
BYTE *  pbData,
ULONG  cbMax,
ULONG *  pcbData 
)
static

Definition at line 1239 of file compositemoniker.c.

1241{
1242 CompositeMonikerImpl *This = impl_from_IROTData(iface);
1243 IEnumMoniker *pEnumMk;
1244 IMoniker *pmk;
1245 HRESULT hr;
1246
1247 TRACE("(%p, %u, %p)\n", pbData, cbMax, pcbData);
1248
1249 *pcbData = sizeof(CLSID);
1250
1251 hr = IMoniker_Enum(&This->IMoniker_iface, TRUE, &pEnumMk);
1252 if (FAILED(hr)) return hr;
1253
1254 while(IEnumMoniker_Next(pEnumMk, 1, &pmk, NULL) == S_OK)
1255 {
1256 IROTData *pROTData;
1257 hr = IMoniker_QueryInterface(pmk, &IID_IROTData, (void **)&pROTData);
1258 if (FAILED(hr))
1259 ERR("moniker doesn't support IROTData interface\n");
1260
1261 if (SUCCEEDED(hr))
1262 {
1263 ULONG cbData;
1264 hr = IROTData_GetComparisonData(pROTData, NULL, 0, &cbData);
1265 IROTData_Release(pROTData);
1266 if (SUCCEEDED(hr) || (hr == E_OUTOFMEMORY))
1267 {
1268 *pcbData += cbData;
1269 hr = S_OK;
1270 }
1271 else
1272 ERR("IROTData_GetComparisonData failed with error 0x%08x\n", hr);
1273 }
1274
1275 IMoniker_Release(pmk);
1276
1277 if (FAILED(hr))
1278 {
1279 IEnumMoniker_Release(pEnumMk);
1280 return hr;
1281 }
1282 }
1283 if (cbMax < *pcbData)
1284 return E_OUTOFMEMORY;
1285
1286 IEnumMoniker_Reset(pEnumMk);
1287
1288 memcpy(pbData, &CLSID_CompositeMoniker, sizeof(CLSID));
1289 pbData += sizeof(CLSID);
1290 cbMax -= sizeof(CLSID);
1291
1292 while (IEnumMoniker_Next(pEnumMk, 1, &pmk, NULL) == S_OK)
1293 {
1294 IROTData *pROTData;
1295 hr = IMoniker_QueryInterface(pmk, &IID_IROTData, (void **)&pROTData);
1296 if (FAILED(hr))
1297 ERR("moniker doesn't support IROTData interface\n");
1298
1299 if (SUCCEEDED(hr))
1300 {
1301 ULONG cbData;
1302 hr = IROTData_GetComparisonData(pROTData, pbData, cbMax, &cbData);
1303 IROTData_Release(pROTData);
1304 if (SUCCEEDED(hr))
1305 {
1306 pbData += cbData;
1307 cbMax -= cbData;
1308 }
1309 else
1310 ERR("IROTData_GetComparisonData failed with error 0x%08x\n", hr);
1311 }
1312
1313 IMoniker_Release(pmk);
1314
1315 if (FAILED(hr))
1316 {
1317 IEnumMoniker_Release(pEnumMk);
1318 return hr;
1319 }
1320 }
1321
1322 IEnumMoniker_Release(pEnumMk);
1323
1324 return S_OK;
1325}
memcpy
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
_IID
Definition: mstsclib_i.c:51
pbData
_In_ HCRYPTHASH _In_ BOOL _In_ DWORD _Inout_updates_bytes_to_ pdwDataLen BYTE * pbData
Definition: wincrypt.h:4201
pcbData
_In_ DWORD _Out_writes_bytes_to_opt_ pcbData void _Inout_ DWORD * pcbData
Definition: wincrypt.h:4950

◆ CompositeMonikerROTDataImpl_QueryInterface()

static HRESULT WINAPI CompositeMonikerROTDataImpl_QueryInterface ( IROTData *  iface,
REFIID  riid,
VOID **  ppvObject 
)
static

Definition at line 1200 of file compositemoniker.c.

1202{
1203 CompositeMonikerImpl *This = impl_from_IROTData(iface);
1204
1205 TRACE("(%p,%s,%p)\n",iface,debugstr_guid(riid),ppvObject);
1206
1207 return CompositeMonikerImpl_QueryInterface(&This->IMoniker_iface, riid, ppvObject);
1208}

◆ CompositeMonikerROTDataImpl_Release()

static ULONG WINAPI CompositeMonikerROTDataImpl_Release ( IROTData *  iface)
static

Definition at line 1226 of file compositemoniker.c.

1227{
1228 CompositeMonikerImpl *This = impl_from_IROTData(iface);
1229
1230 TRACE("(%p)\n",iface);
1231
1232 return IMoniker_Release(&This->IMoniker_iface);
1233}

◆ CreateGenericComposite()

HRESULT WINAPI CreateGenericComposite ( IMoniker *  pmkFirst,
IMoniker *  pmkRest,
IMoniker **  ppmkComposite 
)

Definition at line 1952 of file compositemoniker.c.

1953{
1954 IMoniker* moniker = 0;
1955 HRESULT hr = S_OK;
1956
1957 TRACE("(%p,%p,%p)\n",pmkFirst,pmkRest,ppmkComposite);
1958
1959 if (ppmkComposite==NULL)
1960 return E_POINTER;
1961
1962 *ppmkComposite=0;
1963
1964 if (pmkFirst==NULL && pmkRest!=NULL){
1965
1966 *ppmkComposite=pmkRest;
1967 IMoniker_AddRef(pmkRest);
1968 return S_OK;
1969 }
1970 else if (pmkFirst!=NULL && pmkRest==NULL){
1971 *ppmkComposite=pmkFirst;
1972 IMoniker_AddRef(pmkFirst);
1973 return S_OK;
1974 }
1975 else if (pmkFirst==NULL && pmkRest==NULL)
1976 return S_OK;
1977
1978 hr = CompositeMonikerImpl_Construct(&moniker,pmkFirst,pmkRest);
1979
1980 if (FAILED(hr))
1981 return hr;
1982
1983 hr = IMoniker_QueryInterface(moniker,&IID_IMoniker,(void**)ppmkComposite);
1984 IMoniker_Release(moniker);
1985
1986 return hr;
1987}
moniker
Definition: main.c:40

Referenced by AntiMonikerImpl_ComposeWith(), ClassMoniker_ComposeWith(), CompositeMonikerImpl_CommonPrefixWith(), CompositeMonikerImpl_ComposeWith(), CompositeMonikerImpl_Inverse(), CompositeMonikerImpl_IsRunning(), CompositeMonikerImpl_Reduce(), CompositeMonikerImpl_RelativePathTo(), FileMonikerImpl_ComposeWith(), GetAfterCommonPrefix(), IHlinkBC_GetObject(), IHlinkBC_Register(), ItemMonikerImpl_ComposeWith(), ItemMonikerImpl_GetTimeOfLastChange(), PointerMonikerImpl_ComposeWith(), and test_generic_composite_moniker().

◆ EnumMonikerImpl_AddRef()

static ULONG WINAPI EnumMonikerImpl_AddRef ( IEnumMoniker *  iface)
static

Definition at line 1536 of file compositemoniker.c.

1537{
1538 EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
1539
1540 TRACE("(%p)\n",This);
1541
1542 return InterlockedIncrement(&This->ref);
1543
1544}
impl_from_IEnumMoniker
static EnumMonikerImpl * impl_from_IEnumMoniker(IEnumMoniker *iface)
Definition: compositemoniker.c:74

◆ EnumMonikerImpl_Clone()

static HRESULT WINAPI EnumMonikerImpl_Clone ( IEnumMoniker *  iface,
IEnumMoniker **  ppenum 
)
static

Definition at line 1630 of file compositemoniker.c.

1631{
1632 EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
1633
1634 return EnumMonikerImpl_CreateEnumMoniker(This->tabMoniker,This->tabSize,This->currentPos,TRUE,ppenum);
1635}

◆ EnumMonikerImpl_CreateEnumMoniker()

static HRESULT EnumMonikerImpl_CreateEnumMoniker ( IMoniker **  tabMoniker,
ULONG  tabSize,
ULONG  currentPos,
BOOL  leftToRight,
IEnumMoniker **  ppmk 
)
static

Definition at line 1654 of file compositemoniker.c.

1656{
1657 EnumMonikerImpl* newEnumMoniker;
1658 ULONG i;
1659
1660 if (currentPos > tabSize)
1661 return E_INVALIDARG;
1662
1663 newEnumMoniker = HeapAlloc(GetProcessHeap(), 0, sizeof(EnumMonikerImpl));
1664
1665 if (newEnumMoniker == 0)
1666 return STG_E_INSUFFICIENTMEMORY;
1667
1668 /* Initialize the virtual function table. */
1669 newEnumMoniker->IEnumMoniker_iface.lpVtbl = &VT_EnumMonikerImpl;
1670 newEnumMoniker->ref = 1;
1671
1672 newEnumMoniker->tabSize=tabSize;
1673 newEnumMoniker->currentPos=currentPos;
1674
1675 newEnumMoniker->tabMoniker=HeapAlloc(GetProcessHeap(),0,tabSize*sizeof(newEnumMoniker->tabMoniker[0]));
1676
1677 if (newEnumMoniker->tabMoniker==NULL) {
1678 HeapFree(GetProcessHeap(), 0, newEnumMoniker);
1679 return E_OUTOFMEMORY;
1680 }
1681
1682 if (leftToRight)
1683 for (i=0;i<tabSize;i++){
1684
1685 newEnumMoniker->tabMoniker[i]=tabMoniker[i];
1686 IMoniker_AddRef(tabMoniker[i]);
1687 }
1688 else
1689 for (i = tabSize; i > 0; i--){
1690
1691 newEnumMoniker->tabMoniker[tabSize-i]=tabMoniker[i - 1];
1692 IMoniker_AddRef(tabMoniker[i - 1]);
1693 }
1694
1695 *ppmk=&newEnumMoniker->IEnumMoniker_iface;
1696
1697 return S_OK;
1698}
VT_EnumMonikerImpl
static const IEnumMonikerVtbl VT_EnumMonikerImpl
Definition: compositemoniker.c:1639
EnumMonikerImpl::IEnumMoniker_iface
IEnumMoniker IEnumMoniker_iface
Definition: mediacatenum.c:36
EnumMonikerImpl::tabMoniker
IMoniker ** tabMoniker
Definition: compositemoniker.c:69
STG_E_INSUFFICIENTMEMORY
#define STG_E_INSUFFICIENTMEMORY
Definition: winerror.h:2570

Referenced by CompositeMonikerImpl_Enum(), and EnumMonikerImpl_Clone().

◆ EnumMonikerImpl_Next()

static HRESULT WINAPI EnumMonikerImpl_Next ( IEnumMoniker *  iface,
ULONG  celt,
IMoniker **  rgelt,
ULONG *  pceltFethed 
)
static

Definition at line 1575 of file compositemoniker.c.

1577{
1578 EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
1579 ULONG i;
1580
1581 /* retrieve the requested number of moniker from the current position */
1582 for(i=0;((This->currentPos < This->tabSize) && (i < celt));i++)
1583 {
1584 rgelt[i]=This->tabMoniker[This->currentPos++];
1585 IMoniker_AddRef(rgelt[i]);
1586 }
1587
1588 if (pceltFethed!=NULL)
1589 *pceltFethed= i;
1590
1591 if (i==celt)
1592 return S_OK;
1593 else
1594 return S_FALSE;
1595}

◆ EnumMonikerImpl_QueryInterface()

static HRESULT WINAPI EnumMonikerImpl_QueryInterface ( IEnumMoniker *  iface,
REFIID  riid,
void **  ppvObject 
)
static

Definition at line 1505 of file compositemoniker.c.

1506{
1507 EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
1508
1509 TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppvObject);
1510
1511 /* Perform a sanity check on the parameters.*/
1512 if ( ppvObject==0 )
1513 return E_INVALIDARG;
1514
1515 /* Initialize the return parameter */
1516 *ppvObject = 0;
1517
1518 /* Compare the riid with the interface IDs implemented by this object.*/
1519 if (IsEqualIID(&IID_IUnknown, riid) || IsEqualIID(&IID_IEnumMoniker, riid))
1520 *ppvObject = iface;
1521
1522 /* Check that we obtained an interface.*/
1523 if ((*ppvObject)==0)
1524 return E_NOINTERFACE;
1525
1526 /* Query Interface always increases the reference count by one when it is successful */
1527 IEnumMoniker_AddRef(iface);
1528
1529 return S_OK;
1530}
IID_IEnumMoniker
const GUID IID_IEnumMoniker

◆ EnumMonikerImpl_Release()

static ULONG WINAPI EnumMonikerImpl_Release ( IEnumMoniker *  iface)
static

Definition at line 1550 of file compositemoniker.c.

1551{
1552 EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
1553 ULONG i;
1554 ULONG ref;
1555 TRACE("(%p)\n",This);
1556
1557 ref = InterlockedDecrement(&This->ref);
1558
1559 /* destroy the object if there are no more references to it */
1560 if (ref == 0) {
1561
1562 for(i=0;i<This->tabSize;i++)
1563 IMoniker_Release(This->tabMoniker[i]);
1564
1565 HeapFree(GetProcessHeap(),0,This->tabMoniker);
1566 HeapFree(GetProcessHeap(),0,This);
1567 }
1568 return ref;
1569}

◆ EnumMonikerImpl_Reset()

static HRESULT WINAPI EnumMonikerImpl_Reset ( IEnumMoniker *  iface)
static

Definition at line 1617 of file compositemoniker.c.

1618{
1619 EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
1620
1621 This->currentPos=0;
1622
1623 return S_OK;
1624}

◆ EnumMonikerImpl_Skip()

static HRESULT WINAPI EnumMonikerImpl_Skip ( IEnumMoniker *  iface,
ULONG  celt 
)
static

Definition at line 1601 of file compositemoniker.c.

1602{
1603 EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
1604
1605 if ((This->currentPos+celt) >= This->tabSize)
1606 return S_FALSE;
1607
1608 This->currentPos+=celt;
1609
1610 return S_OK;
1611}

◆ GetAfterCommonPrefix()

static VOID GetAfterCommonPrefix ( IMoniker *  pGenMk,
IMoniker *  commonMk,
IMoniker **  restMk 
)
static

Definition at line 955 of file compositemoniker.c.

956{
957 IMoniker *tempMk,*tempMk1,*tempMk2;
958 IEnumMoniker *enumMoniker1,*enumMoniker2,*enumMoniker3;
959 ULONG nbRestMk=0;
960 DWORD mkSys;
961 HRESULT res1,res2;
962
963 *restMk=0;
964
965 /* to create an enumerator for pGenMk with current position pointed on the first element after common */
966 /* prefix: enum the two monikers (left-right) then compare these enumerations (left-right) and stop */
967 /* on the first difference. */
968 IMoniker_Enum(pGenMk,TRUE,&enumMoniker1);
969
970 IMoniker_IsSystemMoniker(commonMk,&mkSys);
971
972 if (mkSys==MKSYS_GENERICCOMPOSITE){
973
974 IMoniker_Enum(commonMk,TRUE,&enumMoniker2);
975 while(1){
976
977 res1=IEnumMoniker_Next(enumMoniker1,1,&tempMk1,NULL);
978 res2=IEnumMoniker_Next(enumMoniker2,1,&tempMk2,NULL);
979
980 if ((res1==S_FALSE)||(res2==S_FALSE)){
981
982 if (res1==S_OK)
983
984 nbRestMk++;
985
986 IMoniker_Release(tempMk1);
987 IMoniker_Release(tempMk2);
988
989 break;
990 }
991 IMoniker_Release(tempMk1);
992 IMoniker_Release(tempMk2);
993 }
994 }
995 else{
996 IEnumMoniker_Next(enumMoniker1,1,&tempMk1,NULL);
997 IMoniker_Release(tempMk1);
998 }
999
1000 /* count the number of elements in the enumerator after the common prefix */
1001 IEnumMoniker_Clone(enumMoniker1,&enumMoniker3);
1002
1003 for(;IEnumMoniker_Next(enumMoniker3,1,&tempMk,NULL)==S_OK;nbRestMk++)
1004
1005 IMoniker_Release(tempMk);
1006
1007 if (nbRestMk==0)
1008 return;
1009
1010 /* create a generic composite moniker with monikers located after the common prefix */
1011 IEnumMoniker_Next(enumMoniker1,1,&tempMk1,NULL);
1012
1013 if (nbRestMk==1){
1014
1015 *restMk= tempMk1;
1016 return;
1017 }
1018 else {
1019
1020 IEnumMoniker_Next(enumMoniker1,1,&tempMk2,NULL);
1021
1022 CreateGenericComposite(tempMk1,tempMk2,restMk);
1023
1024 IMoniker_Release(tempMk1);
1025
1026 IMoniker_Release(tempMk2);
1027
1028 while(IEnumMoniker_Next(enumMoniker1,1,&tempMk1,NULL)==S_OK){
1029
1030 CreateGenericComposite(*restMk,tempMk1,&tempMk2);
1031
1032 IMoniker_Release(tempMk1);
1033
1034 IMoniker_Release(*restMk);
1035
1036 *restMk=tempMk2;
1037 }
1038 }
1039}

Referenced by CompositeMonikerImpl_RelativePathTo().

◆ impl_from_IEnumMoniker()

static EnumMonikerImpl * impl_from_IEnumMoniker ( IEnumMoniker *  iface)
inlinestatic

Definition at line 74 of file compositemoniker.c.

75{
76 return CONTAINING_RECORD(iface, EnumMonikerImpl, IEnumMoniker_iface);
77}
CONTAINING_RECORD
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260

Referenced by EnumMonikerImpl_AddRef(), EnumMonikerImpl_Clone(), EnumMonikerImpl_Next(), EnumMonikerImpl_QueryInterface(), EnumMonikerImpl_Release(), EnumMonikerImpl_Reset(), and EnumMonikerImpl_Skip().

◆ impl_from_IMarshal()

static CompositeMonikerImpl * impl_from_IMarshal ( IMarshal *  iface)
inlinestatic

Definition at line 60 of file compositemoniker.c.

61{
62 return CONTAINING_RECORD(iface, CompositeMonikerImpl, IMarshal_iface);
63}

Referenced by CompositeMonikerMarshalImpl_AddRef(), CompositeMonikerMarshalImpl_GetMarshalSizeMax(), CompositeMonikerMarshalImpl_GetUnmarshalClass(), CompositeMonikerMarshalImpl_MarshalInterface(), CompositeMonikerMarshalImpl_QueryInterface(), CompositeMonikerMarshalImpl_Release(), and CompositeMonikerMarshalImpl_UnmarshalInterface().

◆ impl_from_IMoniker()

static CompositeMonikerImpl * impl_from_IMoniker ( IMoniker *  iface)
inlinestatic

Definition at line 50 of file compositemoniker.c.

51{
52 return CONTAINING_RECORD(iface, CompositeMonikerImpl, IMoniker_iface);
53}

Referenced by CompositeMonikerImpl_AddRef(), CompositeMonikerImpl_Enum(), CompositeMonikerImpl_Load(), CompositeMonikerImpl_QueryInterface(), CompositeMonikerImpl_Release(), and CompositeMonikerImpl_Save().

◆ impl_from_IROTData()

static CompositeMonikerImpl * impl_from_IROTData ( IROTData *  iface)
inlinestatic

Definition at line 55 of file compositemoniker.c.

56{
57 return CONTAINING_RECORD(iface, CompositeMonikerImpl, IROTData_iface);
58}

Referenced by CompositeMonikerROTDataImpl_AddRef(), CompositeMonikerROTDataImpl_GetComparisonData(), CompositeMonikerROTDataImpl_QueryInterface(), and CompositeMonikerROTDataImpl_Release().

◆ MonikerCommonPrefixWith()

HRESULT WINAPI MonikerCommonPrefixWith ( IMoniker *  pmkThis,
IMoniker *  pmkOther,
IMoniker **  ppmkCommon 
)

Definition at line 1993 of file compositemoniker.c.

1994{
1995 FIXME("(),stub!\n");
1996 return E_NOTIMPL;
1997}
E_NOTIMPL
#define E_NOTIMPL
Definition: ddrawi.h:99

Referenced by AntiMonikerImpl_CommonPrefixWith(), ClassMoniker_CommonPrefixWith(), FileMonikerImpl_CommonPrefixWith(), and ItemMonikerImpl_CommonPrefixWith().

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( ole  )

Variable Documentation

◆ VT_CompositeMonikerImpl

const IMonikerVtbl VT_CompositeMonikerImpl
static
Initial value:
=
{
CompositeMonikerImpl_QueryInterface,
CompositeMonikerImpl_AddRef,
CompositeMonikerImpl_Release,
CompositeMonikerImpl_GetClassID,
CompositeMonikerImpl_IsDirty,
CompositeMonikerImpl_Load,
CompositeMonikerImpl_Save,
CompositeMonikerImpl_GetSizeMax,
CompositeMonikerImpl_BindToObject,
CompositeMonikerImpl_BindToStorage,
CompositeMonikerImpl_Reduce,
CompositeMonikerImpl_ComposeWith,
CompositeMonikerImpl_Enum,
CompositeMonikerImpl_IsEqual,
CompositeMonikerImpl_Hash,
CompositeMonikerImpl_IsRunning,
CompositeMonikerImpl_GetTimeOfLastChange,
CompositeMonikerImpl_Inverse,
CompositeMonikerImpl_CommonPrefixWith,
CompositeMonikerImpl_RelativePathTo,
CompositeMonikerImpl_GetDisplayName,
CompositeMonikerImpl_ParseDisplayName,
CompositeMonikerImpl_IsSystemMoniker
}
CompositeMonikerImpl_ComposeWith
static HRESULT WINAPI CompositeMonikerImpl_ComposeWith(IMoniker *iface, IMoniker *pmkRight, BOOL fOnlyIfNotGeneric, IMoniker **ppmkComposite)
Definition: compositemoniker.c:504
CompositeMonikerImpl_GetDisplayName
static HRESULT WINAPI CompositeMonikerImpl_GetDisplayName(IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft, LPOLESTR *ppszDisplayName)
Definition: compositemoniker.c:1107
CompositeMonikerImpl_IsRunning
static HRESULT WINAPI CompositeMonikerImpl_IsRunning(IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft, IMoniker *pmkNewlyRunning)
Definition: compositemoniker.c:631
CompositeMonikerImpl_Save
static HRESULT WINAPI CompositeMonikerImpl_Save(IMoniker *iface, IStream *pStm, BOOL fClearDirty)
Definition: compositemoniker.c:250
CompositeMonikerImpl_GetSizeMax
static HRESULT WINAPI CompositeMonikerImpl_GetSizeMax(IMoniker *iface, ULARGE_INTEGER *pcbSize)
Definition: compositemoniker.c:293
CompositeMonikerImpl_RelativePathTo
static HRESULT WINAPI CompositeMonikerImpl_RelativePathTo(IMoniker *iface, IMoniker *pmkOther, IMoniker **ppmkRelPath)
Definition: compositemoniker.c:1045
CompositeMonikerImpl_IsSystemMoniker
static HRESULT WINAPI CompositeMonikerImpl_IsSystemMoniker(IMoniker *iface, DWORD *pwdMksys)
Definition: compositemoniker.c:1184
CompositeMonikerImpl_Enum
static HRESULT WINAPI CompositeMonikerImpl_Enum(IMoniker *iface, BOOL fForward, IEnumMoniker **ppenumMoniker)
Definition: compositemoniker.c:528
CompositeMonikerImpl_BindToStorage
static HRESULT WINAPI CompositeMonikerImpl_BindToStorage(IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft, REFIID riid, VOID **ppvResult)
Definition: compositemoniker.c:384
CompositeMonikerImpl_GetTimeOfLastChange
static HRESULT WINAPI CompositeMonikerImpl_GetTimeOfLastChange(IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft, FILETIME *pCompositeTime)
Definition: compositemoniker.c:709
CompositeMonikerImpl_Hash
static HRESULT WINAPI CompositeMonikerImpl_Hash(IMoniker *iface, DWORD *pdwHash)
Definition: compositemoniker.c:595
CompositeMonikerImpl_CommonPrefixWith
static HRESULT WINAPI CompositeMonikerImpl_CommonPrefixWith(IMoniker *iface, IMoniker *pmkOther, IMoniker **ppmkPrefix)
Definition: compositemoniker.c:825
CompositeMonikerImpl_Reduce
static HRESULT WINAPI CompositeMonikerImpl_Reduce(IMoniker *iface, IBindCtx *pbc, DWORD dwReduceHowFar, IMoniker **ppmkToLeft, IMoniker **ppmkReduced)
Definition: compositemoniker.c:432
CompositeMonikerImpl_GetClassID
static HRESULT WINAPI CompositeMonikerImpl_GetClassID(IMoniker *iface, CLSID *pClassID)
Definition: compositemoniker.c:172
CompositeMonikerImpl_BindToObject
static HRESULT WINAPI CompositeMonikerImpl_BindToObject(IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft, REFIID riid, VOID **ppvResult)
Definition: compositemoniker.c:330
CompositeMonikerImpl_IsEqual
static HRESULT WINAPI CompositeMonikerImpl_IsEqual(IMoniker *iface, IMoniker *pmkOtherMoniker)
Definition: compositemoniker.c:544
CompositeMonikerImpl_Load
static HRESULT WINAPI CompositeMonikerImpl_Load(IMoniker *iface, IStream *pStm)
Definition: compositemoniker.c:203
CompositeMonikerImpl_IsDirty
static HRESULT WINAPI CompositeMonikerImpl_IsDirty(IMoniker *iface)
Definition: compositemoniker.c:188
CompositeMonikerImpl_ParseDisplayName
static HRESULT WINAPI CompositeMonikerImpl_ParseDisplayName(IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft, LPOLESTR pszDisplayName, ULONG *pchEaten, IMoniker **ppmkOut)
Definition: compositemoniker.c:1158

Definition at line 1704 of file compositemoniker.c.

Referenced by CompositeMonikerImpl_Construct().

◆ VT_EnumMonikerImpl

const IEnumMonikerVtbl VT_EnumMonikerImpl
static
Initial value:
=
{
EnumMonikerImpl_QueryInterface,
EnumMonikerImpl_AddRef,
EnumMonikerImpl_Release,
EnumMonikerImpl_Next,
EnumMonikerImpl_Skip,
EnumMonikerImpl_Reset,
EnumMonikerImpl_Clone
}
EnumMonikerImpl_Reset
static HRESULT WINAPI EnumMonikerImpl_Reset(IEnumMoniker *iface)
Definition: compositemoniker.c:1617
EnumMonikerImpl_Release
static ULONG WINAPI EnumMonikerImpl_Release(IEnumMoniker *iface)
Definition: compositemoniker.c:1550
EnumMonikerImpl_Clone
static HRESULT WINAPI EnumMonikerImpl_Clone(IEnumMoniker *iface, IEnumMoniker **ppenum)
Definition: compositemoniker.c:1630
EnumMonikerImpl_Skip
static HRESULT WINAPI EnumMonikerImpl_Skip(IEnumMoniker *iface, ULONG celt)
Definition: compositemoniker.c:1601
EnumMonikerImpl_Next
static HRESULT WINAPI EnumMonikerImpl_Next(IEnumMoniker *iface, ULONG celt, IMoniker **rgelt, ULONG *pceltFethed)
Definition: compositemoniker.c:1575
EnumMonikerImpl_AddRef
static ULONG WINAPI EnumMonikerImpl_AddRef(IEnumMoniker *iface)
Definition: compositemoniker.c:1536
EnumMonikerImpl_QueryInterface
static HRESULT WINAPI EnumMonikerImpl_QueryInterface(IEnumMoniker *iface, REFIID riid, void **ppvObject)
Definition: compositemoniker.c:1505

Definition at line 1639 of file compositemoniker.c.

Referenced by EnumMonikerImpl_CreateEnumMoniker().

◆ VT_MarshalImpl

const IMarshalVtbl VT_MarshalImpl
static
Initial value:
=
{
CompositeMonikerMarshalImpl_QueryInterface,
CompositeMonikerMarshalImpl_AddRef,
CompositeMonikerMarshalImpl_Release,
CompositeMonikerMarshalImpl_GetUnmarshalClass,
CompositeMonikerMarshalImpl_GetMarshalSizeMax,
CompositeMonikerMarshalImpl_MarshalInterface,
CompositeMonikerMarshalImpl_UnmarshalInterface,
CompositeMonikerMarshalImpl_ReleaseMarshalData,
CompositeMonikerMarshalImpl_DisconnectObject
}
CompositeMonikerMarshalImpl_DisconnectObject
static HRESULT WINAPI CompositeMonikerMarshalImpl_DisconnectObject(IMarshal *iface, DWORD dwReserved)
Definition: compositemoniker.c:1492
CompositeMonikerMarshalImpl_AddRef
static ULONG WINAPI CompositeMonikerMarshalImpl_AddRef(IMarshal *iface)
Definition: compositemoniker.c:1336
CompositeMonikerMarshalImpl_UnmarshalInterface
static HRESULT WINAPI CompositeMonikerMarshalImpl_UnmarshalInterface(IMarshal *iface, IStream *pStm, REFIID riid, void **ppv)
Definition: compositemoniker.c:1446
CompositeMonikerMarshalImpl_QueryInterface
static HRESULT WINAPI CompositeMonikerMarshalImpl_QueryInterface(IMarshal *iface, REFIID riid, LPVOID *ppv)
Definition: compositemoniker.c:1327
CompositeMonikerMarshalImpl_MarshalInterface
static HRESULT WINAPI CompositeMonikerMarshalImpl_MarshalInterface(IMarshal *iface, IStream *pStm, REFIID riid, void *pv, DWORD dwDestContext, void *pvDestContext, DWORD mshlflags)
Definition: compositemoniker.c:1408
CompositeMonikerMarshalImpl_Release
static ULONG WINAPI CompositeMonikerMarshalImpl_Release(IMarshal *iface)
Definition: compositemoniker.c:1345
CompositeMonikerMarshalImpl_GetUnmarshalClass
static HRESULT WINAPI CompositeMonikerMarshalImpl_GetUnmarshalClass(IMarshal *iface, REFIID riid, void *pv, DWORD dwDestContext, void *pvDestContext, DWORD mshlflags, CLSID *pCid)
Definition: compositemoniker.c:1354
CompositeMonikerMarshalImpl_GetMarshalSizeMax
static HRESULT WINAPI CompositeMonikerMarshalImpl_GetMarshalSizeMax(IMarshal *iface, REFIID riid, void *pv, DWORD dwDestContext, void *pvDestContext, DWORD mshlflags, DWORD *pSize)
Definition: compositemoniker.c:1366
CompositeMonikerMarshalImpl_ReleaseMarshalData
static HRESULT WINAPI CompositeMonikerMarshalImpl_ReleaseMarshalData(IMarshal *iface, IStream *pStm)
Definition: compositemoniker.c:1484

Definition at line 1741 of file compositemoniker.c.

Referenced by CompositeMonikerImpl_Construct().

◆ VT_ROTDataImpl

const IROTDataVtbl VT_ROTDataImpl
static
Initial value:
=
{
CompositeMonikerROTDataImpl_QueryInterface,
CompositeMonikerROTDataImpl_AddRef,
CompositeMonikerROTDataImpl_Release,
CompositeMonikerROTDataImpl_GetComparisonData
}
CompositeMonikerROTDataImpl_GetComparisonData
static HRESULT WINAPI CompositeMonikerROTDataImpl_GetComparisonData(IROTData *iface, BYTE *pbData, ULONG cbMax, ULONG *pcbData)
Definition: compositemoniker.c:1239
CompositeMonikerROTDataImpl_QueryInterface
static HRESULT WINAPI CompositeMonikerROTDataImpl_QueryInterface(IROTData *iface, REFIID riid, VOID **ppvObject)
Definition: compositemoniker.c:1200
CompositeMonikerROTDataImpl_AddRef
static ULONG WINAPI CompositeMonikerROTDataImpl_AddRef(IROTData *iface)
Definition: compositemoniker.c:1214
CompositeMonikerROTDataImpl_Release
static ULONG WINAPI CompositeMonikerROTDataImpl_Release(IROTData *iface)
Definition: compositemoniker.c:1226

Definition at line 1733 of file compositemoniker.c.

Referenced by CompositeMonikerImpl_Construct().