开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
hxresmg.cpp
资源名称：helix.src.0812.rar　[点击查看]
上传用户：zhongxx05
上传日期：2007-06-06
资源大小：33641k
文件大小：18k
源码类别：

Symbian

开发平台：

C/C++

hxresmg.cpp：源码内容
  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 ***** */ 
  36. #include "hxcom.h"
  37. #include "hlxclib/stdio.h"
  38. #include "hlxclib/stdlib.h"
  39. #ifdef _WINDOWS
  40. #include <windows.h>
  41. #endif
  43. #if defined(_MACINTOSH) && !defined(_MAC_MACHO)
  44. #include <stat.h>
  45. #else
  46. #include "hlxclib/sys/stat.h"
  47. #endif
  48. #include "hxxrsmg.h"
  49. #include "hxplugn.h"
  50. #include "hxfiles.h"
  51. #include "hxcomm.h"
  52. #include "hxxres.h"
  53. #include "hxengin.h"
  54. #include "ihxpckts.h"
  55. #include "hxprefs.h"
  56. #include "hxmon.h"
  58. #include "hxslist.h"
  59. #include "hxstrutl.h"
  60. #include "chxpckts.h"
  61. #include "md5.h"
  62. #include "findfile.h"
  63. #include "hxresmg.h"
  64. #include "dllpath.h"
  66. #include "hxheap.h"
  67. #ifdef _DEBUG
  68. #undef HX_THIS_FILE
  69. static const char HX_THIS_FILE[] = __FILE__;
  70. #endif
  72. // IHXPreferences key defines
  73. #define EXT_RES_DIR "ExtResources"
  74. #define EXT_RES_DATA_KEY "ExternalResourcesData"
  75. #define FILE_INFO_KEY "FileInfo"
  76. #define CHECKSUM_KEY "XRSCheckSum"
  77. #define LANGUAGE_KEY "Language"
  78. #define LANG_ID_KEY "LangID"
  80. // for OS_SEPARATOR_CHAR and OS_SEPARATOR_STRING
  81. #include "hxdir.h"
  83. // static initializations
  84. #if !defined(HELIX_CONFIG_NOSTATICS)
  85. HXExternalResourceManager* HXExternalResourceManager::m_pResourceManager = NULL;
  86. #else
  87. #include "globals/hxglobals.h"
  88. const HXExternalResourceManager* const HXExternalResourceManager::m_pResourceManager = NULL;
  89. #endif
  92. // HXExternalResourceManager methods
  93. HXExternalResourceManager::HXExternalResourceManager(IUnknown* pContext):
  94.      m_lRefCount(0)
  95.     ,m_pResourceList(NULL)
  96.     ,m_pContext(pContext)
  97.     ,m_pHXXResPlugin(NULL)
  98.     ,m_ulLanguageID(0x0409)
  99.     ,m_pExternalResDir(NULL)
  100.     ,m_pPrefs(NULL)
  101.     ,m_pRegistry(NULL)
  102. {
  103.     if(m_pContext)
  104.     {
  105. m_pContext->AddRef();
  106.     }
  107.     Init();
  108. }
  110. HXExternalResourceManager::~HXExternalResourceManager()
  111. {
  112.     delete[] m_pExternalResDir;
  114.     if(m_pResourceList)
  115.     {
  116. CHXSimpleList::Iterator i = m_pResourceList->Begin();
  117. for (; i != m_pResourceList->End(); ++i)
  118. {
  119.     IHXXResFile* pRes = (IHXXResFile*)(*i);
  120.     pRes->Close();
  121.     pRes->Release();
  122. }
  123.     }
  125.     HX_DELETE(m_pResourceList);
  126.     HX_RELEASE(m_pPrefs);
  127.     HX_RELEASE(m_pRegistry);
  128.     HX_RELEASE(m_pContext);
  129.     HX_RELEASE(m_pHXXResPlugin);
  131. #if defined(HELIX_CONFIG_NOSTATICS)
  132.     HXExternalResourceManager*& m_pResourceManager =
  133. (HXExternalResourceManager*&)HXGlobalPtr::Get(
  134.     &HXExternalResourceManager::m_pResourceManager);
  135. #endif
  136.     m_pResourceManager = NULL;
  137. }
  139. HXExternalResourceManager*
  140. HXExternalResourceManager::Instance(IUnknown* pContext)
  141. {
  142. #if defined(HELIX_CONFIG_NOSTATICS)
  143.     HXExternalResourceManager*& m_pResourceManager =
  144. (HXExternalResourceManager*&)HXGlobalPtr::Get(
  145.     &HXExternalResourceManager::m_pResourceManager);
  146. #endif
  148.     if(!m_pResourceManager)
  149.     {
  150. m_pResourceManager = new HXExternalResourceManager(pContext);
  151.     }
  153.     if (m_pResourceManager)
  154.     {
  155. m_pResourceManager->AddRef();
  156.     }
  158.     return m_pResourceManager;
  159. }
  162. // IUnknown methods
  164. STDMETHODIMP 
  165. HXExternalResourceManager::QueryInterface(REFIID riid, void** ppvObj)
  166. {
  167.     QInterfaceList qiList[] =
  168.         {
  169.             { GET_IIDHANDLE(IID_IHXExternalResourceManager), (IHXExternalResourceManager*)this },
  170.             { GET_IIDHANDLE(IID_IUnknown), (IUnknown*)(IHXExternalResourceManager*)this },
  171.         };
  172.     
  173.     return ::QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj);
  174. }
  176. STDMETHODIMP_(ULONG32) 
  177. HXExternalResourceManager::AddRef()
  178. {
  179.     return InterlockedIncrement(&m_lRefCount);
  180. }
  182. STDMETHODIMP_(ULONG32) 
  183. HXExternalResourceManager::Release()
  184. {
  185.     if (InterlockedDecrement(&m_lRefCount) > 0)
  186.     {
  187. return m_lRefCount;
  188.     }
  190.     delete this;
  191.     return 0;
  192. }
  194. // IHXExternalResourceManager methods
  196. STDMETHODIMP
  197. HXExternalResourceManager::Init()
  198. {
  199.     HX_RESULT rc = GetHXXResPlugin();
  201.     if(HXR_OK == rc)
  202.     {
  203. // get language and res directory preferences/reg entries
  204. if (HXR_OK == m_pContext->QueryInterface(IID_IHXPreferences,
  205. (void**)&m_pPrefs) &&
  206.     HXR_OK == m_pContext->QueryInterface(IID_IHXRegistry, 
  207. (void**)&m_pRegistry))
  208. {
  209.     IHXBuffer* pBuffer = NULL;
  210.     CHXString strTemp;
  211.     strTemp.Format("%s.%s",HXREGISTRY_PREFPROPNAME, "LangID");
  212.     if(HXR_OK == m_pRegistry->GetStrByName(strTemp, pBuffer))
  213.     {
  214. const char* pActualLangID = (const char*)pBuffer->GetBuffer();
  215. m_ulLanguageID = strtol(pActualLangID, NULL, 10);
  216. HX_RELEASE(pBuffer);
  217.     }
  219.             const char* pPath = NULL;
  220.             // Get the plugin directory from the Dll Access Paths
  221.             if (GetDLLAccessPath() &&
  222.                 (pPath = GetDLLAccessPath()->GetPath(DLLTYPE_PLUGIN)) &&
  223.                 *pPath)
  224.             {
  225.                 UINT32 ulBufLen = strlen(pPath) + 1 + strlen(EXT_RES_DIR) + 1;
  226.                 m_pExternalResDir = new char[ulBufLen];
  227.                 SafeStrCpy(m_pExternalResDir, pPath, ulBufLen);
  228.                 if (m_pExternalResDir[strlen(m_pExternalResDir)-1] != OS_SEPARATOR_CHAR)
  229.                 {
  230.                     SafeStrCat(m_pExternalResDir, OS_SEPARATOR_STRING, ulBufLen);
  231.                 }
  233.                 SafeStrCat(m_pExternalResDir, EXT_RES_DIR, ulBufLen);
  234.                 rc = LoadResourceFiles();
  235.             }
  237. }
  238.     }
  240.     return rc;
  241. }
  243. STDMETHODIMP
  244. HXExternalResourceManager::CreateExternalResourceReader(
  245.     const char* pShortName,
  246.     REF(IHXExternalResourceReader*) pReader)
  247. {
  248.     HX_RESULT rc = HXR_OK;
  250.     HXExternalResourceReader* pHXReader = new HXExternalResourceReader(this);
  251.     if(!pHXReader)
  252.     {
  253. return HXR_OUTOFMEMORY;
  254.     }
  255.     pHXReader->AddRef();
  256.     pHXReader->Init(pShortName, m_pResourceList);
  258.     pReader = pHXReader;
  259.     return rc;
  260. }
  263. // HXExternalResourceManager private methods
  265. HX_RESULT
  266. HXExternalResourceManager::GetHXXResPlugin()
  267. {
  268.     HX_RESULT rc = HXR_FAILED;
  270.     IUnknown* pUnk = NULL;
  271.     IUnknown* pUnknownInstance = NULL;
  272.     IHXCommonClassFactory* pCommonClassFactory = NULL;
  273.     IHXPluginGroupEnumerator* pGroupEnumerator = NULL;
  274.     UINT32 ulNumPlugins = 0;
  276.     // enumerate the plugins
  277.     if (HXR_OK != m_pContext->QueryInterface(
  278. IID_IHXCommonClassFactory,
  279. (void**)&pCommonClassFactory))
  280.     {
  281. goto cleanup;
  282.     }
  284.     if (HXR_OK != pCommonClassFactory->CreateInstance(
  285. CLSID_IHXPluginGroupEnumerator,
  286. (void**)&pUnk))
  287.     {
  288. goto cleanup;
  289.     }
  291.     if (HXR_OK != pUnk->QueryInterface(IID_IHXPluginGroupEnumerator,
  292.     (void**)&pGroupEnumerator))
  293.     {
  294. goto cleanup;
  295.     }
  297.     if (HXR_OK != pGroupEnumerator->Init(IID_IHXXResFile))
  298.     {
  299. goto cleanup;
  300.     }
  302.     ulNumPlugins = pGroupEnumerator->GetNumOfPlugins();
  303.     if(ulNumPlugins > 0)
  304.     {
  305. if (HXR_OK == pGroupEnumerator->GetPlugin(0, pUnknownInstance))
  306. {
  307.     m_pHXXResPlugin = pUnknownInstance;
  308.     m_pHXXResPlugin->AddRef();
  309.     rc = HXR_OK;
  310. }
  311.     }
  313. cleanup:
  314.     HX_RELEASE(pUnk);
  315.     HX_RELEASE(pUnknownInstance);
  316.     HX_RELEASE(pCommonClassFactory);
  317.     HX_RELEASE(pGroupEnumerator);
  319.     return rc;
  320. }
  322. BOOL
  323. HXExternalResourceManager::ContainsCurrentLanguage(IHXXResFile* pResFile)
  324. {
  325.     BOOL rc = FALSE;
  327.     if(!pResFile)
  328.     {
  329. return rc;
  330.     }
  332.     UINT32 ulLangID = 0;
  333.     BOOL bFound = FALSE;
  334.     rc = pResFile->GetFirstResourceLanguage(ulLangID);
  335.     while(HXR_OK == rc)
  336.     {
  337. if(m_ulLanguageID == ulLangID)
  338. {
  339.     rc = TRUE;
  340.     break;
  341. }
  342. rc = pResFile->GetNextResourceLanguage(ulLangID);
  343.     };
  345.     return rc;
  346. }
  348. IHXXResFile*
  349. HXExternalResourceManager::MakeResFileObject(const char* pPath)
  350. {
  351.     IHXXResFile* pResFile = NULL;
  353.     if(m_pHXXResPlugin &&
  354. HXR_OK == m_pHXXResPlugin->QueryInterface(IID_IHXXResFile, 
  355. (void**)&pResFile))
  356.     {
  357. HX_RESULT rc = HXR_OK;
  359. // open res file and see if it contains any resources with the
  360. // current language ID
  362. pResFile->Open(pPath);
  363. if(ContainsCurrentLanguage(pResFile))
  364. {
  365.     pResFile->SetLanguage(m_ulLanguageID);
  366. }
  367. else
  368. {
  369.     HX_RELEASE(pResFile);   // don't want this one
  370. }
  371.     }
  372.     return pResFile;
  373. }
  375. HX_RESULT
  376. HXExternalResourceManager::Stat(const char* pPath, struct stat* pStatBuffer)
  377. {
  378.     HX_RESULT rc = HXR_OK;
  380.     memset(pStatBuffer,0,sizeof(*pStatBuffer));
  382.     if(stat((const char*)pPath, pStatBuffer) < 0)
  383.     {
  384. rc = HXR_FAIL;
  385.     }
  386.     return rc;
  387. }
  389. IHXBuffer* 
  390. HXExternalResourceManager::ConvertToAsciiString(char* pBuffer, UINT32 nBuffLen)
  391. {
  392.     char* pOut = new char[nBuffLen*2+1];
  393.     char* pStartOut = pOut;
  394.     char Nibble;
  396.     IHXBuffer* pOutBuffer = new CHXBuffer;
  397.     pOutBuffer->AddRef();
  399.     for (int i = 0; i < (int)nBuffLen; i++)
  400.     {
  401. Nibble = (*pBuffer >> 4) & 15;
  402. *pOut= (Nibble > 9 ) ? Nibble + 55 : Nibble + 48;
  403. pOut++;
  404. Nibble = *pBuffer & 15;
  405. *pOut= (Nibble > 9 ) ? Nibble + 55 : Nibble + 48;
  406. pOut++;
  407. pBuffer++;
  408.     }
  409.     *pOut = 0;
  410.     pOutBuffer->Set((UCHAR*)pStartOut, strlen(pStartOut)+1);
  411.     delete[] pStartOut;
  412.     return pOutBuffer;
  413. }
  415. IHXBuffer* 
  416. HXExternalResourceManager::ChecksumFile(const char* pPath)
  417. {
  418.     struct stat     stat_struct;
  419.     md5_state_t     MD5_data;
  420.     UCHAR     tempbuf[16];
  422.     md5_init(&MD5_data);
  423.     if (HXR_OK != Stat(pPath, &stat_struct))
  424.     {
  425.         md5_finish(tempbuf, &MD5_data);
  426. return NULL;
  427.     } 
  428.     md5_append(&MD5_data,(UCHAR*)&(stat_struct),sizeof(stat_struct)); 
  429.     md5_finish(tempbuf, &MD5_data);
  430.     return ConvertToAsciiString((char*)tempbuf, sizeof(tempbuf));
  431. }
  433. HX_RESULT
  434. HXExternalResourceManager::SaveFileInfo(const char* pFileName,
  435.          const char* pPath)
  436. {
  437.     HX_RESULT rc = HXR_OK;
  439.    // set/reset cache info
  440.     if(!m_pPrefs)
  441.     {
  442. return HXR_FAIL;
  443.     }
  445.     IHXBuffer* pStatInfo = ChecksumFile(pPath);
  446.     if(pStatInfo)
  447.     {
  448. CHXString prefString;
  449. prefString.Format("%s\%s\%s\%s",
  450.     EXT_RES_DATA_KEY,
  451.     FILE_INFO_KEY,
  452.     pFileName,
  453.     CHECKSUM_KEY);
  454. m_pPrefs->WritePref(prefString, pStatInfo);
  455. HX_RELEASE(pStatInfo);
  456.     }
  458.     // now write out the langages supported in the resource file
  459.     IHXXResFile* pResFile;
  460.     if(HXR_OK == m_pHXXResPlugin->QueryInterface(IID_IHXXResFile, 
  461. (void**)&pResFile))
  462.     {
  463. HX_RESULT rc = HXR_OK;
  465. // open res file and iterate through all of the languages
  466. // it supports
  467. pResFile->Open(pPath);
  469. UINT32 ulLangID = 0;
  470. rc = pResFile->GetFirstResourceLanguage(ulLangID);
  471. while(HXR_OK == rc)
  472. {
  473.     CHXString prefString;
  474.     IHXBuffer* pBuffer = new CHXBuffer;
  475.     prefString.Format("%s\%s\%s\%s\%ld",
  476. EXT_RES_DATA_KEY,
  477. FILE_INFO_KEY,
  478. pFileName,
  479. LANGUAGE_KEY,
  480. ulLangID);
  481.     pBuffer->Set((BYTE*)"", 1);
  482.     m_pPrefs->WritePref(prefString, pBuffer);
  483.     HX_RELEASE(pBuffer);
  485.     rc = pResFile->GetNextResourceLanguage(ulLangID);
  486. };
  487. HX_RELEASE(pResFile);
  488.     }
  490.     return rc;
  491. }
  493. HX_RESULT
  494. HXExternalResourceManager::LoadResourceFile(const char* pPath)
  495. {
  496.     HX_RESULT rc = HXR_OK;
  498.     // MakeResFileObject only returns an IHXXResFile
  499.     // if there are any resources in the current language
  500.     IHXXResFile* pResFile = MakeResFileObject(pPath);
  501.     if (pResFile)
  502.     {
  503. if(!m_pResourceList)
  504. {
  505.     m_pResourceList = new CHXSimpleList;
  506. }
  507.      m_pResourceList->AddTail(pResFile);
  508.     }
  510.     return rc;
  511. }
  513. BOOL
  514. HXExternalResourceManager::FileInfoCurrent(const char* pFileName, 
  515.     const char* pPath)
  516. {
  517.     BOOL rc = FALSE;
  519.     IHXBuffer* pStatInfo = ChecksumFile(pPath);
  520.     if(pStatInfo)
  521.     {
  522. IHXBuffer* pPrefValue = NULL;
  523. CHXString prefString;
  524. prefString.Format("%s\%s\%s\%s",
  525.     EXT_RES_DATA_KEY,
  526.     FILE_INFO_KEY,
  527.     pFileName,
  528.     CHECKSUM_KEY);
  529. if(HXR_OK == m_pPrefs->ReadPref(prefString, pPrefValue) &&
  530.     pPrefValue)
  531. {
  532.     const char* pActualPrefValue = (const char*)pPrefValue->GetBuffer();
  533.     const char* pActualStatInfo = (const char*)pStatInfo->GetBuffer();
  534.     if(strcmp(pActualPrefValue, pActualStatInfo) == 0)
  535.     {
  536. rc = TRUE;
  537.     }
  538.     HX_RELEASE(pPrefValue);
  539. }
  540. HX_RELEASE(pStatInfo);
  541.     }
  543.     return rc;
  544. }
  546. BOOL
  547. HXExternalResourceManager::ContainsCurrentLanguage(const char* pFileName,
  548.    const char* pPath)
  549. {
  550. #if defined (_MACINTOSH) || defined (_UNIX)
  551.     /* Temporary - Mac Installer does not write this pref yet -- XXXRA */
  552.     return TRUE;
  553. #endif
  555.     BOOL rc = FALSE;
  557.     IHXBuffer* pLangInfo = NULL;
  558.     CHXString prefString;
  559.     prefString.Format("%s\%s\%s\%s\%ld",
  560. EXT_RES_DATA_KEY,
  561. FILE_INFO_KEY,
  562. pFileName,
  563. LANGUAGE_KEY,
  564. m_ulLanguageID);
  565.     if(HXR_OK == m_pPrefs->ReadPref(prefString, pLangInfo))
  566.     {
  567. rc = TRUE;
  568. HX_RELEASE(pLangInfo);
  569.     }
  571.     return rc;
  572. }
  574. HX_RESULT
  575. HXExternalResourceManager::LoadResourceFiles()
  576. {
  577.     CFindFile* pFileFinder = NULL;
  578.     char* pResFile = NULL;
  579.     const char* pFileExtension = "*.xrs";
  580.     HX_RESULT   rc = HXR_OK;
  582.     // find plugins with specified pattern
  583.     pFileFinder = CFindFile::CreateFindFile(m_pExternalResDir, 0, 
  584.     pFileExtension);
  585.     if (NULL == pFileFinder)
  586.     {
  587. rc = HXR_FAIL;
  588. goto cleanup;
  589.     }
  591.     // collect plugin info.
  592.     pResFile = pFileFinder->FindFirst();
  593.     while (pResFile)
  594.     {
  595. BOOL bLoadFile = FALSE;
  596. const char* pResPath = pFileFinder->GetCurFilePath();
  597. // only load the file if it has resources that reflect
  598. // the current system language ID
  599. if(!FileInfoCurrent(pResFile, pResPath))
  600. {
  601.     SaveFileInfo(pResFile, pResPath);
  602. }
  603.     
  604. if(ContainsCurrentLanguage(pResFile, pResPath))
  605. {
  606.     rc = LoadResourceFile(pResPath);
  607. }
  608. if(HXR_OK != rc)
  609. {
  610.     // error - log it and keep on?
  611. }
  612. pResFile = pFileFinder->FindNext();
  613.     }
  614.     delete pFileFinder;
  616. cleanup:
  617.     return rc;
  618. }
  620. // HXExternalResourceReader methods
  622. HXExternalResourceReader::HXExternalResourceReader(
  623.      HXExternalResourceManager* pMgr):
  624.      m_lRefCount(0)
  625.     ,m_pResManager(pMgr)
  626.     ,m_pResourceList(NULL)
  627.     ,m_pDefaultRes(NULL)
  628. {
  629. }
  631. HXExternalResourceReader::~HXExternalResourceReader()
  632. {
  633.     HX_DELETE(m_pResourceList);
  634.     HX_RELEASE(m_pDefaultRes);
  635. }
  637. // IUnknown methods
  639. STDMETHODIMP 
  640. HXExternalResourceReader::QueryInterface(REFIID riid, void** ppvObj)
  641. {
  642.     QInterfaceList qiList[] =
  643.         {
  644.             { GET_IIDHANDLE(IID_IHXExternalResourceReader), (IHXExternalResourceReader*)this },
  645.             { GET_IIDHANDLE(IID_IUnknown), (IUnknown*)(IHXExternalResourceReader*)this },
  646.         };
  647.     
  648.     return ::QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj);
  649. }
  651. STDMETHODIMP_(ULONG32) 
  652. HXExternalResourceReader::AddRef()
  653. {
  654.     return InterlockedIncrement(&m_lRefCount);
  655. }
  657. STDMETHODIMP_(ULONG32) 
  658. HXExternalResourceReader::Release()
  659. {
  660.     if (InterlockedDecrement(&m_lRefCount) > 0)
  661.     {
  662. return m_lRefCount;
  663.     }
  665.     delete this;
  666.     return 0;
  667. }
  670. STDMETHODIMP
  671. HXExternalResourceReader::SetDefaultResourceFile(
  672.     const char* pResourcePath)
  673. {
  674.     HX_RESULT rc = HXR_OK;
  676.     m_pDefaultRes = m_pResManager->MakeResFileObject(pResourcePath);
  678.     return rc;
  679. }
  681. IHXXResource*
  682. HXExternalResourceReader::GetResource(IHXXResFile* pResFile,
  683.        UINT32 ulResourceType,
  684.        UINT32 ulResourceID)
  685. {
  686.     IHXXResource* pRes = NULL;
  687.     switch(ulResourceType)
  688.     {
  689. case HX_RT_STRING:
  690. {
  691.     pRes = pResFile->GetString(ulResourceID);
  692. }
  693. break;
  695. case HX_RT_DIALOG:
  696. {
  697.     pRes = pResFile->GetDialog(ulResourceID);
  698. }
  699. break;
  701. case HX_RT_BITMAP:
  702. {
  703.     pRes = pResFile->GetBitmap(ulResourceID);
  704. }
  705. break;
  707. default:
  708. break;
  709.     }
  710.     return pRes;
  711. }
  713. STDMETHODIMP_(IHXXResource*)
  714. HXExternalResourceReader::GetResource(UINT32 ulResourceType,
  715.     UINT32 ulResourceID)
  716. {
  717.     IHXXResource* pRes = NULL;
  719.     if(m_pResourceList)
  720.     {
  721. CHXSimpleList::Iterator i = m_pResourceList->Begin();
  722. for (; i != m_pResourceList->End(); ++i)
  723. {
  724.     IHXXResFile* pResFile = (IHXXResFile*)(*i);
  725.     pRes = GetResource(pResFile, ulResourceType, ulResourceID);
  726.     if(pRes)
  727.     {
  728. break;
  729.     }
  730. }
  731.     }
  733.     if(!pRes &&
  734. m_pDefaultRes) // check default
  735.     {
  736. pRes = GetResource(m_pDefaultRes, ulResourceType, ulResourceID);
  737.     }
  739.     return pRes;
  740. }
  743. HX_RESULT
  744. HXExternalResourceReader::Init(const char* pShortName,
  745. CHXSimpleList* pResList)
  746. {
  747.     HX_RESULT rc = HXR_OK;
  749.     if(pResList)
  750.     {
  751. CHXSimpleList::Iterator i = pResList->Begin();
  752. for (; i != pResList->End(); ++i)
  753. {
  754.     IHXXResFile* pResFile = (IHXXResFile*)(*i);
  755.     if(pResFile->IncludesShortName(pShortName))
  756.     {
  757. if(!m_pResourceList)
  758. {
  759.     m_pResourceList = new CHXSimpleList;
  760. }
  761. m_pResourceList->AddTail(pResFile);
  762.     }
  763. }
  764.     }
  766.     return rc;
  767. }