complete ICatInformation implementation

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



Changelog:
John K. Hohm <jhohm@acm.org>
complete ICatInformation implementation
Index: dlls/comcat/Makefile.in
===================================================================
RCS file: /home/wine/wine/dlls/comcat/Makefile.in,v
retrieving revision 1.3
diff -u -r1.3 Makefile.in
--- dlls/comcat/Makefile.in	29 May 2002 19:25:50 -0000	1.3
+++ dlls/comcat/Makefile.in	1 Jun 2002 21:38:20 -0000
@@ -4,7 +4,7 @@
 VPATH     = @srcdir@
 MODULE    = comcat.dll
 IMPORTS   = ole32 user32 advapi32 kernel32
-EXTRALIBS = $(LIBUUID)
+EXTRALIBS = $(LIBUNICODE) $(LIBUUID)
 
 LDDLLFLAGS = @LDDLLFLAGS@
 SYMBOLFILE = $(MODULE).tmp.o
Index: dlls/comcat/comcat.h
===================================================================
RCS file: /home/wine/wine/dlls/comcat/comcat.h,v
retrieving revision 1.3
diff -u -r1.3 comcat.h
--- dlls/comcat/comcat.h	29 May 2002 19:25:50 -0000	1.3
+++ dlls/comcat/comcat.h	1 Jun 2002 21:38:20 -0000
@@ -27,6 +27,7 @@
 #include "wine/obj_base.h"
 #include "wine/obj_enumguid.h"
 #include "wine/obj_comcat.h"
+#include "wine/unicode.h"
 
 /**********************************************************************
  * Dll lifetime tracking declaration for comcat.dll
Index: dlls/comcat/information.c
===================================================================
RCS file: /home/wine/wine/dlls/comcat/information.c,v
retrieving revision 1.3
diff -u -r1.3 information.c
--- dlls/comcat/information.c	29 May 2002 19:25:50 -0000	1.3
+++ dlls/comcat/information.c	1 Jun 2002 21:38:20 -0000
@@ -30,6 +30,20 @@
 static HRESULT COMCAT_GetCategoryDesc(HKEY key, LCID lcid, PWCHAR pszDesc,
 				      ULONG buf_wchars);
 
+struct class_categories {
+    LPCWSTR impl_strings;
+    LPCWSTR req_strings;
+};
+
+static struct class_categories *COMCAT_PrepareClassCategories(
+    ULONG impl_count, CATID *impl_catids, ULONG req_count, CATID *req_catids);
+static HRESULT COMCAT_IsClassOfCategories(
+    HKEY key, struct class_categories const* class_categories);
+static LPENUMGUID COMCAT_CLSID_IEnumGUID_Construct(
+    struct class_categories const* class_categories);
+static LPENUMGUID COMCAT_CATID_IEnumGUID_Construct(
+    REFCLSID rclsid, LPCWSTR impl_req);
+
 /**********************************************************************
  * COMCAT_ICatInformation_QueryInterface
  */
@@ -146,9 +160,24 @@
     LPENUMCLSID *ppenumCLSID)
 {
 /*     ICOM_THIS_MULTI(ComCatMgrImpl, infVtbl, iface); */
-    FIXME("(): stub\n");
+    struct class_categories *categories;
+
+    TRACE("\n");
 
-    return E_NOTIMPL;
+    if (iface == NULL || ppenumCLSID == NULL ||
+	(cImplemented && rgcatidImpl == NULL) ||
+	(cRequired && rgcatidReq == NULL)) return E_POINTER;
+
+    categories = COMCAT_PrepareClassCategories(cImplemented, rgcatidImpl,
+					       cRequired, rgcatidReq);
+    if (categories == NULL) return E_OUTOFMEMORY;
+    *ppenumCLSID = COMCAT_CLSID_IEnumGUID_Construct(categories);
+    if (*ppenumCLSID == NULL) {
+	HeapFree(GetProcessHeap(), 0, categories);
+	return E_OUTOFMEMORY;
+    }
+    IEnumGUID_AddRef(*ppenumCLSID);
+    return S_OK;
 }
 
 /**********************************************************************
@@ -163,9 +192,40 @@
     CATID *rgcatidReq)
 {
 /*     ICOM_THIS_MULTI(ComCatMgrImpl, infVtbl, iface); */
