shell32: Use shared code to return column details from IShellFolder2::GetDetailsOf().
[wine] / dlls / devenum / mediacatenum.c
1 /*
2  *      IEnumMoniker implementation for DEVENUM.dll
3  *
4  * Copyright (C) 2002 Robert Shearman
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  *
20  * NOTES ON THIS FILE:
21  * - Implements IEnumMoniker interface which enumerates through moniker
22  *   objects created from HKEY_CLASSES/CLSID/{DEVICE_CLSID}/Instance
23  */
24
25 #include "devenum_private.h"
26 #include "oleauto.h"
27 #include "ocidl.h"
28
29 #include "wine/debug.h"
30
31 WINE_DEFAULT_DEBUG_CHANNEL(devenum);
32
33 static ULONG WINAPI DEVENUM_IEnumMoniker_AddRef(LPENUMMONIKER iface);
34 static ULONG WINAPI DEVENUM_IMediaCatMoniker_AddRef(LPMONIKER iface);
35 static ULONG WINAPI DEVENUM_IPropertyBag_AddRef(LPPROPERTYBAG iface);
36
37 typedef struct
38 {
39     const IPropertyBagVtbl *lpVtbl;
40     LONG ref;
41     HKEY hkey;
42 } RegPropBagImpl;
43
44
45 static HRESULT WINAPI DEVENUM_IPropertyBag_QueryInterface(
46     LPPROPERTYBAG iface,
47     REFIID riid,
48     LPVOID *ppvObj)
49 {
50     RegPropBagImpl *This = (RegPropBagImpl *)iface;
51
52     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppvObj);
53
54     if (This == NULL || ppvObj == NULL) return E_POINTER;
55
56     if (IsEqualGUID(riid, &IID_IUnknown) ||
57         IsEqualGUID(riid, &IID_IPropertyBag))
58     {
59         *ppvObj = iface;
60         DEVENUM_IPropertyBag_AddRef(iface);
61         return S_OK;
62     }
63
64     FIXME("- no interface IID: %s\n", debugstr_guid(riid));
65     return E_NOINTERFACE;
66 }
67
68 /**********************************************************************
69  * DEVENUM_IPropertyBag_AddRef (also IUnknown)
70  */
71 static ULONG WINAPI DEVENUM_IPropertyBag_AddRef(LPPROPERTYBAG iface)
72 {
73     RegPropBagImpl *This = (RegPropBagImpl *)iface;
74
75     TRACE("(%p)->() AddRef from %d\n", iface, This->ref);
76
77     return InterlockedIncrement(&This->ref);
78 }
79
80 /**********************************************************************
81  * DEVENUM_IPropertyBag_Release (also IUnknown)
82  */
83 static ULONG WINAPI DEVENUM_IPropertyBag_Release(LPPROPERTYBAG iface)
84 {
85     RegPropBagImpl *This = (RegPropBagImpl *)iface;
86     ULONG ref;
87
88     TRACE("(%p)->() ReleaseThis->ref from %d\n", iface, This->ref);
89
90     ref = InterlockedDecrement(&This->ref);
91     if (ref == 0) {
92         RegCloseKey(This->hkey);
93         CoTaskMemFree(This);
94         DEVENUM_UnlockModule();
95     }
96     return ref;
97 }
98
99 static HRESULT WINAPI DEVENUM_IPropertyBag_Read(
100     LPPROPERTYBAG iface,
101     LPCOLESTR pszPropName,
102     VARIANT* pVar,
103     IErrorLog* pErrorLog)
104 {
105     LPVOID pData = NULL;
106     DWORD received;
107     DWORD type = 0;
108     RegPropBagImpl *This = (RegPropBagImpl *)iface;
109     HRESULT res = S_OK;
110     LONG reswin32;
111
112     TRACE("(%p)->(%s, %p, %p)\n", This, debugstr_w(pszPropName), pVar, pErrorLog);
113
114     if (!pszPropName || !pVar)
115         return E_POINTER;
116
117     reswin32 = RegQueryValueExW(This->hkey, pszPropName, NULL, NULL, NULL, &received);
118     res = HRESULT_FROM_WIN32(reswin32);
119
120     if (SUCCEEDED(res))
121     {
122         pData = HeapAlloc(GetProcessHeap(), 0, received);
123
124         /* work around a GCC bug that occurs here unless we use the reswin32 variable as well */
125         reswin32 = RegQueryValueExW(This->hkey, pszPropName, NULL, &type, pData, &received);
126         res = HRESULT_FROM_WIN32(reswin32);
127     }
128
129     if (SUCCEEDED(res))
130     {
131         res = E_INVALIDARG; /* assume we cannot coerce into right type */
132
133         TRACE("Read %d bytes (%s)\n", received, type == REG_SZ ? debugstr_w(pData) : "binary data");
134
135         switch (type)
136         {
137         case REG_SZ:
138             switch (V_VT(pVar))
139             {
140             case VT_LPWSTR:
141                 V_UNION(pVar, bstrVal) = CoTaskMemAlloc(received);
142                 memcpy(V_UNION(pVar, bstrVal), pData, received);
143                 res = S_OK;
144                 break;
145             case VT_EMPTY:
146                 V_VT(pVar) = VT_BSTR;
147             /* fall through */
148             case VT_BSTR:
149                 V_UNION(pVar, bstrVal) = SysAllocStringLen(pData, received/sizeof(WCHAR) - 1);
150                 res = S_OK;
151                 break;
152             }
153             break;
154         case REG_DWORD:
155             TRACE("REG_DWORD: %x\n", *(DWORD *)pData);
156             switch (V_VT(pVar))
157             {
158             case VT_EMPTY:
159                 V_VT(pVar) = VT_I4;
160                 /* fall through */
161             case VT_I4:
162             case VT_UI4:
163                 V_UNION(pVar, ulVal) = *(DWORD *)pData;
164                 res = S_OK;
165                 break;
166             }
167             break;
168         case REG_BINARY:
169             {
170                 SAFEARRAYBOUND bound;
171                 void * pArrayElements;
172                 bound.lLbound = 0;
173                 bound.cElements = received;
174                 TRACE("REG_BINARY: len = %d\n", received);
175                 switch (V_VT(pVar))
176                 {
177                 case VT_EMPTY:
178                     V_VT(pVar) = VT_ARRAY | VT_UI1;
179                     /* fall through */
180                 case VT_ARRAY | VT_UI1:
181                     if (!(V_UNION(pVar, parray) = SafeArrayCreate(VT_UI1, 1, &bound)))
182                         res = E_OUTOFMEMORY;
183                     else
184                         res = S_OK;
185                     break;
186                 }
187
188                 if (res == E_INVALIDARG)
189                     break;
190
191                 res = SafeArrayAccessData(V_UNION(pVar, parray), &pArrayElements);
192                 if (FAILED(res))
193                     break;
194
195                 CopyMemory(pArrayElements, pData, received);
196                 res = SafeArrayUnaccessData(V_UNION(pVar, parray));
197                 break;
198             }
199         }
200         if (res == E_INVALIDARG)
201             FIXME("Variant type %x not supported for regtype %x\n", V_VT(pVar), type);
202     }
203
204     HeapFree(GetProcessHeap(), 0, pData);
205
206     TRACE("<- %x\n", res);
207     return res;
208 }
209
210 static HRESULT WINAPI DEVENUM_IPropertyBag_Write(
211     LPPROPERTYBAG iface,
212     LPCOLESTR pszPropName,
213     VARIANT* pVar)
214 {
215     RegPropBagImpl *This = (RegPropBagImpl *)iface;
216     LPVOID lpData = NULL;
217     DWORD cbData = 0;
218     DWORD dwType = 0;
219     HRESULT res = S_OK;
220
221     TRACE("(%p)->(%s, %p)\n", This, debugstr_w(pszPropName), pVar);
222
223     switch (V_VT(pVar))
224     {
225     case VT_BSTR:
226         TRACE("writing %s\n", debugstr_w(V_UNION(pVar, bstrVal)));
227         lpData = V_UNION(pVar, bstrVal);
228         dwType = REG_SZ;
229         cbData = (lstrlenW(V_UNION(pVar, bstrVal)) + 1) * sizeof(WCHAR);
230         break;
231     case VT_I4:
232     case VT_UI4:
233         TRACE("writing %u\n", V_UNION(pVar, ulVal));
234         lpData = &V_UNION(pVar, ulVal);
235         dwType = REG_DWORD;
236         cbData = sizeof(DWORD);
237         break;
238     case VT_ARRAY | VT_UI1:
239     {
240         LONG lUbound = 0;
241         LONG lLbound = 0;
242         dwType = REG_BINARY;
243         res = SafeArrayGetLBound(V_UNION(pVar, parray), 1, &lLbound);
244         res = SafeArrayGetUBound(V_UNION(pVar, parray), 1, &lUbound);
245         cbData = (lUbound - lLbound + 1) /* * sizeof(BYTE)*/;
246         TRACE("cbData: %d\n", cbData);
247         res = SafeArrayAccessData(V_UNION(pVar, parray), &lpData);
248         break;
249     }
250     default:
251         FIXME("Variant type %d not handled\n", V_VT(pVar));
252         return E_FAIL;
253     }
254
255     if (RegSetValueExW(This->hkey,
256                        pszPropName, 0,
257                        dwType, lpData, cbData) != ERROR_SUCCESS)
258         res = E_FAIL;
259
260     if (V_VT(pVar) & VT_ARRAY)
261         res = SafeArrayUnaccessData(V_UNION(pVar, parray));
262
263     return res;
264 }
265
266 static const IPropertyBagVtbl IPropertyBag_Vtbl =
267 {
268     DEVENUM_IPropertyBag_QueryInterface,
269     DEVENUM_IPropertyBag_AddRef,
270     DEVENUM_IPropertyBag_Release,
271     DEVENUM_IPropertyBag_Read,
272     DEVENUM_IPropertyBag_Write
273 };
274
275 static HRESULT DEVENUM_IPropertyBag_Construct(HANDLE hkey, IPropertyBag **ppBag)
276 {
277     RegPropBagImpl * rpb = CoTaskMemAlloc(sizeof(RegPropBagImpl));
278     if (!rpb)
279         return E_OUTOFMEMORY;
280     rpb->lpVtbl = &IPropertyBag_Vtbl;
281     rpb->ref = 1;
282     rpb->hkey = hkey;
283     *ppBag = (IPropertyBag*)rpb;
284     DEVENUM_LockModule();
285     return S_OK;
286 }
287
288
289 static HRESULT WINAPI DEVENUM_IMediaCatMoniker_QueryInterface(
290     LPMONIKER iface,
291     REFIID riid,
292     LPVOID *ppvObj)
293 {
294     MediaCatMoniker *This = (MediaCatMoniker *)iface;
295     TRACE("\n\tIID:\t%s\n",debugstr_guid(riid));
296
297     if (This == NULL || ppvObj == NULL) return E_POINTER;
298
299     *ppvObj = NULL;
300
301     if (IsEqualGUID(riid, &IID_IUnknown) ||
302         IsEqualGUID(riid, &IID_IPersist) ||
303         IsEqualGUID(riid, &IID_IPersistStream) ||
304         IsEqualGUID(riid, &IID_IMoniker))
305     {
306         *ppvObj = iface;
307         DEVENUM_IMediaCatMoniker_AddRef(iface);
308         return S_OK;
309     }
310
311     FIXME("- no interface IID: %s\n", debugstr_guid(riid));
312     return E_NOINTERFACE;
313 }
314
315 /**********************************************************************
316  * DEVENUM_IMediaCatMoniker_AddRef (also IUnknown)
317  */
318 static ULONG WINAPI DEVENUM_IMediaCatMoniker_AddRef(LPMONIKER iface)
319 {
320     MediaCatMoniker *This = (MediaCatMoniker *)iface;
321     TRACE("\n");
322
323     return InterlockedIncrement(&This->ref);
324 }
325
326 /**********************************************************************
327  * DEVENUM_IMediaCatMoniker_Release (also IUnknown)
328  */
329 static ULONG WINAPI DEVENUM_IMediaCatMoniker_Release(LPMONIKER iface)
330 {
331     MediaCatMoniker *This = (MediaCatMoniker *)iface;
332     ULONG ref;
333     TRACE("\n");
334
335     ref = InterlockedDecrement(&This->ref);
336     if (ref == 0) {
337         RegCloseKey(This->hkey);
338         CoTaskMemFree(This);
339         DEVENUM_UnlockModule();
340     }
341     return ref;
342 }
343
344 static HRESULT WINAPI DEVENUM_IMediaCatMoniker_GetClassID(
345     LPMONIKER iface,
346     CLSID* pClassID)
347 {
348     MediaCatMoniker *This = (MediaCatMoniker *)iface;
349     FIXME("(%p)->(%p): stub\n", This, pClassID);
350
351     if (pClassID == NULL)
352         return E_POINTER;
353
354     return E_NOTIMPL;
355 }
356
357 static HRESULT WINAPI DEVENUM_IMediaCatMoniker_IsDirty(LPMONIKER iface)
358 {
359     FIXME("(%p)->(): stub\n", iface);
360
361     return S_FALSE;
362 }
363
364 static HRESULT WINAPI DEVENUM_IMediaCatMoniker_Load(LPMONIKER iface, IStream* pStm)
365 {
366     FIXME("(%p)->(%p): stub\n", iface, pStm);
367
368     return E_NOTIMPL;
369 }
370
371 static HRESULT WINAPI DEVENUM_IMediaCatMoniker_Save(LPMONIKER iface, IStream* pStm, BOOL fClearDirty)
372 {
373     FIXME("(%p)->(%p, %s): stub\n", iface, pStm, fClearDirty ? "true" : "false");
374
375     return STG_E_CANTSAVE;
376 }
377
378 static HRESULT WINAPI DEVENUM_IMediaCatMoniker_GetSizeMax(
379     LPMONIKER iface,
380     ULARGE_INTEGER* pcbSize)
381 {
382     FIXME("(%p)->(%p): stub\n", iface, pcbSize);
383
384     ZeroMemory(pcbSize, sizeof(*pcbSize));
385
386     return S_OK;
387 }
388
389 static HRESULT WINAPI DEVENUM_IMediaCatMoniker_BindToObject(
390     LPMONIKER iface,
391     IBindCtx* pbc,
392     IMoniker* pmkToLeft,
393     REFIID riidResult,
394     void** ppvResult)
395 {
396     IUnknown * pObj = NULL;
397     IPropertyBag * pProp = NULL;
398     CLSID clsID;
399     VARIANT var;
400     HRESULT res = E_FAIL;
401
402     MediaCatMoniker *This = (MediaCatMoniker *)iface;
403
404     VariantInit(&var);
405
406     TRACE("(%p)->(%p, %p, %s, %p)\n", This, pbc, pmkToLeft, debugstr_guid(riidResult), ppvResult);
407
408     *ppvResult = NULL;
409
410     if(pmkToLeft==NULL)
411     {
412             /* first activation of this class */
413             LPVOID pvptr;
414             res=IMoniker_BindToStorage(iface, NULL, NULL, &IID_IPropertyBag, &pvptr);
415             pProp = pvptr;
416             if (SUCCEEDED(res))
417             {
418                 V_VT(&var) = VT_LPWSTR;
419                 res = IPropertyBag_Read(pProp, clsid_keyname, &var, NULL);
420             }
421             if (SUCCEEDED(res))
422             {
423                 res = CLSIDFromString(V_UNION(&var,bstrVal), &clsID);
424                 CoTaskMemFree(V_UNION(&var, bstrVal));
425             }
426             if (SUCCEEDED(res))
427             {
428                 res=CoCreateInstance(&clsID,NULL,CLSCTX_ALL,&IID_IUnknown,&pvptr);
429                 pObj = pvptr;
430             }
431     }
432
433     if (pObj!=NULL)
434     {
435         /* get the requested interface from the loaded class */
436         res = S_OK;
437         if (pProp) {
438            HRESULT res2;
439            LPVOID ppv = NULL;
440            res2 = IUnknown_QueryInterface(pObj, &IID_IPersistPropertyBag, &ppv);
441            if (SUCCEEDED(res2)) {
442               res = IPersistPropertyBag_Load((IPersistPropertyBag *) ppv, pProp, NULL);
443               IPersistPropertyBag_Release((IPersistPropertyBag *) ppv);
444            }
445         }
446         if (SUCCEEDED(res))
447            res= IUnknown_QueryInterface(pObj,riidResult,ppvResult);
448         IUnknown_Release(pObj);
449     }
450
451     if (pProp)
452     {
453         IPropertyBag_Release(pProp);
454     }
455
456     TRACE("<- 0x%x\n", res);
457
458     return res;
459 }
460
461 static HRESULT WINAPI DEVENUM_IMediaCatMoniker_BindToStorage(
462     LPMONIKER iface,
463     IBindCtx* pbc,
464     IMoniker* pmkToLeft,
465     REFIID riid,
466     void** ppvObj)
467 {
468     MediaCatMoniker *This = (MediaCatMoniker *)iface;
469     TRACE("(%p)->(%p, %p, %s, %p)\n", This, pbc, pmkToLeft, debugstr_guid(riid), ppvObj);
470
471     *ppvObj = NULL;
472
473     if (pbc || pmkToLeft)
474         return MK_E_NOSTORAGE;
475
476     if (IsEqualGUID(riid, &IID_IPropertyBag))
477     {
478         HANDLE hkey;
479         DuplicateHandle(GetCurrentProcess(), This->hkey, GetCurrentProcess(), &hkey, 0, 0, DUPLICATE_SAME_ACCESS);
480         return DEVENUM_IPropertyBag_Construct(hkey, (IPropertyBag**)ppvObj);
481     }
482
483     return MK_E_NOSTORAGE;
484 }
485
486 static HRESULT WINAPI DEVENUM_IMediaCatMoniker_Reduce(
487     LPMONIKER iface,
488     IBindCtx* pbc,
489     DWORD dwReduceHowFar,
490     IMoniker** ppmkToLeft,
491     IMoniker** ppmkReduced)
492 {
493     TRACE("(%p)->(%p, %d, %p, %p)\n", iface, pbc, dwReduceHowFar, ppmkToLeft, ppmkReduced);
494
495     if (ppmkToLeft)
496         *ppmkToLeft = NULL;
497     *ppmkReduced = iface;
498
499     return MK_S_REDUCED_TO_SELF;
500 }
501
502 static HRESULT WINAPI DEVENUM_IMediaCatMoniker_ComposeWith(
503     LPMONIKER iface,
504     IMoniker* pmkRight,
505     BOOL fOnlyIfNotGeneric,
506     IMoniker** ppmkComposite)
507 {
508     FIXME("(%p)->(%p, %s, %p): stub\n", iface, pmkRight, fOnlyIfNotGeneric ? "true" : "false", ppmkComposite);
509
510     /* FIXME: use CreateGenericComposite? */
511     *ppmkComposite = NULL;
512
513     return E_NOTIMPL;
514 }
515
516 static HRESULT WINAPI DEVENUM_IMediaCatMoniker_Enum(
517     LPMONIKER iface,
518     BOOL fForward,
519     IEnumMoniker** ppenumMoniker)
520 {
521     FIXME("(%p)->(%s, %p): stub\n", iface, fForward ? "true" : "false", ppenumMoniker);
522
523     *ppenumMoniker = NULL;
524
525     return S_OK;
526 }
527
528 static HRESULT WINAPI DEVENUM_IMediaCatMoniker_IsEqual(
529     LPMONIKER iface,
530     IMoniker* pmkOtherMoniker)
531 {
532     FIXME("(%p)->(%p): stub\n", iface, pmkOtherMoniker);
533
534     return E_NOTIMPL;
535 }
536
537 static HRESULT WINAPI DEVENUM_IMediaCatMoniker_Hash(
538     LPMONIKER iface,
539     DWORD* pdwHash)
540 {
541     TRACE("(%p)->(%p)\n", iface, pdwHash);
542
543     *pdwHash = 0;
544
545     return S_OK;
546 }
547
548 static HRESULT WINAPI DEVENUM_IMediaCatMoniker_IsRunning(
549     LPMONIKER iface,
550     IBindCtx* pbc,
551     IMoniker* pmkToLeft,
552     IMoniker* pmkNewlyRunning)
553 {
554     FIXME("(%p)->(%p, %p, %p): stub\n", iface, pbc, pmkToLeft, pmkNewlyRunning);
555
556     return S_FALSE;
557 }
558
559 static HRESULT WINAPI DEVENUM_IMediaCatMoniker_GetTimeOfLastChange(
560     LPMONIKER iface,
561     IBindCtx* pbc,
562     IMoniker* pmkToLeft,
563     FILETIME* pFileTime)
564 {
565     TRACE("(%p)->(%p, %p, %p)\n", iface, pbc, pmkToLeft, pFileTime);
566
567     pFileTime->dwLowDateTime = 0xFFFFFFFF;
568     pFileTime->dwHighDateTime = 0x7FFFFFFF;
569
570     return MK_E_UNAVAILABLE;
571 }
572
573 static HRESULT WINAPI DEVENUM_IMediaCatMoniker_Inverse(
574     LPMONIKER iface,
575     IMoniker** ppmk)
576 {
577     TRACE("(%p)->(%p)\n", iface, ppmk);
578
579     *ppmk = NULL;
580
581     return MK_E_NOINVERSE;
582 }
583
584 static HRESULT WINAPI DEVENUM_IMediaCatMoniker_CommonPrefixWith(
585     LPMONIKER iface,
586     IMoniker* pmkOtherMoniker,
587     IMoniker** ppmkPrefix)
588 {
589     TRACE("(%p)->(%p, %p)\n", iface, pmkOtherMoniker, ppmkPrefix);
590
591     *ppmkPrefix = NULL;
592
593     return MK_E_NOPREFIX;
594 }
595
596 static HRESULT WINAPI DEVENUM_IMediaCatMoniker_RelativePathTo(
597     LPMONIKER iface,
598     IMoniker* pmkOther,
599     IMoniker** ppmkRelPath)
600 {
601     TRACE("(%p)->(%p, %p)\n", iface, pmkOther, ppmkRelPath);
602
603     *ppmkRelPath = pmkOther;
604
605     return MK_S_HIM;
606 }
607
608 static HRESULT WINAPI DEVENUM_IMediaCatMoniker_GetDisplayName(
609     LPMONIKER iface,
610     IBindCtx* pbc,
611     IMoniker* pmkToLeft,
612     LPOLESTR* ppszDisplayName)
613 {
614     MediaCatMoniker *This = (MediaCatMoniker *)iface;
615     WCHAR wszBuffer[MAX_PATH];
616     static const WCHAR wszFriendlyName[] = {'F','r','i','e','n','d','l','y','N','a','m','e',0};
617     LONG received = sizeof(wszFriendlyName);
618
619     TRACE("(%p)->(%p, %p, %p)\n", iface, pbc, pmkToLeft, ppszDisplayName);
620
621     *ppszDisplayName = NULL;
622
623     /* FIXME: should this be the weird stuff we have to parse in IParseDisplayName? */
624     if (RegQueryValueW(This->hkey, wszFriendlyName, wszBuffer, &received) == ERROR_SUCCESS)
625     {
626         *ppszDisplayName = CoTaskMemAlloc(received);
627         strcpyW(*ppszDisplayName, wszBuffer);
628         return S_OK;
629     }
630
631     return E_FAIL;
632 }
633
634 static HRESULT WINAPI DEVENUM_IMediaCatMoniker_ParseDisplayName(
635     LPMONIKER iface,
636     IBindCtx* pbc,
637     IMoniker* pmkToLeft,
638     LPOLESTR pszDisplayName,
639     ULONG* pchEaten,
640     IMoniker** ppmkOut)
641 {
642     FIXME("(%p)->(%p, %p, %s, %p, %p)\n", iface, pbc, pmkToLeft, debugstr_w(pszDisplayName), pchEaten, ppmkOut);
643
644     *pchEaten = 0;
645     *ppmkOut = NULL;
646
647     return MK_E_SYNTAX;
648 }
649
650 static HRESULT WINAPI DEVENUM_IMediaCatMoniker_IsSystemMoniker(
651     LPMONIKER iface,
652     DWORD* pdwMksys)
653 {
654     TRACE("(%p)->(%p)\n", iface, pdwMksys);
655
656     return S_FALSE;
657 }
658
659 static const IMonikerVtbl IMoniker_Vtbl =
660 {
661     DEVENUM_IMediaCatMoniker_QueryInterface,
662     DEVENUM_IMediaCatMoniker_AddRef,
663     DEVENUM_IMediaCatMoniker_Release,
664     DEVENUM_IMediaCatMoniker_GetClassID,
665     DEVENUM_IMediaCatMoniker_IsDirty,
666     DEVENUM_IMediaCatMoniker_Load,
667     DEVENUM_IMediaCatMoniker_Save,
668     DEVENUM_IMediaCatMoniker_GetSizeMax,
669     DEVENUM_IMediaCatMoniker_BindToObject,
670     DEVENUM_IMediaCatMoniker_BindToStorage,
671     DEVENUM_IMediaCatMoniker_Reduce,
672     DEVENUM_IMediaCatMoniker_ComposeWith,
673     DEVENUM_IMediaCatMoniker_Enum,
674     DEVENUM_IMediaCatMoniker_IsEqual,
675     DEVENUM_IMediaCatMoniker_Hash,
676     DEVENUM_IMediaCatMoniker_IsRunning,
677     DEVENUM_IMediaCatMoniker_GetTimeOfLastChange,
678     DEVENUM_IMediaCatMoniker_Inverse,
679     DEVENUM_IMediaCatMoniker_CommonPrefixWith,
680     DEVENUM_IMediaCatMoniker_RelativePathTo,
681     DEVENUM_IMediaCatMoniker_GetDisplayName,
682     DEVENUM_IMediaCatMoniker_ParseDisplayName,
683     DEVENUM_IMediaCatMoniker_IsSystemMoniker
684 };
685
686 MediaCatMoniker * DEVENUM_IMediaCatMoniker_Construct(void)
687 {
688     MediaCatMoniker * pMoniker = NULL;
689     pMoniker = CoTaskMemAlloc(sizeof(MediaCatMoniker));
690     if (!pMoniker)
691         return NULL;
692
693     pMoniker->lpVtbl = &IMoniker_Vtbl;
694     pMoniker->ref = 0;
695     pMoniker->hkey = NULL;
696
697     DEVENUM_IMediaCatMoniker_AddRef((LPMONIKER)pMoniker);
698
699     DEVENUM_LockModule();
700
701     return pMoniker;
702 }
703
704 /**********************************************************************
705  * DEVENUM_IEnumMoniker_QueryInterface (also IUnknown)
706  */
707 static HRESULT WINAPI DEVENUM_IEnumMoniker_QueryInterface(
708     LPENUMMONIKER iface,
709     REFIID riid,
710     LPVOID *ppvObj)
711 {
712     EnumMonikerImpl *This = (EnumMonikerImpl *)iface;
713
714     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppvObj);
715
716     if (This == NULL || ppvObj == NULL) return E_POINTER;
717
718     if (IsEqualGUID(riid, &IID_IUnknown) ||
719         IsEqualGUID(riid, &IID_IEnumMoniker))
720     {
721         *ppvObj = iface;
722         DEVENUM_IEnumMoniker_AddRef(iface);
723         return S_OK;
724     }
725
726     FIXME("- no interface IID: %s\n", debugstr_guid(riid));
727     return E_NOINTERFACE;
728 }
729
730 /**********************************************************************
731  * DEVENUM_IEnumMoniker_AddRef (also IUnknown)
732  */
733 static ULONG WINAPI DEVENUM_IEnumMoniker_AddRef(LPENUMMONIKER iface)
734 {
735     EnumMonikerImpl *This = (EnumMonikerImpl *)iface;
736     ULONG ref = InterlockedIncrement(&This->ref);
737
738     TRACE("(%p)->() AddRef from %d\n", iface, ref - 1);
739
740     return ref;
741 }
742
743 /**********************************************************************
744  * DEVENUM_IEnumMoniker_Release (also IUnknown)
745  */
746 static ULONG WINAPI DEVENUM_IEnumMoniker_Release(LPENUMMONIKER iface)
747 {
748     EnumMonikerImpl *This = (EnumMonikerImpl *)iface;
749     ULONG ref = InterlockedDecrement(&This->ref);
750
751     TRACE("(%p)->() Release from %d\n", iface, ref + 1);
752
753     if (!ref)
754     {
755         RegCloseKey(This->hkey);
756         CoTaskMemFree(This);
757         DEVENUM_UnlockModule();
758         return 0;
759     }
760     return ref;
761 }
762
763 static HRESULT WINAPI DEVENUM_IEnumMoniker_Next(LPENUMMONIKER iface, ULONG celt, IMoniker ** rgelt, ULONG * pceltFetched)
764 {
765     WCHAR buffer[MAX_PATH + 1];
766     LONG res;
767     ULONG fetched = 0;
768     MediaCatMoniker * pMoniker;
769     EnumMonikerImpl *This = (EnumMonikerImpl *)iface;
770
771     TRACE("(%p)->(%d, %p, %p)\n", iface, celt, rgelt, pceltFetched);
772
773     while (fetched < celt)
774     {
775         res = RegEnumKeyW(This->hkey, This->index, buffer, sizeof(buffer) / sizeof(WCHAR));
776         if (res != ERROR_SUCCESS)
777         {
778             break;
779         }
780         pMoniker = DEVENUM_IMediaCatMoniker_Construct();
781         if (!pMoniker)
782             return E_OUTOFMEMORY;
783
784         if (RegOpenKeyW(This->hkey, buffer, &pMoniker->hkey) != ERROR_SUCCESS)
785         {
786             DEVENUM_IMediaCatMoniker_Release((LPMONIKER)pMoniker);
787             break;
788         }
789         rgelt[fetched] = (LPMONIKER)pMoniker;
790         fetched++;
791     }
792
793     This->index += fetched;
794
795     TRACE("-- fetched %d\n", fetched);
796
797     if (pceltFetched)
798         *pceltFetched = fetched;
799
800     if (fetched != celt)
801         return S_FALSE;
802     else
803         return S_OK;
804 }
805
806 static HRESULT WINAPI DEVENUM_IEnumMoniker_Skip(LPENUMMONIKER iface, ULONG celt)
807 {
808     EnumMonikerImpl *This = (EnumMonikerImpl *)iface;
809     DWORD subKeys;
810
811     TRACE("(%p)->(%d)\n", iface, celt);
812
813     /* Before incrementing, check if there are any more values to run thru.
814        Some programs use the Skip() function to get the amount of devices */
815     if(RegQueryInfoKeyW(This->hkey, NULL, NULL, NULL, &subKeys, NULL, NULL, NULL, NULL, NULL, NULL, NULL) != ERROR_SUCCESS)
816     {
817         return S_FALSE;
818     }
819     if((This->index + celt) >= subKeys)
820     {
821         return S_FALSE;
822     }
823
824     This->index += celt;
825
826     return S_OK;
827 }
828
829 static HRESULT WINAPI DEVENUM_IEnumMoniker_Reset(LPENUMMONIKER iface)
830 {
831     EnumMonikerImpl *This = (EnumMonikerImpl *)iface;
832
833     TRACE("(%p)->()\n", iface);
834
835     This->index = 0;
836
837     return S_OK;
838 }
839
840 static HRESULT WINAPI DEVENUM_IEnumMoniker_Clone(LPENUMMONIKER iface, IEnumMoniker ** ppenum)
841 {
842     FIXME("(%p)->(%p): stub\n", iface, ppenum);
843
844     return E_NOTIMPL;
845 }
846
847 /**********************************************************************
848  * IEnumMoniker_Vtbl
849  */
850 static const IEnumMonikerVtbl IEnumMoniker_Vtbl =
851 {
852     DEVENUM_IEnumMoniker_QueryInterface,
853     DEVENUM_IEnumMoniker_AddRef,
854     DEVENUM_IEnumMoniker_Release,
855     DEVENUM_IEnumMoniker_Next,
856     DEVENUM_IEnumMoniker_Skip,
857     DEVENUM_IEnumMoniker_Reset,
858     DEVENUM_IEnumMoniker_Clone
859 };
860
861 HRESULT DEVENUM_IEnumMoniker_Construct(HKEY hkey, IEnumMoniker ** ppEnumMoniker)
862 {
863     EnumMonikerImpl * pEnumMoniker = CoTaskMemAlloc(sizeof(EnumMonikerImpl));
864     if (!pEnumMoniker)
865         return E_OUTOFMEMORY;
866
867     pEnumMoniker->lpVtbl = &IEnumMoniker_Vtbl;
868     pEnumMoniker->ref = 1;
869     pEnumMoniker->index = 0;
870     pEnumMoniker->hkey = hkey;
871
872     *ppEnumMoniker = (IEnumMoniker *)pEnumMoniker;
873
874     DEVENUM_LockModule();
875
876     return S_OK;
877 }