dlls/devenum/mediacatenum.c

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