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