-    FIXME("(): stub\n");
+    WCHAR keyname[45] = { 'C', 'L', 'S', 'I', 'D', '\\', 0 };
+    HRESULT res;
+    struct class_categories *categories;
+    HKEY key;
+
+    if (WINE_TRACE_ON(ole)) {
+	ULONG count;
+	TRACE("\n\tCLSID:\t%s\n\tImplemented %lu\n",debugstr_guid(rclsid),cImplemented);
+	for (count = 0; count < cImplemented; ++count)
+	    DPRINTF("\t\t%s\n",debugstr_guid(&rgcatidImpl[count]));
+	DPRINTF("\tRequired %lu\n",cRequired);
+	for (count = 0; count < cRequired; ++count)
+	    DPRINTF("\t\t%s\n",debugstr_guid(&rgcatidReq[count]));
+    }
+
+    if ((cImplemented && rgcatidImpl == NULL) ||
+	(cRequired && rgcatidReq == NULL)) return E_POINTER;
+
+    res = StringFromGUID2(rclsid, keyname + 6, 39);
+    if (FAILED(res)) return res;
+
+    categories = COMCAT_PrepareClassCategories(cImplemented, rgcatidImpl,
+					       cRequired, rgcatidReq);
+    if (categories == NULL) return E_OUTOFMEMORY;
+
+    res = RegOpenKeyExW(HKEY_CLASSES_ROOT, keyname, 0, KEY_READ, &key);
+    if (res == ERROR_SUCCESS) {
+	res = COMCAT_IsClassOfCategories(key, categories);
+	RegCloseKey(key);
+    } else res = S_FALSE;
+
+    HeapFree(GetProcessHeap(), 0, categories);
 
-    return E_NOTIMPL;
+    return res;
 }
 
 /**********************************************************************
@@ -177,9 +237,18 @@
     LPENUMCATID *ppenumCATID)
 {
 /*     ICOM_THIS_MULTI(ComCatMgrImpl, infVtbl, iface); */
-    FIXME("(): stub\n");
+    WCHAR postfix[24] = { '\\', 'I', 'm', 'p', 'l', 'e', 'm', 'e',
+			  'n', 't', 'e', 'd', ' ', 'C', 'a', 't',
+			  'e', 'g', 'o', 'r', 'i', 'e', 's', 0 };
 
-    return E_NOTIMPL;
+    TRACE("\n\tCLSID:\t%s\n",debugstr_guid(rclsid));
+
+    if (iface == NULL || rclsid == NULL || ppenumCATID == NULL)
+	return E_POINTER;
+
+    *ppenumCATID = COMCAT_CATID_IEnumGUID_Construct(rclsid, postfix);
+    if (*ppenumCATID == NULL) return E_OUTOFMEMORY;
+    return S_OK;
 }
 
 /**********************************************************************
@@ -191,9 +260,18 @@
     LPENUMCATID *ppenumCATID)
 {
 /*     ICOM_THIS_MULTI(ComCatMgrImpl, infVtbl, iface); */
-    FIXME("(): stub\n");
+    WCHAR postfix[21] = { '\\', 'R', 'e', 'q', 'u', 'i', 'r', 'e',
+			  'd', ' ', 'C', 'a', 't', 'e', 'g', 'o',
+			  'r', 'i', 'e', 's', 0 };
+
+    TRACE("\n\tCLSID:\t%s\n",debugstr_guid(rclsid));
+
+    if (iface == NULL || rclsid == NULL || ppenumCATID == NULL)
+	return E_POINTER;
 
-    return E_NOTIMPL;
+    *ppenumCATID = COMCAT_CATID_IEnumGUID_Construct(rclsid, postfix);
+    if (*ppenumCATID == NULL) return E_OUTOFMEMORY;
+    return S_OK;
 }
 
 /**********************************************************************
@@ -322,28 +400,54 @@
     LPENUMCATEGORYINFO iface,
     ULONG celt)
 {
-/*     ICOM_THIS(IEnumCATEGORYINFOImpl, iface); */
-    FIXME("(): stub\n");
+    ICOM_THIS(IEnumCATEGORYINFOImpl, iface);
 
