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