[ros-diffs] [gvg] 20179: dxdiagn vendor drop
gvg at svn.reactos.com
gvg at svn.reactos.com
Wed Dec 14 23:46:12 CET 2005
dxdiagn vendor drop
Added: vendor/wine/dlls/dxdiagn/
Added: vendor/wine/dlls/dxdiagn/current/
Added: vendor/wine/dlls/dxdiagn/current/Makefile.in
Added: vendor/wine/dlls/dxdiagn/current/container.c
Added: vendor/wine/dlls/dxdiagn/current/dxdiag_main.c
Added: vendor/wine/dlls/dxdiagn/current/dxdiag_private.h
Added: vendor/wine/dlls/dxdiagn/current/dxdiagn.spec
Added: vendor/wine/dlls/dxdiagn/current/provider.c
Added: vendor/wine/dlls/dxdiagn/current/regsvr.c
Added: vendor/wine/dlls/dxdiagn/current/version.rc
_____
Added: vendor/wine/dlls/dxdiagn/current/Makefile.in
--- vendor/wine/dlls/dxdiagn/current/Makefile.in 2005-12-14
22:41:16 UTC (rev 20178)
+++ vendor/wine/dlls/dxdiagn/current/Makefile.in 2005-12-14
22:45:50 UTC (rev 20179)
@@ -0,0 +1,19 @@
+TOPSRCDIR = @top_srcdir@
+TOPOBJDIR = ../..
+SRCDIR = @srcdir@
+VPATH = @srcdir@
+MODULE = dxdiagn.dll
+IMPORTS = version ole32 oleaut32 user32 advapi32 kernel32
+EXTRALIBS = -lstrmiids -ldxguid -luuid $(LIBUNICODE)
+
+C_SRCS = \
+ container.c \
+ dxdiag_main.c \
+ provider.c \
+ regsvr.c
+
+RC_SRCS = version.rc
+
+ at MAKE_DLL_RULES@
+
+### Dependencies:
Property changes on: vendor/wine/dlls/dxdiagn/current/Makefile.in
___________________________________________________________________
Name: svn:keywords
+ Author Date Id Revision
Name: svn:eol-style
+ native
_____
Added: vendor/wine/dlls/dxdiagn/current/container.c
--- 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
_____
Added: vendor/wine/dlls/dxdiagn/current/dxdiag_main.c
--- vendor/wine/dlls/dxdiagn/current/dxdiag_main.c 2005-12-14
22:41:16 UTC (rev 20178)
+++ vendor/wine/dlls/dxdiagn/current/dxdiag_main.c 2005-12-14
22:45:50 UTC (rev 20179)
@@ -0,0 +1,127 @@
+/*
+ * DXDiag
+ *
+ * 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"
+
+WINE_DEFAULT_DEBUG_CHANNEL(dxdiag);
+
+LONG DXDIAGN_refCount = 0;
+
+/* At process attach */
+BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID
lpvReserved)
+{
+ TRACE("%p,%lx,%p\n", hInstDLL, fdwReason, lpvReserved);
+ if (fdwReason == DLL_PROCESS_ATTACH) {
+ DisableThreadLibraryCalls(hInstDLL);
+ }
+ return TRUE;
+}
+
+/**********************************************************************
*********
+ * DXDiag ClassFactory
+ */
+typedef struct {
+ const IClassFactoryVtbl *lpVtbl;
+ REFCLSID rclsid;
+ HRESULT (*pfnCreateInstanceFactory)(LPCLASSFACTORY iface, LPUNKNOWN
punkOuter, REFIID riid, LPVOID *ppobj);
+} IClassFactoryImpl;
+
+static HRESULT WINAPI DXDiagCF_QueryInterface(LPCLASSFACTORY
iface,REFIID riid,LPVOID *ppobj) {
+ FIXME("- no interface\n\tIID:\t%s\n", debugstr_guid(riid));
+
+ if (ppobj == NULL) return E_POINTER;
+
+ return E_NOINTERFACE;
+}
+
+static ULONG WINAPI DXDiagCF_AddRef(LPCLASSFACTORY iface) {
+ DXDIAGN_LockModule();
+
+ return 2; /* non-heap based object */
+}
+
+static ULONG WINAPI DXDiagCF_Release(LPCLASSFACTORY iface) {
+ DXDIAGN_UnlockModule();
+
+ return 1; /* non-heap based object */
+}
+
+static HRESULT WINAPI DXDiagCF_CreateInstance(LPCLASSFACTORY
iface,LPUNKNOWN pOuter,REFIID riid,LPVOID *ppobj) {
+ IClassFactoryImpl *This = (IClassFactoryImpl *)iface;
+ TRACE("(%p)->(%p,%s,%p)\n",This,pOuter,debugstr_guid(riid),ppobj);
+
+ return This->pfnCreateInstanceFactory(iface, pOuter, riid, ppobj);
+}
+
+static HRESULT WINAPI DXDiagCF_LockServer(LPCLASSFACTORY iface,BOOL
dolock) {
+ TRACE("(%d)\n", dolock);
+
+ if (dolock)
+ DXDIAGN_LockModule();
+ else
+ DXDIAGN_UnlockModule();
+
+ return S_OK;
+}
+
+static const IClassFactoryVtbl DXDiagCF_Vtbl = {
+ DXDiagCF_QueryInterface,
+ DXDiagCF_AddRef,
+ DXDiagCF_Release,
+ DXDiagCF_CreateInstance,
+ DXDiagCF_LockServer
+};
+
+static IClassFactoryImpl DXDiag_CFS[] = {
+ { &DXDiagCF_Vtbl, &CLSID_DxDiagProvider, DXDiag_CreateDXDiagProvider
},
+ { NULL, NULL, NULL }
+};
+
+/**********************************************************************
*
+ * DllCanUnloadNow (DXDIAGN.@)
+ */
+HRESULT WINAPI DllCanUnloadNow(void)
+{
+ return DXDIAGN_refCount != 0 ? S_FALSE : S_OK;
+}
+
+/**********************************************************************
*
+ * DllGetClassObject (DXDIAGN.@)
+ */
+HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID
*ppv)
+{
+ int i = 0;
+
+ TRACE("(%p,%p,%p)\n", debugstr_guid(rclsid), debugstr_guid(riid),
ppv);
+ while (NULL != DXDiag_CFS[i].rclsid) {
+ if (IsEqualGUID(rclsid, DXDiag_CFS[i].rclsid)) {
+ DXDiagCF_AddRef((IClassFactory*) &DXDiag_CFS[i]);
+ *ppv = &DXDiag_CFS[i];
+ return S_OK;
+ }
+ ++i;
+ }
+
+ FIXME("(%p,%p,%p): no interface found.\n", debugstr_guid(rclsid),
debugstr_guid(riid), ppv);
+ return CLASS_E_CLASSNOTAVAILABLE;
+}
Property changes on: vendor/wine/dlls/dxdiagn/current/dxdiag_main.c
___________________________________________________________________
Name: svn:keywords
+ Author Date Id Revision
Name: svn:eol-style
+ native
_____
Added: vendor/wine/dlls/dxdiagn/current/dxdiag_private.h
--- vendor/wine/dlls/dxdiagn/current/dxdiag_private.h 2005-12-14
22:41:16 UTC (rev 20178)
+++ vendor/wine/dlls/dxdiagn/current/dxdiag_private.h 2005-12-14
22:45:50 UTC (rev 20179)
@@ -0,0 +1,120 @@
+/*
+ * DXDiag private include file
+ *
+ * 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
+ */
+
+#ifndef __WINE_DXDIAG_PRIVATE_H
+#define __WINE_DXDIAG_PRIVATE_H
+
+#include <stdarg.h>
+
+#include "windef.h"
+#include "winbase.h"
+#include "wingdi.h"
+#include "winuser.h"
+#include "objbase.h"
+#include "oleauto.h"
+
+#include "dxdiag.h"
+
+/* DXDiag Interfaces: */
+typedef struct IDxDiagProviderImpl IDxDiagProviderImpl;
+typedef struct IDxDiagContainerImpl IDxDiagContainerImpl;
+
+/* ---------------- */
+/* IDxDiagProvider */
+/* ---------------- */
+
+/**********************************************************************
*******
+ * IDxDiagProvider implementation structure
+ */
+struct IDxDiagProviderImpl {
+ /* IUnknown fields */
+ const IDxDiagProviderVtbl *lpVtbl;
+ LONG ref;
+ /* IDxDiagProvider fields */
+ BOOL init;
+ DXDIAG_INIT_PARAMS params;
+ IDxDiagContainer* pRootContainer;
+};
+
+/* IUnknown: */
+extern HRESULT WINAPI
IDxDiagProviderImpl_QueryInterface(PDXDIAGPROVIDER iface, REFIID riid,
LPVOID *ppobj);
+extern ULONG WINAPI IDxDiagProviderImpl_AddRef(PDXDIAGPROVIDER iface);
+extern ULONG WINAPI IDxDiagProviderImpl_Release(PDXDIAGPROVIDER iface);
+
+/* IDxDiagProvider: */
+extern HRESULT WINAPI IDxDiagProviderImpl_Initialize(PDXDIAGPROVIDER
iface, DXDIAG_INIT_PARAMS* pParams);
+extern HRESULT WINAPI
IDxDiagProviderImpl_GetRootContainer(PDXDIAGPROVIDER iface,
IDxDiagContainer** ppInstance);
+
+/* ---------------- */
+/* IDxDiagContainer */
+/* ---------------- */
+
+typedef struct IDxDiagContainerImpl_SubContainer {
+ IDxDiagContainer* pCont;
+ WCHAR* contName;
+ struct IDxDiagContainerImpl_SubContainer* next;
+} IDxDiagContainerImpl_SubContainer;
+
+typedef struct IDxDiagContainerImpl_Property {
+ LPWSTR vName;
+ VARIANT v;
+ struct IDxDiagContainerImpl_Property* next;
+} IDxDiagContainerImpl_Property;
+
+
+/**********************************************************************
*******
+ * IDxDiagContainer implementation structure
+ */
+struct IDxDiagContainerImpl {
+ /* IUnknown fields */
+ const IDxDiagContainerVtbl *lpVtbl;
+ LONG ref;
+ /* IDxDiagContainer fields */
+ IDxDiagContainerImpl_Property* properties;
+ IDxDiagContainerImpl_SubContainer* subContainers;
+ DWORD nProperties;
+ DWORD nSubContainers;
+};
+
+/* IUnknown: */
+extern HRESULT WINAPI
IDxDiagContainerImpl_QueryInterface(PDXDIAGCONTAINER iface, REFIID riid,
LPVOID *ppobj);
+extern ULONG WINAPI IDxDiagContainerImpl_AddRef(PDXDIAGCONTAINER
iface);
+
+/** Internal */
+extern HRESULT WINAPI IDxDiagContainerImpl_AddProp(PDXDIAGCONTAINER
iface, LPCWSTR pwszPropName, VARIANT* pVarProp);
+extern HRESULT WINAPI
IDxDiagContainerImpl_AddChildContainer(PDXDIAGCONTAINER iface, LPCWSTR
pszContName, PDXDIAGCONTAINER pSubCont);
+
+/**
+ * factories
+ */
+extern HRESULT DXDiag_CreateDXDiagProvider(LPCLASSFACTORY iface,
LPUNKNOWN punkOuter, REFIID riid, LPVOID *ppobj);
+
+/** internal factory */
+extern HRESULT DXDiag_CreateDXDiagContainer(REFIID riid, LPVOID
*ppobj);
+extern HRESULT DXDiag_InitRootDXDiagContainer(IDxDiagContainer*
pRootCont);
+
+/**********************************************************************
+ * Dll lifetime tracking declaration for dxdiagn.dll
+ */
+extern LONG DXDIAGN_refCount;
+static inline void DXDIAGN_LockModule(void) { InterlockedIncrement(
&DXDIAGN_refCount ); }
+static inline void DXDIAGN_UnlockModule(void) { InterlockedDecrement(
&DXDIAGN_refCount ); }
+
+#endif
Property changes on: vendor/wine/dlls/dxdiagn/current/dxdiag_private.h
___________________________________________________________________
Name: svn:keywords
+ Author Date Id Revision
Name: svn:eol-style
+ native
_____
Added: vendor/wine/dlls/dxdiagn/current/dxdiagn.spec
--- vendor/wine/dlls/dxdiagn/current/dxdiagn.spec 2005-12-14
22:41:16 UTC (rev 20178)
+++ vendor/wine/dlls/dxdiagn/current/dxdiagn.spec 2005-12-14
22:45:50 UTC (rev 20179)
@@ -0,0 +1,4 @@
+@ stdcall -private DllCanUnloadNow()
+@ stdcall -private DllGetClassObject(ptr ptr ptr)
+@ stdcall -private DllRegisterServer()
+@ stdcall -private DllUnregisterServer()
Property changes on: vendor/wine/dlls/dxdiagn/current/dxdiagn.spec
___________________________________________________________________
Name: svn:eol-style
+ native
_____
Added: vendor/wine/dlls/dxdiagn/current/provider.c
--- 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->pRootContain
er, &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]
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://www.reactos.org/pipermail/ros-diffs/attachments/20051214/6aace64b/attachment.html
More information about the Ros-diffs
mailing list