resstr.cpp
上传用户:dangjiwu
上传日期:2013-07-19
资源大小:42019k
文件大小:7k
源码类别:

Symbian

开发平台:

Visual C++

  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: resstr.cpp,v 1.5.36.3 2004/07/09 01:47:42 hubbe Exp $
  3.  * 
  4.  * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved.
  5.  * 
  6.  * The contents of this file, and the files included with this file,
  7.  * are subject to the current version of the RealNetworks Public
  8.  * Source License (the "RPSL") available at
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed
  10.  * the file under the current version of the RealNetworks Community
  11.  * Source License (the "RCSL") available at
  12.  * http://www.helixcommunity.org/content/rcsl, in which case the RCSL
  13.  * will apply. You may also obtain the license terms directly from
  14.  * RealNetworks.  You may not use this file except in compliance with
  15.  * the RPSL or, if you have a valid RCSL with RealNetworks applicable
  16.  * to this file, the RCSL.  Please see the applicable RPSL or RCSL for
  17.  * the rights, obligations and limitations governing use of the
  18.  * contents of the file.
  19.  * 
  20.  * Alternatively, the contents of this file may be used under the
  21.  * terms of the GNU General Public License Version 2 or later (the
  22.  * "GPL") in which case the provisions of the GPL are applicable
  23.  * instead of those above. If you wish to allow use of your version of
  24.  * this file only under the terms of the GPL, and not to allow others
  25.  * to use your version of this file under the terms of either the RPSL
  26.  * or RCSL, indicate your decision by deleting the provisions above
  27.  * and replace them with the notice and other provisions required by
  28.  * the GPL. If you do not delete the provisions above, a recipient may
  29.  * use your version of this file under the terms of any one of the
  30.  * RPSL, the RCSL or the GPL.
  31.  * 
  32.  * This file is part of the Helix DNA Technology. RealNetworks is the
  33.  * developer of the Original Code and owns the copyrights in the
  34.  * portions it created.
  35.  * 
  36.  * This file, and the files included with this file, is distributed
  37.  * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY
  38.  * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS
  39.  * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES
  40.  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET
  41.  * ENJOYMENT OR NON-INFRINGEMENT.
  42.  * 
  43.  * Technology Compatibility Kit Test Suite(s) Location:
  44.  *    http://www.helixcommunity.org/content/tck
  45.  * 
  46.  * Contributor(s):
  47.  * 
  48.  * ***** END LICENSE BLOCK ***** */
  49. #include "hxcom.h"
  50. #include "hxassert.h"
  51. #include "ResStr.h"
  52. #include "hxstrutl.h"
  53. #include "hxmullan.h" // Multipl-Language Support API
  54. #include "hxheap.h"
  55. #ifdef _DEBUG
  56. #undef HX_THIS_FILE
  57. static const char HX_THIS_FILE[] = __FILE__;
  58. #endif
  59. /*
  60.  * Class static data
  61.  */
  62. char *ResStr::m_pcNULL = "";
  63. /*
  64.  * Class Constructors
  65.  */
  66. // Default constructor
  67. ResStr::ResStr( void )
  68. {
  69. #if defined( _DEBUG ) && defined( DEBUG_CLASS )
  70. DEBUGOUTSTR( "Called default contructorrn" );
  71. #endif
  72. m_iLen = 0;
  73. m_iResNum = 0;
  74. m_pcString = m_pcNULL;
  75. }
  76. // Initialized constructor
  77. ResStr::ResStr( UINT32 iResNum )
  78. {
  79. #if defined( _DEBUG ) && defined( DEBUG_CLASS )
  80. char acBuffer[100]; /* Flawfinder: ignore */
  81. SafeSprintf( acBuffer, 100, "Called contructor w/ ResStr( %d )rn", iResNum );
  82. DEBUGOUTSTR( acBuffer );
  83. #endif
  84. // Initialize some instance variables
  85. m_iLen = 0;
  86. m_iResNum = 0;
  87. m_pcString = m_pcNULL;
  88. // This member will try to load the resource, but won't
  89. // disturb our member data if it fails.
  90. LoadStr( iResNum );
  91. }
  92. // Copy constructor
  93. ResStr::ResStr( const ResStr &theRes )
  94. {
  95. // Copy the data from theRes into the new ResStr
  96. m_iLen = theRes.m_iLen;
  97. m_iResNum = theRes.m_iResNum;
  98. m_pcString = new char[ m_iLen + 1 ];
  99. // This is a deep copy, so we duplicate the character data
  100. if (m_pcString)
  101. {
  102.     SafeStrCpy( m_pcString, theRes.m_pcString, m_iLen+1 );
  103. }
  104. }
  105. /*
  106.  * Class destructor
  107.  *
  108.  */
  109. ResStr::~ResStr( void )
  110. {
  111. #if defined( _DEBUG ) && defined( DEBUG_CLASS )
  112. DEBUGOUTSTR( "Called desructorrn" );
  113. #endif
  114. if (m_pcString && (m_pcString != m_pcNULL))
  115. {
  116. delete [] m_pcString;
  117. }
  118. m_iLen = 0;
  119. m_iResNum = 0;
  120. m_pcString = NULL;
  121. return;
  122. }
  123. /*
  124.  * Class public methods
  125.  */
  126. // Assignment operator
  127. ResStr &ResStr::operator=( const ResStr &theRes )
  128. {
  129. char *pcBuffer;
  130. #ifndef _WIN32
  131. if (this == &theRes)
  132. {
  133. return( *this );
  134. }
  135. #endif
  136. pcBuffer = new char[ theRes.m_iLen + 1 ];
  137. if (m_pcString && (m_pcString != m_pcNULL))
  138. {
  139. delete [] m_pcString;
  140. }
  141. m_iLen = theRes.m_iLen;
  142. m_iResNum = theRes.m_iResNum;
  143. m_pcString = pcBuffer;
  144. SafeStrCpy( m_pcString, theRes.m_pcString, m_iLen+1 );
  145. return( *this );
  146. }
  147. // This method is used to get the object to load a Resource String
  148. BOOL ResStr::LoadStr( UINT32 iResNum )
  149. {
  150. UINT32 iLen;
  151. BOOL btRes;
  152. char *pcBuff;
  153. pcBuff = NULL;
  154. #if defined( _DEBUG ) && defined( DEBUG_CLASS )
  155. char acBuffer[100]; /* Flawfinder: ignore */
  156. #endif
  157. // Get the resource size and allocate a buffer for it
  158. iLen = ResStr::GetResSize( iResNum );
  159. pcBuff = new char[ iLen ];
  160. if (!pcBuff)
  161. {
  162. goto FatalOut;
  163. }
  164. // Actually load the resource
  165. btRes = ResStr::LoadRes( iResNum, pcBuff, iLen );
  166. if (btRes)
  167. {
  168. m_iLen = ::strlen( pcBuff );
  169. m_iResNum = iResNum;
  170. if (m_pcString && (m_pcString != m_pcNULL))
  171. {
  172. delete [] m_pcString;
  173. }
  174. m_pcString = pcBuff;
  175. #if defined( _DEBUG ) && defined( DEBUG_CLASS )
  176. SafeSprintf( acBuffer, 100, "Succeeded in loading resource as: *'%s'*rn", (LPSTR)pcBuff );
  177. DEBUGOUTSTR( acBuffer );
  178. #endif
  179. }
  180. else
  181. {
  182. #if defined( _DEBUG ) && defined( DEBUG_CLASS )
  183. DEBUGOUTSTR( "Failed resource loadrn" );
  184. #endif
  185. goto FatalOut;
  186. }
  187. return( TRUE );
  188. FatalOut:
  189. if (pcBuff && (pcBuff != m_pcNULL))
  190. {
  191. delete [] pcBuff;
  192. }
  193. return( FALSE );
  194. }
  195. // This method initializes the object to load a Resource String, &
  196. // returns a pointer to the string.
  197. LPSTR ResStr::operator()( UINT32 iResNum )
  198. {
  199. if (iResNum && (iResNum != m_iResNum))
  200. {
  201. LoadStr( iResNum );
  202. }
  203. return( (LPSTR)m_pcString );
  204. }
  205. /*
  206.  * Class Private functions
  207.  * These functions are all used in the implementation, however we don't
  208.  * want to expose the implementation to the caller.  Hence they are Private.
  209.  */
  210. // Returns an integer size guaranteed to be able to hold the string.
  211. UINT32 ResStr::GetResSize( UINT32 iRes )
  212. {
  213. // Turns out that we can't lookup the size of string resources
  214. // for some reason.  So since we DO have a promise that these 
  215. // strings are less than 255 bytes, we just return 256 to be safe.
  216. return( 256 );
  217. }
  218. // At the lowest level, this is what's used to load all resource
  219. // strings.
  220. BOOL ResStr::LoadRes( UINT32 iRes, char *pcBuffer, UINT32 iMax )
  221. {
  222. int iLoad;
  223. #if defined( _DEBUG ) && defined( DEBUG_CLASS )
  224. char acBuffer[100]; /* Flawfinder: ignore */
  225. SafeSprintf( acBuffer, 100, "Attempting to load resource %drn", iRes );
  226. DEBUGOUTSTR( acBuffer );
  227. #endif
  228. iLoad = HXLoadString(HX_SAFEUINT(iRes), (LPSTR)pcBuffer, HX_SAFEINT(iMax));
  229. #if defined( _DEBUG ) && defined( DEBUG_CLASS )
  230. if (!iLoad)
  231. {
  232. DEBUGOUTSTR( "Failed string loadrn" );
  233. }
  234. #endif
  235. return( !!iLoad );
  236. }