1 /*
2 * IDxDiagContainer Implementation
3 *
4 * Copyright 2004 Raphael Junqueira
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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 *
20 */
21
22 #include "config.h"
23
24 #define COBJMACROS
25 #include "dxdiag_private.h"
26 #include "wine/debug.h"
27 #include "wine/unicode.h"
28
29 WINE_DEFAULT_DEBUG_CHANNEL(dxdiag);
30
31 /* IDxDiagContainer IUnknown parts follow: */
32 HRESULT WINAPI IDxDiagContainerImpl_QueryInterface(PDXDIAGCONTAINER iface, REFIID riid, LPVOID *ppobj)
33 {
34 IDxDiagContainerImpl *This = (IDxDiagContainerImpl *)iface;
35
36 if (IsEqualGUID(riid, &IID_IUnknown)
37 || IsEqualGUID(riid, &IID_IDxDiagContainer)) {
38 IUnknown_AddRef(iface);
39 *ppobj = This;
40 return S_OK;
41 }
42
43 WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppobj);
44 return E_NOINTERFACE;
45 }
46
47 static ULONG WINAPI IDxDiagContainerImpl_AddRef(PDXDIAGCONTAINER iface) {
48 IDxDiagContainerImpl *This = (IDxDiagContainerImpl *)iface;
49 ULONG refCount = InterlockedIncrement(&This->ref);
50
51 TRACE("(%p)->(ref before=%u)\n", This, refCount - 1);
52
53 DXDIAGN_LockModule();
54
55 return refCount;
56 }
57
58 static ULONG WINAPI IDxDiagContainerImpl_Release(PDXDIAGCONTAINER iface) {
59 IDxDiagContainerImpl *This = (IDxDiagContainerImpl *)iface;
60 ULONG refCount = InterlockedDecrement(&This->ref);
61
62 TRACE("(%p)->(ref before=%u)\n", This, refCount + 1);
63
64 if (!refCount) {
65 HeapFree(GetProcessHeap(), 0, This);
66 }
67
68 DXDIAGN_UnlockModule();
69
70 return refCount;
71 }
72
73 /* IDxDiagContainer Interface follow: */
74 static HRESULT WINAPI IDxDiagContainerImpl_GetNumberOfChildContainers(PDXDIAGCONTAINER iface, DWORD* pdwCount) {
75 IDxDiagContainerImpl *This = (IDxDiagContainerImpl *)iface;
76 TRACE("(%p)\n", iface);
77 if (NULL == pdwCount) {
78 return E_INVALIDARG;
79 }
80 *pdwCount = This->nSubContainers;
81 return S_OK;
82 }
83
84 static HRESULT WINAPI IDxDiagContainerImpl_EnumChildContainerNames(PDXDIAGCONTAINER iface, DWORD dwIndex, LPWSTR pwszContainer, DWORD cchContainer) {
85 IDxDiagContainerImpl *This = (IDxDiagContainerImpl *)iface;
86 IDxDiagContainerImpl_SubContainer* p = NULL;
87 DWORD i = 0;
88
89 TRACE("(%p, %u, %s, %u)\n", iface, dwIndex, debugstr_w(pwszContainer), cchContainer);
90
91 if (NULL == pwszContainer) {
92 return E_INVALIDARG;
93 }
94 if (256 > cchContainer) {
95 return DXDIAG_E_INSUFFICIENT_BUFFER;
96 }
97
98 p = This->subContainers;
99 while (NULL != p) {
100 if (dwIndex == i) {
101 if (cchContainer <= strlenW(p->contName)) {
102 return DXDIAG_E_INSUFFICIENT_BUFFER;
103 }
104 lstrcpynW(pwszContainer, p->contName, cchContainer);
105 return S_OK;
106 }
107 p = p->next;
108 ++i;
109 }
110 return E_INVALIDARG;
111 }
112
113 static HRESULT IDxDiagContainerImpl_GetChildContainerInternal(PDXDIAGCONTAINER iface, LPCWSTR pwszContainer, IDxDiagContainer** ppInstance) {
114 IDxDiagContainerImpl *This = (IDxDiagContainerImpl *)iface;
115 IDxDiagContainerImpl_SubContainer* p = NULL;
116
117 p = This->subContainers;
118 while (NULL != p) {
119 if (0 == lstrcmpW(p->contName, pwszContainer)) {
120 *ppInstance = p->pCont;
121 return S_OK;
122 }
123 p = p->next;
124 }
125 return E_INVALIDARG;
126 }
127
128 static HRESULT WINAPI IDxDiagContainerImpl_GetChildContainer(PDXDIAGCONTAINER iface, LPCWSTR pwszContainer, IDxDiagContainer** ppInstance) {
129 IDxDiagContainerImpl *This = (IDxDiagContainerImpl *)iface;
130 IDxDiagContainer* pContainer = NULL;
131 LPWSTR tmp, orig_tmp;
132 INT tmp_len;
133 WCHAR* cur;
134 HRESULT hr = E_INVALIDARG;
135
136 TRACE("(%p, %s, %p)\n", iface, debugstr_w(pwszContainer), ppInstance);
137
138 if (NULL == ppInstance || NULL == pwszContainer) {
139 return E_INVALIDARG;
140 }
141
142 pContainer = (PDXDIAGCONTAINER) This;
143
144 tmp_len = strlenW(pwszContainer) + 1;
145 orig_tmp = tmp = HeapAlloc(GetProcessHeap(), 0, tmp_len * sizeof(WCHAR));
146 if (NULL == tmp) return E_FAIL;
147 lstrcpynW(tmp, pwszContainer, tmp_len);
148
149 cur = strchrW(tmp, '.');
150 while (NULL != cur) {
151 *cur = '\0'; /* cut tmp string to '.' */
152 hr = IDxDiagContainerImpl_GetChildContainerInternal(pContainer, tmp, &pContainer);
153 if (FAILED(hr) || NULL == pContainer)
154 goto on_error;
155 cur++; /* go after '.' (just replaced by \0) */
156 tmp = cur;
157 cur = strchrW(tmp, '.');
158 }
159
160 hr = IDxDiagContainerImpl_GetChildContainerInternal(pContainer, tmp, ppInstance);
161 if (SUCCEEDED(hr)) {
162 IDxDiagContainerImpl_AddRef(*ppInstance);
163 }
164
165 on_error:
166 HeapFree(GetProcessHeap(), 0, orig_tmp);
167 return hr;
168 }
169
170 static HRESULT WINAPI IDxDiagContainerImpl_GetNumberOfProps(PDXDIAGCONTAINER iface, DWORD* pdwCount) {
171 IDxDiagContainerImpl *This = (IDxDiagContainerImpl *)iface;
172 TRACE("(%p)\n", iface);
173 if (NULL == pdwCount) {
174 return E_INVALIDARG;
175 }
176 *pdwCount = This->nProperties;
177 return S_OK;
178 }
179
180 static HRESULT WINAPI IDxDiagContainerImpl_EnumPropNames(PDXDIAGCONTAINER iface, DWORD dwIndex, LPWSTR pwszPropName, DWORD cchPropName) {
181 IDxDiagContainerImpl *This = (IDxDiagContainerImpl *)iface;
182 IDxDiagContainerImpl_Property* p = NULL;
183 DWORD i = 0;
184
185 TRACE("(%p, %u, %s, %u)\n", iface, dwIndex, debugstr_w(pwszPropName), cchPropName);
186
187 if (NULL == pwszPropName) {
188 return E_INVALIDARG;
189 }
190 if (256 > cchPropName) {
191 return DXDIAG_E_INSUFFICIENT_BUFFER;
192 }
193
194 p = This->properties;
195 while (NULL != p) {
196 if (dwIndex == i) {
197 if (cchPropName <= strlenW(p->vName)) {
198 return DXDIAG_E_INSUFFICIENT_BUFFER;
199 }
200 lstrcpynW(pwszPropName, p->vName, cchPropName);
201 return S_OK;
202 }
203 p = p->next;
204 ++i;
205 }
206 return E_INVALIDARG;
207 }
208
209 static HRESULT WINAPI IDxDiagContainerImpl_GetProp(PDXDIAGCONTAINER iface, LPCWSTR pwszPropName, VARIANT* pvarProp) {
210 IDxDiagContainerImpl *This = (IDxDiagContainerImpl *)iface;
211 IDxDiagContainerImpl_Property* p = NULL;
212
213 TRACE("(%p, %s, %p)\n", iface, debugstr_w(pwszPropName), pvarProp);
214
215 if (NULL == pvarProp || NULL == pwszPropName) {
216 return E_INVALIDARG;
217 }
218
219 p = This->properties;
220 while (NULL != p) {
221 if (0 == lstrcmpW(p->vName, pwszPropName)) {
222 VariantCopy(pvarProp, &p->v);
223 return S_OK;
224 }
225 p = p->next;
226 }
227 return S_OK;
228 }
229
230 HRESULT WINAPI IDxDiagContainerImpl_AddProp(PDXDIAGCONTAINER iface, LPCWSTR pwszPropName, VARIANT* pVarProp) {
231 IDxDiagContainerImpl *This = (IDxDiagContainerImpl *)iface;
232 IDxDiagContainerImpl_Property* p = NULL;
233 IDxDiagContainerImpl_Property* pNew = NULL;
234
235 TRACE("(%p, %s, %p)\n", iface, debugstr_w(pwszPropName), pVarProp);
236
237 if (NULL == pVarProp || NULL == pwszPropName) {
238 return E_INVALIDARG;
239 }
240
241 pNew = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDxDiagContainerImpl_Property));
242 if (NULL == pNew) {
243 return E_OUTOFMEMORY;
244 }
245 VariantInit(&pNew->v);
246 VariantCopy(&pNew->v, pVarProp);
247 pNew->vName = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (lstrlenW(pwszPropName) + 1) * sizeof(WCHAR));
248 lstrcpyW(pNew->vName, pwszPropName);
249 pNew->next = NULL;
250
251 p = This->properties;
252 if (NULL == p) {
253 This->properties = pNew;
254 } else {
255 while (NULL != p->next) {
256 p = p->next;
257 }
258 p->next = pNew;
259 }
260 ++This->nProperties;
261 return S_OK;
262 }
263
264 HRESULT WINAPI IDxDiagContainerImpl_AddChildContainer(PDXDIAGCONTAINER iface, LPCWSTR pszContName, PDXDIAGCONTAINER pSubCont) {
265 IDxDiagContainerImpl *This = (IDxDiagContainerImpl *)iface;
266 IDxDiagContainerImpl_SubContainer* p = NULL;
267 IDxDiagContainerImpl_SubContainer* pNew = NULL;
268
269 TRACE("(%p, %s, %p)\n", iface, debugstr_w(pszContName), pSubCont);
270
271 if (NULL == pSubCont || NULL == pszContName) {
272 return E_INVALIDARG;
273 }
274
275 pNew = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDxDiagContainerImpl_SubContainer));
276 if (NULL == pNew) {
277 return E_OUTOFMEMORY;
278 }
279 pNew->pCont = pSubCont;
280 pNew->contName = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (lstrlenW(pszContName) + 1) * sizeof(WCHAR));
281 lstrcpyW(pNew->contName, pszContName);
282 pNew->next = NULL;
283
284 p = This->subContainers;
285 if (NULL == p) {
286 This->subContainers = pNew;
287 } else {
288 while (NULL != p->next) {
289 p = p->next;
290 }
291 p->next = pNew;
292 }
293 ++This->nSubContainers;
294 return S_OK;
295 }
296
297 static const IDxDiagContainerVtbl DxDiagContainer_Vtbl =
298 {
299 IDxDiagContainerImpl_QueryInterface,
300 IDxDiagContainerImpl_AddRef,
301 IDxDiagContainerImpl_Release,
302 IDxDiagContainerImpl_GetNumberOfChildContainers,
303 IDxDiagContainerImpl_EnumChildContainerNames,
304 IDxDiagContainerImpl_GetChildContainer,
305 IDxDiagContainerImpl_GetNumberOfProps,
306 IDxDiagContainerImpl_EnumPropNames,
307 IDxDiagContainerImpl_GetProp
308 };
309
310
311 HRESULT DXDiag_CreateDXDiagContainer(REFIID riid, LPVOID *ppobj) {
312 IDxDiagContainerImpl* container;
313
314 TRACE("(%p, %p)\n", debugstr_guid(riid), ppobj);
315
316 container = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDxDiagContainerImpl));
317 if (NULL == container) {
318 *ppobj = NULL;
319 return E_OUTOFMEMORY;
320 }
321 container->lpVtbl = &DxDiagContainer_Vtbl;
322 container->ref = 0; /* will be inited with QueryInterface */
323 return IDxDiagContainerImpl_QueryInterface((PDXDIAGCONTAINER)container, riid, ppobj);
324 }
325
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.