2 * Gameux library coclass GameStatistics implementation
4 * Copyright (C) 2010 Mariusz PluciĆski
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.
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.
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
31 #include "gameux_private.h"
33 #include "wine/debug.h"
35 WINE_DEFAULT_DEBUG_CHANNEL(gameux
);
38 * constant definitions
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
48 /*******************************************************************************
51 * set of structures for containing game's data
53 struct GAMEUX_STATS_STAT
55 WCHAR sName
[MAX_NAME_LENGTH
+1];
56 WCHAR sValue
[MAX_VALUE_LENGTH
+1];
58 struct GAMEUX_STATS_CATEGORY
60 WCHAR sName
[MAX_CATEGORY_LENGTH
+1];
61 struct GAMEUX_STATS_STAT stats
[MAX_STATS_PER_CATEGORY
];
65 WCHAR sStatsFile
[MAX_PATH
];
66 struct GAMEUX_STATS_CATEGORY categories
[MAX_CATEGORIES
];
68 /*******************************************************************************
69 * GAMEUX_createStatsDirectory
71 * Helper function, creates directory to store game statistics
74 * path [I] path to game statistics file.
75 * base directory of this file will
76 * be created if it doesn't exists
78 static HRESULT
GAMEUX_createStatsDirectory(LPCWSTR lpFilePath
)
81 WCHAR lpDirectoryPath
[MAX_PATH
];
84 lpEnd
= StrRChrW(lpFilePath
, NULL
, '\\');
85 lstrcpynW(lpDirectoryPath
, lpFilePath
, lpEnd
-lpFilePath
+1);
87 hr
= HRESULT_FROM_WIN32(SHCreateDirectoryExW(NULL
, lpDirectoryPath
, NULL
));
89 if(hr
== HRESULT_FROM_WIN32(ERROR_FILE_EXISTS
) ||
90 hr
== HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS
))
95 /*******************************************************************
96 * GAMEUX_updateStatisticsFile
98 * Helper function updating data stored in statistics file
101 * data [I] pointer to struct containing
104 static HRESULT
GAMEUX_updateStatisticsFile(struct GAMEUX_STATS
*stats
)
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};
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
;
122 TRACE("(%p)\n", stats
);
124 V_VT(&vStatsFilePath
) = VT_BSTR
;
125 V_BSTR(&vStatsFilePath
) = SysAllocString(stats
->sStatsFile
);
126 if(!V_BSTR(&vStatsFilePath
))
130 hr
= CoCreateInstance(&CLSID_DOMDocument
, NULL
, CLSCTX_INPROC_SERVER
,
131 &IID_IXMLDOMDocument
, (void**)&document
);
135 bstrStatistics
= SysAllocString(sStatistics
);
141 hr
= IXMLDOMDocument_createElement(document
, bstrStatistics
, &root
);
145 bstrCategory
= SysAllocString(sCategory
);
152 bstrIndex
= SysAllocString(sIndex
);
159 bstrStatistic
= SysAllocString(sStatistic
);
166 bstrName
= SysAllocString(sName
);
173 bstrValue
= SysAllocString(sValue
);
181 for(i
=0; i
<MAX_CATEGORIES
; ++i
)
183 if(lstrlenW(stats
->categories
[i
].sName
)==0)
186 V_VT(&vValue
) = VT_INT
;
187 V_INT(&vValue
) = NODE_ELEMENT
;
189 hr
= IXMLDOMDocument_createNode(document
, vValue
, bstrCategory
, NULL
, &categoryNode
);
192 hr
= IXMLDOMNode_QueryInterface(categoryNode
, &IID_IXMLDOMElement
, (LPVOID
*)&categoryElement
);
196 hr
= IXMLDOMElement_setAttribute(categoryElement
, bstrIndex
, vValue
);
200 V_VT(&vValue
) = VT_BSTR
;
201 V_BSTR(&vValue
) = SysAllocString(stats
->categories
[i
].sName
);
208 TRACE("storing category %d: %s\n", i
, debugstr_w(V_BSTR(&vValue
)));
209 hr
= IXMLDOMElement_setAttribute(categoryElement
, bstrName
, vValue
);
212 SysFreeString(V_BSTR(&vValue
));
216 for(j
=0; j
<MAX_STATS_PER_CATEGORY
; ++j
)
218 if(lstrlenW(stats
->categories
[i
].stats
[j
].sName
)==0)
221 V_VT(&vValue
) = VT_INT
;
222 V_INT(&vValue
) = NODE_ELEMENT
;
224 hr
= IXMLDOMDocument_createNode(document
, vValue
, bstrStatistic
, NULL
, &statisticsNode
);
227 hr
= IXMLDOMNode_QueryInterface(statisticsNode
, &IID_IXMLDOMElement
, (LPVOID
*)&statisticsElement
);
231 hr
= IXMLDOMElement_setAttribute(statisticsElement
, bstrIndex
, vValue
);
235 V_VT(&vValue
) = VT_BSTR
;
236 V_BSTR(&vValue
) = SysAllocString(stats
->categories
[i
].stats
[j
].sName
);
243 TRACE(" storing statistic %d: name: %s\n", j
, debugstr_w(V_BSTR(&vValue
)));
244 hr
= IXMLDOMElement_setAttribute(statisticsElement
, bstrName
, vValue
);
247 SysFreeString(V_BSTR(&vValue
));
251 V_VT(&vValue
) = VT_BSTR
;
252 V_BSTR(&vValue
) = SysAllocString(stats
->categories
[i
].stats
[j
].sValue
);
259 TRACE(" storing statistic %d: name: %s\n", j
, debugstr_w(V_BSTR(&vValue
)));
260 hr
= IXMLDOMElement_setAttribute(statisticsElement
, bstrValue
, vValue
);
263 SysFreeString(V_BSTR(&vValue
));
266 hr
= IXMLDOMElement_appendChild(categoryNode
, statisticsNode
, &statisticsNode
);
268 IXMLDOMElement_Release(statisticsElement
);
269 IXMLDOMNode_Release(statisticsNode
);
274 hr
= IXMLDOMElement_appendChild(root
, categoryNode
, &categoryNode
);
276 IXMLDOMElement_Release(categoryElement
);
277 IXMLDOMNode_Release(categoryNode
);
284 hr
= IXMLDOMDocument_putref_documentElement(document
, root
);
286 IXMLDOMElement_Release(root
);
288 TRACE("saving game statistics in %s file\n", debugstr_w(stats
->sStatsFile
));
290 hr
= GAMEUX_createStatsDirectory(stats
->sStatsFile
);
293 hr
= IXMLDOMDocument_save(document
, vStatsFilePath
);
295 IXMLDOMDocument_Release(document
);
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
);
307 /*******************************************************************************
308 * GAMEUX_buildStatisticsFilePath
309 * Creates path to file containing statistics of game with given id.
312 * lpApplicationId [I] application id of game,
314 * lpStatisticsFile [O] array where path will be
315 * stored. Its size must be
318 static HRESULT
GAMEUX_buildStatisticsFilePath(
319 LPCWSTR lpApplicationId
,
320 LPWSTR lpStatisticsFile
)
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};
331 hr
= SHGetFolderPathW(NULL
, CSIDL_LOCAL_APPDATA
, NULL
, SHGFP_TYPE_CURRENT
, lpStatisticsFile
);
335 lstrcatW(lpStatisticsFile
, sStatisticsDir
);
336 lstrcatW(lpStatisticsFile
, lpApplicationId
);
337 lstrcatW(lpStatisticsFile
, sBackslash
);
338 lstrcatW(lpStatisticsFile
, lpApplicationId
);
339 lstrcatW(lpStatisticsFile
, sDotGamestats
);
344 /*******************************************************************************
345 * GAMEUX_getAppIdFromGDFPath
347 * Loads application identifier associated with given GDF binary.
348 * Routine reads identifier from registry, so will fail if game
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
357 static HRESULT
GAMEUX_getAppIdFromGDFPath(
358 LPCWSTR GDFBinaryPath
,
359 LPWSTR lpApplicationId
)
361 static const WCHAR sApplicationId
[] =
362 {'A','p','p','l','i','c','a','t','i','o','n','I','d',0};
365 GAME_INSTALL_SCOPE installScope
;
367 LPWSTR lpRegistryPath
= NULL
;
369 DWORD dwLength
= 49*sizeof(WCHAR
);/* place for GUID */
371 TRACE("(%s, %p)\n", debugstr_w(GDFBinaryPath
), lpApplicationId
);
376 installScope
= GIS_CURRENT_USER
;
377 hr
= GAMEUX_FindGameInstanceId(GDFBinaryPath
, installScope
, &instanceId
);
381 installScope
= GIS_ALL_USERS
;
382 hr
= GAMEUX_FindGameInstanceId(GDFBinaryPath
, installScope
, &instanceId
);
386 /* game not registered, so statistics cannot be used */
390 /* game is registered, let's read it's application id from registry */
391 hr
= GAMEUX_buildGameRegistryPath(installScope
, &instanceId
, &lpRegistryPath
);
394 hr
= HRESULT_FROM_WIN32(RegOpenKeyExW(HKEY_LOCAL_MACHINE
,
395 lpRegistryPath
, 0, KEY_READ
| KEY_WOW64_64KEY
, &hKey
));
398 hr
= HRESULT_FROM_WIN32(RegGetValueW(hKey
,
399 NULL
, sApplicationId
, RRF_RT_REG_SZ
,
400 NULL
, lpApplicationId
, &dwLength
));
402 HeapFree(GetProcessHeap(), 0, lpRegistryPath
);
405 TRACE("found app id: %s, return: %#x\n", debugstr_w(lpApplicationId
), hr
);
408 /*******************************************************************
409 * GAMEUX_loadGameStatisticsFromFile
410 * Helper function, loads game statistics from file and stores them
414 * data [I/O] structure containing file name to
415 * load and data fields to store data in
417 static HRESULT
GAMEUX_loadStatisticsFromFile(struct GAMEUX_STATS
*data
)
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};
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
;
437 TRACE("(%p)\n", data
);
439 V_VT(&vStatsFilePath
) = VT_BSTR
;
440 V_BSTR(&vStatsFilePath
) = SysAllocString(data
->sStatsFile
);
441 if(!V_BSTR(&vStatsFilePath
))
445 hr
= CoCreateInstance(&CLSID_DOMDocument30
, NULL
, CLSCTX_INPROC_SERVER
, &IID_IXMLDOMDocument
, (void**)&document
);
449 bstrStatistics
= SysAllocString(sStatistics
);
456 bstrCategory
= SysAllocString(sCategory
);
463 bstrIndex
= SysAllocString(sIndex
);
470 bstrStatistic
= SysAllocString(sStatistic
);
477 bstrName
= SysAllocString(sName
);
484 bstrValue
= SysAllocString(sValue
);
490 hr
= IXMLDOMDocument_load(document
, vStatsFilePath
, &isSuccessful
);
492 if(hr
== S_OK
&& isSuccessful
!= VARIANT_TRUE
)
496 hr
= IXMLDOMDocument_get_documentElement(document
, &root
);
499 hr
= IXMLDOMElement_get_childNodes(root
, &rootChildren
);
506 hr
= IXMLDOMNodeList_nextNode(rootChildren
, &categoryNode
);
510 hr
= IXMLDOMNode_QueryInterface(categoryNode
, &IID_IXMLDOMElement
, (LPVOID
*)&categoryElement
);
514 hr
= IXMLDOMElement_getAttribute(categoryElement
, bstrIndex
, &vValue
);
515 if( hr
== S_OK
&& V_VT(&vValue
) != VT_BSTR
)
520 i
= StrToIntW(V_BSTR(&vValue
));
521 hr
= IXMLDOMElement_getAttribute(categoryElement
, bstrName
, &vValue
);
522 if( hr
== S_OK
&& V_VT(&vValue
) != VT_BSTR
)
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
);
538 hr
= IXMLDOMNodeList_nextNode(categoryChildren
, &statisticNode
);
542 hr
= IXMLDOMNode_QueryInterface(statisticNode
, &IID_IXMLDOMElement
, (LPVOID
*)&statisticElement
);
546 hr
= IXMLDOMElement_getAttribute(statisticElement
, bstrIndex
, &vValue
);
547 if( hr
== S_OK
&& V_VT(&vValue
) != VT_BSTR
)
552 j
= StrToIntW(V_BSTR(&vValue
));
553 hr
= IXMLDOMElement_getAttribute(statisticElement
, bstrName
, &vValue
);
554 if( hr
== S_OK
&& V_VT(&vValue
) != VT_BSTR
)
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
)
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
));
573 IXMLDOMElement_Release(statisticElement
);
576 IXMLDOMNode_Release(statisticNode
);
583 IXMLDOMElement_Release(categoryElement
);
586 IXMLDOMNode_Release(categoryNode
);
593 if(rootChildren
) IXMLDOMNodeList_Release(rootChildren
);
594 if(root
) IXMLDOMElement_Release(root
);
595 if(document
) IXMLDOMDocument_Release(document
);
597 SysFreeString(bstrValue
);
598 SysFreeString(bstrName
);
599 SysFreeString(bstrStatistic
);
600 SysFreeString(bstrIndex
);
601 SysFreeString(bstrCategory
);
602 SysFreeString(bstrStatistics
);
603 SysFreeString(V_BSTR(&vStatsFilePath
));
606 /*******************************************************************
607 * GAMEUX_loadGameStatistics
609 * Helper function which loads game statistics associated with game
610 * into interface's internal structures
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
620 static HRESULT
GAMEUX_loadGameStatistics(struct GAMEUX_STATS
*pStats
,
622 GAMESTATS_OPEN_TYPE openType
,
623 GAMESTATS_OPEN_RESULT
* pOpenResult
)
626 TRACE("(%p, %s, %d, %p)\n", pStats
, debugstr_w(sGameId
), openType
, pOpenResult
);
628 hr
= GAMEUX_buildStatisticsFilePath(sGameId
, pStats
->sStatsFile
);
630 hr
= GAMEUX_loadStatisticsFromFile(pStats
);
631 TRACE("ldstats finished, res: %#x\n", hr
);
634 *pOpenResult
= GAMESTATS_OPEN_OPENED
;
636 else if(hr
== S_FALSE
&& openType
== GAMESTATS_OPEN_OPENORCREATE
) /* file does not exist */
638 /* create new statistics, not yet connected with file */
639 ZeroMemory(pStats
->categories
, sizeof(pStats
->categories
));
640 *pOpenResult
= GAMESTATS_OPEN_CREATED
;
644 hr
= HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND
);
646 TRACE("openResult=%#x ret=%#x\n", *pOpenResult
, hr
);
649 /*******************************************************************
650 * IGameStatistics implementation
652 typedef struct _GameStatisticsImpl
654 IGameStatistics IGameStatistics_iface
;
656 struct GAMEUX_STATS stats
;
657 } GameStatisticsImpl
;
659 static inline GameStatisticsImpl
*impl_from_IGameStatistics( IGameStatistics
*iface
)
661 return CONTAINING_RECORD(iface
, GameStatisticsImpl
, IGameStatistics_iface
);
664 static HRESULT WINAPI
GameStatisticsImpl_QueryInterface(
665 IGameStatistics
*iface
,
669 GameStatisticsImpl
*This
= impl_from_IGameStatistics( iface
);
671 TRACE("%p %s %p\n", This
, debugstr_guid( riid
), ppvObject
);
675 if ( IsEqualGUID( riid
, &IID_IUnknown
) ||
676 IsEqualGUID( riid
, &IID_IGameStatistics
) )
682 FIXME("interface %s not implemented\n", debugstr_guid(riid
));
683 return E_NOINTERFACE
;
686 IGameStatistics_AddRef( iface
);
690 static ULONG WINAPI
GameStatisticsImpl_AddRef(IGameStatistics
*iface
)
692 GameStatisticsImpl
*This
= impl_from_IGameStatistics( iface
);
695 ref
= InterlockedIncrement(&This
->ref
);
697 TRACE("(%p): ref=%d\n", This
, ref
);
701 static ULONG WINAPI
GameStatisticsImpl_Release(IGameStatistics
*iface
)
703 GameStatisticsImpl
*This
= impl_from_IGameStatistics( iface
);
706 ref
= InterlockedDecrement( &This
->ref
);
707 TRACE("(%p): ref=%d\n", This
, ref
);
711 TRACE("freeing IGameStatistics\n");
712 HeapFree( GetProcessHeap(), 0, This
);
718 static HRESULT WINAPI
GameStatisticsImpl_GetMaxCategoryLength(
719 IGameStatistics
*iface
,
722 TRACE("(%p, %p)\n", iface
, cch
);
726 *cch
= MAX_CATEGORY_LENGTH
;
730 static HRESULT WINAPI
GameStatisticsImpl_GetMaxNameLength(
731 IGameStatistics
*iface
,
734 TRACE("(%p, %p)\n", iface
, cch
);
738 *cch
= MAX_NAME_LENGTH
;
742 static HRESULT WINAPI
GameStatisticsImpl_GetMaxValueLength(
743 IGameStatistics
*iface
,
746 TRACE("(%p, %p)\n", iface
, cch
);
750 *cch
= MAX_VALUE_LENGTH
;
754 static HRESULT WINAPI
GameStatisticsImpl_GetMaxCategories(
755 IGameStatistics
*iface
,
758 TRACE("(%p, %p)\n", iface
, pMax
);
762 *pMax
= MAX_CATEGORIES
;
766 static HRESULT WINAPI
GameStatisticsImpl_GetMaxStatsPerCategory(
767 IGameStatistics
*iface
,
770 TRACE("(%p, %p)\n", iface
, pMax
);
774 *pMax
= MAX_STATS_PER_CATEGORY
;
778 static HRESULT WINAPI
GameStatisticsImpl_SetCategoryTitle(
779 IGameStatistics
*iface
,
785 GameStatisticsImpl
*This
= impl_from_IGameStatistics(iface
);
787 TRACE("(%p, %d, %s)\n", This
, categoryIndex
, debugstr_w(title
));
789 if(!title
|| categoryIndex
>= MAX_CATEGORIES
)
792 dwLength
= lstrlenW(title
);
794 if(dwLength
> MAX_CATEGORY_LENGTH
)
797 dwLength
= MAX_CATEGORY_LENGTH
;
800 lstrcpynW(This
->stats
.categories
[categoryIndex
].sName
,
806 static HRESULT WINAPI
GameStatisticsImpl_GetCategoryTitle(
807 IGameStatistics
*iface
,
813 GameStatisticsImpl
*This
= impl_from_IGameStatistics(iface
);
815 TRACE("%p, %d, %p\n", This
, categoryIndex
, pTitle
);
821 if (categoryIndex
>= MAX_CATEGORIES
)
826 nLength
= lstrlenW(This
->stats
.categories
[categoryIndex
].sName
);
829 *pTitle
= CoTaskMemAlloc(sizeof(WCHAR
)*(nLength
+1));
830 lstrcpyW(*pTitle
, This
->stats
.categories
[categoryIndex
].sName
);
837 static HRESULT WINAPI
GameStatisticsImpl_GetStatistic(
838 IGameStatistics
*iface
,
846 GameStatisticsImpl
*This
= impl_from_IGameStatistics(iface
);
848 TRACE("%p, %d,%d, %p, %p\n", This
, categoryIndex
, statIndex
, pName
, pValue
);
850 if(!pName
|| !pValue
)
856 if(categoryIndex
>= MAX_CATEGORIES
|| statIndex
>= MAX_STATS_PER_CATEGORY
)
861 nLength
= lstrlenW(This
->stats
.categories
[categoryIndex
].stats
[statIndex
].sName
);
864 *pName
= CoTaskMemAlloc(sizeof(WCHAR
)*(nLength
+1));
868 lstrcpyW(*pName
, This
->stats
.categories
[categoryIndex
].stats
[statIndex
].sName
);
874 nLength
= lstrlenW(This
->stats
.categories
[categoryIndex
].stats
[statIndex
].sValue
);
877 *pValue
= CoTaskMemAlloc(sizeof(WCHAR
)*(nLength
+1));
881 lstrcpyW(*pValue
, This
->stats
.categories
[categoryIndex
].stats
[statIndex
].sValue
);
885 TRACE("returning pair; %s => %s\n", debugstr_w(*pName
), debugstr_w(*pValue
));
889 static HRESULT WINAPI
GameStatisticsImpl_SetStatistic(
890 IGameStatistics
*iface
,
897 DWORD dwNameLen
, dwValueLen
;
898 GameStatisticsImpl
*This
= impl_from_IGameStatistics(iface
);
900 TRACE("(%p, %d, %d, %s, %s)\n", This
, categoryIndex
, statIndex
,
901 debugstr_w(name
), debugstr_w(value
));
906 if(categoryIndex
>= MAX_CATEGORIES
|| statIndex
>= MAX_STATS_PER_CATEGORY
)
909 dwNameLen
= lstrlenW(name
);
911 if(dwNameLen
> MAX_NAME_LENGTH
)
914 dwNameLen
= MAX_NAME_LENGTH
;
917 lstrcpynW(This
->stats
.categories
[categoryIndex
].stats
[statIndex
].sName
,
922 dwValueLen
= lstrlenW(value
);
924 if(dwValueLen
> MAX_VALUE_LENGTH
)
927 dwValueLen
= MAX_VALUE_LENGTH
;
930 lstrcpynW(This
->stats
.categories
[categoryIndex
].stats
[statIndex
].sValue
,
931 value
, dwValueLen
+1);
934 /* Windows allows to pass NULL as value */
935 This
->stats
.categories
[categoryIndex
].stats
[statIndex
].sValue
[0] = 0;
940 static HRESULT WINAPI
GameStatisticsImpl_Save(
941 IGameStatistics
*iface
,
944 GameStatisticsImpl
*This
= impl_from_IGameStatistics(iface
);
947 TRACE("(%p, %d)\n", This
, trackChanges
);
949 if(trackChanges
== TRUE
)
950 FIXME("tracking changes not yet implemented\n");
952 hr
= GAMEUX_updateStatisticsFile(&This
->stats
);
957 static HRESULT WINAPI
GameStatisticsImpl_SetLastPlayedCategory(
958 IGameStatistics
*iface
,
965 static HRESULT WINAPI
GameStatisticsImpl_GetLastPlayedCategory(
966 IGameStatistics
*iface
,
967 UINT
*pCategoryIndex
)
973 static const struct IGameStatisticsVtbl GameStatisticsImplVtbl
=
975 GameStatisticsImpl_QueryInterface
,
976 GameStatisticsImpl_AddRef
,
977 GameStatisticsImpl_Release
,
978 GameStatisticsImpl_GetMaxCategoryLength
,
979 GameStatisticsImpl_GetMaxNameLength
,
980 GameStatisticsImpl_GetMaxValueLength
,
981 GameStatisticsImpl_GetMaxCategories
,
982 GameStatisticsImpl_GetMaxStatsPerCategory
,
983 GameStatisticsImpl_SetCategoryTitle
,
984 GameStatisticsImpl_GetCategoryTitle
,
985 GameStatisticsImpl_GetStatistic
,
986 GameStatisticsImpl_SetStatistic
,
987 GameStatisticsImpl_Save
,
988 GameStatisticsImpl_SetLastPlayedCategory
,
989 GameStatisticsImpl_GetLastPlayedCategory
993 static HRESULT
create_IGameStatistics(GameStatisticsImpl
** ppStats
)
995 TRACE("(%p)\n", ppStats
);
997 *ppStats
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(**ppStats
));
999 return E_OUTOFMEMORY
;
1001 (*ppStats
)->IGameStatistics_iface
.lpVtbl
= &GameStatisticsImplVtbl
;
1002 (*ppStats
)->ref
= 1;
1004 TRACE("returning coclass: %p\n", *ppStats
);
1008 /*******************************************************************************
1009 * IGameStatisticsMgr implementation
1011 typedef struct _GameStatisticsMgrImpl
1013 IGameStatisticsMgr IGameStatisticsMgr_iface
;
1015 } GameStatisticsMgrImpl
;
1017 static inline GameStatisticsMgrImpl
*impl_from_IGameStatisticsMgr( IGameStatisticsMgr
*iface
)
1019 return CONTAINING_RECORD(iface
, GameStatisticsMgrImpl
, IGameStatisticsMgr_iface
);
1023 static HRESULT WINAPI
GameStatisticsMgrImpl_QueryInterface(
1024 IGameStatisticsMgr
*iface
,
1028 GameStatisticsMgrImpl
*This
= impl_from_IGameStatisticsMgr( iface
);
1030 TRACE("%p %s %p\n", This
, debugstr_guid( riid
), ppvObject
);
1034 if(IsEqualGUID(riid
, &IID_IUnknown
) ||
1035 IsEqualGUID(riid
, &IID_IGameStatisticsMgr
) )
1041 FIXME("interface %s not implemented\n", debugstr_guid(riid
));
1042 return E_NOINTERFACE
;
1045 IGameStatisticsMgr_AddRef( iface
);
1049 static ULONG WINAPI
GameStatisticsMgrImpl_AddRef(IGameStatisticsMgr
*iface
)
1051 GameStatisticsMgrImpl
*This
= impl_from_IGameStatisticsMgr( iface
);
1054 ref
= InterlockedIncrement(&This
->ref
);
1056 TRACE("(%p): ref=%d\n", This
, ref
);
1060 static ULONG WINAPI
GameStatisticsMgrImpl_Release(IGameStatisticsMgr
*iface
)
1062 GameStatisticsMgrImpl
*This
= impl_from_IGameStatisticsMgr( iface
);
1065 ref
= InterlockedDecrement(&This
->ref
);
1066 TRACE("(%p): ref=%d\n", This
, ref
);
1070 TRACE("freeing GameStatistics object\n");
1071 HeapFree( GetProcessHeap(), 0, This
);
1077 static HRESULT STDMETHODCALLTYPE
GameStatisticsMgrImpl_GetGameStatistics(
1078 IGameStatisticsMgr
* iface
,
1079 LPCWSTR GDFBinaryPath
,
1080 GAMESTATS_OPEN_TYPE openType
,
1081 GAMESTATS_OPEN_RESULT
*pOpenResult
,
1082 IGameStatistics
**ppiStats
)
1085 WCHAR lpApplicationId
[49];
1086 GameStatisticsImpl
*statisticsImpl
= NULL
;
1087 IGameStatistics
*output_iface
;
1089 TRACE("(%p, %s, 0x%x, %p, %p)\n", iface
, debugstr_w(GDFBinaryPath
), openType
, pOpenResult
, ppiStats
);
1091 hr
= GAMEUX_getAppIdFromGDFPath(GDFBinaryPath
, lpApplicationId
);
1094 hr
= create_IGameStatistics(&statisticsImpl
);
1098 output_iface
= &statisticsImpl
->IGameStatistics_iface
;
1099 hr
= GAMEUX_buildStatisticsFilePath(lpApplicationId
, statisticsImpl
->stats
.sStatsFile
);
1103 hr
= GAMEUX_loadGameStatistics(&statisticsImpl
->stats
, lpApplicationId
, openType
, pOpenResult
);
1106 *ppiStats
= output_iface
;
1109 HeapFree(GetProcessHeap(), 0, statisticsImpl
);
1116 static HRESULT STDMETHODCALLTYPE
GameStatisticsMgrImpl_RemoveGameStatistics(
1117 IGameStatisticsMgr
* iface
,
1118 LPCWSTR GDFBinaryPath
)
1121 WCHAR lpApplicationId
[49];
1122 WCHAR sStatsFile
[MAX_PATH
];
1124 TRACE("(%p, %s)\n", iface
, debugstr_w(GDFBinaryPath
));
1126 hr
= GAMEUX_getAppIdFromGDFPath(GDFBinaryPath
, lpApplicationId
);
1129 hr
= GAMEUX_buildStatisticsFilePath(lpApplicationId
, sStatsFile
);
1132 hr
= (DeleteFileW(sStatsFile
)==TRUE
? S_OK
: HRESULT_FROM_WIN32(GetLastError()));
1137 static const struct IGameStatisticsMgrVtbl GameStatisticsMgrImplVtbl
=
1139 GameStatisticsMgrImpl_QueryInterface
,
1140 GameStatisticsMgrImpl_AddRef
,
1141 GameStatisticsMgrImpl_Release
,
1142 GameStatisticsMgrImpl_GetGameStatistics
,
1143 GameStatisticsMgrImpl_RemoveGameStatistics
,
1146 HRESULT
GameStatistics_create(
1147 IUnknown
*pUnkOuter
,
1150 GameStatisticsMgrImpl
*pGameStatistics
;
1152 TRACE("(%p, %p)\n", pUnkOuter
, ppObj
);
1154 pGameStatistics
= HeapAlloc( GetProcessHeap(), 0, sizeof (*pGameStatistics
) );
1156 if( !pGameStatistics
)
1157 return E_OUTOFMEMORY
;
1159 pGameStatistics
->IGameStatisticsMgr_iface
.lpVtbl
= &GameStatisticsMgrImplVtbl
;
1160 pGameStatistics
->ref
= 1;
1162 *ppObj
= (IUnknown
*)&pGameStatistics
->IGameStatisticsMgr_iface
;
1164 TRACE("returning iface %p\n", *ppObj
);