git.oblomov.eu Git - wine/blob - dlls/gameux/gamestatistics.c

   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     if(!pTitle)
 823         return E_INVALIDARG;
 824     *pTitle = NULL;
 825
 826     if (categoryIndex >= MAX_CATEGORIES)
 827         hr = E_INVALIDARG;
 828
 829     if(SUCCEEDED(hr))
 830     {
 831         nLength = lstrlenW(This->stats.categories[categoryIndex].sName);
 832         if(nLength != 0)
 833         {
 834             *pTitle = CoTaskMemAlloc(sizeof(WCHAR)*(nLength+1));
 835             lstrcpyW(*pTitle, This->stats.categories[categoryIndex].sName);
 836         }
 837     }
 838
 839     return hr;
 840 }
 841
 842 static HRESULT WINAPI GameStatisticsImpl_GetStatistic(
 843     IGameStatistics *iface,
 844     WORD categoryIndex,
 845     WORD statIndex,
 846     LPWSTR *pName,
 847     LPWSTR *pValue)
 848 {
 849     HRESULT hr = S_OK;
 850     LONG nLength;
 851     GameStatisticsImpl *This = impl_from_IGameStatistics(iface);
 852
 853     TRACE("%p, %d,%d, %p, %p\n", This, categoryIndex, statIndex, pName, pValue);
 854
 855     if(!pName || !pValue)
 856         return E_INVALIDARG;
 857
 858     *pName = NULL;
 859     *pValue = NULL;
 860
 861     if(categoryIndex >= MAX_CATEGORIES || statIndex >= MAX_STATS_PER_CATEGORY)
 862         hr = E_INVALIDARG;
 863
 864     if(SUCCEEDED(hr))
 865     {
 866         nLength = lstrlenW(This->stats.categories[categoryIndex].stats[statIndex].sName);
 867         if(nLength != 0)
 868         {
 869             *pName = CoTaskMemAlloc(sizeof(WCHAR)*(nLength+1));
 870             if(!(*pName))
 871                 hr = E_OUTOFMEMORY;
 872             else
 873                 lstrcpyW(*pName, This->stats.categories[categoryIndex].stats[statIndex].sName);
 874         }
 875     }
 876
 877     if(SUCCEEDED(hr))
 878     {
 879         nLength = lstrlenW(This->stats.categories[categoryIndex].stats[statIndex].sValue);
 880         if(nLength != 0)
 881         {
 882             *pValue = CoTaskMemAlloc(sizeof(WCHAR)*(nLength+1));
 883             if(!(*pValue))
 884                 hr = E_OUTOFMEMORY;
 885             else
 886                 lstrcpyW(*pValue, This->stats.categories[categoryIndex].stats[statIndex].sValue);
 887         }
 888     }
 889
 890     TRACE("returning pair; %s => %s\n", debugstr_w(*pName), debugstr_w(*pValue));
 891     return hr;
 892 }
 893
 894 static HRESULT WINAPI GameStatisticsImpl_SetStatistic(
 895     IGameStatistics *iface,
 896     WORD categoryIndex,
 897     WORD statIndex,
 898     LPCWSTR name,
 899     LPCWSTR value)
 900 {
 901     HRESULT hr = S_OK;
 902     DWORD dwNameLen, dwValueLen;
 903     GameStatisticsImpl *This = impl_from_IGameStatistics(iface);
 904
 905     TRACE("(%p, %d, %d, %s, %s)\n", This, categoryIndex, statIndex,
 906           debugstr_w(name), debugstr_w(value));
 907
 908     if(!name)
 909         return S_FALSE;
 910
 911     if(categoryIndex >= MAX_CATEGORIES || statIndex >= MAX_STATS_PER_CATEGORY)
 912         return E_INVALIDARG;
 913
 914     dwNameLen = lstrlenW(name);
 915
 916     if(dwNameLen > MAX_NAME_LENGTH)
 917     {
 918         hr = S_FALSE;
 919         dwNameLen = MAX_NAME_LENGTH;
 920     }
 921
 922     lstrcpynW(This->stats.categories[categoryIndex].stats[statIndex].sName,
 923               name, dwNameLen+1);
 924
 925     if(value)
 926     {
 927         dwValueLen = lstrlenW(value);
 928
 929         if(dwValueLen > MAX_VALUE_LENGTH)
 930         {
 931             hr = S_FALSE;
 932             dwValueLen = MAX_VALUE_LENGTH;
 933         }
 934
 935         lstrcpynW(This->stats.categories[categoryIndex].stats[statIndex].sValue,
 936                   value, dwValueLen+1);
 937     }
 938     else
 939         /* Windows allows to pass NULL as value */
 940         This->stats.categories[categoryIndex].stats[statIndex].sValue[0] = 0;
 941
 942     return hr;
 943 }
 944
 945 static HRESULT WINAPI GameStatisticsImpl_Save(
 946     IGameStatistics *iface,
 947     BOOL trackChanges)
 948 {
 949     GameStatisticsImpl *This = impl_from_IGameStatistics(iface);
 950     HRESULT hr = S_OK;
 951
 952     TRACE("(%p, %d)\n", This, trackChanges);
 953
 954     if(trackChanges == TRUE)
 955         FIXME("tracking changes not yet implemented\n");
 956
 957     hr = GAMEUX_updateStatisticsFile(&This->stats);
 958
 959     return hr;
 960 }
 961
 962 static HRESULT WINAPI GameStatisticsImpl_SetLastPlayedCategory(
 963     IGameStatistics *iface,
 964     UINT categoryIndex)
 965 {
 966     FIXME("stub\n");
 967     return E_NOTIMPL;
 968 }
 969
 970 static HRESULT WINAPI GameStatisticsImpl_GetLastPlayedCategory(
 971     IGameStatistics *iface,
 972     UINT *pCategoryIndex)
 973 {
 974     FIXME("stub\n");
 975     return E_NOTIMPL;
 976 }
 977
 978 static const struct IGameStatisticsVtbl GameStatisticsImplVtbl =
 979 {
 980     GameStatisticsImpl_QueryInterface,
 981     GameStatisticsImpl_AddRef,
 982     GameStatisticsImpl_Release,
 983     GameStatisticsImpl_GetMaxCategoryLength,
 984     GameStatisticsImpl_GetMaxNameLength,
 985     GameStatisticsImpl_GetMaxValueLength,
 986     GameStatisticsImpl_GetMaxCategories,
 987     GameStatisticsImpl_GetMaxStatsPerCategory,
 988     GameStatisticsImpl_SetCategoryTitle,
 989     GameStatisticsImpl_GetCategoryTitle,
 990     GameStatisticsImpl_GetStatistic,
 991     GameStatisticsImpl_SetStatistic,
 992     GameStatisticsImpl_Save,
 993     GameStatisticsImpl_SetLastPlayedCategory,
 994     GameStatisticsImpl_GetLastPlayedCategory
 995 };
 996
 997
 998 static HRESULT create_IGameStatistics(GameStatisticsImpl** ppStats)
 999 {
1000     TRACE("(%p)\n", ppStats);
1001
1002     *ppStats = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(**ppStats));
1003     if(!(*ppStats))
1004         return E_OUTOFMEMORY;
1005
1006     (*ppStats)->lpVtbl = &GameStatisticsImplVtbl;
1007     (*ppStats)->ref = 1;
1008
1009     TRACE("returning coclass: %p\n", *ppStats);
1010     return S_OK;
1011 }
1012
1013 /*******************************************************************************
1014  * IGameStatisticsMgr implementation
1015  */
1016 typedef struct _GameStatisticsMgrImpl
1017 {
1018     const struct IGameStatisticsMgrVtbl *lpVtbl;
1019     LONG ref;
1020 } GameStatisticsMgrImpl;
1021
1022 static inline GameStatisticsMgrImpl *impl_from_IGameStatisticsMgr( IGameStatisticsMgr *iface )
1023 {
1024     return (GameStatisticsMgrImpl *)((char*)iface - FIELD_OFFSET(GameStatisticsMgrImpl, lpVtbl));
1025 }
1026
1027
1028 static HRESULT WINAPI GameStatisticsMgrImpl_QueryInterface(
1029         IGameStatisticsMgr *iface,
1030         REFIID riid,
1031         void **ppvObject)
1032 {
1033     GameStatisticsMgrImpl *This = impl_from_IGameStatisticsMgr( iface );
1034
1035     TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
1036
1037     *ppvObject = NULL;
1038
1039     if(IsEqualGUID(riid, &IID_IUnknown) ||
1040        IsEqualGUID(riid, &IID_IGameStatisticsMgr) )
1041     {
1042         *ppvObject = iface;
1043     }
1044     else
1045     {
1046         FIXME("interface %s not implemented\n", debugstr_guid(riid));
1047         return E_NOINTERFACE;
1048     }
1049
1050     IGameStatisticsMgr_AddRef( iface );
1051     return S_OK;
1052 }
1053
1054 static ULONG WINAPI GameStatisticsMgrImpl_AddRef(IGameStatisticsMgr *iface)
1055 {
1056     GameStatisticsMgrImpl *This = impl_from_IGameStatisticsMgr( iface );
1057     LONG ref;
1058
1059     ref = InterlockedIncrement(&This->ref);
1060
1061     TRACE("(%p): ref=%d\n", This, ref);
1062     return ref;
1063 }
1064
1065 static ULONG WINAPI GameStatisticsMgrImpl_Release(IGameStatisticsMgr *iface)
1066 {
1067     GameStatisticsMgrImpl *This = impl_from_IGameStatisticsMgr( iface );
1068     LONG ref;
1069
1070     ref = InterlockedDecrement(&This->ref);
1071     TRACE("(%p): ref=%d\n", This, ref);
1072
1073     if ( ref == 0 )
1074     {
1075         TRACE("freeing GameStatistics object\n");
1076         HeapFree( GetProcessHeap(), 0, This);
1077     }
1078
1079     return ref;
1080 }
1081
1082 static HRESULT STDMETHODCALLTYPE GameStatisticsMgrImpl_GetGameStatistics(
1083         IGameStatisticsMgr* iface,
1084         LPCWSTR GDFBinaryPath,
1085         GAMESTATS_OPEN_TYPE openType,
1086         GAMESTATS_OPEN_RESULT *pOpenResult,
1087         IGameStatistics **ppiStats)
1088 {
1089     HRESULT hr;
1090     WCHAR lpApplicationId[49];
1091     GameStatisticsImpl *statisticsImpl = NULL;
1092     IGameStatistics *output_iface;
1093
1094     TRACE("(%p, %s, 0x%x, %p, %p)\n", iface, debugstr_w(GDFBinaryPath), openType, pOpenResult, ppiStats);
1095
1096     hr = GAMEUX_getAppIdFromGDFPath(GDFBinaryPath, lpApplicationId);
1097
1098     if(SUCCEEDED(hr))
1099         hr = create_IGameStatistics(&statisticsImpl);
1100
1101     if(SUCCEEDED(hr))
1102     {
1103         output_iface = IGameStatistics_from_impl(statisticsImpl);
1104         hr = GAMEUX_buildStatisticsFilePath(lpApplicationId, statisticsImpl->stats.sStatsFile);
1105     }
1106
1107     if(SUCCEEDED(hr))
1108         hr = GAMEUX_loadGameStatistics(&statisticsImpl->stats, lpApplicationId, openType, pOpenResult);
1109
1110     if(SUCCEEDED(hr))
1111         *ppiStats = output_iface;
1112     else
1113     {
1114         HeapFree(GetProcessHeap(), 0, statisticsImpl);
1115         *ppiStats = NULL;
1116     }
1117
1118     return hr;
1119 }
1120
1121 static HRESULT STDMETHODCALLTYPE GameStatisticsMgrImpl_RemoveGameStatistics(
1122         IGameStatisticsMgr* iface,
1123         LPCWSTR GDFBinaryPath)
1124 {
1125     HRESULT hr;
1126     WCHAR lpApplicationId[49];
1127     WCHAR sStatsFile[MAX_PATH];
1128
1129     TRACE("(%p, %s)\n", iface, debugstr_w(GDFBinaryPath));
1130
1131     hr = GAMEUX_getAppIdFromGDFPath(GDFBinaryPath, lpApplicationId);
1132
1133     if(SUCCEEDED(hr))
1134         hr = GAMEUX_buildStatisticsFilePath(lpApplicationId, sStatsFile);
1135
1136     if(SUCCEEDED(hr))
1137         hr = (DeleteFileW(sStatsFile)==TRUE ? S_OK : HRESULT_FROM_WIN32(GetLastError()));
1138
1139     return hr;
1140 }
1141
1142 static const struct IGameStatisticsMgrVtbl GameStatisticsMgrImplVtbl =
1143 {
1144     GameStatisticsMgrImpl_QueryInterface,
1145     GameStatisticsMgrImpl_AddRef,
1146     GameStatisticsMgrImpl_Release,
1147     GameStatisticsMgrImpl_GetGameStatistics,
1148     GameStatisticsMgrImpl_RemoveGameStatistics,
1149 };
1150
1151 HRESULT GameStatistics_create(
1152         IUnknown *pUnkOuter,
1153         IUnknown **ppObj)
1154 {
1155     GameStatisticsMgrImpl *pGameStatistics;
1156
1157     TRACE("(%p, %p)\n", pUnkOuter, ppObj);
1158
1159     pGameStatistics = HeapAlloc( GetProcessHeap(), 0, sizeof (*pGameStatistics) );
1160
1161     if( !pGameStatistics )
1162         return E_OUTOFMEMORY;
1163
1164     pGameStatistics->lpVtbl = &GameStatisticsMgrImplVtbl;
1165     pGameStatistics->ref = 1;
1166
1167     *ppObj = (IUnknown*)(&pGameStatistics->lpVtbl);
1168
1169     TRACE("returning iface %p\n", *ppObj);
1170     return S_OK;
1171 }