git.oblomov.eu Git - wine/blob - 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 = (LPVOID)iface;
  60         DEVENUM_IPropertyBag_AddRef(iface);
  61         return S_OK;
  62     }
  63
  64     FIXME("- no interface\n\tIID:\t%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, (LPBYTE)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((LPWSTR)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), (LPWSTR)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((LPWSTR)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 = (LPVOID)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 = (LPVOID)&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 = (LPVOID)iface;
 307         DEVENUM_IMediaCatMoniker_AddRef(iface);
 308         return S_OK;
 309     }
 310
 311     FIXME("- no interface\n\tIID:\t%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 = (IPropertyBag*)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 = (IUnknown*)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 = (LPVOID)iface;
 722         DEVENUM_IEnumMoniker_AddRef(iface);
 723         return S_OK;
 724     }
 725
 726     FIXME("- no interface\n\tIID:\t%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 }