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, *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         for(i=0; i<MAX_CATEGORIES; ++i)
 180         {
 181             IXMLDOMElement *categoryElement = NULL;
 182
 183             if(!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, (void**)&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             if (categoryElement)
 213                 IXMLDOMElement_Release(categoryElement);
 214
 215             SysFreeString(V_BSTR(&vValue));
 216
 217             if(SUCCEEDED(hr))
 218             {
 219                 for(j=0; j<MAX_STATS_PER_CATEGORY; ++j)
 220                 {
 221                     if(!stats->categories[i].stats[j].sName[0])
 222                         continue;
 223
 224                     V_VT(&vValue) = VT_INT;
 225                     V_INT(&vValue) = NODE_ELEMENT;
 226
 227                     hr = IXMLDOMDocument_createNode(document, vValue, bstrStatistic, NULL, &statisticsNode);
 228
 229                     if(SUCCEEDED(hr))
 230                         hr = IXMLDOMNode_QueryInterface(statisticsNode, &IID_IXMLDOMElement, (LPVOID*)&statisticsElement);
 231
 232                     V_INT(&vValue) = j;
 233                     if(SUCCEEDED(hr))
 234                         hr = IXMLDOMElement_setAttribute(statisticsElement, bstrIndex, vValue);
 235
 236                     if(SUCCEEDED(hr))
 237                     {
 238                         V_VT(&vValue) = VT_BSTR;
 239                         V_BSTR(&vValue) = SysAllocString(stats->categories[i].stats[j].sName);
 240                         if(!V_BSTR(&vValue))
 241                             hr = E_OUTOFMEMORY;
 242                     }
 243
 244                     if(SUCCEEDED(hr))
 245                     {
 246                         TRACE("    storing statistic %d: name: %s\n", j, debugstr_w(V_BSTR(&vValue)));
 247                         hr = IXMLDOMElement_setAttribute(statisticsElement, bstrName, vValue);
 248                         SysFreeString(V_BSTR(&vValue));
 249                     }
 250
 251                     if(SUCCEEDED(hr))
 252                     {
 253                         V_VT(&vValue) = VT_BSTR;
 254                         V_BSTR(&vValue) = SysAllocString(stats->categories[i].stats[j].sValue);
 255                         if(!V_BSTR(&vValue))
 256                             hr = E_OUTOFMEMORY;
 257                     }
 258
 259                     if(SUCCEEDED(hr))
 260                     {
 261                         TRACE("    storing statistic %d: name: %s\n", j, debugstr_w(V_BSTR(&vValue)));
 262                         hr = IXMLDOMElement_setAttribute(statisticsElement, bstrValue, vValue);
 263                         SysFreeString(V_BSTR(&vValue));
 264                     }
 265
 266                     if(SUCCEEDED(hr))
 267                         hr = IXMLDOMNode_appendChild(categoryNode, statisticsNode, NULL);
 268
 269                     IXMLDOMElement_Release(statisticsElement);
 270                     IXMLDOMNode_Release(statisticsNode);
 271                 }
 272             }
 273
 274             if(SUCCEEDED(hr))
 275                 hr = IXMLDOMElement_appendChild(root, categoryNode, &categoryNode);
 276
 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 containing 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. Its 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 its 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         if(SUCCEEDED(hr)) {
 397             hr = HRESULT_FROM_WIN32(RegGetValueW(hKey,
 398                     NULL, sApplicationId, RRF_RT_REG_SZ,
 399                     NULL, lpApplicationId, &dwLength));
 400             RegCloseKey(hKey);
 401         }
 402     }
 403
 404     HeapFree(GetProcessHeap(), 0, lpRegistryPath);
 405
 406     TRACE("found app id: %s, return: %#x\n", debugstr_w(lpApplicationId), hr);
 407     return hr;
 408 }
 409 /*******************************************************************
 410  * GAMEUX_loadGameStatisticsFromFile
 411  * Helper function, loads game statistics from file and stores them
 412  * in the structure.
 413  *
 414  * Parameters:
 415  *  data                [I/O]   structure containing file name to
 416  *                              load and data fields to store data in
 417  */
 418 static HRESULT GAMEUX_loadStatisticsFromFile(struct GAMEUX_STATS *data)
 419 {
 420     static const WCHAR sStatistics[] = {'S','t','a','t','i','s','t','i','c','s',0};
 421     static const WCHAR sCategory[] = {'C','a','t','e','g','o','r','y',0};
 422     static const WCHAR sIndex[] = {'I','n','d','e','x',0};
 423     static const WCHAR sStatistic[] = {'S','t','a','t','i','s','t','i','c',0};
 424     static const WCHAR sName[] = {'N','a','m','e',0};
 425     static const WCHAR sValue[] = {'V','a','l','u','e',0};
 426
 427     HRESULT hr = S_OK;
 428     IXMLDOMDocument *document = NULL;
 429     IXMLDOMElement *root = NULL, *categoryElement, *statisticElement;
 430     IXMLDOMNode *categoryNode, *statisticNode;
 431     IXMLDOMNodeList *rootChildren = NULL, *categoryChildren;
 432     VARIANT vStatsFilePath, vValue;
 433     BSTR bstrStatistics = NULL, bstrCategory = NULL, bstrIndex = NULL,
 434         bstrStatistic = NULL, bstrName = NULL, bstrValue = NULL;
 435     VARIANT_BOOL isSuccessful =  VARIANT_FALSE;
 436     int i, j;
 437
 438     TRACE("(%p)\n", data);
 439
 440     V_VT(&vStatsFilePath) = VT_BSTR;
 441     V_BSTR(&vStatsFilePath) = SysAllocString(data->sStatsFile);
 442     if(!V_BSTR(&vStatsFilePath))
 443         hr = E_OUTOFMEMORY;
 444
 445     if(SUCCEEDED(hr))
 446         hr = CoCreateInstance(&CLSID_DOMDocument30, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (void**)&document);
 447
 448     if(SUCCEEDED(hr))
 449     {
 450         bstrStatistics = SysAllocString(sStatistics);
 451         if(!bstrStatistics)
 452             hr = E_OUTOFMEMORY;
 453     }
 454
 455     if(SUCCEEDED(hr))
 456     {
 457         bstrCategory = SysAllocString(sCategory);
 458         if(!bstrCategory)
 459             hr = E_OUTOFMEMORY;
 460     }
 461
 462     if(SUCCEEDED(hr))
 463     {
 464         bstrIndex = SysAllocString(sIndex);
 465         if(!bstrIndex)
 466             hr = E_OUTOFMEMORY;
 467     }
 468
 469     if(SUCCEEDED(hr))
 470     {
 471         bstrStatistic = SysAllocString(sStatistic);
 472         if(!bstrStatistic)
 473             hr = E_OUTOFMEMORY;
 474     }
 475
 476     if(SUCCEEDED(hr))
 477     {
 478         bstrName = SysAllocString(sName);
 479         if(!bstrName)
 480             hr = E_OUTOFMEMORY;
 481     }
 482
 483     if(SUCCEEDED(hr))
 484     {
 485         bstrValue = SysAllocString(sValue);
 486         if(!bstrValue)
 487             hr = E_OUTOFMEMORY;
 488     }
 489
 490     if(SUCCEEDED(hr))
 491         hr = IXMLDOMDocument_load(document, vStatsFilePath, &isSuccessful);
 492
 493     if(hr == S_OK && isSuccessful != VARIANT_TRUE)
 494         hr = S_FALSE;
 495
 496     if( hr == S_OK )
 497         hr = IXMLDOMDocument_get_documentElement(document, &root);
 498
 499     if(hr == S_OK)
 500         hr = IXMLDOMElement_get_childNodes(root, &rootChildren);
 501
 502     if(hr == S_OK)
 503     {
 504         hr = S_OK;
 505         while(hr == S_OK)
 506         {
 507             hr = IXMLDOMNodeList_nextNode(rootChildren, &categoryNode);
 508
 509             if(hr == S_OK)
 510             {
 511                 hr = IXMLDOMNode_QueryInterface(categoryNode, &IID_IXMLDOMElement, (LPVOID*)&categoryElement);
 512
 513                 if(SUCCEEDED(hr))
 514                 {
 515                     hr = IXMLDOMElement_getAttribute(categoryElement, bstrIndex, &vValue);
 516                     if( hr == S_OK && V_VT(&vValue) != VT_BSTR)
 517                         hr = E_FAIL;
 518
 519                     if(SUCCEEDED(hr))
 520                     {
 521                         i = StrToIntW(V_BSTR(&vValue));
 522                         hr = IXMLDOMElement_getAttribute(categoryElement, bstrName, &vValue);
 523                         if( hr == S_OK && V_VT(&vValue) != VT_BSTR)
 524                             hr = E_FAIL;
 525                     }
 526
 527                     if(SUCCEEDED(hr))
 528                     {
 529                         lstrcpynW(data->categories[i].sName, V_BSTR(&vValue), MAX_CATEGORY_LENGTH);
 530                         TRACE("category %d name %s\n", i, debugstr_w(data->categories[i].sName));
 531                         hr = IXMLDOMElement_get_childNodes(categoryElement, &categoryChildren);
 532                     }
 533
 534                     if(SUCCEEDED(hr))
 535                     {
 536                         hr = S_OK;
 537                         while(hr == S_OK)
 538                         {
 539                             hr = IXMLDOMNodeList_nextNode(categoryChildren, &statisticNode);
 540
 541                             if(hr == S_OK)
 542                             {
 543                                 hr = IXMLDOMNode_QueryInterface(statisticNode, &IID_IXMLDOMElement, (LPVOID*)&statisticElement);
 544
 545                                 if(SUCCEEDED(hr))
 546                                 {
 547                                     hr = IXMLDOMElement_getAttribute(statisticElement, bstrIndex, &vValue);
 548                                     if( hr == S_OK && V_VT(&vValue) != VT_BSTR)
 549                                         hr = E_FAIL;
 550
 551                                     if(SUCCEEDED(hr))
 552                                     {
 553                                         j = StrToIntW(V_BSTR(&vValue));
 554                                         hr = IXMLDOMElement_getAttribute(statisticElement, bstrName, &vValue);
 555                                         if( hr == S_OK && V_VT(&vValue) != VT_BSTR)
 556                                             hr = E_FAIL;
 557                                     }
 558
 559                                     if(SUCCEEDED(hr))
 560                                     {
 561                                         lstrcpynW(data->categories[i].stats[j].sName, V_BSTR(&vValue), MAX_NAME_LENGTH);
 562                                         hr = IXMLDOMElement_getAttribute(statisticElement, bstrValue, &vValue);
 563                                         if( hr == S_OK && V_VT(&vValue) != VT_BSTR)
 564                                             hr = E_FAIL;
 565                                     }
 566
 567                                     if(SUCCEEDED(hr))
 568                                     {
 569                                         lstrcpynW(data->categories[i].stats[j].sValue, V_BSTR(&vValue), MAX_VALUE_LENGTH);
 570                                         TRACE("statistic %d name %s value %s\n", j,
 571                                               debugstr_w(data->categories[i].stats[j].sName),
 572                                               debugstr_w(data->categories[i].stats[j].sValue));
 573                                     }
 574                                     IXMLDOMElement_Release(statisticElement);
 575                                 }
 576
 577                                 IXMLDOMNode_Release(statisticNode);
 578                             }
 579                         }
 580
 581                         IXMLDOMNodeList_Release(categoryChildren);
 582
 583                         if(SUCCEEDED(hr))
 584                             hr = S_OK;
 585                     }
 586                     IXMLDOMElement_Release(categoryElement);
 587                 }
 588
 589                 IXMLDOMNode_Release(categoryNode);
 590             }
 591         }
 592         if(SUCCEEDED(hr))
 593             hr = S_OK;
 594     }
 595
 596     if(rootChildren) IXMLDOMNodeList_Release(rootChildren);
 597     if(root) IXMLDOMElement_Release(root);
 598     if(document) IXMLDOMDocument_Release(document);
 599
 600     SysFreeString(bstrValue);
 601     SysFreeString(bstrName);
 602     SysFreeString(bstrStatistic);
 603     SysFreeString(bstrIndex);
 604     SysFreeString(bstrCategory);
 605     SysFreeString(bstrStatistics);
 606     SysFreeString(V_BSTR(&vStatsFilePath));
 607     return hr;
 608 }
 609 /*******************************************************************
 610  * GAMEUX_loadGameStatistics
 611  *
 612  * Helper function which loads game statistics associated with game
 613  * into interface's internal structures
 614  *
 615  * Parameters:
 616  *  pStats              [O]     structure which will receive data
 617  *  sGameId             [I]     application instance Id, stored as string
 618  *                              to avoid additional conversions
 619  *  openType            [I]     allowed ways of opening statistics
 620  *  pOpenResult         [O]     way used to open statistics
 621  *
 622  */
 623 static HRESULT GAMEUX_loadGameStatistics(struct GAMEUX_STATS *pStats,
 624         LPWSTR sGameId,
 625         GAMESTATS_OPEN_TYPE openType,
 626         GAMESTATS_OPEN_RESULT* pOpenResult)
 627 {
 628     HRESULT hr;
 629     TRACE("(%p, %s, %d, %p)\n", pStats, debugstr_w(sGameId), openType, pOpenResult);
 630
 631     hr = GAMEUX_buildStatisticsFilePath(sGameId, pStats->sStatsFile);
 632     if (FAILED(hr)) return hr;
 633
 634     hr = GAMEUX_loadStatisticsFromFile(pStats);
 635     TRACE("ldstats finished, res: %#x\n", hr);
 636     if(hr == S_OK)
 637     {
 638         *pOpenResult = GAMESTATS_OPEN_OPENED;
 639     }
 640     else if(hr == S_FALSE && openType == GAMESTATS_OPEN_OPENORCREATE) /* file does not exist */
 641     {
 642         /* create new statistics, not yet connected with file */
 643         ZeroMemory(pStats->categories, sizeof(pStats->categories));
 644         *pOpenResult = GAMESTATS_OPEN_CREATED;
 645         hr = S_OK;
 646     }
 647     else
 648         hr = HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
 649
 650     TRACE("openResult=%#x ret=%#x\n", *pOpenResult, hr);
 651     return hr;
 652 }
 653  /*******************************************************************
 654  * IGameStatistics implementation
 655  */
 656 typedef struct _GameStatisticsImpl
 657 {
 658     IGameStatistics IGameStatistics_iface;
 659     LONG ref;
 660     struct GAMEUX_STATS stats;
 661 } GameStatisticsImpl;
 662
 663 static inline GameStatisticsImpl *impl_from_IGameStatistics( IGameStatistics *iface )
 664 {
 665     return CONTAINING_RECORD(iface, GameStatisticsImpl, IGameStatistics_iface);
 666 }
 667
 668 static HRESULT WINAPI GameStatisticsImpl_QueryInterface(
 669         IGameStatistics *iface,
 670         REFIID riid,
 671         void **ppvObject)
 672 {
 673     GameStatisticsImpl *This = impl_from_IGameStatistics( iface );
 674
 675     TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
 676
 677     *ppvObject = NULL;
 678
 679     if ( IsEqualGUID( riid, &IID_IUnknown ) ||
 680          IsEqualGUID( riid, &IID_IGameStatistics ) )
 681     {
 682         *ppvObject = iface;
 683     }
 684     else
 685     {
 686         FIXME("interface %s not implemented\n", debugstr_guid(riid));
 687         return E_NOINTERFACE;
 688     }
 689
 690     IGameStatistics_AddRef( iface );
 691     return S_OK;
 692 }
 693
 694 static ULONG WINAPI GameStatisticsImpl_AddRef(IGameStatistics *iface)
 695 {
 696     GameStatisticsImpl *This = impl_from_IGameStatistics( iface );
 697     LONG ref;
 698
 699     ref = InterlockedIncrement(&This->ref);
 700
 701     TRACE("(%p): ref=%d\n", This, ref);
 702     return ref;
 703 }
 704
 705 static ULONG WINAPI GameStatisticsImpl_Release(IGameStatistics *iface)
 706 {
 707     GameStatisticsImpl *This = impl_from_IGameStatistics( iface );
 708     LONG ref;
 709
 710     ref = InterlockedDecrement( &This->ref );
 711     TRACE("(%p): ref=%d\n", This, ref);
 712
 713     if ( ref == 0 )
 714     {
 715         TRACE("freeing IGameStatistics\n");
 716         HeapFree( GetProcessHeap(), 0, This );
 717     }
 718
 719     return ref;
 720 }
 721
 722 static HRESULT WINAPI GameStatisticsImpl_GetMaxCategoryLength(
 723     IGameStatistics *iface,
 724     UINT *cch)
 725 {
 726     TRACE("(%p, %p)\n", iface, cch);
 727     if(!cch)
 728         return E_INVALIDARG;
 729
 730     *cch = MAX_CATEGORY_LENGTH;
 731     return S_OK;
 732 }
 733
 734 static HRESULT WINAPI GameStatisticsImpl_GetMaxNameLength(
 735     IGameStatistics *iface,
 736     UINT *cch)
 737 {
 738     TRACE("(%p, %p)\n", iface, cch);
 739     if(!cch)
 740         return E_INVALIDARG;
 741
 742     *cch = MAX_NAME_LENGTH;
 743     return S_OK;
 744 }
 745
 746 static HRESULT WINAPI GameStatisticsImpl_GetMaxValueLength(
 747     IGameStatistics *iface,
 748     UINT *cch)
 749 {
 750     TRACE("(%p, %p)\n", iface, cch);
 751     if(!cch)
 752         return E_INVALIDARG;
 753
 754     *cch = MAX_VALUE_LENGTH;
 755     return S_OK;
 756 }
 757
 758 static HRESULT WINAPI GameStatisticsImpl_GetMaxCategories(
 759     IGameStatistics *iface,
 760     WORD *pMax)
 761 {
 762     TRACE("(%p, %p)\n", iface, pMax);
 763     if(!pMax)
 764         return E_INVALIDARG;
 765
 766     *pMax = MAX_CATEGORIES;
 767     return S_OK;
 768 }
 769
 770 static HRESULT WINAPI GameStatisticsImpl_GetMaxStatsPerCategory(
 771     IGameStatistics *iface,
 772     WORD *pMax)
 773 {
 774     TRACE("(%p, %p)\n", iface, pMax);
 775     if(!pMax)
 776         return E_INVALIDARG;
 777
 778     *pMax = MAX_STATS_PER_CATEGORY;
 779     return S_OK;
 780 }
 781
 782 static HRESULT WINAPI GameStatisticsImpl_SetCategoryTitle(
 783     IGameStatistics *iface,
 784     WORD categoryIndex,
 785     LPCWSTR title)
 786 {
 787     HRESULT hr = S_OK;
 788     DWORD dwLength;
 789     GameStatisticsImpl *This = impl_from_IGameStatistics(iface);
 790
 791     TRACE("(%p, %d, %s)\n", This, categoryIndex, debugstr_w(title));
 792
 793     if(!title || categoryIndex >= MAX_CATEGORIES)
 794         return E_INVALIDARG;
 795
 796     dwLength = lstrlenW(title);
 797
 798     if(dwLength > MAX_CATEGORY_LENGTH)
 799     {
 800         hr = S_FALSE;
 801         dwLength = MAX_CATEGORY_LENGTH;
 802     }
 803
 804     lstrcpynW(This->stats.categories[categoryIndex].sName,
 805               title, dwLength+1);
 806
 807     return hr;
 808 }
 809
 810 static HRESULT WINAPI GameStatisticsImpl_GetCategoryTitle(
 811     IGameStatistics *iface,
 812     WORD categoryIndex,
 813     LPWSTR *pTitle)
 814 {
 815     HRESULT hr = S_OK;
 816     LONG nLength;
 817     GameStatisticsImpl *This = impl_from_IGameStatistics(iface);
 818
 819     TRACE("%p, %d, %p\n", This, categoryIndex, pTitle);
 820
 821     if(!pTitle)
 822         return E_INVALIDARG;
 823     *pTitle = NULL;
 824
 825     if (categoryIndex >= MAX_CATEGORIES)
 826         hr = E_INVALIDARG;
 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 passing 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
 950     TRACE("(%p, %d)\n", This, trackChanges);
 951
 952     if(trackChanges)
 953         FIXME("tracking changes not yet implemented\n");
 954
 955     return GAMEUX_updateStatisticsFile(&This->stats);
 956 }
 957
 958 static HRESULT WINAPI GameStatisticsImpl_SetLastPlayedCategory(
 959     IGameStatistics *iface,
 960     UINT categoryIndex)
 961 {
 962     FIXME("stub\n");
 963     return E_NOTIMPL;
 964 }
 965
 966 static HRESULT WINAPI GameStatisticsImpl_GetLastPlayedCategory(
 967     IGameStatistics *iface,
 968     UINT *pCategoryIndex)
 969 {
 970     FIXME("stub\n");
 971     return E_NOTIMPL;
 972 }
 973
 974 static const struct IGameStatisticsVtbl GameStatisticsImplVtbl =
 975 {
 976     GameStatisticsImpl_QueryInterface,
 977     GameStatisticsImpl_AddRef,
 978     GameStatisticsImpl_Release,
 979     GameStatisticsImpl_GetMaxCategoryLength,
 980     GameStatisticsImpl_GetMaxNameLength,
 981     GameStatisticsImpl_GetMaxValueLength,
 982     GameStatisticsImpl_GetMaxCategories,
 983     GameStatisticsImpl_GetMaxStatsPerCategory,
 984     GameStatisticsImpl_SetCategoryTitle,
 985     GameStatisticsImpl_GetCategoryTitle,
 986     GameStatisticsImpl_GetStatistic,
 987     GameStatisticsImpl_SetStatistic,
 988     GameStatisticsImpl_Save,
 989     GameStatisticsImpl_SetLastPlayedCategory,
 990     GameStatisticsImpl_GetLastPlayedCategory
 991 };
 992
 993
 994 static HRESULT create_IGameStatistics(GameStatisticsImpl** ppStats)
 995 {
 996     TRACE("(%p)\n", ppStats);
 997
 998     *ppStats = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(**ppStats));
 999     if(!(*ppStats))
