4 * Copyright 1999 Noomen Hamza
5 * Copyright 2005-2007 Robert Shearman
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 #define WIN32_NO_STATUS
30 #define NONAMELESSUNION
31 #define NONAMELESSSTRUCT
33 //#include "winerror.h"
36 //#include "winuser.h"
37 #include <wine/debug.h>
39 #include <wine/unicode.h>
42 WINE_DEFAULT_DEBUG_CHANNEL(ole
);
44 #define CHARS_IN_GUID 39
46 /* ClassMoniker data structure */
47 typedef struct ClassMoniker
49 IMoniker IMoniker_iface
;
50 IROTData IROTData_iface
;
52 CLSID clsid
; /* clsid identified by this moniker */
53 IUnknown
*pMarshal
; /* custom marshaler */
56 static inline ClassMoniker
*impl_from_IMoniker(IMoniker
*iface
)
58 return CONTAINING_RECORD(iface
, ClassMoniker
, IMoniker_iface
);
61 static inline ClassMoniker
*impl_from_IROTData(IROTData
*iface
)
63 return CONTAINING_RECORD(iface
, ClassMoniker
, IROTData_iface
);
66 /*******************************************************************************
67 * ClassMoniker_QueryInterface
68 *******************************************************************************/
69 static HRESULT WINAPI
ClassMoniker_QueryInterface(IMoniker
* iface
,REFIID riid
,void** ppvObject
)
71 ClassMoniker
*This
= impl_from_IMoniker(iface
);
73 TRACE("(%p,%p,%p)\n",This
,riid
,ppvObject
);
75 /* Perform a sanity check on the parameters.*/
79 /* Initialize the return parameter */
82 /* Compare the riid with the interface IDs implemented by this object.*/
83 if (IsEqualIID(&IID_IUnknown
, riid
) ||
84 IsEqualIID(&IID_IPersist
, riid
) ||
85 IsEqualIID(&IID_IPersistStream
, riid
) ||
86 IsEqualIID(&IID_IMoniker
, riid
))
90 else if (IsEqualIID(&IID_IROTData
, riid
))
91 *ppvObject
= &This
->IROTData_iface
;
92 else if (IsEqualIID(&IID_IMarshal
, riid
))
96 hr
= MonikerMarshal_Create(iface
, &This
->pMarshal
);
99 return IUnknown_QueryInterface(This
->pMarshal
, riid
, ppvObject
);
102 /* Check that we obtained an interface.*/
104 return E_NOINTERFACE
;
106 /* Query Interface always increases the reference count by one when it is successful */
107 IMoniker_AddRef(iface
);
112 /******************************************************************************
113 * ClassMoniker_AddRef
114 ******************************************************************************/
115 static ULONG WINAPI
ClassMoniker_AddRef(IMoniker
* iface
)
117 ClassMoniker
*This
= impl_from_IMoniker(iface
);
119 TRACE("(%p)\n",This
);
121 return InterlockedIncrement(&This
->ref
);
124 /******************************************************************************
125 * ClassMoniker_Destroy (local function)
126 *******************************************************************************/
127 static HRESULT
ClassMoniker_Destroy(ClassMoniker
* This
)
129 TRACE("(%p)\n",This
);
131 if (This
->pMarshal
) IUnknown_Release(This
->pMarshal
);
133 HeapFree(GetProcessHeap(),0,This
);
138 /******************************************************************************
139 * ClassMoniker_Release
140 ******************************************************************************/
141 static ULONG WINAPI
ClassMoniker_Release(IMoniker
* iface
)
143 ClassMoniker
*This
= impl_from_IMoniker(iface
);
146 TRACE("(%p)\n",This
);
148 ref
= InterlockedDecrement(&This
->ref
);
150 /* destroy the object if there's no more reference on it */
151 if (ref
== 0) ClassMoniker_Destroy(This
);
156 /******************************************************************************
157 * ClassMoniker_GetClassID
158 ******************************************************************************/
159 static HRESULT WINAPI
ClassMoniker_GetClassID(IMoniker
* iface
,CLSID
*pClassID
)
161 TRACE("(%p,%p),stub!\n",iface
,pClassID
);
166 *pClassID
= CLSID_ClassMoniker
;
171 /******************************************************************************
172 * ClassMoniker_IsDirty
173 ******************************************************************************/
174 static HRESULT WINAPI
ClassMoniker_IsDirty(IMoniker
* iface
)
176 /* Note that the OLE-provided implementations of the IPersistStream::IsDirty
177 method in the OLE-provided moniker interfaces always return S_FALSE because
178 their internal state never changes. */
180 TRACE("(%p)\n",iface
);
185 /******************************************************************************
187 ******************************************************************************/
188 static HRESULT WINAPI
ClassMoniker_Load(IMoniker
* iface
,IStream
* pStm
)
190 ClassMoniker
*This
= impl_from_IMoniker(iface
);
194 TRACE("(%p)\n", pStm
);
196 hr
= IStream_Read(pStm
, &This
->clsid
, sizeof(This
->clsid
), NULL
);
197 if (hr
!= S_OK
) return STG_E_READFAULT
;
199 hr
= IStream_Read(pStm
, &zero
, sizeof(zero
), NULL
);
200 if ((hr
!= S_OK
) || (zero
!= 0)) return STG_E_READFAULT
;
205 /******************************************************************************
207 ******************************************************************************/
208 static HRESULT WINAPI
ClassMoniker_Save(IMoniker
* iface
, IStream
* pStm
, BOOL fClearDirty
)
210 ClassMoniker
*This
= impl_from_IMoniker(iface
);
214 TRACE("(%p, %s)\n", pStm
, fClearDirty
? "TRUE" : "FALSE");
216 hr
= IStream_Write(pStm
, &This
->clsid
, sizeof(This
->clsid
), NULL
);
217 if (FAILED(hr
)) return hr
;
219 return IStream_Write(pStm
, &zero
, sizeof(zero
), NULL
);
222 /******************************************************************************
223 * ClassMoniker_GetSizeMax
224 ******************************************************************************/
225 static HRESULT WINAPI
ClassMoniker_GetSizeMax(IMoniker
* iface
,
226 ULARGE_INTEGER
* pcbSize
)/* Pointer to size of stream needed to save object */
228 TRACE("(%p)\n", pcbSize
);
230 pcbSize
->QuadPart
= sizeof(CLSID
) + sizeof(DWORD
);
235 /******************************************************************************
236 * ClassMoniker_BindToObject
237 ******************************************************************************/
238 static HRESULT WINAPI
ClassMoniker_BindToObject(IMoniker
* iface
,
244 ClassMoniker
*This
= impl_from_IMoniker(iface
);
246 IClassActivator
*pActivator
;
249 TRACE("(%p,%p,%p,%p)\n", pbc
, pmkToLeft
, riid
, ppvResult
);
251 bindopts
.cbStruct
= sizeof(bindopts
);
252 IBindCtx_GetBindOptions(pbc
, (BIND_OPTS
*)&bindopts
);
255 return CoGetClassObject(&This
->clsid
, bindopts
.dwClassContext
, NULL
,
259 hr
= IMoniker_BindToObject(pmkToLeft
, pbc
, NULL
, &IID_IClassActivator
,
260 (void **)&pActivator
);
261 if (FAILED(hr
)) return hr
;
263 hr
= IClassActivator_GetClassObject(pActivator
, &This
->clsid
,
264 bindopts
.dwClassContext
,
265 bindopts
.locale
, riid
, ppvResult
);
267 IClassActivator_Release(pActivator
);
273 /******************************************************************************
274 * ClassMoniker_BindToStorage
275 ******************************************************************************/
276 static HRESULT WINAPI
ClassMoniker_BindToStorage(IMoniker
* iface
,
282 TRACE("(%p,%p,%p,%p)\n",pbc
, pmkToLeft
, riid
, ppvResult
);
283 return ClassMoniker_BindToObject(iface
, pbc
, pmkToLeft
, riid
, ppvResult
);
286 /******************************************************************************
287 * ClassMoniker_Reduce
288 ******************************************************************************/
289 static HRESULT WINAPI
ClassMoniker_Reduce(IMoniker
* iface
,
291 DWORD dwReduceHowFar
,
292 IMoniker
** ppmkToLeft
,
293 IMoniker
** ppmkReduced
)
295 TRACE("(%p,%p,%d,%p,%p)\n",iface
,pbc
,dwReduceHowFar
,ppmkToLeft
,ppmkReduced
);
300 ClassMoniker_AddRef(iface
);
302 *ppmkReduced
= iface
;
304 return MK_S_REDUCED_TO_SELF
;
306 /******************************************************************************
307 * ClassMoniker_ComposeWith
308 ******************************************************************************/
309 static HRESULT WINAPI
ClassMoniker_ComposeWith(IMoniker
* iface
,
311 BOOL fOnlyIfNotGeneric
,
312 IMoniker
** ppmkComposite
)
316 IEnumMoniker
* penumMk
=0;
317 IMoniker
*pmostLeftMk
=0;
318 IMoniker
* tempMkComposite
=0;
320 TRACE("(%p,%d,%p)\n", pmkRight
, fOnlyIfNotGeneric
, ppmkComposite
);
322 if ((ppmkComposite
==NULL
)||(pmkRight
==NULL
))
327 IMoniker_IsSystemMoniker(pmkRight
,&mkSys
);
329 /* If pmkRight is an anti-moniker, the returned moniker is NULL */
330 if(mkSys
==MKSYS_ANTIMONIKER
)
334 /* if pmkRight is a composite whose leftmost component is an anti-moniker, */
335 /* the returned moniker is the composite after the leftmost anti-moniker is removed. */
337 if(mkSys
==MKSYS_GENERICCOMPOSITE
){
339 res
=IMoniker_Enum(pmkRight
,TRUE
,&penumMk
);
344 res
=IEnumMoniker_Next(penumMk
,1,&pmostLeftMk
,NULL
);
346 IMoniker_IsSystemMoniker(pmostLeftMk
,&mkSys2
);
348 if(mkSys2
==MKSYS_ANTIMONIKER
){
350 IMoniker_Release(pmostLeftMk
);
352 tempMkComposite
=iface
;
353 IMoniker_AddRef(iface
);
355 while(IEnumMoniker_Next(penumMk
,1,&pmostLeftMk
,NULL
)==S_OK
){
357 res
=CreateGenericComposite(tempMkComposite
,pmostLeftMk
,ppmkComposite
);
359 IMoniker_Release(tempMkComposite
);
360 IMoniker_Release(pmostLeftMk
);
362 tempMkComposite
=*ppmkComposite
;
363 IMoniker_AddRef(tempMkComposite
);
368 return CreateGenericComposite(iface
,pmkRight
,ppmkComposite
);
370 /* If pmkRight is not an anti-moniker, the method combines the two monikers into a generic
371 composite if fOnlyIfNotGeneric is FALSE; if fOnlyIfNotGeneric is TRUE, the method returns
372 a NULL moniker and a return value of MK_E_NEEDGENERIC */
374 if (!fOnlyIfNotGeneric
)
375 return CreateGenericComposite(iface
,pmkRight
,ppmkComposite
);
378 return MK_E_NEEDGENERIC
;
381 /******************************************************************************
383 ******************************************************************************/
384 static HRESULT WINAPI
ClassMoniker_Enum(IMoniker
* iface
,BOOL fForward
, IEnumMoniker
** ppenumMoniker
)
386 TRACE("(%p,%d,%p)\n",iface
,fForward
,ppenumMoniker
);
388 if (ppenumMoniker
== NULL
)
391 *ppenumMoniker
= NULL
;
396 /******************************************************************************
397 * ClassMoniker_IsEqual
398 ******************************************************************************/
399 static HRESULT WINAPI
ClassMoniker_IsEqual(IMoniker
* iface
,IMoniker
* pmkOtherMoniker
)
403 LPOLESTR dispName1
,dispName2
;
405 HRESULT res
= S_FALSE
;
407 TRACE("(%p,%p)\n",iface
,pmkOtherMoniker
);
409 if (!pmkOtherMoniker
) return S_FALSE
;
412 /* check if both are ClassMoniker */
413 if(FAILED (IMoniker_GetClassID(pmkOtherMoniker
,&clsid
))) return S_FALSE
;
414 if(!IsEqualCLSID(&clsid
,&CLSID_ClassMoniker
)) return S_FALSE
;
416 /* check if both displaynames are the same */
417 if(SUCCEEDED ((res
= CreateBindCtx(0,&bind
)))) {
418 if(SUCCEEDED (IMoniker_GetDisplayName(iface
,bind
,NULL
,&dispName1
))) {
419 if(SUCCEEDED (IMoniker_GetDisplayName(pmkOtherMoniker
,bind
,NULL
,&dispName2
))) {
420 if(lstrcmpW(dispName1
,dispName2
)==0) res
= S_OK
;
421 CoTaskMemFree(dispName2
);
423 CoTaskMemFree(dispName1
);
429 /******************************************************************************
431 ******************************************************************************/
432 static HRESULT WINAPI
ClassMoniker_Hash(IMoniker
* iface
,DWORD
* pdwHash
)
434 ClassMoniker
*This
= impl_from_IMoniker(iface
);
436 TRACE("(%p)\n", pdwHash
);
438 *pdwHash
= This
->clsid
.Data1
;
443 /******************************************************************************
444 * ClassMoniker_IsRunning
445 ******************************************************************************/
446 static HRESULT WINAPI
ClassMoniker_IsRunning(IMoniker
* iface
,
449 IMoniker
* pmkNewlyRunning
)
451 TRACE("(%p, %p, %p)\n", pbc
, pmkToLeft
, pmkNewlyRunning
);
457 /******************************************************************************
458 * ClassMoniker_GetTimeOfLastChange
459 ******************************************************************************/
460 static HRESULT WINAPI
ClassMoniker_GetTimeOfLastChange(IMoniker
* iface
,
465 TRACE("(%p, %p, %p)\n", pbc
, pmkToLeft
, pItemTime
);
467 return MK_E_UNAVAILABLE
;
470 /******************************************************************************
471 * ClassMoniker_Inverse
472 ******************************************************************************/
473 static HRESULT WINAPI
ClassMoniker_Inverse(IMoniker
* iface
,IMoniker
** ppmk
)
475 TRACE("(%p)\n",ppmk
);
480 return CreateAntiMoniker(ppmk
);
483 /******************************************************************************
484 * ClassMoniker_CommonPrefixWith
485 ******************************************************************************/
486 static HRESULT WINAPI
ClassMoniker_CommonPrefixWith(IMoniker
* iface
,IMoniker
* pmkOther
,IMoniker
** ppmkPrefix
)
490 TRACE("(%p, %p)\n", pmkOther
, ppmkPrefix
);
494 IMoniker_IsSystemMoniker(pmkOther
, &mkSys
);
496 /* If the other moniker is an class moniker that is equal to this moniker, this method sets *ppmkPrefix */
497 /* to this moniker and returns MK_S_US */
499 if (mkSys
== MKSYS_CLASSMONIKER
)
501 if (IMoniker_IsEqual(iface
, pmkOther
) == S_OK
)
505 IMoniker_AddRef(iface
);
510 return MK_E_NOPREFIX
;
513 /* otherwise, the method calls the MonikerCommonPrefixWith function. This function correctly handles */
514 /* the case where the other moniker is a generic composite. */
515 return MonikerCommonPrefixWith(iface
, pmkOther
, ppmkPrefix
);
518 /******************************************************************************
519 * ClassMoniker_RelativePathTo
520 ******************************************************************************/
521 static HRESULT WINAPI
ClassMoniker_RelativePathTo(IMoniker
* iface
,IMoniker
* pmOther
, IMoniker
** ppmkRelPath
)
523 TRACE("(%p, %p)\n",pmOther
,ppmkRelPath
);
530 return MK_E_NOTBINDABLE
;
533 /******************************************************************************
534 * ClassMoniker_GetDisplayName
535 ******************************************************************************/
536 static HRESULT WINAPI
ClassMoniker_GetDisplayName(IMoniker
* iface
,
539 LPOLESTR
*ppszDisplayName
)
541 ClassMoniker
*This
= impl_from_IMoniker(iface
);
542 static const WCHAR wszClsidPrefix
[] = {'c','l','s','i','d',':',0};
544 TRACE("(%p, %p, %p)\n", pbc
, pmkToLeft
, ppszDisplayName
);
546 if (!ppszDisplayName
)
552 *ppszDisplayName
= CoTaskMemAlloc(sizeof(wszClsidPrefix
) + (CHARS_IN_GUID
-2) * sizeof(WCHAR
));
554 StringFromGUID2(&This
->clsid
, *ppszDisplayName
+sizeof(wszClsidPrefix
)/sizeof(WCHAR
)-2, CHARS_IN_GUID
);
556 /* note: this overwrites the opening curly bracket of the CLSID string generated above */
557 memcpy(*ppszDisplayName
, wszClsidPrefix
, sizeof(wszClsidPrefix
)-sizeof(WCHAR
));
559 /* note: this overwrites the closing curly bracket of the CLSID string generated above */
560 (*ppszDisplayName
)[sizeof(wszClsidPrefix
)/sizeof(WCHAR
)-2+CHARS_IN_GUID
-2] = ':';
561 (*ppszDisplayName
)[sizeof(wszClsidPrefix
)/sizeof(WCHAR
)-2+CHARS_IN_GUID
-1] = '\0';
563 TRACE("string is %s\n", debugstr_w(*ppszDisplayName
));
567 /******************************************************************************
568 * ClassMoniker_ParseDisplayName
569 ******************************************************************************/
570 static HRESULT WINAPI
ClassMoniker_ParseDisplayName(IMoniker
* iface
,
573 LPOLESTR pszDisplayName
,
577 FIXME("(%p, %p, %s, %p, %p)\n", pbc
, pmkToLeft
, debugstr_w(pszDisplayName
), pchEaten
, ppmkOut
);
581 /******************************************************************************
582 * ClassMoniker_IsSystemMoniker
583 ******************************************************************************/
584 static HRESULT WINAPI
ClassMoniker_IsSystemMoniker(IMoniker
* iface
,DWORD
* pwdMksys
)
586 TRACE("(%p,%p)\n",iface
,pwdMksys
);
591 *pwdMksys
= MKSYS_CLASSMONIKER
;
596 /*******************************************************************************
597 * ClassMonikerIROTData_QueryInterface
598 *******************************************************************************/
599 static HRESULT WINAPI
ClassMonikerROTData_QueryInterface(IROTData
*iface
,REFIID riid
,VOID
** ppvObject
)
602 ClassMoniker
*This
= impl_from_IROTData(iface
);
604 TRACE("(%p,%p,%p)\n",iface
,riid
,ppvObject
);
606 return ClassMoniker_QueryInterface(&This
->IMoniker_iface
, riid
, ppvObject
);
609 /***********************************************************************
610 * ClassMonikerIROTData_AddRef
612 static ULONG WINAPI
ClassMonikerROTData_AddRef(IROTData
*iface
)
614 ClassMoniker
*This
= impl_from_IROTData(iface
);
616 TRACE("(%p)\n",iface
);
618 return ClassMoniker_AddRef(&This
->IMoniker_iface
);
621 /***********************************************************************
622 * ClassMonikerIROTData_Release
624 static ULONG WINAPI
ClassMonikerROTData_Release(IROTData
* iface
)
626 ClassMoniker
*This
= impl_from_IROTData(iface
);
628 TRACE("(%p)\n",iface
);
630 return ClassMoniker_Release(&This
->IMoniker_iface
);
633 /******************************************************************************
634 * ClassMonikerIROTData_GetComparisonData
635 ******************************************************************************/
636 static HRESULT WINAPI
ClassMonikerROTData_GetComparisonData(IROTData
* iface
,
641 ClassMoniker
*This
= impl_from_IROTData(iface
);
643 TRACE("(%p, %u, %p)\n", pbData
, cbMax
, pcbData
);
645 *pcbData
= 2*sizeof(CLSID
);
646 if (cbMax
< *pcbData
)
647 return E_OUTOFMEMORY
;
649 /* write CLSID of the moniker */
650 memcpy(pbData
, &CLSID_ClassMoniker
, sizeof(CLSID
));
651 /* write CLSID the moniker represents */
652 memcpy(pbData
+sizeof(CLSID
), &This
->clsid
, sizeof(CLSID
));
657 /********************************************************************************/
658 /* Virtual function table for the ClassMoniker class which include IPersist,*/
659 /* IPersistStream and IMoniker functions. */
660 static const IMonikerVtbl ClassMonikerVtbl
=
662 ClassMoniker_QueryInterface
,
664 ClassMoniker_Release
,
665 ClassMoniker_GetClassID
,
666 ClassMoniker_IsDirty
,
669 ClassMoniker_GetSizeMax
,
670 ClassMoniker_BindToObject
,
671 ClassMoniker_BindToStorage
,
673 ClassMoniker_ComposeWith
,
675 ClassMoniker_IsEqual
,
677 ClassMoniker_IsRunning
,
678 ClassMoniker_GetTimeOfLastChange
,
679 ClassMoniker_Inverse
,
680 ClassMoniker_CommonPrefixWith
,
681 ClassMoniker_RelativePathTo
,
682 ClassMoniker_GetDisplayName
,
683 ClassMoniker_ParseDisplayName
,
684 ClassMoniker_IsSystemMoniker
687 /********************************************************************************/
688 /* Virtual function table for the IROTData class. */
689 static const IROTDataVtbl ROTDataVtbl
=
691 ClassMonikerROTData_QueryInterface
,
692 ClassMonikerROTData_AddRef
,
693 ClassMonikerROTData_Release
,
694 ClassMonikerROTData_GetComparisonData
697 /******************************************************************************
698 * ClassMoniker_Construct (local function)
699 *******************************************************************************/
700 static HRESULT
ClassMoniker_Construct(ClassMoniker
* This
, REFCLSID rclsid
)
702 TRACE("(%p,%s)\n",This
,debugstr_guid(rclsid
));
704 /* Initialize the virtual function table. */
705 This
->IMoniker_iface
.lpVtbl
= &ClassMonikerVtbl
;
706 This
->IROTData_iface
.lpVtbl
= &ROTDataVtbl
;
708 This
->clsid
= *rclsid
;
709 This
->pMarshal
= NULL
;
714 /******************************************************************************
715 * CreateClassMoniker [OLE32.@]
716 ******************************************************************************/
717 HRESULT WINAPI
CreateClassMoniker(REFCLSID rclsid
, IMoniker
**ppmk
)
719 ClassMoniker
* newClassMoniker
;
722 TRACE("(%s,%p)\n", debugstr_guid(rclsid
), ppmk
);
724 newClassMoniker
= HeapAlloc(GetProcessHeap(), 0, sizeof(ClassMoniker
));
726 if (!newClassMoniker
)
727 return STG_E_INSUFFICIENTMEMORY
;
729 hr
= ClassMoniker_Construct(newClassMoniker
, rclsid
);
733 HeapFree(GetProcessHeap(), 0, newClassMoniker
);
737 return ClassMoniker_QueryInterface(&newClassMoniker
->IMoniker_iface
, &IID_IMoniker
,
741 HRESULT
ClassMoniker_CreateFromDisplayName(LPBC pbc
, LPCOLESTR szDisplayName
, LPDWORD pchEaten
,
745 LPCWSTR s
= strchrW(szDisplayName
, ':');
756 for (end
= s
; *end
&& (*end
!= ':'); end
++)
759 TRACE("parsing %s\n", debugstr_wn(s
, end
- s
));
761 /* validate the CLSID string */
764 if ((end
- s
!= 38) || (s
[37] != '}'))
776 if ((i
== 8)||(i
== 13)||(i
== 18)||(i
== 23))
782 if (!(((s
[i
] >= '0') && (s
[i
] <= '9')) ||
783 ((s
[i
] >= 'a') && (s
[i
] <= 'f')) ||
784 ((s
[i
] >= 'A') && (s
[i
] <= 'F'))))
788 /* quick lookup table */
789 memset(table
, 0, 256);
791 for (i
= 0; i
< 10; i
++)
793 for (i
= 0; i
< 6; i
++)
795 table
['A' + i
] = i
+10;
796 table
['a' + i
] = i
+10;
799 /* in form XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX */
801 clsid
.Data1
= (table
[s
[0]] << 28 | table
[s
[1]] << 24 | table
[s
[2]] << 20 | table
[s
[3]] << 16 |
802 table
[s
[4]] << 12 | table
[s
[5]] << 8 | table
[s
[6]] << 4 | table
[s
[7]]);
803 clsid
.Data2
= table
[s
[9]] << 12 | table
[s
[10]] << 8 | table
[s
[11]] << 4 | table
[s
[12]];
804 clsid
.Data3
= table
[s
[14]] << 12 | table
[s
[15]] << 8 | table
[s
[16]] << 4 | table
[s
[17]];
806 /* these are just sequential bytes */
807 clsid
.Data4
[0] = table
[s
[19]] << 4 | table
[s
[20]];
808 clsid
.Data4
[1] = table
[s
[21]] << 4 | table
[s
[22]];
809 clsid
.Data4
[2] = table
[s
[24]] << 4 | table
[s
[25]];
810 clsid
.Data4
[3] = table
[s
[26]] << 4 | table
[s
[27]];
811 clsid
.Data4
[4] = table
[s
[28]] << 4 | table
[s
[29]];
812 clsid
.Data4
[5] = table
[s
[30]] << 4 | table
[s
[31]];
813 clsid
.Data4
[6] = table
[s
[32]] << 4 | table
[s
[33]];
814 clsid
.Data4
[7] = table
[s
[34]] << 4 | table
[s
[35]];
816 hr
= CreateClassMoniker(&clsid
, ppmk
);
818 *pchEaten
= (*end
== ':' ? end
+ 1 : end
) - szDisplayName
;
822 static HRESULT WINAPI
ClassMonikerCF_QueryInterface(IClassFactory
*iface
, REFIID riid
, void **ppv
)
825 if (IsEqualIID(riid
, &IID_IUnknown
) || IsEqualIID(riid
, &IID_IClassFactory
))
828 IClassFactory_AddRef(iface
);
831 return E_NOINTERFACE
;
834 static ULONG WINAPI
ClassMonikerCF_AddRef(LPCLASSFACTORY iface
)
836 return 2; /* non-heap based object */
839 static ULONG WINAPI
ClassMonikerCF_Release(LPCLASSFACTORY iface
)
841 return 1; /* non-heap based object */
844 static HRESULT WINAPI
ClassMonikerCF_CreateInstance(LPCLASSFACTORY iface
,
845 LPUNKNOWN pUnk
, REFIID riid
, LPVOID
*ppv
)
850 TRACE("(%p, %s, %p)\n", pUnk
, debugstr_guid(riid
), ppv
);
855 return CLASS_E_NOAGGREGATION
;
857 hr
= CreateClassMoniker(&CLSID_NULL
, &pmk
);
858 if (FAILED(hr
)) return hr
;
860 hr
= IMoniker_QueryInterface(pmk
, riid
, ppv
);
861 IMoniker_Release(pmk
);
866 static HRESULT WINAPI
ClassMonikerCF_LockServer(LPCLASSFACTORY iface
, BOOL fLock
)
868 FIXME("(%d), stub!\n",fLock
);
872 static const IClassFactoryVtbl ClassMonikerCFVtbl
=
874 ClassMonikerCF_QueryInterface
,
875 ClassMonikerCF_AddRef
,
876 ClassMonikerCF_Release
,
877 ClassMonikerCF_CreateInstance
,
878 ClassMonikerCF_LockServer
880 static const IClassFactoryVtbl
*ClassMonikerCF
= &ClassMonikerCFVtbl
;
882 HRESULT
ClassMonikerCF_Create(REFIID riid
, LPVOID
*ppv
)
884 return IClassFactory_QueryInterface((IClassFactory
*)&ClassMonikerCF
, riid
, ppv
);