?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
inetcpl: Add a security propsheet.
[wine/multimedia.git] / dlls / gameux / gamestatistics.c
blobb0e7674a2fdff81ed30c927987a6ec1ef447b61b
1 /*
2 * Gameux library coclass GameStatistics implementation
3 *
4 * Copyright (C) 2010 Mariusz Pluciński
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 #define COBJMACROS
21
22 #include "config.h"
23
24 #include "ole2.h"
25 #include "winreg.h"
26 #include "msxml2.h"
27 #include "shlwapi.h"
28 #include "shlobj.h"
29
30 #include "gameux.h"
31 #include "gameux_private.h"
32
33 #include "wine/debug.h"
34
35 WINE_DEFAULT_DEBUG_CHANNEL(gameux);
36
37 /*
38 * constant definitions
39 */
40 #define MAX_CATEGORY_LENGTH 60
41 #define MAX_NAME_LENGTH 30
42 #define MAX_VALUE_LENGTH 30
43 #define MAX_CATEGORIES 10
44 #define MAX_STATS_PER_CATEGORY 10
45 /*******************************************************************************
46 * Game statistics helper components
47 */
48 /*******************************************************************************
49 * struct GAMEUX_STATS
50 *
51 * set of structures for containing game's data
52 */
53 struct GAMEUX_STATS_STAT
54 {
55 WCHAR sName[MAX_NAME_LENGTH+1];
56 WCHAR sValue[MAX_VALUE_LENGTH+1];
57 };
58 struct GAMEUX_STATS_CATEGORY
59 {
60 WCHAR sName[MAX_CATEGORY_LENGTH+1];
61 struct GAMEUX_STATS_STAT stats[MAX_STATS_PER_CATEGORY];
62 };
63 struct GAMEUX_STATS
64 {
65 WCHAR sStatsFile[MAX_PATH];
66 struct GAMEUX_STATS_CATEGORY categories[MAX_CATEGORIES];
67 };
68 /*******************************************************************************
69 * GAMEUX_createStatsDirectory
70 *
71 * Helper function, creates directory to store game statistics
72 *
73 * Parameters
74 * path [I] path to game statistics file.
75 * base directory of this file will
76 * be created if it doesn't exists
77 */
78 static HRESULT GAMEUX_createStatsDirectory(LPCWSTR lpFilePath)
79 {
80 HRESULT hr;
81 WCHAR lpDirectoryPath[MAX_PATH];
82 LPCWSTR lpEnd;
83
84 lpEnd = StrRChrW(lpFilePath, NULL, '\\');
85 lstrcpynW(lpDirectoryPath, lpFilePath, lpEnd-lpFilePath+1);
86
87 hr = HRESULT_FROM_WIN32(SHCreateDirectoryExW(NULL, lpDirectoryPath, NULL));
88
89 if(hr == HRESULT_FROM_WIN32(ERROR_FILE_EXISTS) ||
90 hr == HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS))
91 hr = S_FALSE;
92
93 return hr;
94 }
95 /*******************************************************************
96 * GAMEUX_updateStatisticsFile
97 *
98 * Helper function updating data stored in statistics file
99 *
100 * Parameters:
101 * data [I] pointer to struct containing
102 * statistics data
103 */
104 static HRESULT GAMEUX_updateStatisticsFile(struct GAMEUX_STATS *stats)
105 {
106 static const WCHAR sStatistics[] = {'S','t','a','t','i','s','t','i','c','s',0};
107 static const WCHAR sCategory[] = {'C','a','t','e','g','o','r','y',0};
108 static const WCHAR sIndex[] = {'I','n','d','e','x',0};
109 static const WCHAR sStatistic[] = {'S','t','a','t','i','s','t','i','c',0};
110 static const WCHAR sName[] = {'N','a','m','e',0};
111 static const WCHAR sValue[] = {'V','a','l','u','e',0};
112
113 HRESULT hr = S_OK;
114 IXMLDOMDocument *document;
115 IXMLDOMElement *root, *categoryElement, *statisticsElement;
116 IXMLDOMNode *categoryNode, *statisticsNode;
117 VARIANT vStatsFilePath, vValue;
118 BSTR bstrStatistics = NULL, bstrCategory = NULL, bstrIndex = NULL,
119 bstrStatistic = NULL, bstrName = NULL, bstrValue = NULL;
120 int i, j;
121
122 TRACE("(%p)\n", stats);
123
124 V_VT(&vStatsFilePath) = VT_BSTR;
125 V_BSTR(&vStatsFilePath) = SysAllocString(stats->sStatsFile);
126 if(!V_BSTR(&vStatsFilePath))
127 hr = E_OUTOFMEMORY;
128
129 if(SUCCEEDED(hr))
130 hr = CoCreateInstance(&CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER,
131 &IID_IXMLDOMDocument, (void**)&document);
132
133 if(SUCCEEDED(hr))
134 {
135 bstrStatistics = SysAllocString(sStatistics);
136 if(!bstrStatistics)
137 hr = E_OUTOFMEMORY;
138 }
139
140 if(SUCCEEDED(hr))
141 hr = IXMLDOMDocument_createElement(document, bstrStatistics, &root);
142
143 if(SUCCEEDED(hr))
144 {
145 bstrCategory = SysAllocString(sCategory);
146 if(!bstrCategory)
147 hr = E_OUTOFMEMORY;
148 }
149
150 if(SUCCEEDED(hr))
151 {
152 bstrIndex = SysAllocString(sIndex);
153 if(!bstrIndex)
154 hr = E_OUTOFMEMORY;
155 }
156
157 if(SUCCEEDED(hr))
158 {
159 bstrStatistic = SysAllocString(sStatistic);
160 if(!bstrStatistic)
161 hr = E_OUTOFMEMORY;
162 }
163
164 if(SUCCEEDED(hr))
165 {
166 bstrName = SysAllocString(sName);
167 if(!bstrName)
168 hr = E_OUTOFMEMORY;
169 }
170
171 if(SUCCEEDED(hr))
172 {
173 bstrValue = SysAllocString(sValue);
174 if(!bstrValue)
175 hr = E_OUTOFMEMORY;
176 }
177
178 if(SUCCEEDED(hr))
179
180 if(SUCCEEDED(hr))
181 for(i=0; i<MAX_CATEGORIES; ++i)
182 {
183 if(lstrlenW(stats->categories[i].sName)==0)
184 continue;
185
186 V_VT(&vValue) = VT_INT;
187 V_INT(&vValue) = NODE_ELEMENT;
188
189 hr = IXMLDOMDocument_createNode(document, vValue, bstrCategory, NULL, &categoryNode);
190
191 if(SUCCEEDED(hr))
192 hr = IXMLDOMNode_QueryInterface(categoryNode, &IID_IXMLDOMElement, (LPVOID*)&categoryElement);
193
194 V_INT(&vValue) = i;
195 if(SUCCEEDED(hr))
196 hr = IXMLDOMElement_setAttribute(categoryElement, bstrIndex, vValue);
197
198 if(SUCCEEDED(hr))
199 {
200 V_VT(&vValue) = VT_BSTR;
201 V_BSTR(&vValue) = SysAllocString(stats->categories[i].sName);
202 if(!V_BSTR(&vValue))
203 hr = E_OUTOFMEMORY;
204 }
205
206 if(SUCCEEDED(hr))
207 {
208 TRACE("storing category %d: %s\n", i, debugstr_w(V_BSTR(&vValue)));
209 hr = IXMLDOMElement_setAttribute(categoryElement, bstrName, vValue);
210 }
211
212 SysFreeString(V_BSTR(&vValue));
213
214 if(SUCCEEDED(hr))
215 {
216 for(j=0; j<MAX_STATS_PER_CATEGORY; ++j)
217 {
218 if(lstrlenW(stats->categories[i].stats[j].sName)==0)
219 continue;
220
221 V_VT(&vValue) = VT_INT;
222 V_INT(&vValue) = NODE_ELEMENT;
223
224 hr = IXMLDOMDocument_createNode(document, vValue, bstrStatistic, NULL, &statisticsNode);
225
226 if(SUCCEEDED(hr))
227 hr = IXMLDOMNode_QueryInterface(statisticsNode, &IID_IXMLDOMElement, (LPVOID*)&statisticsElement);
228
229 V_INT(&vValue) = j;
230 if(SUCCEEDED(hr))
231 hr = IXMLDOMElement_setAttribute(statisticsElement, bstrIndex, vValue);
232
233 if(SUCCEEDED(hr))
234 {
235 V_VT(&vValue) = VT_BSTR;
236 V_BSTR(&vValue) = SysAllocString(stats->categories[i].stats[j].sName);
237 if(!V_BSTR(&vValue))
238 hr = E_OUTOFMEMORY;
239 }
240
241 if(SUCCEEDED(hr))
242 {
243 TRACE(" storing statistic %d: name: %s\n", j, debugstr_w(V_BSTR(&vValue)));
244 hr = IXMLDOMElement_setAttribute(statisticsElement, bstrName, vValue);
245 }
246
247 SysFreeString(V_BSTR(&vValue));
248
249 if(SUCCEEDED(hr))
250 {
251 V_VT(&vValue) = VT_BSTR;
252 V_BSTR(&vValue) = SysAllocString(stats->categories[i].stats[j].sValue);
253 if(!V_BSTR(&vValue))
254 hr = E_OUTOFMEMORY;
255 }
256
257 if(SUCCEEDED(hr))
258 {
259 TRACE(" storing statistic %d: name: %s\n", j, debugstr_w(V_BSTR(&vValue)));
260 hr = IXMLDOMElement_setAttribute(statisticsElement, bstrValue, vValue);
261 }
262
263 SysFreeString(V_BSTR(&vValue));
264
265 if(SUCCEEDED(hr))
266 hr = IXMLDOMElement_appendChild(categoryNode, statisticsNode, &statisticsNode);
267
268 IXMLDOMElement_Release(statisticsElement);
269 IXMLDOMNode_Release(statisticsNode);
270 }
271 }
272
273 if(SUCCEEDED(hr))
274 hr = IXMLDOMElement_appendChild(root, categoryNode, &categoryNode);
275
276 IXMLDOMElement_Release(categoryElement);
277 IXMLDOMNode_Release(categoryNode);
278
279 if(FAILED(hr))
280 break;
281 }
282
283 if(SUCCEEDED(hr))
284 hr = IXMLDOMDocument_putref_documentElement(document, root);
285
286 IXMLDOMElement_Release(root);
287
288 TRACE("saving game statistics in %s file\n", debugstr_w(stats->sStatsFile));
289 if(SUCCEEDED(hr))
290 hr = GAMEUX_createStatsDirectory(stats->sStatsFile);
291
292 if(SUCCEEDED(hr))
293 hr = IXMLDOMDocument_save(document, vStatsFilePath);
294
295 IXMLDOMDocument_Release(document);
296
297 SysFreeString(bstrValue);
298 SysFreeString(bstrName);
299 SysFreeString(bstrStatistic);
300 SysFreeString(bstrIndex);
301 SysFreeString(bstrCategory);
302 SysFreeString(bstrStatistics);
303 SysFreeString(V_BSTR(&vStatsFilePath));
304 TRACE("ret=0x%x\n", hr);
305 return hr;
306 }
307 /*******************************************************************************
308 * GAMEUX_buildStatisticsFilePath
309 * Creates path to file contaning statistics of game with given id.
310 *
311 * Parameters:
312 * lpApplicationId [I] application id of game,
313 * as string
314 * lpStatisticsFile [O] array where path will be
315 * stored. It's size must be
316 * at least MAX_PATH
317 */
318 static HRESULT GAMEUX_buildStatisticsFilePath(
319 LPCWSTR lpApplicationId,
320 LPWSTR lpStatisticsFile)
321 {
322 static const WCHAR sBackslash[] = {'\\',0};
323 static const WCHAR sStatisticsDir[] = {'\\','M','i','c','r','o','s','o','f','t',
324 '\\','W','i','n','d','o','w','s','\\','G','a','m','e','E','x','p',
325 'l','o','r','e','r','\\','G','a','m','e','S','t','a','t','i','s',
326 't','i','c','s','\\',0};
327 static const WCHAR sDotGamestats[] = {'.','g','a','m','e','s','t','a','t','s',0};
328
329 HRESULT hr;
330
331 hr = SHGetFolderPathW(NULL, CSIDL_LOCAL_APPDATA, NULL, SHGFP_TYPE_CURRENT, lpStatisticsFile);
332
333 if(SUCCEEDED(hr))
334 {
335 lstrcatW(lpStatisticsFile, sStatisticsDir);
336 lstrcatW(lpStatisticsFile, lpApplicationId);
337 lstrcatW(lpStatisticsFile, sBackslash);
338 lstrcatW(lpStatisticsFile, lpApplicationId);
339 lstrcatW(lpStatisticsFile, sDotGamestats);
340 }
341
342 return hr;
343 }
344 /*******************************************************************************
345 * GAMEUX_getAppIdFromGDFPath
346 *
347 * Loads application identifier associated with given GDF binary.
348 * Routine reads identifier from registry, so will fail if game
349 * is not registered.
350 *
351 * Parameters:
352 * GDFBinaryPath [I] path to gdf binary
353 * lpApplicationId [O] place to store application id.
354 * must be at least 49 characters
355 * to store guid and termination 0
356 */
357 static HRESULT GAMEUX_getAppIdFromGDFPath(
358 LPCWSTR GDFBinaryPath,
359 LPWSTR lpApplicationId)
360 {
361 static const WCHAR sApplicationId[] =
362 {'A','p','p','l','i','c','a','t','i','o','n','I','d',0};
363
364 HRESULT hr;
365 GAME_INSTALL_SCOPE installScope;
366 GUID instanceId;
367 LPWSTR lpRegistryPath = NULL;
368 HKEY hKey;
369 DWORD dwLength = 49*sizeof(WCHAR);/* place for GUID */
370
371 TRACE("(%s, %p)\n", debugstr_w(GDFBinaryPath), lpApplicationId);
372
373 if(!GDFBinaryPath)
374 return E_INVALIDARG;
375
376 installScope = GIS_CURRENT_USER;
377 hr = GAMEUX_FindGameInstanceId(GDFBinaryPath, installScope, &instanceId);
378
379 if(hr == S_FALSE)
380 {
381 installScope = GIS_ALL_USERS;
382 hr = GAMEUX_FindGameInstanceId(GDFBinaryPath, installScope, &instanceId);
383 }
384
385 if(hr == S_FALSE)
386 /* game not registered, so statistics cannot be used */
387 hr = E_FAIL;
388
389 if(SUCCEEDED(hr))
390 /* game is registered, let's read it's application id from registry */
391 hr = GAMEUX_buildGameRegistryPath(installScope, &instanceId, &lpRegistryPath);
392
393 if(SUCCEEDED(hr))
394 hr = HRESULT_FROM_WIN32(RegOpenKeyExW(HKEY_LOCAL_MACHINE,
395 lpRegistryPath, 0, KEY_READ | KEY_WOW64_64KEY, &hKey));
396
397 if(SUCCEEDED(hr))
398 hr = HRESULT_FROM_WIN32(RegGetValueW(hKey,
399 NULL, sApplicationId, RRF_RT_REG_SZ,
400 NULL, lpApplicationId, &dwLength));
401
402 HeapFree(GetProcessHeap(), 0, lpRegistryPath);
403 RegCloseKey(hKey);
404
405 TRACE("found app id: %s, return: %#x\n", debugstr_w(lpApplicationId), hr);
406 return hr;
407 }
408 /*******************************************************************
409 * GAMEUX_loadGameStatisticsFromFile
410 * Helper function, loads game statistics from file and stores them
411 * in the structure.
412 *
413 * Parameters:
414 * data [I/O] structure containing file name to
415 * load and data fields to store data in
416 */
417 static HRESULT GAMEUX_loadStatisticsFromFile(struct GAMEUX_STATS *data)
418 {
419 static const WCHAR sStatistics[] = {'S','t','a','t','i','s','t','i','c','s',0};
420 static const WCHAR sCategory[] = {'C','a','t','e','g','o','r','y',0};
421 static const WCHAR sIndex[] = {'I','n','d','e','x',0};
422 static const WCHAR sStatistic[] = {'S','t','a','t','i','s','t','i','c',0};
423 static const WCHAR sName[] = {'N','a','m','e',0};
424 static const WCHAR sValue[] = {'V','a','l','u','e',0};
425
426 HRESULT hr = S_OK;
427 IXMLDOMDocument *document = NULL;
428 IXMLDOMElement *root = NULL, *categoryElement, *statisticElement;
429 IXMLDOMNode *categoryNode, *statisticNode;
430 IXMLDOMNodeList *rootChildren = NULL, *categoryChildren;
431 VARIANT vStatsFilePath, vValue;
432 BSTR bstrStatistics = NULL, bstrCategory = NULL, bstrIndex = NULL,
433 bstrStatistic = NULL, bstrName = NULL, bstrValue = NULL;
434 VARIANT_BOOL isSuccessful = VARIANT_FALSE;
435 int i, j;
436
437 TRACE("(%p)\n", data);
438
439 V_VT(&vStatsFilePath) = VT_BSTR;
440 V_BSTR(&vStatsFilePath) = SysAllocString(data->sStatsFile);
441 if(!V_BSTR(&vStatsFilePath))
442 hr = E_OUTOFMEMORY;
443
444 if(SUCCEEDED(hr))
445 hr = CoCreateInstance(&CLSID_DOMDocument30, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (void**)&document);
446
447 if(SUCCEEDED(hr))
448 {
449 bstrStatistics = SysAllocString(sStatistics);
450 if(!bstrStatistics)
451 hr = E_OUTOFMEMORY;
452 }
453
454 if(SUCCEEDED(hr))
455 {
456 bstrCategory = SysAllocString(sCategory);
457 if(!bstrCategory)
458 hr = E_OUTOFMEMORY;
459 }
460
461 if(SUCCEEDED(hr))
462 {
463 bstrIndex = SysAllocString(sIndex);
464 if(!bstrIndex)
465 hr = E_OUTOFMEMORY;
466 }
467
468 if(SUCCEEDED(hr))
469 {
470 bstrStatistic = SysAllocString(sStatistic);
471 if(!bstrStatistic)
472 hr = E_OUTOFMEMORY;
473 }
474
475 if(SUCCEEDED(hr))
476 {
477 bstrName = SysAllocString(sName);
478 if(!bstrName)
479 hr = E_OUTOFMEMORY;
480 }
481
482 if(SUCCEEDED(hr))
483 {
484 bstrValue = SysAllocString(sValue);
485 if(!bstrValue)
486 hr = E_OUTOFMEMORY;
487 }
488
489 if(SUCCEEDED(hr))
490 hr = IXMLDOMDocument_load(document, vStatsFilePath, &isSuccessful);
491
492 if(hr == S_OK && isSuccessful != VARIANT_TRUE)
493 hr = S_FALSE;
494
495 if( hr == S_OK )
496 hr = IXMLDOMDocument_get_documentElement(document, &root);
497
498 if(hr == S_OK)
499 hr = IXMLDOMElement_get_childNodes(root, &rootChildren);
500
501 if(hr == S_OK)
502 {
503 hr = S_OK;
504 while(hr == S_OK)
505 {
506 hr = IXMLDOMNodeList_nextNode(rootChildren, &categoryNode);
507
508 if(hr == S_OK)
509 {
510 hr = IXMLDOMNode_QueryInterface(categoryNode, &IID_IXMLDOMElement, (LPVOID*)&categoryElement);
511
512 if(SUCCEEDED(hr))
513 {
514 hr = IXMLDOMElement_getAttribute(categoryElement, bstrIndex, &vValue);
515 if( hr == S_OK && V_VT(&vValue) != VT_BSTR)
516 hr = E_FAIL;
517
518 if(SUCCEEDED(hr))
519 {
520 i = StrToIntW(V_BSTR(&vValue));
521 hr = IXMLDOMElement_getAttribute(categoryElement, bstrName, &vValue);
522 if( hr == S_OK && V_VT(&vValue) != VT_BSTR)
523 hr = E_FAIL;
524 }
525
526 if(SUCCEEDED(hr))
527 {
528 lstrcpynW(data->categories[i].sName, V_BSTR(&vValue), MAX_CATEGORY_LENGTH);
529 TRACE("category %d name %s\n", i, debugstr_w(data->categories[i].sName));
530 hr = IXMLDOMElement_get_childNodes(categoryElement, &categoryChildren);
531 }
532
533 if(SUCCEEDED(hr))
534 {
535 hr = S_OK;
536 while(hr == S_OK)
537 {
538 hr = IXMLDOMNodeList_nextNode(categoryChildren, &statisticNode);
539
540 if(hr == S_OK)
541 {
542 hr = IXMLDOMNode_QueryInterface(statisticNode, &IID_IXMLDOMElement, (LPVOID*)&statisticElement);
543
544 if(SUCCEEDED(hr))
545 {
546 hr = IXMLDOMElement_getAttribute(statisticElement, bstrIndex, &vValue);
547 if( hr == S_OK && V_VT(&vValue) != VT_BSTR)
548 hr = E_FAIL;
549
550 if(SUCCEEDED(hr))
551 {
552 j = StrToIntW(V_BSTR(&vValue));
553 hr = IXMLDOMElement_getAttribute(statisticElement, bstrName, &vValue);
554 if( hr == S_OK && V_VT(&vValue) != VT_BSTR)
555 hr = E_FAIL;
556 }
557
558 if(SUCCEEDED(hr))
559 {
560 lstrcpynW(data->categories[i].stats[j].sName, V_BSTR(&vValue), MAX_NAME_LENGTH);
561 hr = IXMLDOMElement_getAttribute(statisticElement, bstrValue, &vValue);
562 if( hr == S_OK && V_VT(&vValue) != VT_BSTR)
563 hr = E_FAIL;
564 }
565
566 if(SUCCEEDED(hr))
567 {
568 lstrcpynW(data->categories[i].stats[j].sValue, V_BSTR(&vValue), MAX_VALUE_LENGTH);
569 TRACE("statistic %d name %s value %s\n", j,
570 debugstr_w(data->categories[i].stats[j].sName),
571 debugstr_w(data->categories[i].stats[j].sValue));
572 }
573 IXMLDOMElement_Release(statisticElement);
574 }
575
576 IXMLDOMNode_Release(statisticNode);
577 }
578 }
579
580 if(SUCCEEDED(hr))
581 hr = S_OK;
582 }
583 IXMLDOMElement_Release(categoryElement);
584 }
585
586 IXMLDOMNode_Release(categoryNode);
587 }
588 }
589 if(SUCCEEDED(hr))
590 hr = S_OK;
591 }
592
593 if(rootChildren) IXMLDOMNodeList_Release(rootChildren);
594 if(root) IXMLDOMElement_Release(root);
595 if(document) IXMLDOMDocument_Release(document);
596
597 SysFreeString(bstrValue);
598 SysFreeString(bstrName);
599 SysFreeString(bstrStatistic);
600 SysFreeString(bstrIndex);
601 SysFreeString(bstrCategory);
602 SysFreeString(bstrStatistics);
603 SysFreeString(V_BSTR(&vStatsFilePath));
604 return hr;
605 }
606 /*******************************************************************
607 * GAMEUX_loadGameStatistics
608 *
609 * Helper function which loads game statistics associated with game
610 * into interface's internal structures
611 *
612 * Parameters:
613 * pStats [O] structure which will receive data
614 * sGameId [I] application instance Id, stored as string
615 * to avoid additional conversions
616 * openType [I] allowed ways of opening statistics
617 * pOpenResult [O] way used to open statistics
618 *
619 */
620 static HRESULT GAMEUX_loadGameStatistics(struct GAMEUX_STATS *pStats,
621 LPWSTR sGameId,
622 GAMESTATS_OPEN_TYPE openType,
623 GAMESTATS_OPEN_RESULT* pOpenResult)
624 {
625 HRESULT hr;
626 TRACE("(%p, %s, %d, %p)\n", pStats, debugstr_w(sGameId), openType, pOpenResult);
627
628 hr = GAMEUX_buildStatisticsFilePath(sGameId, pStats->sStatsFile);
629
630 hr = GAMEUX_loadStatisticsFromFile(pStats);
631 TRACE("ldstats finished, res: %#x\n", hr);
632 if(hr == S_OK)
633 {
634 *pOpenResult = GAMESTATS_OPEN_OPENED;
635 }
636 else if(hr == S_FALSE && openType == GAMESTATS_OPEN_OPENORCREATE) /* file does not exist */
637 {
638 /* create new statitics, not yet connected with file */
639 ZeroMemory(pStats->categories, sizeof(pStats->categories));
640 *pOpenResult = GAMESTATS_OPEN_CREATED;
641 hr = S_OK;
642 }
643 else
644 hr = HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
645
646 TRACE("openResult=%#x ret=%#x\n", *pOpenResult, hr);
647 return hr;
648 }
649 /*******************************************************************
650 * IGameStatistics implementation
651 */
652 typedef struct _GameStatisticsImpl
653 {
654 const struct IGameStatisticsVtbl *lpVtbl;
655 LONG ref;
656 struct GAMEUX_STATS stats;
657 } GameStatisticsImpl;
658
659 static inline GameStatisticsImpl *impl_from_IGameStatistics( IGameStatistics *iface )
660 {
661 return (GameStatisticsImpl *)((char*)iface - FIELD_OFFSET(GameStatisticsImpl, lpVtbl));
662 }
663 static inline IGameStatistics *IGameStatistics_from_impl( GameStatisticsImpl* This )
664 {
665 return (struct IGameStatistics*)&This->lpVtbl;
666 }
667
668
669 static HRESULT WINAPI GameStatisticsImpl_QueryInterface(
670 IGameStatistics *iface,
671 REFIID riid,
672 void **ppvObject)
673 {
674 GameStatisticsImpl *This = impl_from_IGameStatistics( iface );
675
676 TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
677
678 *ppvObject = NULL;
679
680 if ( IsEqualGUID( riid, &IID_IUnknown ) ||
681 IsEqualGUID( riid, &IID_IGameStatistics ) )
682 {
683 *ppvObject = iface;
684 }
685 else
686 {
687 FIXME("interface %s not implemented\n", debugstr_guid(riid));
688 return E_NOINTERFACE;
689 }
690
691 IGameStatistics_AddRef( iface );
692 return S_OK;
693 }
694
695 static ULONG WINAPI GameStatisticsImpl_AddRef(IGameStatistics *iface)
696 {
697 GameStatisticsImpl *This = impl_from_IGameStatistics( iface );
698 LONG ref;
699
700 ref = InterlockedIncrement(&This->ref);
701
702 TRACE("(%p): ref=%d\n", This, ref);
703 return ref;
704 }
705
706 static ULONG WINAPI GameStatisticsImpl_Release(IGameStatistics *iface)
707 {
708 GameStatisticsImpl *This = impl_from_IGameStatistics( iface );
709 LONG ref;
710
711 ref = InterlockedDecrement( &This->ref );
712 TRACE("(%p): ref=%d\n", This, ref);
713
714 if ( ref == 0 )
715 {
716 TRACE("freeing IGameStatistics\n");
717 HeapFree( GetProcessHeap(), 0, This );
718 }
719
720 return ref;
721 }
722
723 static HRESULT WINAPI GameStatisticsImpl_GetMaxCategoryLength(
724 IGameStatistics *iface,
725 UINT *cch)
726 {
727 TRACE("(%p, %p)\n", iface, cch);
728 if(!cch)
729 return E_INVALIDARG;
730
731 *cch = MAX_CATEGORY_LENGTH;
732 return S_OK;
733 }
734
735 static HRESULT WINAPI GameStatisticsImpl_GetMaxNameLength(
736 IGameStatistics *iface,
737 UINT *cch)
738 {
739 TRACE("(%p, %p)\n", iface, cch);
740 if(!cch)
741 return E_INVALIDARG;
742
743 *cch = MAX_NAME_LENGTH;
744 return S_OK;
745 }
746
747 static HRESULT WINAPI GameStatisticsImpl_GetMaxValueLength(
748 IGameStatistics *iface,
749 UINT *cch)
750 {
751 TRACE("(%p, %p)\n", iface, cch);
752 if(!cch)
753 return E_INVALIDARG;
754
755 *cch = MAX_VALUE_LENGTH;
756 return S_OK;
757 }
758
759 static HRESULT WINAPI GameStatisticsImpl_GetMaxCategories(
760 IGameStatistics *iface,
761 WORD *pMax)
762 {
763 TRACE("(%p, %p)\n", iface, pMax);
764 if(!pMax)
765 return E_INVALIDARG;
766
767 *pMax = MAX_CATEGORIES;
768 return S_OK;
769 }
770
771 static HRESULT WINAPI GameStatisticsImpl_GetMaxStatsPerCategory(
772 IGameStatistics *iface,
773 WORD *pMax)
774 {
775 TRACE("(%p, %p)\n", iface, pMax);
776 if(!pMax)
777 return E_INVALIDARG;
778
779 *pMax = MAX_STATS_PER_CATEGORY;
780 return S_OK;
781 }
782
783 static HRESULT WINAPI GameStatisticsImpl_SetCategoryTitle(
784 IGameStatistics *iface,
785 WORD categoryIndex,
786 LPCWSTR title)
787 {
788 HRESULT hr = S_OK;
789 DWORD dwLength;
790 GameStatisticsImpl *This = impl_from_IGameStatistics(iface);
791
792 TRACE("(%p, %d, %s)\n", This, categoryIndex, debugstr_w(title));
793
794 if(!title || categoryIndex >= MAX_CATEGORIES)
795 return E_INVALIDARG;
796
797 dwLength = lstrlenW(title);
798
799 if(dwLength > MAX_CATEGORY_LENGTH)
800 {
801 hr = S_FALSE;
802 dwLength = MAX_CATEGORY_LENGTH;
803 }
804
805 lstrcpynW(This->stats.categories[categoryIndex].sName,
806 title, dwLength+1);
807
808 return hr;
809 }
810
811 static HRESULT WINAPI GameStatisticsImpl_GetCategoryTitle(
812 IGameStatistics *iface,
813 WORD categoryIndex,
814 LPWSTR *pTitle)
815 {
816 HRESULT hr = S_OK;
817 LONG nLength;
818 GameStatisticsImpl *This = impl_from_IGameStatistics(iface);
819
820 TRACE("%p, %d, %p\n", This, categoryIndex, pTitle);
821
822 *pTitle = NULL;
823
824 if(!pTitle || categoryIndex >= MAX_CATEGORIES)
825 hr = E_INVALIDARG;
826
827
828 if(SUCCEEDED(hr))
829 {
830 nLength = lstrlenW(This->stats.categories[categoryIndex].sName);
831 if(nLength != 0)
832 {
833 *pTitle = CoTaskMemAlloc(sizeof(WCHAR)*(nLength+1));
834 lstrcpyW(*pTitle, This->stats.categories[categoryIndex].sName);
835 }
836 }
837
838 return hr;
839 }
840
841 static HRESULT WINAPI GameStatisticsImpl_GetStatistic(
842 IGameStatistics *iface,
843 WORD categoryIndex,
844 WORD statIndex,
845 LPWSTR *pName,
846 LPWSTR *pValue)
847 {
848 HRESULT hr = S_OK;
849 LONG nLength;
850 GameStatisticsImpl *This = impl_from_IGameStatistics(iface);
851
852 TRACE("%p, %d,%d, %p, %p\n", This, categoryIndex, statIndex, pName, pValue);
853
854 if(!pName || !pValue)
855 return E_INVALIDARG;
856
857 *pName = NULL;
858 *pValue = NULL;
859
860 if(categoryIndex >= MAX_CATEGORIES || statIndex >= MAX_STATS_PER_CATEGORY)
861 hr = E_INVALIDARG;
862
863 if(SUCCEEDED(hr))
864 {
865 nLength = lstrlenW(This->stats.categories[categoryIndex].stats[statIndex].sName);
866 if(nLength != 0)
867 {
868 *pName = CoTaskMemAlloc(sizeof(WCHAR)*(nLength+1));
869 if(!(*pName))
870 hr = E_OUTOFMEMORY;
871 else
872 lstrcpyW(*pName, This->stats.categories[categoryIndex].stats[statIndex].sName);
873 }
874 }
875
876 if(SUCCEEDED(hr))
877 {
878 nLength = lstrlenW(This->stats.categories[categoryIndex].stats[statIndex].sValue);
879 if(nLength != 0)
880 {
881 *pValue = CoTaskMemAlloc(sizeof(WCHAR)*(nLength+1));
882 if(!(*pValue))
883 hr = E_OUTOFMEMORY;
884 else
885 lstrcpyW(*pValue, This->stats.categories[categoryIndex].stats[statIndex].sValue);
886 }
887 }
888
889 TRACE("returning pair; %s => %s\n", debugstr_w(*pName), debugstr_w(*pValue));
890 return hr;
891 }
892
893 static HRESULT WINAPI GameStatisticsImpl_SetStatistic(
894 IGameStatistics *iface,
895 WORD categoryIndex,
896 WORD statIndex,
897 LPCWSTR name,
898 LPCWSTR value)
899 {
900 HRESULT hr = S_OK;
901 DWORD dwNameLen, dwValueLen;
902 GameStatisticsImpl *This = impl_from_IGameStatistics(iface);
903
904 TRACE("(%p, %d, %d, %s, %s)\n", This, categoryIndex, statIndex,
905 debugstr_w(name), debugstr_w(value));
906
907 if(!name)
908 return S_FALSE;
909
910 if(categoryIndex >= MAX_CATEGORIES || statIndex >= MAX_STATS_PER_CATEGORY)
911 return E_INVALIDARG;
912
913 dwNameLen = lstrlenW(name);
914
915 if(dwNameLen > MAX_NAME_LENGTH)
916 {
917 hr = S_FALSE;
918 dwNameLen = MAX_NAME_LENGTH;
919 }
920
921 lstrcpynW(This->stats.categories[categoryIndex].stats[statIndex].sName,
922 name, dwNameLen+1);
923
924 if(value)
925 {
926 dwValueLen = lstrlenW(value);
927
928 if(dwValueLen > MAX_VALUE_LENGTH)
929 {
930 hr = S_FALSE;
931 dwValueLen = MAX_VALUE_LENGTH;
932 }
933
934 lstrcpynW(This->stats.categories[categoryIndex].stats[statIndex].sValue,
935 value, dwValueLen+1);
936 }
937 else
938 /* Windows allows to pass NULL as value */
939 This->stats.categories[categoryIndex].stats[statIndex].sValue[0] = 0;
940
941 return hr;
942 }
943
944 static HRESULT WINAPI GameStatisticsImpl_Save(
945 IGameStatistics *iface,
946 BOOL trackChanges)
947 {
948 GameStatisticsImpl *This = impl_from_IGameStatistics(iface);
949 HRESULT hr = S_OK;
950
951 TRACE("(%p, %d)\n", This, trackChanges);
952
953 if(trackChanges == TRUE)
954 FIXME("tracking changes not yet implemented\n");
955
956 hr = GAMEUX_updateStatisticsFile(&This->stats);
957
958 return hr;
959 }
960
961 static HRESULT WINAPI GameStatisticsImpl_SetLastPlayedCategory(
962 IGameStatistics *iface,
963 UINT categoryIndex)
964 {
965 FIXME("stub\n");
966 return E_NOTIMPL;
967 }
968
969 static HRESULT WINAPI GameStatisticsImpl_GetLastPlayedCategory(
970 IGameStatistics *iface,
971 UINT *pCategoryIndex)
972 {
973 FIXME("stub\n");
974 return E_NOTIMPL;
975 }
976
977 static const struct IGameStatisticsVtbl GameStatisticsImplVtbl =
978 {
979 GameStatisticsImpl_QueryInterface,
980 GameStatisticsImpl_AddRef,
981 GameStatisticsImpl_Release,
982 GameStatisticsImpl_GetMaxCategoryLength,
983 GameStatisticsImpl_GetMaxNameLength,
984 GameStatisticsImpl_GetMaxValueLength,
985 GameStatisticsImpl_GetMaxCategories,
986 GameStatisticsImpl_GetMaxStatsPerCategory,
987 GameStatisticsImpl_SetCategoryTitle,
988 GameStatisticsImpl_GetCategoryTitle,
989 GameStatisticsImpl_GetStatistic,
990 GameStatisticsImpl_SetStatistic,
991 GameStatisticsImpl_Save,
992 GameStatisticsImpl_SetLastPlayedCategory,
993 GameStatisticsImpl_GetLastPlayedCategory
994 };
995
996
997 HRESULT create_IGameStatistics(GameStatisticsImpl** ppStats)
998 {
999 TRACE("(%p)\n", ppStats);
1000
1001 *ppStats = HeapAlloc( GetProcessHeap(), 0, sizeof(**ppStats));
1002 if(!(*ppStats))
1003 return E_OUTOFMEMORY;
1004
1005 (*ppStats)->lpVtbl = &GameStatisticsImplVtbl;
1006 (*ppStats)->ref = 1;
1007
1008 TRACE("returning coclass: %p\n", *ppStats);
1009 return S_OK;
1010 }
1011
1012 /*******************************************************************************
1013 * IGameStatisticsMgr implementation
1014 */
1015 typedef struct _GameStatisticsMgrImpl
1016 {
1017 const struct IGameStatisticsMgrVtbl *lpVtbl;
1018 LONG ref;
1019 } GameStatisticsMgrImpl;
1020
1021 static inline GameStatisticsMgrImpl *impl_from_IGameStatisticsMgr( IGameStatisticsMgr *iface )
1022 {
1023 return (GameStatisticsMgrImpl *)((char*)iface - FIELD_OFFSET(GameStatisticsMgrImpl, lpVtbl));
1024 }
1025
1026
1027 static HRESULT WINAPI GameStatisticsMgrImpl_QueryInterface(
1028 IGameStatisticsMgr *iface,
1029 REFIID riid,
1030 void **ppvObject)
1031 {
1032 GameStatisticsMgrImpl *This = impl_from_IGameStatisticsMgr( iface );
1033
1034 TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
1035
1036 *ppvObject = NULL;
1037
1038 if(IsEqualGUID(riid, &IID_IUnknown) ||
1039 IsEqualGUID(riid, &IID_IGameStatisticsMgr) )
1040 {
1041 *ppvObject = iface;
1042 }
1043 else
1044 {
1045 FIXME("interface %s not implemented\n", debugstr_guid(riid));
1046 return E_NOINTERFACE;
1047 }
1048
1049 IGameStatisticsMgr_AddRef( iface );
1050 return S_OK;
1051 }
1052
1053 static ULONG WINAPI GameStatisticsMgrImpl_AddRef(IGameStatisticsMgr *iface)
1054 {
1055 GameStatisticsMgrImpl *This = impl_from_IGameStatisticsMgr( iface );
1056 LONG ref;
1057
1058 ref = InterlockedIncrement(&This->ref);
1059
1060 TRACE("(%p): ref=%d\n", This, ref);
1061 return ref;
1062 }
1063
1064 static ULONG WINAPI GameStatisticsMgrImpl_Release(IGameStatisticsMgr *iface)
1065 {
1066 GameStatisticsMgrImpl *This = impl_from_IGameStatisticsMgr( iface );
1067 LONG ref;
1068
1069 ref = InterlockedDecrement(&This->ref);
1070 TRACE("(%p): ref=%d\n", This, ref);
1071
1072 if ( ref == 0 )
1073 {
1074 TRACE("freeing GameStatistics object\n");
1075 HeapFree( GetProcessHeap(), 0, This);
1076 }
1077
1078 return ref;
1079 }
1080
1081 static HRESULT STDMETHODCALLTYPE GameStatisticsMgrImpl_GetGameStatistics(
1082 IGameStatisticsMgr* iface,
1083 LPCWSTR GDFBinaryPath,
1084 GAMESTATS_OPEN_TYPE openType,
1085 GAMESTATS_OPEN_RESULT *pOpenResult,
1086 IGameStatistics **ppiStats)
1087 {
1088 HRESULT hr;
1089 WCHAR lpApplicationId[49];
1090 GameStatisticsImpl *statisticsImpl = NULL;
1091 IGameStatistics *output_iface;
1092
1093 TRACE("(%p, %s, 0x%x, %p, %p)\n", iface, debugstr_w(GDFBinaryPath), openType, pOpenResult, ppiStats);
1094
1095 hr = GAMEUX_getAppIdFromGDFPath(GDFBinaryPath, lpApplicationId);
1096
1097 if(SUCCEEDED(hr))
1098 hr = create_IGameStatistics(&statisticsImpl);
1099
1100 if(SUCCEEDED(hr))
1101 {
1102 output_iface = IGameStatistics_from_impl(statisticsImpl);
1103 hr = GAMEUX_buildStatisticsFilePath(lpApplicationId, statisticsImpl->stats.sStatsFile);
1104 }
1105
1106 if(SUCCEEDED(hr))
1107 hr = GAMEUX_loadGameStatistics(&statisticsImpl->stats, lpApplicationId, openType, pOpenResult);
1108
1109 if(SUCCEEDED(hr))
1110 *ppiStats = output_iface;
1111 else
1112 {
1113 HeapFree(GetProcessHeap(), 0, statisticsImpl);
1114 *ppiStats = NULL;
1115 }
1116
1117 return hr;
1118 }
1119
1120 static HRESULT STDMETHODCALLTYPE GameStatisticsMgrImpl_RemoveGameStatistics(
1121 IGameStatisticsMgr* iface,
1122 LPCWSTR GDFBinaryPath)
1123 {
1124 HRESULT hr;
1125 WCHAR lpApplicationId[49];
1126 WCHAR sStatsFile[MAX_PATH];
1127
1128 TRACE("(%p, %s)\n", iface, debugstr_w(GDFBinaryPath));
1129
1130 hr = GAMEUX_getAppIdFromGDFPath(GDFBinaryPath, lpApplicationId);
1131
1132 if(SUCCEEDED(hr))
1133 hr = GAMEUX_buildStatisticsFilePath(lpApplicationId, sStatsFile);
1134
1135 if(SUCCEEDED(hr))
1136 hr = (DeleteFileW(sStatsFile)==TRUE ? S_OK : HRESULT_FROM_WIN32(GetLastError()));
1137
1138 return hr;
1139 }
1140
1141 static const struct IGameStatisticsMgrVtbl GameStatisticsMgrImplVtbl =
1142 {
1143 GameStatisticsMgrImpl_QueryInterface,
1144 GameStatisticsMgrImpl_AddRef,
1145 GameStatisticsMgrImpl_Release,
1146 GameStatisticsMgrImpl_GetGameStatistics,
1147 GameStatisticsMgrImpl_RemoveGameStatistics,
1148 };
1149
1150 HRESULT GameStatistics_create(
1151 IUnknown *pUnkOuter,
1152 IUnknown **ppObj)
1153 {
1154 GameStatisticsMgrImpl *pGameStatistics;
1155
1156 TRACE("(%p, %p)\n", pUnkOuter, ppObj);
1157
1158 pGameStatistics = HeapAlloc( GetProcessHeap(), 0, sizeof (*pGameStatistics) );
1159
1160 if( !pGameStatistics )
1161 return E_OUTOFMEMORY;
1162
1163 pGameStatistics->lpVtbl = &GameStatisticsMgrImplVtbl;
1164 pGameStatistics->ref = 1;
1165
1166 *ppObj = (IUnknown*)(&pGameStatistics->lpVtbl);
1167
1168 TRACE("returning iface %p\n", *ppObj);
1169 return S_OK;
1170 }
Maarten's multimedia branch