1000         return E_OUTOFMEMORY;
1001
1002     (*ppStats)->IGameStatistics_iface.lpVtbl = &GameStatisticsImplVtbl;
1003     (*ppStats)->ref = 1;
1004
1005     TRACE("returning coclass: %p\n", *ppStats);
1006     return S_OK;
1007 }
1008
1009 /*******************************************************************************
1010  * IGameStatisticsMgr implementation
1011  */
1012 typedef struct _GameStatisticsMgrImpl
1013 {
1014     IGameStatisticsMgr IGameStatisticsMgr_iface;
1015     LONG ref;
1016 } GameStatisticsMgrImpl;
1017
1018 static inline GameStatisticsMgrImpl *impl_from_IGameStatisticsMgr( IGameStatisticsMgr *iface )
1019 {
1020     return CONTAINING_RECORD(iface, GameStatisticsMgrImpl, IGameStatisticsMgr_iface);
1021 }
1022
1023
1024 static HRESULT WINAPI GameStatisticsMgrImpl_QueryInterface(
1025         IGameStatisticsMgr *iface,
1026         REFIID riid,
1027         void **ppvObject)
1028 {
1029     GameStatisticsMgrImpl *This = impl_from_IGameStatisticsMgr( iface );
1030
1031     TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
1032
1033     *ppvObject = NULL;
1034
1035     if(IsEqualGUID(riid, &IID_IUnknown) ||
1036        IsEqualGUID(riid, &IID_IGameStatisticsMgr) )
1037     {
1038         *ppvObject = iface;
1039     }
1040     else
1041     {
1042         FIXME("interface %s not implemented\n", debugstr_guid(riid));
1043         return E_NOINTERFACE;
1044     }
1045
1046     IGameStatisticsMgr_AddRef( iface );
1047     return S_OK;
1048 }
1049
1050 static ULONG WINAPI GameStatisticsMgrImpl_AddRef(IGameStatisticsMgr *iface)
1051 {
1052     GameStatisticsMgrImpl *This = impl_from_IGameStatisticsMgr( iface );
1053     LONG ref;
1054
1055     ref = InterlockedIncrement(&This->ref);
1056
1057     TRACE("(%p): ref=%d\n", This, ref);
1058     return ref;
1059 }
1060
1061 static ULONG WINAPI GameStatisticsMgrImpl_Release(IGameStatisticsMgr *iface)
1062 {
1063     GameStatisticsMgrImpl *This = impl_from_IGameStatisticsMgr( iface );
1064     LONG ref;
1065
1066     ref = InterlockedDecrement(&This->ref);
1067     TRACE("(%p): ref=%d\n", This, ref);
1068
1069     if ( ref == 0 )
1070     {
1071         TRACE("freeing GameStatistics object\n");
1072         HeapFree( GetProcessHeap(), 0, This);
1073     }
1074
1075     return ref;
1076 }
1077
1078 static HRESULT STDMETHODCALLTYPE GameStatisticsMgrImpl_GetGameStatistics(
1079         IGameStatisticsMgr* iface,
1080         LPCWSTR GDFBinaryPath,
1081         GAMESTATS_OPEN_TYPE openType,
1082         GAMESTATS_OPEN_RESULT *pOpenResult,
1083         IGameStatistics **ppiStats)
1084 {
1085     HRESULT hr;
1086     WCHAR lpApplicationId[49];
1087     GameStatisticsImpl *statisticsImpl = NULL;
1088     IGameStatistics *output_iface;
1089
1090     TRACE("(%p, %s, 0x%x, %p, %p)\n", iface, debugstr_w(GDFBinaryPath), openType, pOpenResult, ppiStats);
1091
1092     hr = GAMEUX_getAppIdFromGDFPath(GDFBinaryPath, lpApplicationId);
1093
1094     if(SUCCEEDED(hr))
1095         hr = create_IGameStatistics(&statisticsImpl);
1096
1097     if(SUCCEEDED(hr))
1098     {
1099         output_iface = &statisticsImpl->IGameStatistics_iface;
1100         hr = GAMEUX_buildStatisticsFilePath(lpApplicationId, statisticsImpl->stats.sStatsFile);
1101     }
1102
1103     if(SUCCEEDED(hr))
1104         hr = GAMEUX_loadGameStatistics(&statisticsImpl->stats, lpApplicationId, openType, pOpenResult);
1105
1106     if(SUCCEEDED(hr))
1107         *ppiStats = output_iface;
1108     else
1109     {
1110         HeapFree(GetProcessHeap(), 0, statisticsImpl);
1111         *ppiStats = NULL;
1112     }
1113
1114     return hr;
1115 }
1116
1117 static HRESULT STDMETHODCALLTYPE GameStatisticsMgrImpl_RemoveGameStatistics(
1118         IGameStatisticsMgr* iface,
1119         LPCWSTR GDFBinaryPath)
1120 {
1121     HRESULT hr;
1122     WCHAR lpApplicationId[49];
1123     WCHAR sStatsFile[MAX_PATH];
1124
1125     TRACE("(%p, %s)\n", iface, debugstr_w(GDFBinaryPath));
1126
1127     hr = GAMEUX_getAppIdFromGDFPath(GDFBinaryPath, lpApplicationId);
1128
1129     if(SUCCEEDED(hr))
1130         hr = GAMEUX_buildStatisticsFilePath(lpApplicationId, sStatsFile);
1131
1132     if(SUCCEEDED(hr))
1133         hr = DeleteFileW(sStatsFile) ? S_OK : HRESULT_FROM_WIN32(GetLastError());
1134
1135     return hr;
1136 }
1137
1138 static const struct IGameStatisticsMgrVtbl GameStatisticsMgrImplVtbl =
1139 {
1140     GameStatisticsMgrImpl_QueryInterface,
1141     GameStatisticsMgrImpl_AddRef,
1142     GameStatisticsMgrImpl_Release,
1143     GameStatisticsMgrImpl_GetGameStatistics,
1144     GameStatisticsMgrImpl_RemoveGameStatistics,
1145 };
1146
1147 HRESULT GameStatistics_create(
1148         IUnknown *pUnkOuter,
1149         IUnknown **ppObj)
1150 {
1151     GameStatisticsMgrImpl *pGameStatistics;
1152
1153     TRACE("(%p, %p)\n", pUnkOuter, ppObj);
1154
1155     pGameStatistics = HeapAlloc( GetProcessHeap(), 0, sizeof (*pGameStatistics) );
1156
1157     if( !pGameStatistics )
1158         return E_OUTOFMEMORY;
1159
1160     pGameStatistics->IGameStatisticsMgr_iface.lpVtbl = &GameStatisticsMgrImplVtbl;
1161     pGameStatistics->ref = 1;
1162
1163     *ppObj = (IUnknown*)&pGameStatistics->IGameStatisticsMgr_iface;
1164
1165     TRACE("returning iface %p\n", *ppObj);
1166     return S_OK;
1167 }