-    return E_NOTIMPL;
+    TRACE("\n");
+
+    if (This == NULL) return E_POINTER;
+    This->next_index += celt;
+    /* This should return S_FALSE when there aren't celt elems to skip. */
+    return S_OK;
 }
 
 static HRESULT WINAPI COMCAT_IEnumCATEGORYINFO_Reset(LPENUMCATEGORYINFO iface)
 {
-/*     ICOM_THIS(IEnumCATEGORYINFOImpl, iface); */
-    FIXME("(): stub\n");
+    ICOM_THIS(IEnumCATEGORYINFOImpl, iface);
 
-    return E_NOTIMPL;
+    TRACE("\n");
+
+    if (This == NULL) return E_POINTER;
+    This->next_index = 0;
+    return S_OK;
 }
 
 static HRESULT WINAPI COMCAT_IEnumCATEGORYINFO_Clone(
     LPENUMCATEGORYINFO iface,
     IEnumCATEGORYINFO **ppenum)
 {
-/*     ICOM_THIS(IEnumCATEGORYINFOImpl, iface); */
-    FIXME("(): stub\n");
+    ICOM_THIS(IEnumCATEGORYINFOImpl, iface);
+    WCHAR keyname[21] = { 'C', 'o', 'm', 'p', 'o', 'n', 'e', 'n',
+			  't', ' ', 'C', 'a', 't', 'e', 'g', 'o',
+			  'r', 'i', 'e', 's', 0 };
+    IEnumCATEGORYINFOImpl *new_this;
+
+    TRACE("\n");
+
+    if (This == NULL || ppenum == NULL) return E_POINTER;
+
+    new_this = (IEnumCATEGORYINFOImpl *) HeapAlloc(
+	GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IEnumCATEGORYINFOImpl));
+    if (new_this == NULL) return E_OUTOFMEMORY;
+
+    ICOM_VTBL(new_this) = ICOM_VTBL(This);
+    new_this->ref = 1;
+    new_this->lcid = This->lcid;
+    /* FIXME: could we more efficiently use DuplicateHandle? */
+    RegOpenKeyExW(HKEY_CLASSES_ROOT, keyname, 0, KEY_READ, &new_this->key);
+    new_this->next_index = This->next_index;
 
-    return E_NOTIMPL;
+    *ppenum = (LPENUMCATEGORYINFO)new_this;
+    return S_OK;
 }
 
 ICOM_VTABLE(IEnumCATEGORYINFO) COMCAT_IEnumCATEGORYINFO_Vtbl =
@@ -392,8 +496,470 @@
     /* FIXME: lcid comparisons are more complex than this! */
     wsprintfW(valname, fmt, lcid);
     res = RegQueryValueExW(key, valname, 0, &type, (LPBYTE)pszDesc, &size);
-    if (res != ERROR_SUCCESS || type != REG_SZ) return CAT_E_NODESCRIPTION;
+    if (res != ERROR_SUCCESS || type != REG_SZ) {
+	FIXME("Simplified lcid comparison\n");
+	return CAT_E_NODESCRIPTION;
+    }
     pszDesc[size / sizeof(WCHAR)] = (WCHAR)0;
 
     return S_OK;
