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