--- vendor/wine/dlls/dxdiagn/current/container.c 2005-12-14 22:41:16 UTC (rev 20178)
+++ vendor/wine/dlls/dxdiagn/current/container.c 2005-12-14 22:45:50 UTC (rev 20179)
@@ -0,0 +1,321 @@
+/*
+ * IDxDiagContainer Implementation
+ *
+ * Copyright 2004 Raphael Junqueira
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+#include "config.h"
+#include "dxdiag_private.h"
+#include "wine/debug.h"
+#include "wine/unicode.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(dxdiag);
+
+/* IDxDiagContainer IUnknown parts follow: */
+HRESULT WINAPI IDxDiagContainerImpl_QueryInterface(PDXDIAGCONTAINER iface, REFIID riid, LPVOID *ppobj)
+{
+ IDxDiagContainerImpl *This = (IDxDiagContainerImpl *)iface;
+
+ if (IsEqualGUID(riid, &IID_IUnknown)
+ || IsEqualGUID(riid, &IID_IDxDiagContainer)) {
+ IDxDiagContainerImpl_AddRef(iface);
+ *ppobj = This;
+ return S_OK;
+ }
+
+ WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppobj);
+ return E_NOINTERFACE;
+}
+
+ULONG WINAPI IDxDiagContainerImpl_AddRef(PDXDIAGCONTAINER iface) {
+ IDxDiagContainerImpl *This = (IDxDiagContainerImpl *)iface;
+ ULONG refCount = InterlockedIncrement(&This->ref);
+
+ TRACE("(%p)->(ref before=%lu)\n", This, refCount - 1);
+
+ DXDIAGN_LockModule();
+
+ return refCount;
+}
+
+ULONG WINAPI IDxDiagContainerImpl_Release(PDXDIAGCONTAINER iface) {
+ IDxDiagContainerImpl *This = (IDxDiagContainerImpl *)iface;
+ ULONG refCount = InterlockedDecrement(&This->ref);
+
+ TRACE("(%p)->(ref before=%lu)\n", This, refCount + 1);
+
+ if (!refCount) {
+ HeapFree(GetProcessHeap(), 0, This);
+ }
+
+ DXDIAGN_UnlockModule();
+
+ return refCount;
+}
+
+/* IDxDiagContainer Interface follow: */
+HRESULT WINAPI IDxDiagContainerImpl_GetNumberOfChildContainers(PDXDIAGCONTAINER iface, DWORD* pdwCount) {
+ IDxDiagContainerImpl *This = (IDxDiagContainerImpl *)iface;
+ TRACE("(%p)\n", iface);
+ if (NULL == pdwCount) {
+ return E_INVALIDARG;
+ }
+ *pdwCount = This->nSubContainers;
+ return S_OK;
+}
+
+HRESULT WINAPI IDxDiagContainerImpl_EnumChildContainerNames(PDXDIAGCONTAINER iface, DWORD dwIndex, LPWSTR pwszContainer, DWORD cchContainer) {
+ IDxDiagContainerImpl *This = (IDxDiagContainerImpl *)iface;
+ IDxDiagContainerImpl_SubContainer* p = NULL;
+ DWORD i = 0;
+
+ TRACE("(%p, %lu, %s, %lu)\n", iface, dwIndex, debugstr_w(pwszContainer), cchContainer);
+
+ if (NULL == pwszContainer) {
+ return E_INVALIDARG;
+ }
+ if (256 > cchContainer) {
+ return DXDIAG_E_INSUFFICIENT_BUFFER;
+ }
+
+ p = This->subContainers;
+ while (NULL != p) {
+ if (dwIndex == i) {
+ if (cchContainer <= strlenW(p->contName)) {
+ return DXDIAG_E_INSUFFICIENT_BUFFER;
+ }
+ lstrcpynW(pwszContainer, p->contName, cchContainer);
+ return S_OK;
+ }
+ p = p->next;
+ ++i;
+ }
+ return E_INVALIDARG;
+}
+
+HRESULT WINAPI IDxDiagContainerImpl_GetChildContainerInternal(PDXDIAGCONTAINER iface, LPCWSTR pwszContainer, IDxDiagContainer** ppInstance) {
+ IDxDiagContainerImpl *This = (IDxDiagContainerImpl *)iface;
+ IDxDiagContainerImpl_SubContainer* p = NULL;
+
+ p = This->subContainers;
+ while (NULL != p) {
+ if (0 == lstrcmpW(p->contName, pwszContainer)) {
+ *ppInstance = (PDXDIAGCONTAINER)p->pCont;
+ return S_OK;
+ }
+ p = p->next;
+ }
+ return E_INVALIDARG;
+}
+
+HRESULT WINAPI IDxDiagContainerImpl_GetChildContainer(PDXDIAGCONTAINER iface, LPCWSTR pwszContainer, IDxDiagContainer** ppInstance) {
+ IDxDiagContainerImpl *This = (IDxDiagContainerImpl *)iface;
+ IDxDiagContainer* pContainer = NULL;
+ LPWSTR tmp, orig_tmp;
+ INT tmp_len;
+ WCHAR* cur;
+ HRESULT hr = E_INVALIDARG;
+
+ FIXME("(%p, %s, %p)\n", iface, debugstr_w(pwszContainer), ppInstance);
+
+ if (NULL == ppInstance || NULL == pwszContainer) {
+ return E_INVALIDARG;
+ }
+
+ pContainer = (PDXDIAGCONTAINER) This;
+
+ tmp_len = strlenW(pwszContainer) + 1;
+ orig_tmp = tmp = HeapAlloc(GetProcessHeap(), 0, tmp_len * sizeof(WCHAR));
+ if (NULL == tmp) return E_FAIL;
+ lstrcpynW(tmp, pwszContainer, tmp_len);
+
+ cur = strchrW(tmp, '.');
+ while (NULL != cur) {
+ *cur = '\0'; /* cut tmp string to '.' */
+ hr = IDxDiagContainerImpl_GetChildContainerInternal(pContainer, tmp, &pContainer);
+ if (!SUCCEEDED(hr) || NULL == pContainer)
+ goto on_error;
+ *cur++; /* go after '.' (just replaced by \0) */
+ tmp = cur;
+ cur = strchrW(tmp, '.');
+ }
+
+ hr = IDxDiagContainerImpl_GetChildContainerInternal(pContainer, tmp, ppInstance);
+ if (SUCCEEDED(hr)) {
+ IDxDiagContainerImpl_AddRef((PDXDIAGCONTAINER)*ppInstance);
+ }
+
+on_error:
+ HeapFree(GetProcessHeap(), 0, orig_tmp);
+ return hr;
+}
+
+HRESULT WINAPI IDxDiagContainerImpl_GetNumberOfProps(PDXDIAGCONTAINER iface, DWORD* pdwCount) {
+ IDxDiagContainerImpl *This = (IDxDiagContainerImpl *)iface;
+ TRACE("(%p)\n", iface);
+ if (NULL == pdwCount) {
+ return E_INVALIDARG;
+ }
+ *pdwCount = This->nProperties;
+ return S_OK;
+}
+
+HRESULT WINAPI IDxDiagContainerImpl_EnumPropNames(PDXDIAGCONTAINER iface, DWORD dwIndex, LPWSTR pwszPropName, DWORD cchPropName) {
+ IDxDiagContainerImpl *This = (IDxDiagContainerImpl *)iface;
+ IDxDiagContainerImpl_Property* p = NULL;
+ DWORD i = 0;
+
+ FIXME("(%p, %lu, %s, %lu)\n", iface, dwIndex, debugstr_w(pwszPropName), cchPropName);
+
+ if (NULL == pwszPropName) {
+ return E_INVALIDARG;
+ }
+ if (256 > cchPropName) {
+ return DXDIAG_E_INSUFFICIENT_BUFFER;
+ }
+
+ p = This->properties;
+ while (NULL != p) {
+ if (dwIndex == i) {
+ if (cchPropName <= lstrlenW(p->vName)) {
+ return DXDIAG_E_INSUFFICIENT_BUFFER;
+ }
+ lstrcpynW(pwszPropName, p->vName, cchPropName);
+ return S_OK;
+ }
+ p = p->next;
+ ++i;
+ }
+ return E_INVALIDARG;
+}
+
+HRESULT WINAPI IDxDiagContainerImpl_GetProp(PDXDIAGCONTAINER iface, LPCWSTR pwszPropName, VARIANT* pvarProp) {
+ IDxDiagContainerImpl *This = (IDxDiagContainerImpl *)iface;
+ IDxDiagContainerImpl_Property* p = NULL;
+ FIXME("(%p, %s, %p)\n", iface, debugstr_w(pwszPropName), pvarProp);
+
+ if (NULL == pvarProp || NULL == pwszPropName) {
+ return E_INVALIDARG;
+ }
+
+ p = This->properties;
+ while (NULL != p) {
+ if (0 == lstrcmpW(p->vName, pwszPropName)) {
+ VariantCopy(pvarProp, &p->v);
+ return S_OK;
+ }
+ p = p->next;
+ }
+ return S_OK;
+}
+
+HRESULT WINAPI IDxDiagContainerImpl_AddProp(PDXDIAGCONTAINER iface, LPCWSTR pwszPropName, VARIANT* pVarProp) {
+ IDxDiagContainerImpl *This = (IDxDiagContainerImpl *)iface;
+ IDxDiagContainerImpl_Property* p = NULL;
+ IDxDiagContainerImpl_Property* pNew = NULL;
+
+ FIXME("(%p, %s, %p)\n", iface, debugstr_w(pwszPropName), pVarProp);
+
+ if (NULL == pVarProp || NULL == pwszPropName) {
+ return E_INVALIDARG;
+ }
+
+ pNew = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDxDiagContainerImpl_Property));
+ if (NULL == pNew) {
+ return E_OUTOFMEMORY;
+ }
+ VariantInit(&pNew->v);
+ VariantCopy(&pNew->v, pVarProp);
+ pNew->vName = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (lstrlenW(pwszPropName) + 1) * sizeof(WCHAR));
+ lstrcpyW(pNew->vName, pwszPropName);
+ pNew->next = NULL;
+
+ p = This->properties;
+ if (NULL == p) {
+ This->properties = pNew;
+ } else {
+ while (NULL != p->next) {
+ p = p->next;
+ }
+ p->next = pNew;
+ }
+ ++This->nProperties;
+ return S_OK;
+}
+
+HRESULT WINAPI IDxDiagContainerImpl_AddChildContainer(PDXDIAGCONTAINER iface, LPCWSTR pszContName, PDXDIAGCONTAINER pSubCont) {
+ IDxDiagContainerImpl *This = (IDxDiagContainerImpl *)iface;
+ IDxDiagContainerImpl_SubContainer* p = NULL;
+ IDxDiagContainerImpl_SubContainer* pNew = NULL;
+
+ FIXME("(%p, %s, %p)\n", iface, debugstr_w(pszContName), pSubCont);
+
+ if (NULL == pSubCont || NULL == pszContName) {
+ return E_INVALIDARG;
+ }
+
+ pNew = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDxDiagContainerImpl_SubContainer));
+ if (NULL == pNew) {
+ return E_OUTOFMEMORY;
+ }
+ pNew->pCont = pSubCont;
+ pNew->contName = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (lstrlenW(pszContName) + 1) * sizeof(WCHAR));
+ lstrcpyW(pNew->contName, pszContName);
+ pNew->next = NULL;
+
+ p = This->subContainers;
+ if (NULL == p) {
+ This->subContainers = pNew;
+ } else {
+ while (NULL != p->next) {
+ p = p->next;
+ }
+ p->next = pNew;
+ }
+ ++This->nSubContainers;
+ return S_OK;
+}
+
+static const IDxDiagContainerVtbl DxDiagContainer_Vtbl =
+{
+ IDxDiagContainerImpl_QueryInterface,
+ IDxDiagContainerImpl_AddRef,
+ IDxDiagContainerImpl_Release,
+ IDxDiagContainerImpl_GetNumberOfChildContainers,
+ IDxDiagContainerImpl_EnumChildContainerNames,
+ IDxDiagContainerImpl_GetChildContainer,
+ IDxDiagContainerImpl_GetNumberOfProps,
+ IDxDiagContainerImpl_EnumPropNames,
+ IDxDiagContainerImpl_GetProp
+};
+
+
+HRESULT DXDiag_CreateDXDiagContainer(REFIID riid, LPVOID *ppobj) {
+ IDxDiagContainerImpl* container;
+
+ TRACE("(%p, %p)\n", debugstr_guid(riid), ppobj);
+
+ container = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDxDiagContainerImpl));
+ if (NULL == container) {
+ *ppobj = NULL;
+ return E_OUTOFMEMORY;
+ }
+ container->lpVtbl = &DxDiagContainer_Vtbl;
+ container->ref = 0; /* will be inited with QueryInterface */
+ return IDxDiagContainerImpl_QueryInterface((PDXDIAGCONTAINER)container, riid, ppobj);
+}
Property changes on: vendor/wine/dlls/dxdiagn/current/container.c
___________________________________________________________________
Name: svn:keywords
+ Author Date Id Revision
Name: svn:eol-style
+ native
--- vendor/wine/dlls/dxdiagn/current/provider.c 2005-12-14 22:41:16 UTC (rev 20178)
+++ vendor/wine/dlls/dxdiagn/current/provider.c 2005-12-14 22:45:50 UTC (rev 20179)
@@ -0,0 +1,689 @@
+/*
+ * IDxDiagProvider Implementation
+ *
+ * Copyright 2004-2005 Raphael Junqueira
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+#include "config.h"
+#include "wine/debug.h"
+
+#define COBJMACROS
+#include "dxdiag_private.h"
+#include "wine/unicode.h"
+#include "winver.h"
+#include "objidl.h"
+#include "dshow.h"
+#include "strmif.h"
+#include "vfw.h"
+#include "mmddk.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(dxdiag);
+
+/* IDxDiagProvider IUnknown parts follow: */
+HRESULT WINAPI IDxDiagProviderImpl_QueryInterface(PDXDIAGPROVIDER iface, REFIID riid, LPVOID *ppobj)
+{
+ IDxDiagProviderImpl *This = (IDxDiagProviderImpl *)iface;
+
+ if (IsEqualGUID(riid, &IID_IUnknown)
+ || IsEqualGUID(riid, &IID_IDxDiagProvider)) {
+ IDxDiagProviderImpl_AddRef(iface);
+ *ppobj = This;
+ return S_OK;
+ }
+
+ WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppobj);
+ return E_NOINTERFACE;
+}
+
+ULONG WINAPI IDxDiagProviderImpl_AddRef(PDXDIAGPROVIDER iface) {
+ IDxDiagProviderImpl *This = (IDxDiagProviderImpl *)iface;
+ ULONG refCount = InterlockedIncrement(&This->ref);
+
+ TRACE("(%p)->(ref before=%lu)\n", This, refCount - 1);
+
+ DXDIAGN_LockModule();
+
+ return refCount;
+}
+
+ULONG WINAPI IDxDiagProviderImpl_Release(PDXDIAGPROVIDER iface) {
+ IDxDiagProviderImpl *This = (IDxDiagProviderImpl *)iface;
+ ULONG refCount = InterlockedDecrement(&This->ref);
+
+ TRACE("(%p)->(ref before=%lu)\n", This, refCount + 1);
+
+ if (!refCount) {
+ HeapFree(GetProcessHeap(), 0, This);
+ }
+
+ DXDIAGN_UnlockModule();
+
+ return refCount;
+}
+
+/* IDxDiagProvider Interface follow: */
+HRESULT WINAPI IDxDiagProviderImpl_Initialize(PDXDIAGPROVIDER iface, DXDIAG_INIT_PARAMS* pParams) {
+ IDxDiagProviderImpl *This = (IDxDiagProviderImpl *)iface;
+ TRACE("(%p,%p)\n", iface, pParams);
+
+ if (NULL == pParams) {
+ return E_POINTER;
+ }
+ if (pParams->dwSize != sizeof(DXDIAG_INIT_PARAMS)) {
+ return E_INVALIDARG;
+ }
+
+ This->init = TRUE;
+ memcpy(&This->params, pParams, pParams->dwSize);
+ return S_OK;
+}
+
+HRESULT WINAPI IDxDiagProviderImpl_GetRootContainer(PDXDIAGPROVIDER iface, IDxDiagContainer** ppInstance) {
+ HRESULT hr = S_OK;
+ IDxDiagProviderImpl *This = (IDxDiagProviderImpl *)iface;
+ TRACE("(%p,%p)\n", iface, ppInstance);
+
+ if (NULL == ppInstance) {
+ return E_INVALIDARG;
+ }
+ if (FALSE == This->init) {
+ return E_INVALIDARG; /* should be E_CO_UNINITIALIZED */
+ }
+ if (NULL == This->pRootContainer) {
+ hr = DXDiag_CreateDXDiagContainer(&IID_IDxDiagContainer, (void**) &This->pRootContainer);
+ if (FAILED(hr)) {
+ return hr;
+ }
+ hr = DXDiag_InitRootDXDiagContainer((PDXDIAGCONTAINER)This->pRootContainer);
+ }
+ return IDxDiagContainerImpl_QueryInterface((PDXDIAGCONTAINER)This->pRootContainer, &IID_IDxDiagContainer, (void**) ppInstance);
+}
+
+static const IDxDiagProviderVtbl DxDiagProvider_Vtbl =
+{
+ IDxDiagProviderImpl_QueryInterface,
+ IDxDiagProviderImpl_AddRef,
+ IDxDiagProviderImpl_Release,
+ IDxDiagProviderImpl_Initialize,
+ IDxDiagProviderImpl_GetRootContainer
+};
+
+HRESULT DXDiag_CreateDXDiagProvider(LPCLASSFACTORY iface, LPUNKNOWN punkOuter, REFIID riid, LPVOID *ppobj) {
+ IDxDiagProviderImpl* provider;
+
+ TRACE("(%p, %s, %p)\n", punkOuter, debugstr_guid(riid), ppobj);
+
+ provider = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDxDiagProviderImpl));
+ if (NULL == provider) {
+ *ppobj = NULL;
+ return E_OUTOFMEMORY;
+ }
+ provider->lpVtbl = &DxDiagProvider_Vtbl;
+ provider->ref = 0; /* will be inited with QueryInterface */
+ return IDxDiagProviderImpl_QueryInterface ((PDXDIAGPROVIDER)provider, riid, ppobj);
+}
+
+/**
+ * @param szFilePath: usually GetSystemDirectoryW
+ * @param szFileName: name of the dll without path
+ */
+HRESULT DXDiag_AddFileDescContainer(IDxDiagContainer* pSubCont, const WCHAR* szFilePath, const WCHAR* szFileName) {
+ HRESULT hr = S_OK;
+ /**/
+ static const WCHAR szSlashSep[] = {'\\',0};
+ static const WCHAR szPath[] = {'s','z','P','a','t','h',0};
+ static const WCHAR szName[] = {'s','z','N','a','m','e',0};
+ static const WCHAR szVersion[] = {'s','z','V','e','r','s','i','o','n',0};
+ static const WCHAR szAttributes[] = {'s','z','A','t','t','r','i','b','u','t','e','s',0};
+ static const WCHAR szLanguageEnglish[] = {'s','z','L','a','n','g','u','a','g','e','E','n','g','l','i','s','h',0};
+ static const WCHAR dwFileTimeHigh[] = {'d','w','F','i','l','e','T','i','m','e','H','i','g','h',0};
+ static const WCHAR dwFileTimeLow[] = {'d','w','F','i','l','e','T','i','m','e','L','o','w',0};
+ static const WCHAR bBeta[] = {'b','B','e','t','a',0};
+ static const WCHAR bDebug[] = {'b','D','e','b','u','g',0};
+ static const WCHAR bExists[] = {'b','E','x','i','s','t','s',0};
+ /** values */
+ static const WCHAR szFinal_Retail_v[] = {'F','i','n','a','l',' ','R','e','t','a','i','l',0};
+ static const WCHAR szEnglish_v[] = {'E','n','g','l','i','s','h',0};
+ static const WCHAR szVersionFormat[] = {'%','u','.','%','0','2','u','.','%','0','4','u','.','%','0','4','u',0};
+ VARIANT v;
+
+ WCHAR szFile[512];
+ WCHAR szVersion_v[1024];
+ DWORD retval, hdl;
+ LPVOID pVersionInfo;
+ BOOL boolret;
+ UINT uiLength;
+ VS_FIXEDFILEINFO* pFileInfo;
+
+ FIXME("(%p,%s)\n", pSubCont, debugstr_w(szFileName));
+
+ lstrcpyW(szFile, szFilePath);
+ lstrcatW(szFile, szSlashSep);
+ lstrcatW(szFile, szFileName);
+
+ retval = GetFileVersionInfoSizeW(szFile, &hdl);
+ pVersionInfo = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, retval);
+ hr = GetFileVersionInfoW(szFile, 0, retval, pVersionInfo);
+ boolret = VerQueryValueW(pVersionInfo, (LPWSTR) szSlashSep, (LPVOID) &pFileInfo, &uiLength);
+
+ V_VT(&v) = VT_BSTR; V_BSTR(&v) = SysAllocString(szFile);
+ hr = IDxDiagContainerImpl_AddProp(pSubCont, szPath, &v);
+ VariantClear(&v);
+ V_VT(&v) = VT_BSTR; V_BSTR(&v) = SysAllocString(szFileName);
+ hr = IDxDiagContainerImpl_AddProp(pSubCont, szName, &v);
+ VariantClear(&v);
+ V_VT(&v) = VT_BOOL; V_BOOL(&v) = boolret;
+ hr = IDxDiagContainerImpl_AddProp(pSubCont, bExists, &v);
+ VariantClear(&v);
+
+ if (boolret) {
+ snprintfW(szVersion_v, sizeof(szVersion_v),
+ szVersionFormat,
+ HIWORD(pFileInfo->dwFileVersionMS),
+ LOWORD(pFileInfo->dwFileVersionMS),
+ HIWORD(pFileInfo->dwFileVersionLS),
+ LOWORD(pFileInfo->dwFileVersionLS));
+
+ TRACE("Found version as (%s)\n", debugstr_w(szVersion_v));
+
+ V_VT(&v) = VT_BSTR; V_BSTR(&v) = SysAllocString(szVersion_v);
+ hr = IDxDiagContainerImpl_AddProp(pSubCont, szVersion, &v);
+ VariantClear(&v);
+ V_VT(&v) = VT_BSTR; V_BSTR(&v) = SysAllocString(szFinal_Retail_v);
+ hr = IDxDiagContainerImpl_AddProp(pSubCont, szAttributes, &v);
+ VariantClear(&v);
+ V_VT(&v) = VT_BSTR; V_BSTR(&v) = SysAllocString(szEnglish_v);
+ hr = IDxDiagContainerImpl_AddProp(pSubCont, szLanguageEnglish, &v);
+ VariantClear(&v);
+ V_VT(&v) = VT_UI4; V_UI4(&v) = pFileInfo->dwFileDateMS;
+ hr = IDxDiagContainerImpl_AddProp(pSubCont, dwFileTimeHigh, &v);
+ VariantClear(&v);
+ V_VT(&v) = VT_UI4; V_UI4(&v) = pFileInfo->dwFileDateLS;
+ hr = IDxDiagContainerImpl_AddProp(pSubCont, dwFileTimeLow, &v);
+ VariantClear(&v);
+ V_VT(&v) = VT_BOOL; V_BOOL(&v) = (0 != ((pFileInfo->dwFileFlags & pFileInfo->dwFileFlagsMask) & VS_FF_PRERELEASE));
+ hr = IDxDiagContainerImpl_AddProp(pSubCont, bBeta, &v);
+ VariantClear(&v);
+ V_VT(&v) = VT_BOOL; V_BOOL(&v) = (0 != ((pFileInfo->dwFileFlags & pFileInfo->dwFileFlagsMask) & VS_FF_DEBUG));
+ hr = IDxDiagContainerImpl_AddProp(pSubCont, bDebug, &v);
+ VariantClear(&v);
+ }
+
+ HeapFree(GetProcessHeap(), 0, pVersionInfo);
+
+ return hr;
+}
+
+HRESULT DXDiag_InitDXDiagSystemInfoContainer(IDxDiagContainer* pSubCont) {
+ HRESULT hr = S_OK;
+ static const WCHAR dwDirectXVersionMajor[] = {'d','w','D','i','r','e','c','t','X','V','e','r','s','i','o','n','M','a','j','o','r',0};
+ static const WCHAR dwDirectXVersionMinor[] = {'d','w','D','i','r','e','c','t','X','V','e','r','s','i','o','n','M','i','n','o','r',0};
+ static const WCHAR szDirectXVersionLetter[] = {'s','z','D','i','r','e','c','t','X','V','e','r','s','i','o','n','L','e','t','t','e','r',0};
+ static const WCHAR szDirectXVersionLetter_v[] = {'c',0};
+ static const WCHAR bDebug[] = {'b','D','e','b','u','g',0};
+ static const WCHAR szDirectXVersionEnglish[] = {'s','z','D','i','r','e','c','t','X','V','e','r','s','i','o','n','E','n','g','l','i','s','h',0};
+ static const WCHAR szDirectXVersionEnglish_v[] = {'4','.','0','9','.','0','0','0','0','.','0','9','0','4',0};
+ static const WCHAR szDirectXVersionLongEnglish[] = {'s','z','D','i','r','e','c','t','X','V','e','r','s','i','o','n','L','o','n','g','E','n','g','l','i','s','h',0};
+ static const WCHAR szDirectXVersionLongEnglish_v[] = {'=',' ','"','D','i','r','e','c','t','X',' ','9','.','0','c',' ','(','4','.','0','9','.','0','0','0','0','.','0','9','0','4',')',0};
+ /*static const WCHAR szDxDiagVersion[] = {'s','z','D','x','D','i','a','g','V','e','r','s','i','o','n',0};*/
+ /*szWindowsDir*/
+ /*szWindowsDir*/
+ /*"dwOSMajorVersion"*/
+ /*"dwOSMinorVersion"*/
+ /*"dwOSBuildNumber"*/
+ /*"dwOSPlatformID"*/
+ VARIANT v;
+
+ V_VT(&v) = VT_UI4; V_UI4(&v) = 9;
+ hr = IDxDiagContainerImpl_AddProp(pSubCont, dwDirectXVersionMajor, &v);
+ VariantClear(&v);
+ V_VT(&v) = VT_UI4; V_UI4(&v) = 0;
+ hr = IDxDiagContainerImpl_AddProp(pSubCont, dwDirectXVersionMinor, &v);
+ VariantClear(&v);
+ V_VT(&v) = VT_BSTR; V_BSTR(&v) = SysAllocString(szDirectXVersionLetter_v);
+ hr = IDxDiagContainerImpl_AddProp(pSubCont, szDirectXVersionLetter, &v);
+ VariantClear(&v);
+ V_VT(&v) = VT_BSTR; V_BSTR(&v) = SysAllocString(szDirectXVersionEnglish_v);
+ hr = IDxDiagContainerImpl_AddProp(pSubCont, szDirectXVersionEnglish, &v);
+ VariantClear(&v);
+ V_VT(&v) = VT_BSTR; V_BSTR(&v) = SysAllocString(szDirectXVersionLongEnglish_v);
+ hr = IDxDiagContainerImpl_AddProp(pSubCont, szDirectXVersionLongEnglish, &v);
+ VariantClear(&v);
+ V_VT(&v) = VT_BOOL; V_BOOL(&v) = FALSE;
+ hr = IDxDiagContainerImpl_AddProp(pSubCont, bDebug, &v);
+ VariantClear(&v);
+
+ return hr;
+}
+
+HRESULT DXDiag_InitDXDiagSystemDevicesContainer(IDxDiagContainer* pSubCont) {
+ HRESULT hr = S_OK;
+ /*
+ static const WCHAR szDescription[] = {'s','z','D','e','s','c','r','i','p','t','i','o','n',0};
+ static const WCHAR szDeviceID[] = {'s','z','D','e','v','i','c','e','I','D',0};
+
+ static const WCHAR szDrivers[] = {'s','z','D','r','i','v','e','r','s',0};
+
+ VARIANT v;
+ IDxDiagContainer* pDeviceSubCont = NULL;
+ IDxDiagContainer* pDriversCont = NULL;
+
+ hr = DXDiag_CreateDXDiagContainer(&IID_IDxDiagContainer, (void**) &pDeviceSubCont);
+ if (FAILED(hr)) { return hr; }
+ V_VT(pvarProp) = VT_BSTR; V_BSTR(pvarProp) = SysAllocString(property->psz);
+ hr = IDxDiagContainerImpl_AddProp(pDeviceSubCont, szDescription, &v);
+ VariantClear(&v);
+ V_VT(pvarProp) = VT_BSTR; V_BSTR(pvarProp) = SysAllocString(property->psz);
+ hr = IDxDiagContainerImpl_AddProp(pDeviceSubCont, szDeviceID, &v);
+ VariantClear(&v);
+
+ hr = IDxDiagContainerImpl_AddChildContainer(pSubCont, "", pDeviceSubCont);
+ */
+
+ /*
+ * Drivers Cont contains Files Desc Containers
+ */
+ /*
+ hr = DXDiag_CreateDXDiagContainer(&IID_IDxDiagContainer, (void**) &pDriversCont);
+ if (FAILED(hr)) { return hr; }
+ hr = IDxDiagContainerImpl_AddChildContainer(pDeviceSubCont, szDrivers, pDriversCont);
+
+ */
+ return hr;
+}
+
+HRESULT DXDiag_InitDXDiagLogicalDisksContainer(IDxDiagContainer* pSubCont) {
+ HRESULT hr = S_OK;
+ /*
+ static const WCHAR szDriveLetter[] = {'s','z','D','r','i','v','e','L','e','t','t','e','r',0};
+ static const WCHAR szFreeSpace[] = {'s','z','F','r','e','e','S','p','a','c','e',0};
+ static const WCHAR szMaxSpace[] = {'s','z','M','a','x','S','p','a','c','e',0};
+ static const WCHAR szFileSystem[] = {'s','z','F','i','l','e','S','y','s','t','e','m',0};
+ static const WCHAR szModel[] = {'s','z','M','o','d','e','l',0};
+ static const WCHAR szPNPDeviceID[] = {'s','z','P','N','P','D','e','v','i','c','e','I','D',0};
+ static const WCHAR dwHardDriveIndex[] = {'d','w','H','a','r','d','D','r','i','v','e','I','n','d','e','x',0};
+
+ static const WCHAR szDrivers[] = {'s','z','D','r','i','v','e','r','s',0};
+
+ VARIANT v;
+ IDxDiagContainer* pDiskSubCont = NULL;
+ IDxDiagContainer* pDriversCont = NULL;
+
+ hr = DXDiag_CreateDXDiagContainer(&IID_IDxDiagContainer, (void**) &pDiskSubCont);
+ if (FAILED(hr)) { return hr; }
+ hr = IDxDiagContainerImpl_AddChildContainer(pSubCont, "" , pDiskSubCont);
+ */
+
+ /*
+ * Drivers Cont contains Files Desc Containers
+ */
+ /*
+ hr = DXDiag_CreateDXDiagContainer(&IID_IDxDiagContainer, (void**) &pDriversCont);
+ if (FAILED(hr)) { return hr; }
+ hr = IDxDiagContainerImpl_AddChildContainer(pDeviceSubCont, szDrivers, pDriversCont);
+ */
+ return hr;
+}
+HRESULT DXDiag_InitDXDiagDirectXFilesContainer(IDxDiagContainer* pSubCont) {
+ HRESULT hr = S_OK;
+ /**/
+ static const WCHAR ddraw_dll[] = {'d','d','r','a','w','.','d','l','l',0};
+ static const WCHAR dplayx_dll[] = {'d','p','l','a','y','x','.','d','l','l',0};
+ static const WCHAR dpnet_dll[] = {'d','p','n','e','t','.','d','l','l',0};
+ static const WCHAR dinput_dll[] = {'d','i','n','p','u','t','.','d','l','l',0};
+ static const WCHAR dinput8_dll[] = {'d','i','n','p','u','t','8','.','d','l','l',0};
+ static const WCHAR dsound_dll[] = {'d','s','o','u','n','d','.','d','l','l',0};
+ static const WCHAR dswave_dll[] = {'d','s','w','a','v','e','.','d','l','l',0};
[truncated at 1000 lines; 947 more skipped]