+}
+
+/**********************************************************************
+ * COMCAT_PrepareClassCategories
+ */
+static struct class_categories *COMCAT_PrepareClassCategories(
+    ULONG impl_count, CATID *impl_catids, ULONG req_count, CATID *req_catids)
+{
+    struct class_categories *categories;
+    WCHAR *strings;
+
+    categories = (struct class_categories *)HeapAlloc(
+	GetProcessHeap(), HEAP_ZERO_MEMORY,
+	sizeof(struct class_categories) +
+	((impl_count + req_count) * 39 + 2) * sizeof(WCHAR));
+    if (categories == NULL) return categories;
+
+    strings = (WCHAR *)(categories + 1);
+    categories->impl_strings = strings;
+    while (impl_count--) {
+	StringFromGUID2(impl_catids++, strings, 39);
+	strings += 39;
+    }
+    *strings++ = 0;
+
+    categories->req_strings = strings;
+    while (req_count--) {
+	StringFromGUID2(req_catids++, strings, 39);
+	strings += 39;
+    }
+    *strings++ = 0;
+
+    return categories;
+}
+
+/**********************************************************************
+ * COMCAT_IsClassOfCategories
+ */
+static HRESULT COMCAT_IsClassOfCategories(
+    HKEY key,
+    struct class_categories const* categories)
+{
+    WCHAR impl_keyname[23] = { 'I', 'm', 'p', 'l', 'e', 'm', 'e', 'n',
+			       't', 'e', 'd', ' ', 'C', 'a', 't', 'e',
+			       'g', 'o', 'r', 'i', 'e', 's', 0 };
+    WCHAR req_keyname[20] = { 'R', 'e', 'q', 'u', 'i', 'r', 'e', 'd', 
+			      ' ', 'C', 'a', 't', 'e', 'g', 'o', 'r',
+			      'i', 'e', 's', 0 };
+    HKEY subkey;
+    HRESULT res;
+    DWORD index;
+    LPCWSTR string;
+
+    /* Check that every given category is implemented by class. */
+    res = RegOpenKeyExW(key, impl_keyname, 0, KEY_READ, &subkey);
+    if (res != ERROR_SUCCESS) return S_FALSE;
+    for (string = categories->impl_strings; *string; string += 39) {
+	HKEY catkey;
+	res = RegOpenKeyExW(subkey, string, 0, 0, &catkey);
+	if (res != ERROR_SUCCESS) {
+	    RegCloseKey(subkey);
+	    return S_FALSE;
+	}
+	RegCloseKey(catkey);
+    }
+    RegCloseKey(subkey);
+
+    /* Check that all categories required by class are given. */
+    res = RegOpenKeyExW(key, req_keyname, 0, KEY_READ, &subkey);
+    if (res == ERROR_SUCCESS) {
+	for (index = 0; ; ++index) {
+	    WCHAR keyname[39];
+	    DWORD size = 39;
+
+	    res = RegEnumKeyExW(subkey, index, keyname, &size,
+				NULL, NULL, NULL, NULL);
+	    if (res != ERROR_SUCCESS && res != ERROR_MORE_DATA) break;
+	    if (size != 38) continue; /* bogus catid in registry */
+	    for (string = categories->req_strings; *string; string += 39)
+		if (!strcmpiW(string, keyname)) break;
+	    if (!*string) {
+		RegCloseKey(subkey);
+		return S_FALSE;
+	    }
+	}
+	RegCloseKey(subkey);
+    }
+
+    return S_OK;
+}
+
+/**********************************************************************
+ * ClassesOfCategories IEnumCLSID (IEnumGUID) implementation
+ *
+ * This implementation is not thread-safe.  The manager itself is, but
+ * I can't imagine a valid use of an enumerator in several threads.
+ */
+typedef struct
+{
+    ICOM_VFIELD(IEnumGUID);
+    DWORD ref;
+    struct class_categories const *categories;
+    HKEY  key;
+    DWORD next_index;
+} CLSID_IEnumGUIDImpl;
+
+static ULONG WINAPI COMCAT_CLSID_IEnumGUID_AddRef(LPENUMGUID iface)
+{
+    ICOM_THIS(CLSID_IEnumGUIDImpl, iface);
+    TRACE("\n");
+
+    if (This == NULL) return E_POINTER;
+
+    return ++(This->ref);
+}
+
+static HRESULT WINAPI COMCAT_CLSID_IEnumGUID_QueryInterface(
+    LPENUMGUID iface,
+    REFIID riid,
+    LPVOID *ppvObj)
+{
+    ICOM_THIS(CLSID_IEnumGUIDImpl, iface);
+    TRACE("\n\tIID:\t%s\n",debugstr_guid(riid));
+
+    if (This == NULL || ppvObj == NULL) return E_POINTER;
+
+    if (IsEqualGUID(riid, &IID_IUnknown) ||
+	IsEqualGUID(riid, &IID_IEnumGUID))
+    {
+	*ppvObj = (LPVOID)iface;
+	COMCAT_CLSID_IEnumGUID_AddRef(iface);
+	return S_OK;
+    }
+
+    return E_NOINTERFACE;
+}
+
+static ULONG WINAPI COMCAT_CLSID_IEnumGUID_Release(LPENUMGUID iface)
+{
+    ICOM_THIS(CLSID_IEnumGUIDImpl, iface);
+    TRACE("\n");
+
+    if (This == NULL) return E_POINTER;
+
+    if (--(This->ref) == 0) {
+	if (This->key) RegCloseKey(This->key);
+	HeapFree(GetProcessHeap(), 0, (LPVOID)This->categories);
+	HeapFree(GetProcessHeap(), 0, This);
+	return 0;
+    }
+    return This->ref;
+}
+
+static HRESULT WINAPI COMCAT_CLSID_IEnumGUID_Next(
+    LPENUMGUID iface,
+    ULONG celt,
+    GUID *rgelt,
+    ULONG *pceltFetched)
+{
+    ICOM_THIS(CLSID_IEnumGUIDImpl, iface);
+    ULONG fetched = 0;
+
+    TRACE("\n");
+
+    if (This == NULL || rgelt == NULL) return E_POINTER;
+
+    if (This->key) while (fetched < celt) {
+	HRESULT res;
+	WCHAR clsid[39];
+	DWORD cName = 39;
+	HKEY subkey;
+
+	res = RegEnumKeyExW(This->key, This->next_index, clsid, &cName,
+			    NULL, NULL, NULL, NULL);
+	if (res != ERROR_SUCCESS && res != ERROR_MORE_DATA) break;
+	++(This->next_index);
+
+	res = CLSIDFromString(clsid, rgelt);
+	if (FAILED(res)) continue;
+
+	res = RegOpenKeyExW(This->key, clsid, 0, KEY_READ, &subkey);
+	if (res != ERROR_SUCCESS) continue;
+
+	res = COMCAT_IsClassOfCategories(subkey, This->categories);
+	RegCloseKey(subkey);
+	if (res != S_OK) continue;
+
+	++fetched;
+	++rgelt;
+    }
+
+    if (pceltFetched) *pceltFetched = fetched;
+    return fetched == celt ? S_OK : S_FALSE;
+}
+
+static HRESULT WINAPI COMCAT_CLSID_IEnumGUID_Skip(
+    LPENUMGUID iface,
+    ULONG celt)
+{
+    ICOM_THIS(CLSID_IEnumGUIDImpl, iface);
+
+    TRACE("\n");
+
+    if (This == NULL) return E_POINTER;
+    This->next_index += celt;
+    FIXME("Never returns S_FALSE\n");
+    return S_OK;
+}
+
+static HRESULT WINAPI COMCAT_CLSID_IEnumGUID_Reset(LPENUMGUID iface)
+{
+    ICOM_THIS(CLSID_IEnumGUIDImpl, iface);
+
+    TRACE("\n");
+
+    if (This == NULL) return E_POINTER;
+    This->next_index = 0;
+    return S_OK;
+}
+
+static HRESULT WINAPI COMCAT_CLSID_IEnumGUID_Clone(
+    LPENUMGUID iface,
+    IEnumGUID **ppenum)
+{
+    ICOM_THIS(CLSID_IEnumGUIDImpl, iface);
+    WCHAR keyname[6] = { 'C', 'L', 'S', 'I', 'D', 0 };
+    CLSID_IEnumGUIDImpl *new_this;
+    DWORD size;
+
+    TRACE("\n");
+
+    if (This == NULL || ppenum == NULL) return E_POINTER;
+
+    new_this = (CLSID_IEnumGUIDImpl *) HeapAlloc(
+	GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(CLSID_IEnumGUIDImpl));
+    if (new_this == NULL) return E_OUTOFMEMORY;
+
+    ICOM_VTBL(new_this) = ICOM_VTBL(This);
+    new_this->ref = 1;
+    size = HeapSize(GetProcessHeap(), 0, (LPVOID)This->categories);
+    new_this->categories = (struct class_categories *)
+	HeapAlloc(GetProcessHeap(), 0, size);
+    if (new_this->categories == NULL) {
+	HeapFree(GetProcessHeap(), 0, new_this);
+	return E_OUTOFMEMORY;
+    }
+    memcpy((LPVOID)new_this->categories, This->categories, size);
+    /* FIXME: could we more efficiently use DuplicateHandle? */
+    RegOpenKeyExW(HKEY_CLASSES_ROOT, keyname, 0, KEY_READ, &new_this->key);
+    new_this->next_index = This->next_index;
+
+    *ppenum = (LPENUMGUID)new_this;
+    return S_OK;
+}
+
+ICOM_VTABLE(IEnumGUID) COMCAT_CLSID_IEnumGUID_Vtbl =
+{
+    ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
+    COMCAT_CLSID_IEnumGUID_QueryInterface,
+    COMCAT_CLSID_IEnumGUID_AddRef,
+    COMCAT_CLSID_IEnumGUID_Release,
+    COMCAT_CLSID_IEnumGUID_Next,
+    COMCAT_CLSID_IEnumGUID_Skip,
+    COMCAT_CLSID_IEnumGUID_Reset,
+    COMCAT_CLSID_IEnumGUID_Clone
+};
+
+static LPENUMGUID COMCAT_CLSID_IEnumGUID_Construct(
+    struct class_categories const* categories)
+{
+    CLSID_IEnumGUIDImpl *This;
+
+    This = (CLSID_IEnumGUIDImpl *) HeapAlloc(
+	GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(CLSID_IEnumGUIDImpl));
+    if (This) {
+	WCHAR keyname[6] = { 'C', 'L', 'S', 'I', 'D', 0 };
+
+	ICOM_VTBL(This) = &COMCAT_CLSID_IEnumGUID_Vtbl;
+	This->categories = categories;
+	RegOpenKeyExW(HKEY_CLASSES_ROOT, keyname, 0, KEY_READ, &This->key);
+    }
+    return (LPENUMGUID)This;
+}
+
+/**********************************************************************
+ * CategoriesOfClass IEnumCATID (IEnumGUID) implementation
+ *
+ * This implementation is not thread-safe.  The manager itself is, but
+ * I can't imagine a valid use of an enumerator in several threads.
+ */
+typedef struct
+{
+    ICOM_VFIELD(IEnumGUID);
+    DWORD ref;
+    WCHAR keyname[68];
+    HKEY  key;
+    DWORD next_index;
+} CATID_IEnumGUIDImpl;
+
+static ULONG WINAPI COMCAT_CATID_IEnumGUID_AddRef(LPENUMGUID iface)
+{
+    ICOM_THIS(CATID_IEnumGUIDImpl, iface);
+    TRACE("\n");
+
+    if (This == NULL) return E_POINTER;
+
+    return ++(This->ref);
+}
+
+static HRESULT WINAPI COMCAT_CATID_IEnumGUID_QueryInterface(
+    LPENUMGUID iface,
+    REFIID riid,
+    LPVOID *ppvObj)
+{
+    ICOM_THIS(CATID_IEnumGUIDImpl, iface);
+    TRACE("\n\tIID:\t%s\n",debugstr_guid(riid));
+
+    if (This == NULL || ppvObj == NULL) return E_POINTER;
+
+    if (IsEqualGUID(riid, &IID_IUnknown) ||
+	IsEqualGUID(riid, &IID_IEnumGUID))
+    {
+	*ppvObj = (LPVOID)iface;
+	COMCAT_CATID_IEnumGUID_AddRef(iface);
+	return S_OK;
+    }
+
+    return E_NOINTERFACE;
+}
+
+static ULONG WINAPI COMCAT_CATID_IEnumGUID_Release(LPENUMGUID iface)
+{
+    ICOM_THIS(CATID_IEnumGUIDImpl, iface);
+    TRACE("\n");
+
+    if (This == NULL) return E_POINTER;
+
+    if (--(This->ref) == 0) {
+	if (This->key) RegCloseKey(This->key);
+	HeapFree(GetProcessHeap(), 0, This);
+	return 0;
+    }
+    return This->ref;
+}
+
+static HRESULT WINAPI COMCAT_CATID_IEnumGUID_Next(
+    LPENUMGUID iface,
+    ULONG celt,
+    GUID *rgelt,
+    ULONG *pceltFetched)
+{
+    ICOM_THIS(CATID_IEnumGUIDImpl, iface);
+    ULONG fetched = 0;
+
+    TRACE("\n");
+
+    if (This == NULL || rgelt == NULL) return E_POINTER;
+
+    if (This->key) while (fetched < celt) {
+	HRESULT res;
+	WCHAR catid[39];
+	DWORD cName = 39;
+
+	res = RegEnumKeyExW(This->key, This->next_index, catid, &cName,
+			    NULL, NULL, NULL, NULL);
+	if (res != ERROR_SUCCESS && res != ERROR_MORE_DATA) break;
+	++(This->next_index);
+
+	res = CLSIDFromString(catid, rgelt);
+	if (FAILED(res)) continue;
+
+	++fetched;
+	++rgelt;
+    }
+
+    if (pceltFetched) *pceltFetched = fetched;
+    return fetched == celt ? S_OK : S_FALSE;
+}
+
+static HRESULT WINAPI COMCAT_CATID_IEnumGUID_Skip(
+    LPENUMGUID iface,
+    ULONG celt)
+{
+    ICOM_THIS(CATID_IEnumGUIDImpl, iface);
+
+    TRACE("\n");
+
+    if (This == NULL) return E_POINTER;
+    This->next_index += celt;
+    FIXME("Never returns S_FALSE\n");
+    return S_OK;
+}
+
+static HRESULT WINAPI COMCAT_CATID_IEnumGUID_Reset(LPENUMGUID iface)
+{
+    ICOM_THIS(CATID_IEnumGUIDImpl, iface);
+
+    TRACE("\n");
+
+    if (This == NULL) return E_POINTER;
+    This->next_index = 0;
+    return S_OK;
+}
+
+static HRESULT WINAPI COMCAT_CATID_IEnumGUID_Clone(
+    LPENUMGUID iface,
+    IEnumGUID **ppenum)
+{
+    ICOM_THIS(CATID_IEnumGUIDImpl, iface);
+    CATID_IEnumGUIDImpl *new_this;
+
+    TRACE("\n");
+
+    if (This == NULL || ppenum == NULL) return E_POINTER;
+
+    new_this = (CATID_IEnumGUIDImpl *) HeapAlloc(
+	GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(CATID_IEnumGUIDImpl));
+    if (new_this == NULL) return E_OUTOFMEMORY;
+
+    ICOM_VTBL(new_this) = ICOM_VTBL(This);
+    new_this->ref = 1;
+    lstrcpyW(new_this->keyname, This->keyname);
+    /* FIXME: could we more efficiently use DuplicateHandle? */
+    RegOpenKeyExW(HKEY_CLASSES_ROOT, new_this->keyname, 0, KEY_READ, &new_this->key);
+    new_this->next_index = This->next_index;
+
+    *ppenum = (LPENUMGUID)new_this;
+    return S_OK;
+}
+
+ICOM_VTABLE(IEnumGUID) COMCAT_CATID_IEnumGUID_Vtbl =
+{
+    ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
+    COMCAT_CATID_IEnumGUID_QueryInterface,
+    COMCAT_CATID_IEnumGUID_AddRef,
+    COMCAT_CATID_IEnumGUID_Release,
+    COMCAT_CATID_IEnumGUID_Next,
+    COMCAT_CATID_IEnumGUID_Skip,
+    COMCAT_CATID_IEnumGUID_Reset,
+    COMCAT_CATID_IEnumGUID_Clone
+};
+
+static LPENUMGUID COMCAT_CATID_IEnumGUID_Construct(
+    REFCLSID rclsid, LPCWSTR postfix)
+{
+    CATID_IEnumGUIDImpl *This;
+
+    This = (CATID_IEnumGUIDImpl *) HeapAlloc(
+	GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(CATID_IEnumGUIDImpl));
+    if (This) {
+	WCHAR prefix[6] = { 'C', 'L', 'S', 'I', 'D', '\\' };
+
+	ICOM_VTBL(This) = &COMCAT_CATID_IEnumGUID_Vtbl;
+	memcpy(This->keyname, prefix, sizeof prefix);
+	StringFromGUID2(rclsid, This->keyname + 6, 39);
+	lstrcpyW(This->keyname + 44, postfix);
+	RegOpenKeyExW(HKEY_CLASSES_ROOT, This->keyname, 0, KEY_READ, &This->key);
+    }
+    return (LPENUMGUID)This;
 }

[Index of Archives]     [Gimp for Windows]     [Red Hat]     [Samba]     [Yosemite Camping]     [Graphics Cards]     [Wine Home]

  Powered by Linux