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