pref.cpp
上传用户:zhongxx05
上传日期:2007-06-06
资源大小:33641k
文件大小:20k
源码类别:

Symbian

开发平台:

C/C++

  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  35.    
  36. #include "hxtypes.h"
  37. #include "hxwintyp.h"
  38. #include "hxresult.h"
  39. #include "hxcom.h"
  40. #include "hxprefs.h"
  41. #include "pref.h"
  42. #include "hxassert.h"
  43. #include "hxbuffer.h"
  44. #include "hxstring.h"
  45. #include "hxstrutl.h"
  46. //#include "hlxclib/stdio.h"
  47. #include "hlxclib/stdlib.h"
  48. #if defined(_MACINTOSH) || defined(_MAC_UNIX)
  49. #if defined(_CARBON) || defined(_MAC_UNIX)
  50. #include "platform/mac/mac_pref_cf.h"
  51. #else
  52. #include "mac_pref.h"
  53. #endif
  54. #elif defined(_UNIX) && !defined(_MAC_UNIX)
  55. #include "unix_pref.h"
  56. #elif defined(_WIN32) || defined(_WINDOWS)
  57. #include "win_pref.h"
  58. #elif defined(_SYMBIAN)
  59. #include "symbian_pref.h"
  60. #elif defined(_OPENWAVE)
  61. #include "openwave_pref.h"
  62. #else
  63. #error Undefined platform!
  64. #endif
  65. #include "hxheap.h"
  66. #ifdef _DEBUG
  67. #undef HX_THIS_FILE
  68. static const char HX_THIS_FILE[] = __FILE__;
  69. #endif
  70. //  call open_pref() to automatically create the correct platform specific preference 
  71. //  object. If open_pref() returns NULL, an error occurred and the CPref object was 
  72. //  not created. Call last_error to get the error 
  73. CPref * CPref::open_pref(const char* pCompanyName, const char* pProductName, int nProdMajorVer, int nProdMinorVer, BOOL bCommon)
  74. {
  75.     CPref * pPref = NULL;
  76. #if   defined (_CARBON) || defined(_MAC_UNIX)
  77. pPref = CMacPref::open_pref(pCompanyName, pProductName, nProdMajorVer, nProdMinorVer, bCommon);
  78. #elif   defined (_MACINTOSH)
  79. pPref = CMacPref::open_pref(pCompanyName, pProductName, nProdMajorVer, nProdMinorVer);
  80. #elif defined( _UNIX)
  81. pPref = ( CPref *) CUnixPref::open_pref(pCompanyName, pProductName, nProdMajorVer, nProdMinorVer);
  82.         
  83. #elif defined(_SYMBIAN)
  84. pPref = ( CPref *) CSymbianPref::open_pref( pCompanyName,
  85.                                                     pProductName,
  86.                                                     nProdMajorVer,
  87.                                                     nProdMinorVer);
  88. #elif defined(_OPENWAVE)
  89. pPref = ( CPref *) COpenwavePref::open_pref( pCompanyName,
  90.                                                      pProductName,
  91.                                                      nProdMajorVer,
  92.                                                      nProdMinorVer);
  93. #elif defined( _WIN32 ) || defined( _WINDOWS )
  94. pPref = CWinPref::open_pref(pCompanyName, pProductName, nProdMajorVer, nProdMinorVer, bCommon);
  95. #endif
  96. if (pPref)
  97. {
  98. pPref->m_bIsCommonPref = bCommon;
  99. }
  100. return pPref;
  101. }
  102. CPref* CPref::open_shared_pref(const char* pCompanyName)
  103. {
  104.     // Major and Minor version numbers are not used for a shared preference since it is shared among all products
  105.     return CPref::open_pref(pCompanyName,HX_PRODUCTNAME_SHARED,0,0);
  106. }
  107. CPref* CPref::open_shared_user_pref(const char* pCompanyName)
  108. {
  109.     // Major and Minor version numbers are not used for a shared preference since it is shared among all products
  110.     return CPref::open_pref(pCompanyName,HX_PRODUCTNAME_SHARED,0,0,false);
  111. }
  112. //  Constructor NOTE: use open_pref() to create an instance of this class 
  113. CPref::CPref() :
  114.     m_pPrefTable(NULL), m_bIsCommonPref(FALSE)
  115. {
  116. mLastError = HXR_OK;
  117. }   
  118. //      class destructor 
  119. CPref::~CPref(void)
  120. {
  121.     HX_DELETE(m_pPrefTable);
  122. }
  123. void CPref::SetupPrefTable(PrefTableEntry* pPrefTable,INT32 nTableEntries)
  124.     // Cleanup existing pref table
  125.     HX_DELETE(m_pPrefTable);
  126.     // Create new pref table
  127.     m_pPrefTable = new CPrefTable(pPrefTable,nTableEntries,this);
  128.     HX_ASSERT(m_pPrefTable);
  129. }
  130. CPrefTable::CPrefTable(PrefTableEntry* pPrefTable,INT32 nTableEntries,CPref* pPrefs) :
  131.     m_pPrefTable(pPrefTable),
  132.     m_nTableEntries(nTableEntries),
  133.     m_pCPref(pPrefs),
  134.     m_pIHXPrefs(NULL)
  135. {
  136. }
  137. CPrefTable::CPrefTable(PrefTableEntry* pPrefTable,INT32 nTableEntries,IHXPreferences* pPrefs) :
  138.     m_pPrefTable(pPrefTable),
  139.     m_nTableEntries(nTableEntries),
  140.     m_pCPref(NULL),
  141.     m_pIHXPrefs(pPrefs)
  142. {
  143.     if (m_pIHXPrefs)
  144. m_pIHXPrefs->AddRef();
  145. }
  146. CPrefTable::~CPrefTable()
  147. {
  148.     HX_RELEASE(m_pIHXPrefs);
  149. }
  150. HX_RESULT CPrefTable::RemoveIndexedPref(INT32 nPrefKey)
  151. {
  152.     // Index is out of table range if this is false
  153.     HX_ASSERT(nPrefKey >= 0 && nPrefKey < m_nTableEntries);
  154.     // Need to call SetupPrefTable() if this is false
  155.     HX_ASSERT(m_pPrefTable);
  156.     // Index is out of table range
  157.     if (nPrefKey < 0 || nPrefKey >= m_nTableEntries)
  158. return HXR_INVALID_PARAMETER;
  159.     // Need to call SetupPrefTable()
  160.     if (!m_pPrefTable || !m_pCPref)
  161. return HXR_UNEXPECTED;
  162.     return m_pCPref->remove_indexed_pref(m_pPrefTable[nPrefKey].szPrefName);
  163. }
  164. HX_RESULT CPrefTable::RemovePref(INT32 nPrefKey)
  165. {
  166.     // Index is out of table range if this is false
  167.     HX_ASSERT(nPrefKey >= 0 && nPrefKey < m_nTableEntries);
  168.     // Need to call SetupPrefTable() if this is false
  169.     HX_ASSERT(m_pPrefTable);
  170.     // Index is out of table range
  171.     if (nPrefKey < 0 || nPrefKey >= m_nTableEntries)
  172. return HXR_INVALID_PARAMETER;
  173.     // Need to call SetupPrefTable()
  174.     if (!m_pPrefTable || !m_pCPref)
  175. return HXR_UNEXPECTED;
  176.     return m_pCPref->remove_pref(m_pPrefTable[nPrefKey].szPrefName);
  177. }
  178. BOOL CPrefTable::ReadPoints(const char* pBuffer,HXxPoint* pt,int nNumPoints)
  179. {
  180.     // If this is false something is really messed up
  181.     HX_ASSERT(pBuffer);
  182.     HX_ASSERT(pt);
  183.     const char* szSeperators = ",";
  184.     char szBufferCopy[MAX_PREF_SIZE]; /* Flawfinder: ignore */
  185.     char* pToken= NULL;
  186.     
  187.     SafeStrCpy(szBufferCopy, pBuffer, MAX_PREF_SIZE);
  188.    // Establish string and get the first token: 
  189.    pToken = strtok( szBufferCopy, szSeperators );
  190.    int i = 0;
  191.    while( pToken != NULL )
  192.    {
  193. // Store x value
  194. pt[i].x = atol(pToken);
  195. // Get next token and store y value
  196. pToken = strtok( NULL, szSeperators );
  197. pt[i].y = atol(pToken);
  198. // Get next token and continue
  199. i++;
  200. pToken = strtok( NULL, szSeperators );
  201.    }
  202.    return (i == nNumPoints) ? TRUE : FALSE;
  203. }
  204. HX_RESULT CPrefTable::ReadPrefColor(INT32 nPrefKey,HXxColor& color,INT32 nIndex)
  205. {
  206.     HX_RESULT theErr = HXR_OK;
  207.     INT32 lValue = 0;
  208.     theErr = ReadPrefInt(nPrefKey,lValue,nIndex);
  209.     color = (HXxColor) lValue;
  210.     return theErr;
  211. }
  212. HX_RESULT CPrefTable::ReadPref(INT32 nPrefKey,INT32 nIndex,IHXBuffer*& pBuffer)
  213. {
  214.     // Index is out of table range if this is false
  215.     HX_ASSERT(nPrefKey >= 0 && nPrefKey < m_nTableEntries);
  216.     // Need to call SetupPrefTable() if this is false
  217.     HX_ASSERT(m_pPrefTable);
  218.     // Index is out of table range
  219.     if (nPrefKey < 0 || nPrefKey >= m_nTableEntries)
  220. return HXR_INVALID_PARAMETER;
  221.     // Need to call SetupPrefTable()
  222.     if (!m_pPrefTable || (!m_pCPref && !m_pIHXPrefs))
  223. return HXR_UNEXPECTED;
  224.     // If we have an indexed pref append index number to pref
  225.     if (nIndex > 0)
  226.     {
  227.         char szIndexedPref[MAX_PREF_NAME]; /* Flawfinder: ignore */
  228. SafeSprintf(szIndexedPref,MAX_PREF_NAME,"%s%ld",m_pPrefTable[nPrefKey].szPrefName,nIndex);
  229. return (m_pCPref ? m_pCPref->read_pref(szIndexedPref,pBuffer) : m_pIHXPrefs->ReadPref(szIndexedPref,pBuffer));
  230.     }
  231.     // otherwise just read in this pref
  232.     else
  233. return (m_pCPref ? m_pCPref->read_pref(m_pPrefTable[nPrefKey].szPrefName,pBuffer) : m_pIHXPrefs->ReadPref(m_pPrefTable[nPrefKey].szPrefName,pBuffer));
  234. }
  235. BOOL CPrefTable::IsPrefSet(INT32 nPrefKey,INT32 nIndex)
  236. {
  237.     CHXBuffer* pBuffer = NULL;
  238.     HX_RESULT result;
  239.     // Try to read the pref
  240.     result = ReadPref(nPrefKey,nIndex,(IHXBuffer*&)pBuffer);
  241.     // Don't need buffer anymore
  242.     HX_RELEASE(pBuffer);
  243.     return SUCCEEDED(result) ? TRUE : FALSE;
  244. }
  245. HX_RESULT CPrefTable::ReadPrefInt(INT32 nPrefKey,INT32& nValue,INT32 nIndex)
  246. {
  247.     CHXBuffer* pBuffer = NULL;
  248.     HX_RESULT result;
  249.     // Default return value
  250.     nValue = 0;
  251.     // Try to read the pref
  252.     result = ReadPref(nPrefKey,nIndex,(IHXBuffer*&)pBuffer);
  253.     // Convert the preference to an integer 
  254.     if (result == HXR_OK)
  255. nValue = atol((const char*)pBuffer->GetBuffer());
  256.     // Pref doesn't exist convert default value to integer
  257.     // Added the invalid parameter check to insure the index in valid range RBP 8/20/01 
  258.     else if (HXR_INVALID_PARAMETER != result && HXR_UNEXPECTED != result)
  259.     {
  260. if(NULL != m_pPrefTable[nPrefKey].pDefaultValue)
  261. {
  262.     nValue = atol(m_pPrefTable[nPrefKey].pDefaultValue);
  263. }
  264. else
  265. {
  266.     return result;
  267. }
  268.     }
  269.     else
  270. return HXR_FAIL;
  271.     // Don't need buffer anymore
  272.     if (pBuffer)
  273. pBuffer->Release();
  274.     return HXR_OK;
  275. }
  276. HX_RESULT CPrefTable::ReadPrefRect(INT32 nPrefKey,HXxRect& rect,INT32 nIndex)
  277. {
  278.     CHXBuffer* pBuffer = NULL;
  279.     HX_RESULT result;
  280.     // Try to read the pref
  281.     result = ReadPref(nPrefKey,nIndex,(IHXBuffer*&)pBuffer);
  282.     // Convert the preference to a rect
  283.     HXxPoint ptArray[2];
  284.     if (result == HXR_OK)
  285.     {
  286. if (ReadPoints((const char*)pBuffer->GetBuffer(),ptArray,2))
  287. {
  288.     rect.left = ptArray[0].x;
  289.     rect.top = ptArray[0].y;
  290.     rect.right = ptArray[1].x;
  291.     rect.bottom = ptArray[1].y;
  292.     // Don't need buffer anymore
  293.     if (pBuffer)
  294. pBuffer->Release();
  295.     return HXR_OK;
  296. }
  297.     }
  298.     if (m_pPrefTable[nPrefKey].pDefaultValue)
  299.     {
  300. ReadPoints(m_pPrefTable[nPrefKey].pDefaultValue,ptArray,2);
  301. rect.left = ptArray[0].x;
  302. rect.top = ptArray[0].y;
  303. rect.right = ptArray[1].x;
  304. rect.bottom = ptArray[1].y;
  305.     }
  306.     else
  307. return HXR_FAIL;
  308.     // Don't need buffer anymore
  309.     if (pBuffer)
  310. pBuffer->Release();
  311.     return HXR_OK;
  312. }
  313. HX_RESULT CPrefTable::ReadPrefSize(INT32 nPrefKey,HXxSize& size,INT32 nIndex)
  314. {
  315.     CHXBuffer* pBuffer = NULL;
  316.     HX_RESULT result;
  317.     // Try to read the pref
  318.     result = ReadPref(nPrefKey,nIndex,(IHXBuffer*&)pBuffer);
  319.     // Convert the preference to a size
  320.     HXxPoint ptArray;
  321.     if (result == HXR_OK)
  322.     {
  323. if (ReadPoints((const char*)pBuffer->GetBuffer(),&ptArray,1))
  324. {
  325.     size.cx = ptArray.x;
  326.     size.cy = ptArray.y;
  327.     // Don't need buffer anymore
  328.     if (pBuffer)
  329. pBuffer->Release();
  330.     return HXR_OK;
  331. }
  332.     }
  333.     if (m_pPrefTable[nPrefKey].pDefaultValue)
  334.     {
  335. ReadPoints(m_pPrefTable[nPrefKey].pDefaultValue,&ptArray,1);
  336. size.cx = ptArray.x;
  337. size.cy = ptArray.y;
  338.     }
  339.     else
  340. return HXR_FAIL;
  341.     // Don't need buffer anymore
  342.     if (pBuffer)
  343. pBuffer->Release();
  344.     return HXR_OK;
  345. }
  346. HX_RESULT CPrefTable::ReadPrefPoint(INT32 nPrefKey,HXxPoint& pt,INT32 nIndex)
  347. {
  348.     CHXBuffer* pBuffer = NULL;
  349.     HX_RESULT result;
  350.     // Try to read the pref
  351.     result = ReadPref(nPrefKey,nIndex,(IHXBuffer*&)pBuffer);
  352.     // Convert the preference to a size
  353.     HXxPoint ptArray;
  354.     if (result == HXR_OK)
  355.     {
  356. if (ReadPoints((const char*)pBuffer->GetBuffer(),&ptArray,1))
  357. {
  358.     pt.x = ptArray.x;
  359.     pt.y = ptArray.y;
  360.     // Don't need buffer anymore
  361.     if (pBuffer)
  362. pBuffer->Release();
  363.     return HXR_OK;
  364. }
  365.     }
  366.     if (m_pPrefTable[nPrefKey].pDefaultValue)
  367.     {
  368. ReadPoints(m_pPrefTable[nPrefKey].pDefaultValue,&ptArray,1);
  369. pt.x = ptArray.x;
  370. pt.y = ptArray.y;
  371.     }
  372.     else
  373. return HXR_FAIL;
  374.     // Don't need buffer anymore
  375.     if (pBuffer)
  376. pBuffer->Release();
  377.     return HXR_OK;
  378. }
  379. HX_RESULT CPrefTable::ReadPrefString(INT32 nPrefKey,char* szString,INT32 nStrLen,INT32 nIndex)
  380. {
  381.     CHXBuffer* pBuffer = NULL;
  382.     HX_RESULT result;
  383.     if (!szString || !nStrLen)
  384. return HXR_INVALID_PARAMETER;
  385.     // Default return value
  386.     szString[0] = '';
  387.     // Try to read the pref
  388.     result = ReadPref(nPrefKey,nIndex,(IHXBuffer*&)pBuffer);
  389.     // Convert the preference to a string
  390.     if (result == HXR_OK)
  391.     {
  392. strncpy(szString,(const char*)pBuffer->GetBuffer(),(int)nStrLen);
  393.         szString[nStrLen-1] = '';
  394.     }
  395.     // Pref doesn't exist convert default value to integer
  396.     else if (m_pPrefTable[(int)nPrefKey].pDefaultValue)
  397.     {
  398. strncpy(szString,m_pPrefTable[nPrefKey].pDefaultValue,(int)nStrLen);
  399.         szString[nStrLen-1] = '';
  400.     }
  401.     else
  402. return HXR_FAIL;
  403.     // Don't need buffer anymore
  404.     if (pBuffer)
  405. pBuffer->Release();
  406.     return HXR_OK;
  407. }
  408.     
  409. HX_RESULT CPrefTable::ReadPrefBuffer(INT32 nPrefKey,IHXBuffer*& pBuffer,INT32 nIndex)
  410. {
  411.     HX_RESULT result;
  412.     // read_pref creates an IHXBuffer so this should be NULL
  413.     HX_ASSERT(!pBuffer);
  414.     // Try to read the pref
  415.     result = ReadPref(nPrefKey,nIndex,pBuffer);
  416.     // If the pref read failed try to create our own IMRABuffer and copy in the default pref
  417.     if (result != HXR_OK)
  418.     {
  419. if (m_pPrefTable[nPrefKey].pDefaultValue)
  420. {
  421.     pBuffer = new CHXBuffer;
  422.     if (!pBuffer)
  423. return HXR_OUTOFMEMORY;
  424.     pBuffer->AddRef();
  425.     pBuffer->Set((const UCHAR*)m_pPrefTable[nPrefKey].pDefaultValue,strlen(m_pPrefTable[nPrefKey].pDefaultValue)+1);
  426. }
  427. else
  428.     return HXR_FAIL;
  429.     }
  430.     return HXR_OK;
  431. }
  432. HX_RESULT CPrefTable::WritePref(INT32 nPrefKey,INT32 nIndex,IHXBuffer* pBuffer)
  433. {
  434.     // Index is out of table range if this is false
  435.     HX_ASSERT(nPrefKey >= 0 && nPrefKey < m_nTableEntries);
  436.     // Need to call SetupPrefTable() if this is false
  437.     HX_ASSERT(m_pPrefTable);
  438.     // Index is out of table range
  439.     if (nPrefKey < 0 || nPrefKey >= m_nTableEntries)
  440. return HXR_INVALID_PARAMETER;
  441.     // Need to call SetupPrefTable()
  442.     if (!m_pPrefTable || (!m_pCPref && !m_pIHXPrefs))
  443. return HXR_UNEXPECTED;
  444.     // If we have an indexed pref append index number to pref
  445.     if (nIndex > 0)
  446.     {
  447.         char szIndexedPref[MAX_PREF_NAME]; /* Flawfinder: ignore */
  448. SafeSprintf(szIndexedPref,MAX_PREF_NAME,"%s%ld",m_pPrefTable[nPrefKey].szPrefName,nIndex);
  449. return (m_pCPref ? m_pCPref->write_pref(szIndexedPref,pBuffer) : m_pIHXPrefs->WritePref(szIndexedPref,pBuffer));
  450.     }
  451.     else
  452. return (m_pCPref ? m_pCPref->write_pref(m_pPrefTable[nPrefKey].szPrefName,pBuffer) : m_pIHXPrefs->WritePref(m_pPrefTable[nPrefKey].szPrefName,pBuffer));
  453. }
  454. IHXBuffer* CPrefTable::CreateIHXBuffer(const char* szString)
  455. {
  456.     // Create new buffer
  457.     CHXBuffer* pBuffer = new CHXBuffer();
  458.     if (!pBuffer)
  459. return NULL;
  460.     // Addref and fill buffer
  461.     pBuffer->AddRef();
  462.     pBuffer->Set((const UCHAR*)szString,strlen(szString)+1);
  463.     return pBuffer;
  464. }
  465. HX_RESULT CPrefTable::WritePrefColor(INT32 nPrefKey,const HXxColor& color,INT32 nIndex)
  466. {
  467.     INT32 lValue = (INT32)color;
  468.     return WritePrefInt(nPrefKey,lValue,nIndex);
  469. }
  470. HX_RESULT CPrefTable::WritePrefInt(INT32 nPrefKey,INT32 nValue,INT32 nIndex)
  471. {
  472.     IHXBuffer* pBuffer = NULL;
  473.     char szBuff[MAX_INT_BUFFER]; /* Flawfinder: ignore */
  474.     
  475.     SafeSprintf(szBuff, sizeof(szBuff), "%ld", nValue);
  476.     // Create buffer and write pref
  477.     pBuffer = CreateIHXBuffer(szBuff);
  478.     HX_RESULT result = WritePref(nPrefKey,nIndex,pBuffer);
  479.     // Don't need buffer anymore
  480.     if (pBuffer)
  481. pBuffer->Release();
  482.     return result;
  483. }
  484. HX_RESULT CPrefTable::WritePrefRect(INT32 nPrefKey,const HXxRect& rect,INT32 nIndex)
  485. {
  486.     IHXBuffer* pBuffer = NULL;
  487.     char szBuff[MAX_RECT_BUFFER]; /* Flawfinder: ignore */
  488.     
  489.     SafeSprintf(szBuff, sizeof(szBuff), "%ld,%ld,%ld,%ld",
  490.                 rect.left, rect.top, rect.right, rect.bottom);
  491.     // Create buffer and write pref
  492.     pBuffer = CreateIHXBuffer(szBuff);
  493.     HX_RESULT result = WritePref(nPrefKey,nIndex,pBuffer);
  494.     // Don't need buffer anymore
  495.     if (pBuffer)
  496. pBuffer->Release();
  497.     return result;
  498. }
  499. HX_RESULT CPrefTable::WritePrefSize(INT32 nPrefKey,const HXxSize& size,INT32 nIndex)
  500. {
  501.     IHXBuffer* pBuffer = NULL;
  502.     char szBuff[MAX_SIZE_BUFFER]; /* Flawfinder: ignore */
  503.     
  504.     SafeSprintf(szBuff, sizeof(szBuff), "%ld,%ld", size.cx, size.cy);
  505.     // Create buffer and write pref
  506.     pBuffer = CreateIHXBuffer(szBuff);
  507.     HX_RESULT result = WritePref(nPrefKey,nIndex,pBuffer);
  508.     // Don't need buffer anymore
  509.     if (pBuffer)
  510. pBuffer->Release();
  511.     return result;
  512. }
  513. HX_RESULT CPrefTable::WritePrefPoint(INT32 nPrefKey,const HXxPoint& pt,INT32 nIndex)
  514. {
  515.     IHXBuffer* pBuffer = NULL;
  516.     char szBuff[MAX_POINT_BUFFER]; /* Flawfinder: ignore */
  517.     
  518.     SafeSprintf(szBuff, sizeof(szBuff), "%ld,%ld", pt.x, pt.y);
  519.     // Create buffer and write pref
  520.     pBuffer = CreateIHXBuffer(szBuff);
  521.     HX_RESULT result = WritePref(nPrefKey,nIndex,pBuffer);
  522.     // Don't need buffer anymore
  523.     if (pBuffer)
  524. pBuffer->Release();
  525.     return result;
  526. }
  527. HX_RESULT CPrefTable::WritePrefString(INT32 nPrefKey,const char* szString,INT32 nIndex)
  528. {
  529.     IHXBuffer* pBuffer = NULL;
  530.     // Create buffer and write pref
  531.     pBuffer = CreateIHXBuffer(szString);
  532.     HX_RESULT result = WritePref(nPrefKey,nIndex,pBuffer);
  533.     // Don't need buffer anymore
  534.     if (pBuffer)
  535. pBuffer->Release();
  536.     return result;
  537. }
  538. HX_RESULT CPrefTable::WritePrefBuffer(INT32 nPrefKey,IHXBuffer* pBuffer,INT32 nIndex)
  539. {
  540.     return WritePref(nPrefKey,nIndex,pBuffer);
  541. }
  542. HX_RESULT CPrefTable::BeginSubPref(INT32 nPrefKey)
  543. {
  544.     // Index is out of table range if this is false
  545.     HX_ASSERT(nPrefKey >= 0 && nPrefKey < m_nTableEntries);
  546.     // Need to call SetupPrefTable() if this is false
  547.     HX_ASSERT(m_pPrefTable);
  548.     // Index is out of table range
  549.     if (nPrefKey < 0 || nPrefKey >= m_nTableEntries)
  550. return HXR_INVALID_PARAMETER;
  551.     // Need to call SetupPrefTable()
  552.     if (!m_pPrefTable || !m_pCPref)
  553. return HXR_UNEXPECTED;
  554.     // Call BeginSubPref with the actual string
  555.     return m_pCPref->BeginSubPref(m_pPrefTable[nPrefKey].szPrefName);
  556. }
  557. ///////////////////////////////////////////////
  558. #ifdef PREFTESTING
  559. #include <stdio.h>
  560. #define INITGUID
  561. #include "hxcom.h"
  562. #include "ihxpckts.h"
  563. #include "pref.h"
  564. #include "playpref.h"
  565. #include "chxpckts.h"
  566. int main(int argc, char **argv)
  567. {
  568. CPref *mPref = 0;
  569. CHXBuffer* pinBuffer = 0;
  570. CHXBuffer* poutBuffer = 0;
  571. #ifdef _WINDOWS
  572. const char* pCompanyName = HXVER_COMPANY;
  573. const char* pProductName = HXVER_SDK_PRODUCT;
  574. int nMajVer = TARVER_MAJOR_VERSION;
  575. int nMinVer = TARVER_MINOR_VERSION;
  576. #else
  577. const char* pCompanyName = HXVER_COMPANY;
  578. const char* pProductName = HXVER_SDK_PRODUCT;
  579. int nMajVer = 6;
  580. int nMinVer = 0;
  581. #endif
  582. char * pComa = HXFindChar(pCompanyName, ',');
  583. if(pComa)
  584.         *pComa = 0;
  585. mPref = CPlayerPref::open_pref(pCompanyName,pProductName,nMajVer,nMinVer);
  586. pinBuffer = new CHXBuffer;
  587. if ( !pinBuffer )
  588. {
  589. printf("can't create CHXBuffern");
  590. exit(0);
  591. }
  592. char *svalue = 0;
  593. svalue = (char*) new char [ 10 ];
  594. strcpy(svalue, "IsADog"); /* Flawfinder: ignore */
  595. pinBuffer->AddRef();
  596. pinBuffer->Set((const unsigned char*) svalue, strlen(svalue) + 1);
  597. mPref->write_pref("Pushkin",pinBuffer);
  598. mPref->read_pref("Pushkin",poutBuffer);
  599. // printf("Pushkin is: %sn",(char*) (poutBuffer->GetBuffer()));
  600. if ( mPref ) 
  601. delete mPref;
  602. exit(0);
  603. }
  604. #endif