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