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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 对话框与窗口 > 查看源码
XTPResourceManager.cpp
资源名称：Xtreme.ToolkitPro.v12.0.0.rar　[点击查看]
上传用户：szled88
上传日期：2015-04-09
资源大小：43957k
文件大小：33k
源码类别：

对话框与窗口

开发平台：

Visual C++

XTPResourceManager.cpp：源码内容
  1. // XTPResourceManager.cpp: implementation of the CXTPResourceManager class.
  2. //
  3. // This file is a part of the XTREME TOOLKIT PRO MFC class library.
  4. // (c)1998-2008 Codejock Software, All Rights Reserved.
  5. //
  6. // THIS SOURCE FILE IS THE PROPERTY OF CODEJOCK SOFTWARE AND IS NOT TO BE
  7. // RE-DISTRIBUTED BY ANY MEANS WHATSOEVER WITHOUT THE EXPRESSED WRITTEN
  8. // CONSENT OF CODEJOCK SOFTWARE.
  9. //
  10. // THIS SOURCE CODE CAN ONLY BE USED UNDER THE TERMS AND CONDITIONS OUTLINED
  11. // IN THE XTREME TOOLKIT PRO LICENSE AGREEMENT. CODEJOCK SOFTWARE GRANTS TO
  12. // YOU (ONE SOFTWARE DEVELOPER) THE LIMITED RIGHT TO USE THIS SOFTWARE ON A
  13. // SINGLE COMPUTER.
  14. //
  15. // CONTACT INFORMATION:
  16. // support@codejock.com
  17. // http://www.codejock.com
  18. //
  19. /////////////////////////////////////////////////////////////////////////////
  21. #include "stdafx.h"
  22. #include "XTPVC80Helpers.h"
  23. #include "XTPVC50Helpers.h"
  24. #include "XTPResourceManager.h"
  25. #include "XTPMacros.h"
  26. #include "XTPPropExchange.h"
  27. #include "XTPSystemHelpers.h"
  29. #ifdef _DEBUG
  30. #define new DEBUG_NEW
  31. #undef THIS_FILE
  32. static char THIS_FILE[] = __FILE__;
  33. #endif
  35. #define MAKELANGINFO(l, s, w, e, c, f) {MAKELANGID(l, s), w, e, c, _T(#l), _T(#s), f}
  36. #define ENGLISH_CHARSET ANSI_CHARSET
  38. const WORD cwXTPResManDefLangID = MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US);
  40. static XTP_RESOURCEMANAGER_LANGINFO langinfo[] =
  41. {
  42. MAKELANGINFO(LANG_RUSSIAN, SUBLANG_DEFAULT, 1251, _T("windows-1251"), _T("Russian"), RUSSIAN_CHARSET),
  43. MAKELANGINFO(LANG_JAPANESE, SUBLANG_DEFAULT, 932, _T("shift-jis"), _T("Japanese"), SHIFTJIS_CHARSET),
  44. MAKELANGINFO(LANG_ARABIC, SUBLANG_ARABIC_SAUDI_ARABIA, 1256, _T("windows-1256"), _T("Arabic (Saudi Arabia)"), ARABIC_CHARSET),
  45. MAKELANGINFO(LANG_CZECH, SUBLANG_DEFAULT, 1250, _T("windows-1250"), _T("Czech"), EASTEUROPE_CHARSET),
  46. MAKELANGINFO(LANG_DANISH, SUBLANG_DEFAULT, 1252, _T("windows-1252"), _T("Danish"), ENGLISH_CHARSET),
  47. MAKELANGINFO(LANG_GERMAN, SUBLANG_GERMAN, 1252, _T("windows-1252"), _T("German (Germany)"), ENGLISH_CHARSET),
  48. MAKELANGINFO(LANG_GREEK, SUBLANG_DEFAULT, 1253, _T("windows-1253"), _T("Greek"), GREEK_CHARSET),
  49. MAKELANGINFO(LANG_ENGLISH, SUBLANG_ENGLISH_US, CP_ACP, _T("windows-1252"), _T("English (United States)"), ENGLISH_CHARSET),
  50. MAKELANGINFO(LANG_SPANISH, SUBLANG_SPANISH_MODERN, 1252, _T("windows-1252"), _T("Spanish (Spain - Modern Sort)"), ENGLISH_CHARSET),
  51. MAKELANGINFO(LANG_ESTONIAN, SUBLANG_DEFAULT, 1257, _T("windows-1257"), _T("Estonian"), BALTIC_CHARSET),
  52. MAKELANGINFO(LANG_FINNISH, SUBLANG_DEFAULT, 1252, _T("windows-1252"), _T("Finnish"), ENGLISH_CHARSET),
  53. MAKELANGINFO(LANG_FRENCH, SUBLANG_FRENCH, 1252, _T("windows-1252"), _T("French (France)"), ENGLISH_CHARSET),
  54. MAKELANGINFO(LANG_HEBREW, SUBLANG_DEFAULT, 1255, _T("windows-1255"), _T("Hebrew"), HEBREW_CHARSET),
  55. MAKELANGINFO(LANG_CROATIAN, SUBLANG_DEFAULT, 1250, _T("windows-1250"), _T("Croatian"), EASTEUROPE_CHARSET),
  56. MAKELANGINFO(LANG_HUNGARIAN, SUBLANG_DEFAULT, 1250, _T("windows-1250"), _T("Hungarian"), EASTEUROPE_CHARSET),
  57. MAKELANGINFO(LANG_ITALIAN, SUBLANG_ITALIAN, 1252, _T("windows-1252"), _T("Italian (Italy)"), ENGLISH_CHARSET),
  58. MAKELANGINFO(LANG_KOREAN, SUBLANG_DEFAULT, 949, _T("ks_c_5601"), _T("Korean"), HANGEUL_CHARSET),
  59. MAKELANGINFO(LANG_LITHUANIAN, SUBLANG_LITHUANIAN, 1257, _T("windows-1257"), _T("Lithuanian"), BALTIC_CHARSET),
  60. MAKELANGINFO(LANG_LATVIAN, SUBLANG_DEFAULT, 1257, _T("windows-1257"), _T("Latvian"), BALTIC_CHARSET),
  61. MAKELANGINFO(LANG_DUTCH, SUBLANG_DUTCH, 1252, _T("windows-1252"), _T("Dutch"), ENGLISH_CHARSET),
  62. MAKELANGINFO(LANG_NORWEGIAN, SUBLANG_NORWEGIAN_BOKMAL, 1252, _T("windows-1252"), _T("Norwegian (Bokmal)"), ENGLISH_CHARSET),
  63. MAKELANGINFO(LANG_POLISH, SUBLANG_DEFAULT, 1250, _T("windows-1250"), _T("Polish"), EASTEUROPE_CHARSET),
  64. MAKELANGINFO(LANG_PORTUGUESE, SUBLANG_PORTUGUESE, 1252, _T("windows-1252"), _T("Portuguese (Portugal)"), ENGLISH_CHARSET),
  65. MAKELANGINFO(LANG_PORTUGUESE, SUBLANG_PORTUGUESE_BRAZILIAN, 1252, _T("windows-1252"), _T("Portuguese (Brazil)"), ENGLISH_CHARSET),
  66. MAKELANGINFO(LANG_ROMANIAN, SUBLANG_DEFAULT, 1250, _T("windows-1250"), _T("Romanian"), EASTEUROPE_CHARSET),
  67. MAKELANGINFO(LANG_SLOVAK, SUBLANG_DEFAULT, 1250, _T("windows-1250"), _T("Slovak"), EASTEUROPE_CHARSET),
  68. MAKELANGINFO(LANG_SLOVENIAN, SUBLANG_DEFAULT, 1250, _T("windows-1250"), _T("Slovenian"), EASTEUROPE_CHARSET),
  69. MAKELANGINFO(LANG_SWEDISH, SUBLANG_DEFAULT, 1252, _T("windows-1252"), _T("Swedish"), ENGLISH_CHARSET),
  70. MAKELANGINFO(LANG_THAI, SUBLANG_DEFAULT, 874, _T("windows-874"), _T("Thai"), THAI_CHARSET),
  71. MAKELANGINFO(LANG_TURKISH, SUBLANG_DEFAULT, 1254, _T("windows-1254"), _T("Turkish"), TURKISH_CHARSET),
  72. MAKELANGINFO(LANG_UKRAINIAN, SUBLANG_DEFAULT, 1251, _T("windows-1251"), _T("Ukrainian "), RUSSIAN_CHARSET),
  73. MAKELANGINFO(LANG_BULGARIAN, SUBLANG_DEFAULT, 1251, _T("windows-1251"), _T("Bulgarian"), RUSSIAN_CHARSET),
  74. MAKELANGINFO(LANG_CHINESE, SUBLANG_CHINESE_SIMPLIFIED, 936, _T("gb2312"), _T("Chinese (PRC)"), GB2312_CHARSET),
  75. MAKELANGINFO(LANG_CHINESE, SUBLANG_CHINESE_TRADITIONAL, 950, _T("big5"), _T("Chinese (Taiwan)"), CHINESEBIG5_CHARSET)
  76. };
  78. //////////////////////////////////////////////////////////////////////////
  79. // CW2CT
  81. CXTPResourceManager::CXTPW2A::CXTPW2A(LPCWSTR lpwstr)
  82. {
  83. UINT nCodePage = XTPResourceManager()->GetLanguageInfo()->nCodePage;
  84. int nDestLen = WideCharToMultiByte(nCodePage, 0, lpwstr, -1, NULL, 0, NULL, NULL);
  86. m_lpsrt = new CHAR[nDestLen + 1];
  87. WideCharToMultiByte(nCodePage, 0, lpwstr, -1, m_lpsrt, nDestLen, NULL, NULL);
  88. m_lpsrt[nDestLen] = 0;
  89. }
  91. CXTPResourceManager::CXTPW2A::~CXTPW2A()
  92. {
  93. delete[] m_lpsrt;
  94. }
  96. CXTPResourceManager::CXTPW2A::operator LPCSTR() const
  97. {
  98. return m_lpsrt;
  99. }
  101. CXTPResourceManager::CXTPA2W::CXTPA2W(LPCSTR lptstr)
  102. {
  103. UINT nCodePage = XTPResourceManager()->GetLanguageInfo()->nCodePage;
  104. int nDestLen = MultiByteToWideChar(nCodePage, 0, lptstr, -1, NULL, 0);
  106. m_lpwsrt = new WCHAR[nDestLen + 1];
  107. MultiByteToWideChar(nCodePage, 0, lptstr, -1, m_lpwsrt, nDestLen);
  108. m_lpwsrt[nDestLen] = 0;
  109. }
  111. CXTPResourceManager::CXTPA2W::~CXTPA2W()
  112. {
  113. delete[] m_lpwsrt;
  114. }
  116. CXTPResourceManager::CXTPA2W::operator LPCWSTR() const
  117. {
  118. return m_lpwsrt;
  119. }
  122. //////////////////////////////////////////////////////////////////////////
  123. // CXTPResourceManager
  125. CProcessLocal<CXTPResourceManager> CXTPResourceManager::m_managerInstance;
  128. CXTPResourceManager* AFX_CDECL XTPResourceManager()
  129. {
  130. return CXTPResourceManager::m_managerInstance.GetData();
  131. }
  134. BOOL CXTPResourceManager::SetResourceManager(CXTPResourceManager* pResourceManager)
  135. {
  136. if (pResourceManager == NULL)
  137. return FALSE;
  139. if (!pResourceManager->m_bValid)
  140. {
  141. delete pResourceManager;
  142. return FALSE;
  144. }
  146. pResourceManager->UpdateResourcesLangID();
  149. if (m_managerInstance.m_pObject != NULL)
  150. delete m_managerInstance.m_pObject;
  152. m_managerInstance.m_pObject = pResourceManager;
  153. return TRUE;
  154. }
  156. /////////////////////////////////////////////////////////////////////////
  157. // CXTPResourceManager
  160. HINSTANCE CXTPResourceManager::m_hModXTResource = NULL;
  162. CXTPResourceManager::CManageState::CManageState()
  163. {
  164. m_bSet = false;
  165. Redo();
  166. }
  168. CXTPResourceManager::CManageState::~CManageState()
  169. {
  170. Undo();
  171. m_hModOldResource = NULL;
  172. }
  174. void CXTPResourceManager::CManageState::Undo()
  175. {
  176. if (!m_bSet)
  177. return;
  179. AFX_MODULE_STATE* pModuleState = AfxGetModuleState();
  180. pModuleState->m_hCurrentResourceHandle = m_hModOldResource;
  182. m_bSet = false;
  183. }
  185. void CXTPResourceManager::CManageState::Redo()
  186. {
  187. if (XTPResourceManager()->GetResourceHandle() == NULL)
  188. {
  189. m_bSet = false;
  190. return;
  191. }
  193. AFX_MODULE_STATE* pModuleState = AfxGetModuleState();
  194. m_hModOldResource = pModuleState->m_hCurrentResourceHandle;
  196. pModuleState->m_hCurrentResourceHandle = XTPResourceManager()->GetResourceHandle();
  198. m_bSet = true;
  199. }
  202. CXTPResourceManager::CXTPResourceManager()
  203. {
  204. m_bValid = TRUE;
  205. m_hResourceFile = 0;
  207. m_pLanguageInfo = GetLanguageInfo(cwXTPResManDefLangID);
  208. }
  210. CXTPResourceManager::~CXTPResourceManager()
  211. {
  212. Close();
  213. }
  215. void CXTPResourceManager::Close()
  216. {
  217. if (m_hResourceFile != 0)
  218. {
  219. FreeLibrary(m_hResourceFile);
  220. m_hResourceFile = 0;
  221. }
  222. }
  224. HMODULE CXTPResourceManager::GetResourceHandle() const
  225. {
  226. return m_hModXTResource;
  227. }
  229. void CXTPResourceManager::SetResourceHandle(HMODULE hModRes)
  230. {
  231. m_hModXTResource = hModRes;
  232. UpdateResourcesLangID();
  233. }
  235. void CXTPResourceManager::SetResourceFile(const CString& strResourceFile)
  236. {
  237. CString strExtension = strResourceFile.GetLength() > 3 ? strResourceFile.Right(3) : _T("");
  238. strExtension.MakeLower();
  240. if (strExtension == _T("xml"))
  241. {
  242. SetResourceManager(new CXTPResourceManagerXML(strResourceFile));
  243. }
  244. else
  245. {
  246. CXTPResourceManager* pResourceManager = new CXTPResourceManager;
  248. pResourceManager->m_hResourceFile = strResourceFile.IsEmpty() ? 0 : LoadLibrary(strResourceFile);
  250. if (pResourceManager->m_hResourceFile)
  251. {
  252. SetResourceHandle(pResourceManager->m_hResourceFile);
  253. }
  254. else
  255. {
  256. SetResourceHandle(AfxGetInstanceHandle());
  257. }
  259. SetResourceManager(pResourceManager);
  260. }
  261. }
  263. void CXTPResourceManager::UpdateResourcesLangID()
  264. {
  265. HMODULE hResModule = GetResourceHandle();
  266. WORD wLangID = GetResourceLanguage(hResModule);
  267. ASSERT(wLangID);
  269. SetResourceLanguage(wLangID);
  270. }
  272. void CXTPResourceManager::SetResourceLanguage(WORD wLangID)
  273. {
  274. m_pLanguageInfo = GetLanguageInfo(wLangID);
  276. if (!m_pLanguageInfo)
  277. m_pLanguageInfo = GetLanguageInfo(cwXTPResManDefLangID);
  278. }
  280. WORD CXTPResourceManager::GetResourceLanguage(HMODULE hResModule)
  281. {
  282. WORD wLangID = 0;
  283. ::EnumResourceTypes(hResModule, &CXTPResourceManager::EnumResTypeProc, (LONG_PTR)&wLangID);
  284. return wLangID;
  285. }
  287. BOOL CXTPResourceManager::EnumResTypeProc(HMODULE hModule, LPTSTR lpszType, LONG_PTR lParam)
  288. {
  289. WORD* pwLangID = (WORD*)lParam;
  290. ASSERT(pwLangID);
  291. if (!pwLangID)
  292. return FALSE;
  294. ::EnumResourceNames(hModule, lpszType, &CXTPResourceManager::EnumResNameProc, lParam);
  296. if(*pwLangID == LANG_NEUTRAL)
  297. return TRUE; // continue if neutral
  299. return *pwLangID == cwXTPResManDefLangID; // continue if default
  300. }
  302. BOOL CXTPResourceManager::EnumResNameProc(HMODULE hModule, LPCTSTR lpszType, LPTSTR lpszName,
  303.   LONG_PTR lParam)
  304. {
  305. WORD* pwLangID = (WORD*)lParam;
  306. ASSERT(pwLangID);
  307. if (!pwLangID)
  308. return FALSE;
  310. ::EnumResourceLanguages(hModule, lpszType, lpszName,
  311. &CXTPResourceManager::EnumResLangProc, lParam);
  313. if(*pwLangID == LANG_NEUTRAL)
  314. return TRUE; // continue if neutral
  316. return *pwLangID == cwXTPResManDefLangID; // continue if default
  317. }
  319. BOOL CXTPResourceManager::EnumResLangProc(HMODULE hModule, LPCTSTR lpszType,
  320.  LPCTSTR lpszName, WORD wIDLanguage, LONG_PTR lParam)
  321. {
  322. UNREFERENCED_PARAMETER(hModule); UNREFERENCED_PARAMETER(lpszType); UNREFERENCED_PARAMETER(lpszName);
  324. WORD* pwLangID = (WORD*)lParam;
  325. ASSERT(pwLangID);
  327. if (!pwLangID)
  328. return FALSE; // stop emuneration
  330. if(wIDLanguage == LANG_NEUTRAL)
  331. return TRUE; // continue if neutral
  333. *pwLangID = wIDLanguage;
  335. return *pwLangID == cwXTPResManDefLangID; // continue if default
  336. }
  338. BOOL CXTPResourceManager::LoadFailed()
  339. {
  340. #ifdef _LIB
  341. //TRACE(_T("WARNING: Make sure to include XTToolkitPro.rc in your .rc2 filen"));
  342. #endif
  344. return FALSE;
  345. }
  347. BOOL CXTPResourceManager::LoadString(CString* pString, UINT nIDResource)
  348. {
  349. HMODULE hResourceInstanse = GetResourceHandle();
  351. if (hResourceInstanse && ::FindResource(hResourceInstanse, MAKEINTRESOURCE((nIDResource >> 4)+1), RT_STRING))
  352. {
  353. if (LoadLocaleString(hResourceInstanse, nIDResource, *pString))
  354. return TRUE;
  355. }
  357. if (pString->LoadString(nIDResource))
  358. return TRUE;
  360. return LoadFailed();
  361. }
  363. BOOL CXTPResourceManager::LoadMenu(CMenu* lpMenu, UINT nIDResource)
  364. {
  365. HMODULE hResourceInstanse = GetResourceHandle();
  367. if (hResourceInstanse && ::FindResource(hResourceInstanse, MAKEINTRESOURCE(nIDResource), RT_MENU))
  368. {
  369. CManageState state;
  371. if (lpMenu->LoadMenu(nIDResource))
  372. return TRUE;
  373. }
  375. if (lpMenu->LoadMenu(nIDResource))
  376. return TRUE;
  378. return LoadFailed();
  379. }
  381. BOOL CXTPResourceManager::LoadToolBar(CToolBar* pToolBar, UINT nIDResource)
  382. {
  383. CManageState state;
  385. if (pToolBar->LoadToolBar(nIDResource))
  386. return TRUE;
  388. return LoadFailed();
  389. }
  391. BOOL CXTPResourceManager::LoadBitmap(CBitmap* pBitmap, UINT nIDResource)
  392. {
  393. HMODULE hResourceInstanse = GetResourceHandle();
  395. if (hResourceInstanse && ::FindResource(hResourceInstanse, MAKEINTRESOURCE(nIDResource), RT_BITMAP))
  396. {
  397. CManageState state;
  399. if (pBitmap->LoadBitmap(nIDResource))
  400. return TRUE;
  402. }
  404. if (pBitmap->LoadBitmap(nIDResource))
  405. return TRUE;
  407. return LoadFailed();
  408. }
  410. HCURSOR CXTPResourceManager::LoadCursor(UINT nIDResource)
  411. {
  412. HMODULE hResourceInstanse = GetResourceHandle();
  414. if (hResourceInstanse && ::FindResource(hResourceInstanse, MAKEINTRESOURCE(nIDResource), RT_GROUP_CURSOR))
  415. {
  416. CManageState state;
  418. HCURSOR hCursor = AfxGetApp()->LoadCursor(nIDResource);
  419. if (hCursor)
  420. return hCursor;
  421. }
  423. HCURSOR hCursor = AfxGetApp()->LoadCursor(nIDResource);
  424. if (hCursor)
  425. return hCursor;
  427. LoadFailed();
  428. return NULL;
  429. }
  431. HGLOBAL CXTPResourceManager::LoadDialogTemplate2(LPCTSTR pszTemplate)
  432. {
  433. HINSTANCE hResourceInstanse = GetResourceHandle();
  434. HRSRC hResource = hResourceInstanse ? FindResource(hResourceInstanse, pszTemplate, RT_DIALOG) : NULL;
  436. if (hResource == NULL)
  437. {
  438. hResourceInstanse = AfxFindResourceHandle(pszTemplate, RT_DIALOG);
  439. hResource = hResourceInstanse ? FindResource(hResourceInstanse, pszTemplate, RT_DIALOG) : NULL;
  440. }
  442. if (hResource)
  443. {
  444. HGLOBAL hTemplate = LoadResource(hResourceInstanse, hResource);
  445. return hTemplate;
  446. }
  448. LoadFailed();
  449. return NULL;
  450. }
  452. LPCDLGTEMPLATE CXTPResourceManager::LoadDialogTemplate(UINT nIDResource)
  453. {
  454. LPCTSTR pszTemplate = MAKEINTRESOURCE(nIDResource);
  456. HGLOBAL hTemplate = LoadDialogTemplate2(pszTemplate);
  457. return (LPCDLGTEMPLATE)LockResource(hTemplate);
  458. }
  460. BOOL CXTPResourceManager::LoadHTML(CString* pText, UINT nIDResource)
  461. {
  462. if (pText == NULL)
  463. return FALSE;
  465. HMODULE hResourceInstanse = GetResourceHandle();
  466. HRSRC hResource = ::FindResource(hResourceInstanse, MAKEINTRESOURCE(nIDResource), RT_HTML);
  468. if (hResource == NULL)
  469. {
  470. hResourceInstanse = AfxFindResourceHandle(MAKEINTRESOURCE(nIDResource), RT_HTML);
  471. if (hResourceInstanse == NULL)
  472. return FALSE;
  474. hResource = ::FindResource(hResourceInstanse, MAKEINTRESOURCE(nIDResource), RT_HTML);
  475. }
  477. if (!hResource)
  478. return FALSE;
  480. HGLOBAL hMem = ::LoadResource(hResourceInstanse, hResource);
  481. if (!hMem)
  482. return FALSE;
  484. DWORD dwSize = ::SizeofResource(hResourceInstanse, hResource);
  485. char *pSrc = (char*)::LockResource(hMem);
  486. if (!pSrc)
  487. return FALSE;
  489. const DWORD dwDstSize = (dwSize + 1) * sizeof(TCHAR);
  490. TCHAR *pDst = pText->GetBuffer(dwDstSize);
  491. if (pDst == NULL)
  492. return FALSE;
  494. ::ZeroMemory((BYTE*)pDst, dwDstSize);
  496. #ifdef _UNICODE
  497. int nLen = ::MultiByteToWideChar(CP_ACP, 0, (LPCSTR)pSrc, dwSize,
  498. pDst, dwDstSize);
  499. #else
  500. ::CopyMemory(pDst, pSrc, dwSize);
  501. int nLen = dwSize;
  502. #endif
  504. pText->ReleaseBuffer();
  506. return nLen > 0;
  507. }
  509. HICON CXTPResourceManager::CreateIconFromResource(HMODULE hModule, LPCTSTR lpszID, CSize iconSize)
  510. {
  511. // Find the icon directory whose identifier is lpszID.
  512. HRSRC hResource = ::FindResource(hModule,
  513. lpszID, RT_GROUP_ICON);
  515. if (hResource == NULL)
  516. return NULL;
  518. // Load and lock the icon directory.
  519. HGLOBAL hMem = ::LoadResource(hModule, hResource);
  520. if (!hMem)
  521. return NULL;
  522. LPVOID lpResource = ::LockResource(hMem);
  524. // Get the identifier of the icon that is most appropriate
  525. // for the video display.
  526. int nID = ::LookupIconIdFromDirectoryEx((PBYTE) lpResource, TRUE,
  527. iconSize.cx, iconSize.cy, LR_DEFAULTCOLOR);
  529. // Find the bits for the nID icon.
  530. hResource = ::FindResource(hModule,
  531. MAKEINTRESOURCE(nID), MAKEINTRESOURCE(RT_ICON));
  533. if (hResource == NULL)
  534. return NULL;
  536. // Load and lock the icon.
  537. hMem = ::LoadResource(hModule, hResource);
  538. if (!hMem)
  539. return NULL;
  540. lpResource = ::LockResource(hMem);
  542. // Create a handle to the icon.
  543. HICON hIcon = ::CreateIconFromResourceEx((PBYTE)lpResource,
  544. ::SizeofResource(hModule, hResource), TRUE, 0x00030000,
  545. iconSize.cx, iconSize.cy, LR_DEFAULTCOLOR);
  547. return hIcon;
  548. }
  550. HICON CXTPResourceManager::LoadIcon(LPCTSTR lpszID, CSize iconSize)
  551. {
  552. HICON hIcon = NULL;
  554. HMODULE hResource = GetResourceHandle();
  555. if (hResource && ::FindResource(hResource, lpszID, RT_GROUP_ICON))
  556. {
  557. CManageState state;
  559. hIcon = (HICON)::LoadImage(hResource, lpszID,
  560. IMAGE_ICON, iconSize.cx, iconSize.cy, 0);
  562. if (hIcon != NULL)
  563. return hIcon;
  564. }
  566. hResource = AfxFindResourceHandle(lpszID, RT_GROUP_ICON);
  567. if (hResource)
  568. {
  569. hIcon = (HICON)::LoadImage(hResource, lpszID,
  570. IMAGE_ICON, iconSize.cx, iconSize.cy, 0);
  572. if (hIcon != NULL)
  573. return hIcon;
  574. }
  576. return NULL;
  577. }
  579. HICON CXTPResourceManager::LoadIcon(int nID, CSize iconSize)
  580. {
  581. return LoadIcon(MAKEINTRESOURCE(nID), iconSize);
  582. }
  584. int CXTPResourceManager::ShowMessageBox(UINT nIDPrompt, UINT nType)
  585. {
  586. CString strPrompt;
  587. VERIFY(LoadString(&strPrompt, nIDPrompt));
  589. return ShowMessageBox(strPrompt, nType);
  590. }
  592. int CXTPResourceManager::ShowMessageBox(LPCTSTR lpszText, UINT nType)
  593. {
  594. if (m_pLanguageInfo && (m_pLanguageInfo->nCodePage == 1256 || m_pLanguageInfo->nCodePage == 1255)) // Arabic or Hebrew ?
  595. nType |= MB_RTLREADING;
  597. return AfxMessageBox(lpszText, nType);
  598. }
  600. //////////////////////////////////////////////////////////////////////////
  601. // Locale methods
  603. XTP_RESOURCEMANAGER_LANGINFO* CXTPResourceManager::GetLanguageInfo(UINT nLangId)
  604. {
  605. for (int i = 0; i < _countof(langinfo); i++)
  606. {
  607. if (nLangId == langinfo[i].wLanguage)
  608. return &langinfo[i];
  609. }
  610. return 0;
  611. }
  613. int CXTPResourceManager::GetMenuLocaleString(CMenu* pMenu, UINT nIDItem, CString& rString, UINT nFlags) const
  614. {
  615. if (!pMenu || !pMenu->m_hMenu)
  616. return 0;
  618. ASSERT(m_pLanguageInfo);
  619. if (!m_pLanguageInfo)
  620. {
  621. return pMenu->GetMenuString(nIDItem, rString, nFlags);
  622. }
  624. ASSERT(::IsMenu(pMenu->m_hMenu));
  626. // offer no buffer first
  627. int nStringLen = ::GetMenuString(pMenu->m_hMenu, nIDItem, NULL, 0, nFlags);
  629. // use exact buffer length
  630. if (nStringLen > 0)
  631. {
  632. #ifndef _UNICODE
  633. if (XTPSystemVersion()->IsWin2KOrGreater())
  634. {
  635. LPWSTR lpwstr = new WCHAR[nStringLen + 1];
  636. ::GetMenuStringW(pMenu->m_hMenu, nIDItem, lpwstr, nStringLen + 1, nFlags);
  638. int nDestLen = WideCharToMultiByte(m_pLanguageInfo->nCodePage, 0, lpwstr, nStringLen, NULL, 0, NULL, NULL);
  639. LPTSTR pstrString = rString.GetBufferSetLength(nDestLen);
  641. WideCharToMultiByte(m_pLanguageInfo->nCodePage, 0, lpwstr, nStringLen, pstrString, nDestLen, NULL, NULL);
  642. pstrString[nDestLen] = 0;
  643. delete[] lpwstr;
  644. rString.ReleaseBuffer();
  645. }
  646. else
  647. #endif
  648. {
  649. LPTSTR pstrString = rString.GetBufferSetLength(nStringLen);
  650. ::GetMenuString(pMenu->m_hMenu, nIDItem, pstrString, nStringLen + 1, nFlags);
  651. rString.ReleaseBuffer(nStringLen);
  652. }
  653. }
  654. else
  655. rString.Empty();
  657. return nStringLen;
  659. }
  661. int CXTPResourceManager::LoadLocaleString(HINSTANCE hInstance, UINT nID, CString& rString) const
  662. {
  663. rString.Empty();
  665. HRSRC hResource = ::FindResource(hInstance, MAKEINTRESOURCE(((nID >> 4) + 1)), RT_STRING);
  666. if (!hResource)
  667. return 0;
  669. HGLOBAL hGlobal = ::LoadResource(hInstance, hResource);
  670. if (!hGlobal)
  671. return 0;
  673. LPWORD pImage = (LPWORD)::LockResource(hGlobal);
  674. if (!pImage)
  675. return 0;
  677. ULONG nResourceSize = ::SizeofResource(hInstance, hResource);
  678. WORD* pImageEnd = (LPWORD)(LPBYTE(pImage) + nResourceSize);
  679. UINT iIndex = nID & 0x000F;
  681. while ((iIndex > 0) && (pImage < pImageEnd))
  682. {
  683. pImage = (LPWORD)(LPBYTE(pImage) + (sizeof(WORD) + (*pImage * sizeof(WCHAR))));
  684. iIndex--;
  685. }
  687. if (pImage >= pImageEnd)
  688. return 0;
  690. int nLength = *pImage;
  692. if (nLength == 0)
  693. return 0;
  696. #ifdef _UNICODE
  697. LPTSTR lpsz = rString.GetBufferSetLength(nLength);
  698. MEMCPY_S(lpsz, (LPWSTR)(pImage + 1), nLength * sizeof(WCHAR));
  699. rString.ReleaseBuffer(nLength);
  700. return nLength;
  702. #else
  703. UINT nCodePage = m_pLanguageInfo ? m_pLanguageInfo->nCodePage : CP_ACP;
  704. int nDestLen = WideCharToMultiByte(nCodePage, 0, (LPWSTR)(pImage + 1), nLength, NULL, 0, NULL, NULL);
  706. LPTSTR lpsz = rString.GetBufferSetLength(nDestLen);
  707. WideCharToMultiByte(nCodePage, 0, (LPWSTR)(pImage + 1), nLength, lpsz, nDestLen, NULL, NULL);
  708. rString.ReleaseBuffer(nDestLen);
  709. return nDestLen;
  710. #endif
  713. }
  717. #ifndef  _XTP_EXCLUDE_XML
  720. //////////////////////////////////////////////////////////////////////////
  721. // CXTPResourceManagerXML
  723. CXTPResourceManagerXML::CXTPResourceManagerXML(LPCTSTR strFileName)
  724. {
  725. m_pResourceRoot = new CXTPPropExchangeXMLNode(TRUE, 0, _T("resource"));
  727. m_bValid = FALSE;
  729. if (!m_pResourceRoot->LoadFromFile(strFileName))
  730. return;
  732. if (!m_pResourceRoot->OnBeforeExchange())
  733. return;
  735. m_bValid = TRUE;
  736. }
  738. CXTPResourceManagerXML::CXTPResourceManagerXML(CXTPPropExchangeXMLNode* pResourceRoot)
  739. {
  740. m_bValid = FALSE;
  742. m_pResourceRoot = pResourceRoot;
  744. if (m_pResourceRoot == NULL)
  745. return;
  747. if (!m_pResourceRoot->OnBeforeExchange())
  748. return;
  750. m_bValid = TRUE;
  751. }
  754. CXTPResourceManagerXML::~CXTPResourceManagerXML()
  755. {
  756. Close();
  757. }
  759. void CXTPResourceManagerXML::Close()
  760. {
  761. CXTPResourceManager::Close();
  763. CMDTARGET_RELEASE(m_pResourceRoot);
  765. POSITION pos = m_mapDialogs.GetStartPosition();
  766. while (pos)
  767. {
  768. DLGTEMPLATE* pDlgTemplate;
  769. UINT nIDResource;
  770. m_mapDialogs.GetNextAssoc(pos, nIDResource, pDlgTemplate);
  771. free (pDlgTemplate);
  772. }
  773. m_mapDialogs.RemoveAll();
  775. m_bValid = FALSE;
  776. }
  778. void CXTPResourceManagerXML::UpdateResourcesLangID()
  779. {
  780. long wResourcesLangID = cwXTPResManDefLangID;
  781. PX_Long(m_pResourceRoot, _T("LANGID"), wResourcesLangID);
  783. SetResourceLanguage((WORD)wResourcesLangID);
  784. }
  786. BOOL CXTPResourceManagerXML::LoadString(CString* pString, UINT nIDResource)
  787. {
  788. if (!m_bValid || m_pResourceRoot == NULL)
  789. return CXTPResourceManager::LoadString(pString, nIDResource);
  791. CString strPattern;
  792. strPattern.Format(_T("string[@id = "%i"]"), nIDResource);
  794. if (!m_pResourceRoot->IsSectionExists(strPattern))
  795. return CXTPResourceManager::LoadString(pString, nIDResource);
  798. CXTPPropExchangeSection secString(m_pResourceRoot->GetSection(strPattern));
  799. PX_String(&secString, _T("value"), *pString);
  801. return TRUE;
  802. }
  804. struct CXTPResourceManagerXML::MENUITEMTEMPLATEINFO : public MENUITEMTEMPLATE
  805. {
  806. BSTR lpszCaption;
  808. public:
  809. MENUITEMTEMPLATEINFO()
  810. {
  811. mtOption = 0;
  812. lpszCaption = NULL;
  813. }
  814. ~MENUITEMTEMPLATEINFO()
  815. {
  816. if (lpszCaption)
  817. {
  818. SysFreeString(lpszCaption);
  819. }
  820. }
  821. UINT GetLength() const
  822. {
  823. return sizeof(mtOption) + sizeof(WCHAR) * ((int)wcslen(lpszCaption) + 1) +
  824. (mtOption & MF_POPUP ? 0 : sizeof(mtID));
  825. }
  826. };
  828. struct CXTPResourceManagerXML::MENUTEMPLATEINFO
  829. {
  830. CArray<MENUITEMTEMPLATEINFO*, MENUITEMTEMPLATEINFO*> aItems;
  832. public:
  833. ~MENUTEMPLATEINFO()
  834. {
  835. for (int i = 0; i < (int)aItems.GetSize(); i++)
  836. {
  837. delete aItems[i];
  838. }
  839. }
  840. UINT GetLength() const
  841. {
  842. int nLength = sizeof(MENUITEMTEMPLATEHEADER);
  844. for (int i = 0; i < aItems.GetSize(); i++)
  845. {
  846. nLength += aItems[i]->GetLength();
  847. }
  849. return nLength;
  850. }
  851. };
  853. /////////////////////////////////////////////////////////////////////////////
  854. // Extended dialog templates (new in Win95)
  856. #pragma pack(push, 1)
  858. struct CXTPResourceManagerXML::DLGTEMPLATEEX
  859. {
  860. WORD dlgVer;
  861. WORD signature;
  862. DWORD helpID;
  863. DWORD exStyle;
  864. DWORD style;
  865. WORD cDlgItems;
  866. short x;
  867. short y;
  868. short cx;
  869. short cy;
  870. };
  872. struct CXTPResourceManagerXML::DLGITEMTEMPLATEEX
  873. {
  874. DWORD helpID;
  875. DWORD exStyle;
  876. DWORD style;
  877. short x;
  878. short y;
  879. short cx;
  880. short cy;
  881. DWORD id;
  882. };
  884. #pragma pack(pop)
  887. struct CXTPResourceManagerXML::DLGITEMTEMPLATEINFO : public DLGITEMTEMPLATEEX
  888. {
  889. BSTR lpszCaption;
  890. CString strClassName;
  891. int nCaptionID;
  893. public:
  894. DLGITEMTEMPLATEINFO()
  895. {
  896. lpszCaption = NULL;
  897. nCaptionID = 0;
  898. }
  899. ~DLGITEMTEMPLATEINFO()
  900. {
  901. if (lpszCaption)
  902. {
  903. SysFreeString(lpszCaption);
  904. }
  905. }
  906. ULONG AlignDWord(ULONG uLong) const
  907. {
  908. return ((uLong + 3) & ~3);
  909. }
  911. UINT GetLength() const
  912. {
  913. return AlignDWord(sizeof(DLGITEMTEMPLATEEX)
  914. + ((nCaptionID != 0 ? 1 : (int)wcslen(lpszCaption)) * sizeof(WORD)) +  sizeof(WORD)
  915. + strClassName.GetLength() * sizeof(WORD) +  sizeof(WORD)
  916. + 0
  917. + sizeof(WORD)
  918. );
  919. }
  920. };
  922. struct CXTPResourceManagerXML::DLGTEMPLATEINFO : public DLGTEMPLATEEX
  923. {
  924. BSTR lpszCaption;
  925. CString strFaceName;
  926. int nPointSize;
  928. CArray<DLGITEMTEMPLATEINFO*, DLGITEMTEMPLATEINFO*> aItems;
  930. public:
  931. DLGTEMPLATEINFO()
  932. {
  933. lpszCaption = NULL;
  934. }
  935. ~DLGTEMPLATEINFO()
  936. {
  937. if (lpszCaption)
  938. {
  939. SysFreeString(lpszCaption);
  940. }
  941. for (int i = 0; i < (int)aItems.GetSize(); i++)
  942. {
  943. delete aItems[i];
  944. }
  945. }
  947. ULONG AlignDWord(ULONG uLong) const
  948. {
  949. return ((uLong + 3) & ~3);
  950. }
  952. UINT GetHeaderLength() const
  953. {
  954. return AlignDWord(sizeof(DLGTEMPLATEEX)
  955. + sizeof(WORD)
  956. + sizeof(WORD)
  957. + ((int)wcslen(lpszCaption) * sizeof(WORD) +  sizeof(WORD))
  958. + (style & DS_SETFONT ? strFaceName.GetLength() * sizeof(WORD) + sizeof(WORD)
  959. + sizeof(WORD) + sizeof(WORD) + sizeof(BYTE) + sizeof(BYTE)
  960. : 0)
  961. );
  962. }
  964. UINT GetLength() const
  965. {
  966. int nLength = GetHeaderLength();
  968. for (int i = 0; i < aItems.GetSize(); i++)
  969. {
  970. nLength += aItems[i]->GetLength();
  971. }
  973. return nLength;
  974. }
  975. };
  977. void CXTPResourceManagerXML::AddMenuItems(CXTPPropExchange* pPX, MENUTEMPLATEINFO* pItems)
  978. {
  979. CXTPPropExchangeEnumeratorPtr enumerator(pPX->GetEnumerator(_T("menuitem")));
  980. POSITION pos = enumerator->GetPosition();
  982. while (pos)
  983. {
  984. CXTPPropExchangeSection sec(enumerator->GetNext(pos));
  985. int id = 0;
  987. MENUITEMTEMPLATEINFO* pItemInfo = new MENUITEMTEMPLATEINFO;
  988. PX_Int(&sec, _T("id"), id, 0);
  989. PX_Bstr(&sec, _T("caption"), pItemInfo->lpszCaption, L"");
  991. pItemInfo->mtID = (WORD)id;
  993. pItems->aItems.Add(pItemInfo);
  995. CXTPPropExchangeEnumeratorPtr enumeratorChilds(sec->GetEnumerator(_T("menuitem")));
  997. if (enumeratorChilds->GetPosition())
  998. {
  999. pItemInfo->mtOption |= MF_POPUP;
  1000. AddMenuItems(&sec, pItems);
  1001. }
  1002. else if (id == 0)
  1003. {
  1004. pItemInfo->mtOption |= MF_SEPARATOR;
  1005. }
  1007. if (!pos)
  1008. {
  1009. pItemInfo->mtOption |= MF_END;
  1010. }
  1011. }
  1012. }
  1014. BOOL CXTPResourceManagerXML::CreateMenu(CMenu& menu, CXTPPropExchange* pPX)
  1015. {
  1016. MENUTEMPLATEINFO menuTemplate;
  1018. AddMenuItems(pPX, &menuTemplate);
  1020. if (menuTemplate.aItems.GetSize() == 0)
  1021. return FALSE;
  1023. ASSERT(menuTemplate.aItems[menuTemplate.aItems.GetSize() - 1]->mtOption & MF_END);
  1025. int nLength = menuTemplate.GetLength() + sizeof(MENUITEMTEMPLATE);
  1026. LPVOID lpDlgTemplate = malloc(nLength);
  1027. ZeroMemory(lpDlgTemplate, nLength);
  1029. MENUITEMTEMPLATE* mitem = (MENUITEMTEMPLATE*) ((BYTE*)lpDlgTemplate + sizeof(MENUITEMTEMPLATEHEADER));
  1031. for (int i = 0; i < menuTemplate.aItems.GetSize(); i++)
  1032. {
  1033. MENUITEMTEMPLATEINFO& itemInfo = *menuTemplate.aItems[i];
  1034. mitem->mtOption = itemInfo.mtOption;
  1036. if (itemInfo.mtOption & MF_POPUP)
  1037. {
  1038. MEMCPY_S((BYTE*)mitem + sizeof(mitem->mtOption), itemInfo.lpszCaption, (wcslen(itemInfo.lpszCaption) + 1) * sizeof(WORD));
  1039. }
  1040. else
  1041. {
  1042. mitem->mtID = itemInfo.mtID;
  1043. MEMCPY_S(mitem->mtString, itemInfo.lpszCaption, (wcslen(itemInfo.lpszCaption) + 1) * sizeof(WORD));
  1044. }
  1046. mitem = (MENUITEMTEMPLATE*) ((BYTE*)mitem + itemInfo.GetLength());
  1047. }
  1048. mitem->mtOption = MF_END;
  1050. BOOL bResult = menu.LoadMenuIndirect(lpDlgTemplate);
  1052. free(lpDlgTemplate);
  1054. return bResult;
  1055. }
  1057. BOOL CXTPResourceManagerXML::LoadMenu(CMenu* lpMenu, UINT nIDResource)
  1058. {
  1059. if (!m_bValid || m_pResourceRoot == NULL)
  1060. return CXTPResourceManager::LoadMenu(lpMenu, nIDResource);
  1062. CString strPattern;
  1063. strPattern.Format(_T("menu[@id = "%i"]"), nIDResource);
  1065. if (!m_pResourceRoot->IsSectionExists(strPattern))
  1066. return CXTPResourceManager::LoadMenu(lpMenu, nIDResource);
  1068. CXTPPropExchangeSection secMenu(m_pResourceRoot->GetSection(strPattern));
  1070. if (CreateMenu(*lpMenu, &secMenu))
  1071. return TRUE;
  1073. return CXTPResourceManager::LoadMenu(lpMenu, nIDResource);
  1074. }
  1076. //////////////////////////////////////////////////////////////////////////
  1077. // Utils
  1080. LPDLGTEMPLATE CXTPResourceManagerXML::CreateDialogTemplate(DLGTEMPLATEINFO& dlgTemplate)
  1081. {
  1082. int nDlgLength = dlgTemplate.GetLength();
  1084. DLGTEMPLATEEX* lpDlgTemplate = (DLGTEMPLATEEX*)malloc(nDlgLength);
  1085. if (lpDlgTemplate == NULL)
  1086. return NULL;
  1088. ZeroMemory(lpDlgTemplate, nDlgLength);
  1089. *lpDlgTemplate = dlgTemplate;
  1091. BYTE* pMain = (BYTE*) lpDlgTemplate + sizeof(DLGTEMPLATEEX) + sizeof(WORD) * 2;
  1093. // Caption
  1094. ASSERT(dlgTemplate.lpszCaption != 0);
  1095. if (!dlgTemplate.lpszCaption)
  1096. return NULL;
  1098. size_t nLength = (wcslen(dlgTemplate.lpszCaption) + 1) * sizeof(WORD);
  1099. MEMCPY_S(pMain, dlgTemplate.lpszCaption, nLength);
  1100. pMain += nLength;
  1102. if (dlgTemplate.style & DS_SETFONT)
  1103. {
  1104. *((WORD *)pMain) = (WORD)dlgTemplate.nPointSize;
  1105. pMain += sizeof(WORD);
  1107. pMain += sizeof(WORD) + sizeof(BYTE) + sizeof(BYTE);
  1109. MBSTOWCS_S((LPWSTR)pMain, dlgTemplate.strFaceName, dlgTemplate.strFaceName.GetLength() + 1);
  1110. }
  1112. pMain = (BYTE*) lpDlgTemplate + dlgTemplate.GetHeaderLength();
  1113. ASSERT(dlgTemplate.cDlgItems == dlgTemplate.aItems.GetSize());
  1116. CArray<DLGITEMTEMPLATEINFO*, DLGITEMTEMPLATEINFO*>& aItems = dlgTemplate.aItems;
  1118. for (int i = 0; i < aItems.GetSize(); i++)
  1119. {
  1120. DLGITEMTEMPLATEINFO& itemInfo = *aItems[i];
  1122. // Copy constant part of the template
  1123. *(DLGITEMTEMPLATEEX*)pMain = itemInfo;
  1124. BYTE* pControlMain = pMain + sizeof(DLGITEMTEMPLATEEX);
  1126. // Class
  1127. MBSTOWCS_S((LPWSTR)pControlMain, itemInfo.strClassName, itemInfo.strClassName.GetLength() + 1);
  1128. pControlMain += (itemInfo.strClassName.GetLength() + 1) * sizeof(WORD);
  1131. // Copy Caption
  1132. if (itemInfo.nCaptionID != 0)
  1133. {
  1134. *((PWORD)pControlMain) = 0xFFFF;
  1135. *((PWORD)pControlMain + 1) = (WORD)itemInfo.nCaptionID;
  1137. pControlMain += sizeof(WORD) * 2;
  1138. }
  1139. else
  1140. {
  1141. ASSERT(itemInfo.lpszCaption != 0);
  1142. if (itemInfo.lpszCaption)
  1143. {
  1144. nLength = (wcslen(itemInfo.lpszCaption) + 1) * sizeof(WORD);
  1145. MEMCPY_S(pControlMain, itemInfo.lpszCaption, nLength);
  1146. pControlMain += nLength;
  1147. }
  1148. else
  1149. {
  1150. pControlMain += sizeof(WORD);
  1151. }
  1152. }
  1155. // Init Data length
  1156. *((WORD *)pControlMain) = 0;
  1157. pControlMain += sizeof(WORD);
  1159. pMain += itemInfo.GetLength();
  1160. }
  1162. return (LPDLGTEMPLATE)lpDlgTemplate;
  1163. }
  1166. LPDLGTEMPLATE CXTPResourceManagerXML::CreateDialogTemplate(CXTPPropExchange* pPX)
  1167. {
  1168. DLGTEMPLATEINFO dlgTemplate;
  1170. CString strPos;
  1171. CRect rc;
  1172. DWORD dwStyle = 0, dwExtendedStyle = 0, id;
  1174. PX_DWord(pPX, _T("style"), dwStyle, 0);
  1175. PX_DWord(pPX, _T("styleex"), dwExtendedStyle, 0);
  1176. PX_Rect(pPX, _T("position"), rc, CRect(0, 0, 0, 0));
  1177. PX_String(pPX, _T("fontface"), dlgTemplate.strFaceName, _T("MS Sans Serif"));
  1178. PX_Int(pPX, _T("fontsize"), dlgTemplate.nPointSize, 8);
  1179. PX_Bstr(pPX, _T("caption"), dlgTemplate.lpszCaption, L"");
  1180. PX_DWord(pPX, _T("id"), id, 0);
  1182. dlgTemplate.x = (short)rc.left;
  1183. dlgTemplate.y = (short)rc.top;
  1184. dlgTemplate.cx = (short)rc.right;
  1185. dlgTemplate.cy = (short)rc.bottom;
  1186. dlgTemplate.style = dwStyle;
  1187. dlgTemplate.exStyle = dwExtendedStyle;
  1188. dlgTemplate.helpID = id;
  1190. dlgTemplate.cDlgItems = 0;
  1191. dlgTemplate.style |= DS_SETFONT;
  1192. dlgTemplate.dlgVer = 1;
  1193. dlgTemplate.signature = 0xFFFF;
  1196. CArray<DLGITEMTEMPLATEINFO*, DLGITEMTEMPLATEINFO*>& aItems = dlgTemplate.aItems;
  1198. CXTPPropExchangeEnumeratorPtr enumerator(pPX->GetEnumerator(_T("control")));
  1199. POSITION pos = enumerator->GetPosition();
  1201. while (pos)
  1202. {
  1203. CXTPPropExchangeSection sec(enumerator->GetNext(pos));
  1205. DLGITEMTEMPLATEINFO* pItemInfo = new DLGITEMTEMPLATEINFO;
  1207. PX_DWord(&sec, _T("style"), dwStyle, WS_CHILD | WS_VISIBLE | WS_GROUP);
  1208. PX_DWord(&sec, _T("styleex"), dwExtendedStyle, 0);
  1209. PX_Rect(&sec, _T("position"), rc, CRect(0, 0, 0, 0));
  1210. PX_Bstr(&sec, _T("caption"), pItemInfo->lpszCaption, L"");
  1211. PX_String(&sec, _T("class"), pItemInfo->strClassName, _T("STATIC"));
  1212. PX_DWord(&sec, _T("id"), id, (DWORD)IDC_STATIC);
  1213. PX_Int(&sec, _T("resource"), pItemInfo->nCaptionID, 0);
  1215. pItemInfo->x = (short)rc.left;
  1216. pItemInfo->y = (short)rc.top;
  1217. pItemInfo->cx = (short)rc.right;
  1218. pItemInfo->cy = (short)rc.bottom;
  1219. pItemInfo->style = dwStyle;
  1220. pItemInfo->exStyle = dwExtendedStyle;
  1221. pItemInfo->helpID = 0;
  1222. pItemInfo->id = id;
  1224. aItems.Add(pItemInfo);
  1225. dlgTemplate.cDlgItems++;
  1226. }
  1229. return CreateDialogTemplate(dlgTemplate);
  1230. }
  1232. LPCDLGTEMPLATE CXTPResourceManagerXML::LoadDialogTemplate(UINT nIDResource)
  1233. {
  1234. if (!m_bValid || m_pResourceRoot == NULL)
  1235. return CXTPResourceManager::LoadDialogTemplate(nIDResource);
  1237. CString strPattern;
  1238. strPattern.Format(_T("dialog[@id = "%i"]"), nIDResource);
  1240. DLGTEMPLATE* pTemplate = 0;
  1241. if (m_mapDialogs.Lookup(nIDResource, (DLGTEMPLATE*&)pTemplate))
  1242. return pTemplate;
  1244. if (!m_pResourceRoot->IsSectionExists(strPattern))
  1245. return CXTPResourceManager::LoadDialogTemplate(nIDResource);
  1247. CXTPPropExchangeSection secDialog(m_pResourceRoot->GetSection(strPattern));
  1249. pTemplate = CreateDialogTemplate(&secDialog);
  1251. if (pTemplate)
  1252. {
  1253. m_mapDialogs.SetAt(nIDResource, pTemplate);
  1254. return pTemplate;
  1255. }
  1257. return CXTPResourceManager::LoadDialogTemplate(nIDResource);
  1258. }
  1261. #endif