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

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

对话框与窗口

开发平台：

Visual C++

ResourceExport.cpp：源码内容
  1. // ResourceExport.cpp: implementation of the CResourceExport class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  5. #include "stdafx.h"
  6. #include "ResourceExport.h"
  7. #include "ResourceViewRecord.h"
  9. #ifdef _DEBUG
  10. #undef THIS_FILE
  11. static char THIS_FILE[]=__FILE__;
  12. #define new DEBUG_NEW
  13. #endif
  17. class CBufferFile  : public CMemFile
  18. {
  19. public:
  20. CBufferFile(int nFileSize = 120000)
  21. : CMemFile(nFileSize)
  22. {
  24. }
  25. public:
  26. LPBYTE GetBuffer() {
  27. return m_lpBuffer + GetPosition();
  28. }
  29. LPBYTE GetBufferHeader() {
  30. return m_lpBuffer;
  31. }
  32. };
  34. #pragma pack(push, 1)
  36. typedef struct
  37. {
  38. WORD dlgVer;
  39. WORD signature;
  40. DWORD helpID;
  41. DWORD exStyle;
  42. DWORD style;
  43. WORD cDlgItems;
  44. short x;
  45. short y;
  46. short cx;
  47. short cy;
  48. } DLLDLGTEMPLATEEX;
  50. typedef struct
  51. {
  52. DWORD helpID;
  53. DWORD exStyle;
  54. DWORD style;
  55. short x;
  56. short y;
  57. short cx;
  58. short cy;
  59. DWORD id;
  60. } DLLDLGITEMTEMPLATEEX;
  62. #pragma pack(pop)
  65. struct DIRECTORY;
  66. typedef CArray<DIRECTORY*, DIRECTORY*> CArrayDirectories;
  70. struct DIRECTORY
  71. {
  72. DIRECTORY()
  73. {
  74. nID  = 0;
  75. nResourceOffset = 0;
  77. lpFatEntry = 0;
  78. lpFatDataEntry = 0;
  79. pResource = NULL;
  80. }
  81. ~DIRECTORY()
  82. {
  83. for (int i = 0; i < arrDirs.GetSize(); i++)
  84. {
  85. delete arrDirs[i];
  86. }
  87. if (pResource)
  88. delete pResource;
  89. }
  90. int GetNumberOfIdEntries()
  91. {
  92. return (int)arrDirs.GetSize() - GetNumberOfNamedEntries();
  93. }
  94. int GetNumberOfNamedEntries()
  95. {
  96. int nCount = 0;
  97. for (int i = 0; i < arrDirs.GetSize(); i++)
  98. {
  99. if (!arrDirs[i]->strName.IsEmpty())
  100. {
  101. nCount++;
  102. }
  103. }
  104. return nCount;
  105. }
  107. DIRECTORY* AddDirectory(CString strSub);
  108. DIRECTORY* AddDirectory(int nSub);
  111. CString strName;
  112. CString strResource;
  113. int nID;
  114. int nResourceOffset;
  115. CBufferFile* pResource;
  117. PIMAGE_RESOURCE_DIRECTORY_ENTRY lpFatEntry;
  118. PIMAGE_RESOURCE_DATA_ENTRY lpFatDataEntry;
  119. CArrayDirectories arrDirs;
  120. };
  122. DIRECTORY* DIRECTORY::AddDirectory(CString strSub)
  123. {
  124. int i;
  125. for (i = 0; i < arrDirs.GetSize(); i++)
  126. {
  127. if (arrDirs[i]->strName.IsEmpty())
  128. break;
  130. if (arrDirs[i]->strName == strSub)
  131. {
  132. return arrDirs[i];
  133. }
  135. if (arrDirs[i]->strName > strSub)
  136. {
  137. break;
  138. }
  139. }
  141. DIRECTORY* pType = new DIRECTORY();
  142. pType->strName = strSub;
  143. arrDirs.InsertAt(i, pType);
  145. return pType;
  146. }
  148. DIRECTORY* DIRECTORY::AddDirectory(int nSub)
  149. {
  150. int i;
  151. for (i = 0; i <arrDirs.GetSize(); i++)
  152. {
  153. if (arrDirs[i]->nID == nSub)
  154. {
  155. return arrDirs[i];
  156. }
  157. if (arrDirs[i]->nID > nSub)
  158. {
  159. break;
  160. }
  161. }
  162. DIRECTORY* pType = new DIRECTORY();
  163. pType->nID = nSub;
  164. arrDirs.InsertAt(i, pType);
  166. return pType;
  167. }
  169. DIRECTORY* AddDirectory(DIRECTORY* pRootDir, CString strType, CString strResourceName, UINT nLocale = 0x409)
  170. {
  171. DIRECTORY* pType = pRootDir->AddDirectory(strType);
  172. DIRECTORY* pResName = pType->AddDirectory(strResourceName);
  173. DIRECTORY* pEntry = pResName->AddDirectory(nLocale);
  174. return pEntry;
  175. }
  177. DIRECTORY* AddDirectory(DIRECTORY* pRootDir, int nID, CString strResourceName, UINT nLocale = 0x409)
  178. {
  179. DIRECTORY* pType = pRootDir->AddDirectory(nID);
  180. DIRECTORY* pResName = pType->AddDirectory(strResourceName);
  181. DIRECTORY* pEntry = pResName->AddDirectory(nLocale);
  182. return pEntry;
  183. }
  185. DIRECTORY* AddDirectory(DIRECTORY* pRootDir, int nID, int nResourceName, UINT nLocale = 0x409)
  186. {
  187. DIRECTORY* pType = pRootDir->AddDirectory(nID);
  188. DIRECTORY* pResName = pType->AddDirectory(nResourceName);
  189. DIRECTORY* pEntry = pResName->AddDirectory(nLocale);
  190. return pEntry;
  191. }
  194. void WriteFAT(CBufferFile* lpFAT, DIRECTORY* pDirectory, CArrayDirectories* pDataDirs)
  195. {
  197. IMAGE_RESOURCE_DIRECTORY dir;
  198. ZeroMemory(&dir, sizeof(IMAGE_RESOURCE_DIRECTORY));
  200. dir.NumberOfIdEntries = (WORD)pDirectory->GetNumberOfIdEntries();
  201. dir.NumberOfNamedEntries = (WORD)pDirectory->GetNumberOfNamedEntries();
  202. lpFAT->Write(&dir, sizeof(IMAGE_RESOURCE_DIRECTORY));
  203. int i;
  205. for (i = 0; i < pDirectory->arrDirs.GetSize(); i++)
  206. {
  207. IMAGE_RESOURCE_DIRECTORY_ENTRY entry;
  208. ZeroMemory(&entry, sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY));
  210. DIRECTORY* pSubDir = pDirectory->arrDirs[i];
  212. if (pSubDir->arrDirs.GetSize() > 0)
  213. {
  214. entry.DataIsDirectory = 1;
  215. }
  217. if (pSubDir->strName.IsEmpty())
  218. {
  219. entry.Id = (WORD)pSubDir->nID;
  220. }
  221. else
  222. {
  223. entry.NameIsString = 1;
  224. }
  226. pSubDir->lpFatEntry = (PIMAGE_RESOURCE_DIRECTORY_ENTRY)lpFAT->GetBuffer();
  227. lpFAT->Write(&entry, sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY));
  228. }
  230. for (i = 0; i < pDirectory->arrDirs.GetSize(); i++)
  231. {
  232. DIRECTORY* pSubDir = pDirectory->arrDirs[i];
  233. PIMAGE_RESOURCE_DIRECTORY_ENTRY lpEntry = pSubDir->lpFatEntry;
  235. if (pSubDir->arrDirs.GetSize() > 0)
  236. {
  237. lpEntry->OffsetToDirectory = lpFAT->GetPosition();
  238. WriteFAT(lpFAT, pSubDir, pDataDirs);
  239. }
  240. else
  241. {
  242. lpEntry->OffsetToData = (DWORD)lpFAT->GetPosition();
  244. IMAGE_RESOURCE_DATA_ENTRY data;
  246. ZeroMemory(&data, sizeof(IMAGE_RESOURCE_DATA_ENTRY));
  248. pSubDir->lpFatDataEntry = (PIMAGE_RESOURCE_DATA_ENTRY)lpFAT->GetBuffer();
  250. lpFAT->Write(&data, sizeof(IMAGE_RESOURCE_DATA_ENTRY));
  252. pDataDirs->Add(pSubDir);
  253. }
  254. }
  255. }
  256. void WriteFATNames(CBufferFile* lpFAT, DIRECTORY* pDirectory)
  257. {
  258. USES_CONVERSION;
  260. int i;
  261. for (i = 0; i < pDirectory->arrDirs.GetSize(); i++)
  262. {
  263. DIRECTORY* pSubDir = pDirectory->arrDirs[i];
  264. if (!pSubDir->strName.IsEmpty())
  265. {
  266. PIMAGE_RESOURCE_DIRECTORY_ENTRY lpEntry = pSubDir->lpFatEntry;
  267. lpEntry->NameOffset = lpFAT->GetPosition();
  269. WORD Length = (WORD)pSubDir->strName.GetLength();
  270. lpFAT->Write(&Length, sizeof(Length));
  272. LPCWSTR lpw = T2W((LPTSTR)(LPCTSTR)pSubDir->strName);
  273. lpFAT->Write(lpw, (pSubDir->strName.GetLength()) * sizeof(WCHAR));
  274. }
  275. }
  276. for (i = 0; i < pDirectory->arrDirs.GetSize(); i++)
  277. {
  278. DIRECTORY* pSubDir = pDirectory->arrDirs[i];
  280. if (pSubDir->arrDirs.GetSize() > 0)
  281. {
  282. WriteFATNames(lpFAT, pSubDir);
  283. }
  284. }
  285. }
  287. //////////////////////////////////////////////////////////////////////
  288. // Construction/Destruction
  289. //////////////////////////////////////////////////////////////////////
  291. CResourceExport::CResourceExport()
  292. {
  293. m_pResources = NULL;
  294. m_pLanguageInfo = 0;
  295. }
  297. CResourceExport::~CResourceExport()
  298. {
  300. }
  302. struct STRINGTABLE
  303. {
  304. STRINGTABLE()
  305. {
  306. ZeroMemory(m_bstr, sizeof(m_bstr));
  308. }
  309. ~STRINGTABLE()
  310. {
  311. for (int i = 0; i < 16; i++)
  312. {
  313. if (m_bstr[i])
  314. {
  315. SysFreeString(m_bstr[i]);
  316. }
  317. }
  319. }
  320. BSTR m_bstr[16];
  321. };
  323. void CResourceExport::ExportDllMenuItems(CMemFile* pFile, CXTPPropExchange* pResourceMenu)
  324. {
  325. CXTPPropExchangeEnumeratorPtr ptrEnumeratorStrings(pResourceMenu->GetEnumerator(_T("menuitem")));
  326. POSITION pos = ptrEnumeratorStrings->GetPosition();
  328. while (pos)
  329. {
  330. CXTPPropExchangeSection ptrSectionMenuItem(ptrEnumeratorStrings->GetNext(pos));
  331. DWORD dwId = 0;
  333. PX_DWord(&ptrSectionMenuItem, _T("id"), dwId);
  335. BSTR bstrValue = 0;
  336. PX_Bstr(&ptrSectionMenuItem, _T("caption"), bstrValue, 0);
  338. BOOL bPopup = (((CXTPPropExchangeXMLNode*)&ptrSectionMenuItem)->IsSectionExists(_T("menuitem")));
  340. WORD mtOption = 0, mtID = 0;
  341. if (bPopup)
  342. mtOption |= MF_POPUP;
  343. if (!pos)
  344. mtOption |= MF_END;
  346. if (!bPopup && dwId == 0)
  347. mtOption |= MF_SEPARATOR;
  349. pFile->Write(&mtOption, sizeof(WORD));
  351. mtID = (WORD)dwId;
  353. if (!bPopup)
  354. pFile->Write(&mtID, sizeof(WORD));
  356. LPCWSTR lpDispalyName = (LPCWSTR)bstrValue;
  357. WORD wLength = 0;
  359. if (lpDispalyName)
  360. {
  361. wLength = (WORD)wcslen(lpDispalyName);
  362. pFile->Write(lpDispalyName, (1 + wLength) * sizeof(WCHAR));
  363. }
  364. else
  365. {
  366. pFile->Write(&wLength, sizeof(WCHAR));
  367. }
  369. if (bstrValue)
  370. {
  371. SysFreeString(bstrValue);
  372. }
  374. if (bPopup)
  375. {
  376. ExportDllMenuItems(pFile, &ptrSectionMenuItem);
  377. }
  378. }
  379. }
  381. AFX_INLINE DWORD AlignDWord(DWORD uLong)  {  return ((uLong + 3) & ~3); }
  383. void CResourceExport::ExportDllMenus(DIRECTORY* pRoot)
  384. {
  385. CXTPPropExchangeEnumeratorPtr ptrEnumeratorMenus(m_pResources->GetEnumerator(_T("menu")));
  386. POSITION pos = ptrEnumeratorMenus->GetPosition();
  387. while (pos)
  388. {
  389. CXTPPropExchangeSection ptrSection(ptrEnumeratorMenus->GetNext(pos));
  390. DWORD dwId = 0;
  392. PX_DWord(&ptrSection, _T("id"), dwId);
  393. if (dwId == 0)
  394. continue;
  396. DIRECTORY* pDirectory = AddDirectory(pRoot, (WORD)(DWORD_PTR)RT_MENU, dwId, m_pLanguageInfo->wLanguage);
  397. CBufferFile* pFile = pDirectory->pResource = new CBufferFile(10000);
  399. WORD wVerison = 0;
  400. WORD wOffset = 0;
  402. pFile->Write(&wVerison, sizeof(WORD));
  403. pFile->Write(&wOffset, sizeof(WORD));
  404. ExportDllMenuItems(pFile, &ptrSection);
  406. AlignFile(pFile, 0);
  407. }
  408. }
  410. int CResourceExport::GetDialogControlsCount(CXTPPropExchange* pResourceDialog)
  411. {
  412. CXTPPropExchangeEnumeratorPtr ptrEnumerator(pResourceDialog->GetEnumerator(_T("control")));
  413. POSITION pos = ptrEnumerator->GetPosition();
  414. int nCount = 0;
  416. while (pos)
  417. {
  418. CXTPPropExchangeSection ptrSection(ptrEnumerator->GetNext(pos));
  419. nCount++;
  420. }
  422. return nCount;
  423. }
  425. void CResourceExport::AlignFile(CMemFile* pFile, DWORD dwPosition)
  426. {
  427. DWORD dwAlign = 0;
  428. DWORD dwSize = DWORD(pFile->GetPosition() - dwPosition);
  430. DWORD dwBytes = AlignDWord(dwSize) - dwSize;
  431. ASSERT(dwBytes >= 0 && dwBytes < 4);
  433. pFile->Write(&dwAlign, dwBytes);
  434. }
  436. void CResourceExport::ExportDllDialogControls(CMemFile* pFile, CXTPPropExchange* pResourceDialog)
  437. {
  438. USES_CONVERSION;
  440. CXTPPropExchangeEnumeratorPtr ptrEnumerator(pResourceDialog->GetEnumerator(_T("control")));
  441. POSITION pos = ptrEnumerator->GetPosition();
  443. while (pos)
  444. {
  445. CXTPPropExchangeSection ptrSection(ptrEnumerator->GetNext(pos));
  447. DLLDLGITEMTEMPLATEEX templ;
  448. ZeroMemory(&templ, sizeof(DLLDLGITEMTEMPLATEEX));
  449. WORD dwEmpty = 0;
  450. DWORD dwPosition = (DWORD)pFile->GetPosition();
  452. RECT rcPos = {0, 0, 0, 0};
  453. PX_Rect(&ptrSection, _T("position"), rcPos, rcPos);
  454. templ.x = (short)rcPos.left;
  455. templ.y = (short)rcPos.top;
  456. templ.cx = (short)rcPos.right;
  457. templ.cy = (short)rcPos.bottom;
  459. PX_DWord(&ptrSection, _T("style"), templ.style, WS_CHILD | WS_VISIBLE | WS_GROUP);
  460. PX_DWord(&ptrSection, _T("styleex"), templ.exStyle, 0);
  462. int id = 0;
  463. PX_Int(&ptrSection, _T("id"), id, 0);
  465. templ.id = id == 0 ? (DWORD)IDC_STATIC : (DWORD)id;
  467. pFile->Write(&templ, sizeof(DLLDLGITEMTEMPLATEEX));
  469. CString strClass;
  470. PX_String(&ptrSection, _T("class"), strClass, _T("STATIC"));
  471. WORD nClass = 0;
  473. if (strClass == _T("BUTTON")) nClass = 0x0080;
  474. if (strClass == _T("EDIT")) nClass = 0x0081;
  475. if (strClass == _T("STATIC")) nClass = 0x0082;
  476. if (strClass == _T("LISTBOX")) nClass = 0x0083;
  477. if (strClass == _T("SCROLLBAR")) nClass = 0x0084;
  478. if (strClass == _T("COMBOBOX")) nClass = 0x0085;
  480. if (nClass != 0)
  481. {
  482. WORD dwSignature = 0xFFFF;
  483. pFile->Write(&dwSignature, sizeof(WORD));
  484. pFile->Write(&nClass, sizeof(WORD));
  485. }
  486. else
  487. {
  488. pFile->Write(T2CW(strClass), (strClass.GetLength() + 1) * sizeof(WCHAR));
  489. }
  491. int nResource = 0;
  492. BOOL bExists = PX_Int(&ptrSection, _T("resource"), nResource);
  493. if (bExists)
  494. {
  495. WORD dwSignature = 0xFFFF;
  496. WORD dwResource = (WORD)nResource;
  497. pFile->Write(&dwSignature, sizeof(WORD));
  498. pFile->Write(&dwResource, sizeof(WORD));
  499. }
  500. else
  501. {
  502. BSTR bstrValue = 0;
  503. PX_Bstr(&ptrSection, _T("caption"), bstrValue, 0);
  505. if (bstrValue)
  506. {
  507. pFile->Write(bstrValue, (1 + (int)wcslen(bstrValue)) * sizeof(WCHAR));
  508. }
  509. else
  510. {
  511. pFile->Write(&dwEmpty, sizeof(WORD));
  512. }
  514. if (bstrValue)
  515. SysFreeString(bstrValue);
  517. }
  518. pFile->Write(&dwEmpty, sizeof(WORD)); // extraCount;
  521. AlignFile(pFile, dwPosition);
  522. }
  523. }
  526. void CResourceExport::ExportDllDialogs(DIRECTORY* pRoot)
  527. {
  528. USES_CONVERSION;
  530. CXTPPropExchangeEnumeratorPtr ptrEnumeratorDialog(m_pResources->GetEnumerator(_T("dialog")));
  531. POSITION pos = ptrEnumeratorDialog->GetPosition();
  532. while (pos)
  533. {
  534. CXTPPropExchangeSection ptrSection(ptrEnumeratorDialog->GetNext(pos));
  535. DWORD dwId = 0;
  537. PX_DWord(&ptrSection, _T("id"), dwId);
  538. if (dwId == 0)
  539. continue;
  542. DIRECTORY* pDirectory = AddDirectory(pRoot, (WORD)(DWORD_PTR)RT_DIALOG, dwId, m_pLanguageInfo->wLanguage);
  543. CBufferFile* pFile = pDirectory->pResource = new CBufferFile(10000);
  545. DLLDLGTEMPLATEEX templ;
  546. ZeroMemory(&templ, sizeof(DLLDLGTEMPLATEEX));
  547. RECT rcPos = {0, 0, 0, 0};
  549. PX_DWord(&ptrSection, _T("style"), templ.style);
  550. PX_DWord(&ptrSection, _T("styleex"), templ.exStyle, 0);
  551. PX_Rect(&ptrSection, _T("position"), rcPos, rcPos);
  553. templ.dlgVer = 1;
  554. templ.signature = 0xFFFF;
  555. templ.cDlgItems = (WORD)GetDialogControlsCount(&ptrSection);
  556. templ.x = (short)rcPos.left;
  557. templ.y = (short)rcPos.top;
  558. templ.cx = (short)rcPos.right;
  559. templ.cy = (short)rcPos.bottom;
  560. templ.style |= DS_SETFONT;
  561. templ.helpID = dwId;
  563. WORD dwEmpty = 0;
  565. pFile->Write(&templ, sizeof(DLLDLGTEMPLATEEX));
  567. pFile->Write(&dwEmpty, sizeof(WORD));  // menu;
  568. pFile->Write(&dwEmpty, sizeof(WORD));  // windowClass;
  570. BSTR bstrValue = 0;
  571. PX_Bstr(&ptrSection, _T("caption"), bstrValue, 0);
  573. if (bstrValue)
  574. {
  575. pFile->Write(bstrValue, (1 + (int)wcslen(bstrValue)) * sizeof(WCHAR));
  576. }
  577. else
  578. {
  579. pFile->Write(&dwEmpty, sizeof(WORD));
  580. }
  582. if (bstrValue)
  583. SysFreeString(bstrValue);
  585. if (templ.style & DS_SETFONT)
  586. {
  587. int nHeight = 8;
  588. PX_Int(&ptrSection, _T("fontsize"), nHeight, 8);
  589. WORD pointsize = (WORD)nHeight, weight = 0;
  590. BYTE bItalic = 0, charset = 0;
  592. pFile->Write(&pointsize, sizeof(WORD));
  593. pFile->Write(&weight, sizeof(WORD));
  594. pFile->Write(&bItalic, sizeof(BYTE));
  595. pFile->Write(&charset, sizeof(BYTE));
  597. CString strFont;
  598. PX_String(&ptrSection, _T("fontface"), strFont, _T("MS Sans Serif"));
  600. if (!strFont.IsEmpty())
  601. {
  602. pFile->Write(T2CW(strFont), (1 + strFont.GetLength()) * sizeof(WCHAR));
  603. }
  604. else
  605. {
  606. pFile->Write(&dwEmpty, sizeof(WORD));
  607. }
  608. }
  610. AlignFile(pFile, 0);
  612. if (templ.cDlgItems > 0)
  613. {
  614. ExportDllDialogControls(pFile, &ptrSection);
  615. }
  616. }
  617. }
  620. void CResourceExport::ExportDllStringTable(DIRECTORY* pRoot)
  621. {
  622. CMap<UINT, UINT, STRINGTABLE*, STRINGTABLE*> mapStrings;
  624. CXTPPropExchangeEnumeratorPtr ptrEnumeratorStrings(m_pResources->GetEnumerator(_T("string")));
  625. POSITION pos = ptrEnumeratorStrings->GetPosition();
  626. while (pos)
  627. {
  628. CXTPPropExchangeSection ptrSectionString(ptrEnumeratorStrings->GetNext(pos));
  629. BSTR bstrValue = 0;
  630. DWORD dwId = 0;
  632. PX_DWord(&ptrSectionString, _T("id"), dwId);
  633. PX_Bstr(&ptrSectionString, _T("value"), bstrValue, 0);
  635. int IdTable = (dwId >> 4) + 1;
  636. STRINGTABLE* pst = NULL;
  637. if (!mapStrings.Lookup(IdTable, pst))
  638. {
  639. pst = new STRINGTABLE;
  640. mapStrings.SetAt(IdTable, pst);
  641. }
  643. int nIndex = dwId - (((IdTable - 1 ) << 4));
  644. ASSERT(nIndex >= 0 && nIndex < 16);
  645. pst->m_bstr[nIndex] = bstrValue;
  646. }
  648. pos = mapStrings.GetStartPosition();
  649. while (pos)
  650. {
  651. UINT Id;
  652. STRINGTABLE* pst;
  654. mapStrings.GetNextAssoc(pos, Id, pst);
  656. DIRECTORY* pDirectory = AddDirectory(pRoot, (WORD)(DWORD_PTR)RT_STRING, Id, m_pLanguageInfo->wLanguage);
  657. CBufferFile* pFile = pDirectory->pResource = new CBufferFile(10000);
  658. for (int i = 0; i < 16; i++)
  659. {
  660. WORD wLength = 0;
  662. if (pst->m_bstr[i] != 0)
  663. {
  664. LPCWSTR lpDispalyName = (LPCWSTR)pst->m_bstr[i];
  665. wLength = (WORD)wcslen(lpDispalyName);
  666. pFile->Write(&wLength, sizeof(WORD));
  667. pFile->Write(lpDispalyName, wLength * sizeof(WCHAR));
  668. }
  669. else
  670. {
  671. pFile->Write(&wLength, sizeof(WORD));
  672. }
  673. }
  674. AlignFile(pFile, 0);
  676. delete pst;
  677. }
  678. }
  680. void CResourceExport::ExportDll(CXTPPropExchangeXMLNode* pResources, LPCTSTR lpszOutput)
  681. {
  682. m_pResources = pResources;
  684. DWORD nLangId = 0;
  685. PX_DWord(m_pResources, _T("LANGID"), nLangId);
  687. m_pLanguageInfo = CXTPResourceManager::GetLanguageInfo(nLangId);
  688. if (!m_pLanguageInfo)
  689. {
  690. m_pResources = NULL;
  691. return;
  692. }
  696. DIRECTORY* pRoot = new DIRECTORY();
  698. ExportDllStringTable(pRoot);
  699. ExportDllDialogs(pRoot);
  700. ExportDllMenus(pRoot);
  702. CString lpszResourcePath = lpszOutput ? lpszOutput : _T("C:\out.dll");
  705. CFile file;
  706. file.Open(lpszResourcePath, CFile::modeWrite | CFile::modeCreate);
  708. PIMAGE_DOS_HEADER pDosExeHdr = (PIMAGE_DOS_HEADER)(_alloca(512));
  709. {
  711. HRSRC hResource = ::FindResource(::GetModuleHandle(NULL), _T("DOSHEADER"), _T("BIN"));
  713. if (hResource == NULL)
  714. return;
  716. HGLOBAL hGlobal = LoadResource(::GetModuleHandle(NULL), hResource);
  717. if (hGlobal == NULL)
  718. return;
  720. LPBYTE pHeader = (LPBYTE)::LockResource(hGlobal);
  721. memcpy(pDosExeHdr, pHeader, 512);
  723. UnlockResource(hGlobal);
  724. FreeResource(hGlobal);
  725. }
  727. PIMAGE_NT_HEADERS pNTHeader = PIMAGE_NT_HEADERS((LPBYTE)pDosExeHdr + (DWORD) pDosExeHdr->e_lfanew);
  730. CBufferFile FAT;
  731. CArrayDirectories DataDirs;
  732. WriteFAT(&FAT, pRoot, &DataDirs);
  733. WriteFATNames(&FAT, pRoot);
  735. file.Write(pDosExeHdr, 512);
  736. file.Write(FAT.GetBufferHeader(), (UINT)FAT.GetLength());
  737. int nOffset = (int)FAT.GetLength();
  739. for (int i = 0; i < DataDirs.GetSize(); i++)
  740. {
  741. DIRECTORY* pSubDir = DataDirs[i];
  743. if (pSubDir->pResource)
  744. {
  745. DWORD dwSize = (DWORD)pSubDir->pResource->GetLength();
  747. pSubDir->lpFatDataEntry->OffsetToData = nOffset + 0x00001000;
  748. pSubDir->lpFatDataEntry->Size = dwSize;
  750. file.Write(pSubDir->pResource->GetBufferHeader(), dwSize);
  751. nOffset += dwSize;
  752. }
  753. else
  754. {
  755. CFile filebmp;
  756. filebmp.Open(pSubDir->strResource, CFile::modeRead);
  758. DWORD dwSize = (DWORD)((int)filebmp.GetLength() - pSubDir->nResourceOffset);
  759. LPBYTE pBitmapInfo =(LPBYTE) malloc(dwSize);
  760. if (pSubDir->nResourceOffset > 0) filebmp.Seek(pSubDir->nResourceOffset, CFile::begin);
  761. filebmp.Read(pBitmapInfo, dwSize);
  762. filebmp.Close();
  764. pSubDir->lpFatDataEntry->OffsetToData = nOffset + 0x00001000;
  765. pSubDir->lpFatDataEntry->Size = dwSize;
  767. file.Write(pBitmapInfo, dwSize);
  768. free(pBitmapInfo);
  769. nOffset += dwSize;
  770. }
  772. }
  773. int nAdd = 0x1000 - (nOffset & 0xFFF);
  774. LPBYTE lpAlign = (LPBYTE)_alloca(0x200 + nAdd);
  775. ZeroMemory(lpAlign, 0x200 + nAdd);
  776. lpAlign[nAdd + 4] = 0x8;
  777. file.Write(lpAlign, 0x200 + nAdd);
  778. nOffset += nAdd;
  781. PIMAGE_SECTION_HEADER pSection = IMAGE_FIRST_SECTION( pNTHeader );
  782. pSection->Misc.VirtualSize = nOffset;
  783. pSection->SizeOfRawData = nOffset;
  784. pNTHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESOURCE].Size = nOffset;
  786. pSection++;
  787. pSection->VirtualAddress = nOffset + 0x1000;
  788. pSection->PointerToRawData = nOffset + 0x200;
  789. pNTHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress = nOffset + 0x1000;
  791. pNTHeader->OptionalHeader.SizeOfImage = nOffset + 0x2000;
  792. pNTHeader->OptionalHeader.SizeOfInitializedData = nOffset + 0x200;
  794. file.SeekToBegin();
  795. file.Write(pDosExeHdr, 512);
  796. file.Write(FAT.GetBufferHeader(), (UINT)FAT.GetLength());
  798. file.Close();
  801. delete pRoot;
  804. m_pLanguageInfo= NULL;
  805. m_pResources = NULL;
  806. }
  808. void Replace(LPSTR lpszData, LPCSTR lpszOld, LPCSTR lpszNew)
  809. {
  810. int nSourceLen = (int)strlen(lpszOld);
  811. int nReplacementLen = (int)strlen(lpszNew);
  813. int nOldLength = (int)strlen(lpszData);
  814. LPSTR lpszStart = lpszData;
  815. LPSTR lpszTarget;
  817. while ((lpszTarget = strstr(lpszStart, lpszOld)) != NULL)
  818. {
  819. int nBalance = nOldLength - int(lpszTarget - lpszData + nSourceLen);
  821. memmove(lpszTarget + nReplacementLen, lpszTarget + nSourceLen,
  822. nBalance);
  824. memcpy(lpszTarget, lpszNew, nReplacementLen);
  826. lpszStart = lpszTarget + nReplacementLen;
  827. lpszStart[nBalance] = '';
  828. nOldLength += (nReplacementLen - nSourceLen);
  829. }
  830. }
  832. void WriteString(CFile& file, const CString& str)
  833. {
  834. USES_CONVERSION;
  835. file.Write(T2CA((LPCTSTR)str), str.GetLength());
  836. }
  838. void WriteString(CFile& file, LPSTR str)
  839. {
  840. file.Write(str, (int)strlen(str));
  841. }
  843. void CResourceExport::ExchangeString(CXTPPropExchange* pPX, LPCTSTR pszPropName, LPSTR lpString)
  844. {
  845. BSTR bstrValue = 0;
  846. PX_Bstr(pPX, pszPropName, bstrValue, 0);
  848. ASSERT(!bstrValue || wcslen(bstrValue) < 500);
  850. lpString[0] = 0;
  851. WideCharToMultiByte(m_pLanguageInfo->nCodePage, 0, bstrValue, -1, lpString, 512, 0, 0);
  853. Replace(lpString, "\", "\\");
  854. Replace(lpString, "n", "\n");
  855. Replace(lpString, "r", "\r");
  856. Replace(lpString, "t", "\t");
  857. Replace(lpString, """, """");
  859. SysFreeString(bstrValue);
  860. }
  862. void CResourceExport::ExportRcStringTable(CFile& file)
  863. {
  864. LPCSTR lpszHeader = 
  865. "/////////////////////////////////////////////////////////////////////////////rn"
  866. "//rn"
  867. "// String Tablern"
  868. "//rnrn"
  869. "STRINGTABLErn"
  870. "BEGINrn";
  872. WriteString(file, lpszHeader);
  874. CXTPPropExchangeEnumeratorPtr ptrEnumeratorStrings(m_pResources->GetEnumerator(_T("string")));
  875. POSITION pos = ptrEnumeratorStrings->GetPosition();
  876. while (pos)
  877. {
  878. CXTPPropExchangeSection ptrSectionString(ptrEnumeratorStrings->GetNext(pos));
  879. DWORD dwId = 0;
  881. char lpString[512];
  882. PX_DWord(&ptrSectionString, _T("id"), dwId);
  883. ExchangeString(&ptrSectionString, _T("value"), lpString);
  885. WriteString(file, "    ");
  887. CString strResourceName = GetResourceName(dwId);
  889. WriteString(file, strResourceName);
  890. file.Write("                                  ", max(1, 34 - strResourceName.GetLength()));
  892. WriteString(file, """);
  893. WriteString(file, lpString);
  894. WriteString(file, ""rn");
  895. }
  897. WriteString(file, "ENDrnrn");
  898. };
  900. void CResourceExport::ExportRcMenuItems(CFile& file, DWORD dwParent, CXTPPropExchange* pResourceMenu, const CString& strIndent)
  901. {
  902. CXTPPropExchangeEnumeratorPtr ptrEnumeratorStrings(pResourceMenu->GetEnumerator(_T("menuitem")));
  903. POSITION pos = ptrEnumeratorStrings->GetPosition();
  905. while (pos)
  906. {
  907. CXTPPropExchangeSection ptrSectionMenuItem(ptrEnumeratorStrings->GetNext(pos));
  908. DWORD dwId = 0;
  910. PX_DWord(&ptrSectionMenuItem, _T("id"), dwId);
  912. char lpString[512];
  913. ExchangeString(&ptrSectionMenuItem, _T("caption"), lpString);
  915. if (((CXTPPropExchangeXMLNode*)&ptrSectionMenuItem)->IsSectionExists(_T("menuitem")))
  916. {
  917. WriteString(file, strIndent);
  918. WriteString(file, "POPUP "");
  919. WriteString(file, lpString);
  920. WriteString(file, ""rn");
  921. WriteString(file, strIndent);
  922. WriteString(file, "BEGINrn");
  924. ExportRcMenuItems(file, dwParent, &ptrSectionMenuItem, strIndent + _T("    "));
  925. WriteString(file, strIndent);
  926. WriteString(file, "ENDrn");
  927. }
  928. else if (dwId != 0)
  929. {
  930. WriteString(file, strIndent);
  931. WriteString(file, "MENUITEM "");
  933. WriteString(file, lpString);
  935. WriteString(file, "", ");
  936. CString strResourceName = GetResourceName(dwId, dwParent);
  937. WriteString(file, strResourceName);
  939. WriteString(file, "rn");
  940. }
  941. else
  942. {
  943. WriteString(file, strIndent);
  944. WriteString(file, "MENUITEM SEPARATORrn");
  945. }
  946. }
  947. }
  949. void CResourceExport::ExportRcMenus(CFile& file)
  950. {
  951. LPCSTR lpszHeader = 
  952. "/////////////////////////////////////////////////////////////////////////////rn"
  953. "//rn"
  954. "// Menurn"
  955. "//rnrn";
  957. WriteString(file, lpszHeader);
  959. CXTPPropExchangeEnumeratorPtr ptrEnumeratorStrings(m_pResources->GetEnumerator(_T("menu")));
  960. POSITION pos = ptrEnumeratorStrings->GetPosition();
  962. while (pos)
  963. {
  964. CXTPPropExchangeSection ptrSectionMenu(ptrEnumeratorStrings->GetNext(pos));
  965. DWORD dwId = 0;
  967. PX_DWord(&ptrSectionMenu, _T("id"), dwId);
  968. if (dwId == 0)
  969. continue;
  970. CString strResourceName = GetResourceName(dwId);
  972. CString strMenuHeader; 
  973. strMenuHeader.Format(_T("%s MENU DISCARDABLErnBEGINrn"), (LPCTSTR)strResourceName);
  974. WriteString(file, strMenuHeader);
  976. ExportRcMenuItems(file, dwId, &ptrSectionMenu, _T("    "));
  978. WriteString(file, "ENDrnrn");
  979. }
  980. }
  982. void CResourceExport::ExportRcDialogControls(CFile& file, DWORD dwParent, CXTPPropExchange* pResourceDialog)
  983. {
  984. CXTPPropExchangeEnumeratorPtr ptrEnumeratorStrings(pResourceDialog->GetEnumerator(_T("control")));
  985. POSITION pos = ptrEnumeratorStrings->GetPosition();
  987. while (pos)
  988. {
  989. CXTPPropExchangeSection ptrSectionControl(ptrEnumeratorStrings->GetNext(pos));
  990. DWORD dwId = 0;
  991. DWORD dwStyle = 0, styleex = 0;
  992. RECT rc = {0, 0, 0, 0};
  993. CString strClass;
  995. PX_DWord(&ptrSectionControl, _T("id"), dwId);
  996. PX_DWord(&ptrSectionControl, _T("style"), dwStyle, WS_CHILD | WS_VISIBLE | WS_GROUP);
  997. PX_DWord(&ptrSectionControl, _T("styleex"), styleex, 0);
  999. PX_Rect(&ptrSectionControl, _T("position"), rc, rc);
  1000. PX_String(&ptrSectionControl, _T("class"), strClass, _T("STATIC"));
  1002. CString strResourceName = dwId == 0 ? _T("IDC_STATIC") :
  1003. dwId == 1 ? _T("IDOK") : dwId == 2 ? _T("IDCANCEL") : GetResourceName(dwId, dwParent);
  1004. char lpCaption[512];
  1005. ExchangeString(&ptrSectionControl, _T("caption"), lpCaption);
  1007. LPCSTR strType = NULL;
  1008. DWORD dwStyleDefault = (WS_CHILD | WS_VISIBLE | WS_TABSTOP);
  1010. DWORD bsStyle = dwStyle & 0xF;
  1011. BOOL bAddCaption = TRUE;
  1013. if (strClass.CompareNoCase(_T("BUTTON")) == 0)
  1014. {
  1015. if (bsStyle == BS_DEFPUSHBUTTON) strType = "    DEFPUSHBUTTON   "";
  1016. if (bsStyle == BS_PUSHBUTTON)    strType = "    PUSHBUTTON      "";
  1017. if (bsStyle == BS_RADIOBUTTON)   strType = "    RADIOBUTTON     "";
  1019. if (bsStyle == BS_GROUPBOX) 
  1020. {
  1021. strType = "    GROUPBOX        "";
  1022. dwStyleDefault = (WS_CHILD | WS_VISIBLE);
  1023. }
  1025. dwStyleDefault += bsStyle;
  1026. }
  1027. else if (strClass.CompareNoCase(_T("STATIC")) == 0)
  1028. {
  1029. if (bsStyle == SS_LEFT) strType = "    LTEXT           "";
  1030. if (bsStyle == SS_RIGHT)strType = "    RTEXT           "";
  1032. dwStyleDefault = (WS_CHILD | WS_VISIBLE | WS_GROUP) + bsStyle;
  1033. }
  1034. else if (strClass.CompareNoCase(_T("COMBOBOX")) == 0)
  1035. {
  1036. strType = "    COMBOBOX        ";
  1037. bAddCaption = FALSE;
  1038. }
  1039. else if (strClass.CompareNoCase(_T("LISTBOX")) == 0)
  1040. {
  1041. strType = "    LISTBOX         ";
  1042. bAddCaption = FALSE;
  1043. }
  1044. else if (strClass.CompareNoCase(_T("EDIT")) == 0)
  1045. {
  1046. strType = "    EDITTEXT        ";
  1047. bAddCaption = FALSE;
  1048. }
  1052. CString str;
  1054. if (strType == NULL)
  1055. {
  1056. WriteString(file, "    CONTROL         "");
  1057. WriteString(file, lpCaption);
  1059. str.Format(_T("",%s,"%s",0x%x,%i,%i,%i,%i"), (LPCTSTR)strResourceName, 
  1060. (LPCTSTR)strClass, dwStyle, 
  1061. rc.left, rc.top, rc.right, rc.bottom);
  1062. WriteString(file, str);
  1063. }
  1064. else
  1065. {
  1066. WriteString(file, strType);
  1067. if (bAddCaption)
  1068. {
  1069. WriteString(file, lpCaption);
  1070. WriteString(file, "",");
  1071. }
  1073. str.Format(_T("%s,%i,%i,%i,%i"), (LPCTSTR)strResourceName,
  1074. rc.left, rc.top, rc.right, rc.bottom);
  1075. WriteString(file, str);
  1077. if (dwStyle != dwStyleDefault || styleex != 0)
  1078. {
  1079. str.Format(_T(",0x%x"), dwStyle);
  1080. WriteString(file, str);
  1081. }
  1082. }
  1084. if (styleex != 0)
  1085. {
  1086. str.Format(_T(",0x%x"), styleex);
  1087. WriteString(file,str);
  1088. }
  1090. WriteString(file, "rn");
  1091. }
  1092. }
  1095. void CResourceExport::ExportRcDialogs(CFile& file)
  1096. {
  1097. LPCSTR lpszHeader = 
  1098. "/////////////////////////////////////////////////////////////////////////////rn"
  1099. "//rn"
  1100. "// Dialogrn"
  1101. "//rnrn";
  1103. WriteString(file, lpszHeader);
  1105. CXTPPropExchangeEnumeratorPtr ptrEnumeratorStrings(m_pResources->GetEnumerator(_T("dialog")));
  1106. POSITION pos = ptrEnumeratorStrings->GetPosition();
  1108. while (pos)
  1109. {
  1110. CXTPPropExchangeSection ptrSectionDailog(ptrEnumeratorStrings->GetNext(pos));
  1111. DWORD dwId = 0;
  1112. DWORD dwStyle = 0, dwExStyle = 0;
  1113. RECT rc = {0, 0, 0, 0};
  1114. CString strFace;
  1116. PX_DWord(&ptrSectionDailog, _T("id"), dwId);
  1117. PX_DWord(&ptrSectionDailog, _T("style"), dwStyle);
  1118. PX_DWord(&ptrSectionDailog, _T("styleex"), dwExStyle, 0);
  1119. PX_Rect(&ptrSectionDailog, _T("position"), rc, rc);
  1120. PX_String(&ptrSectionDailog, _T("fontface"), strFace, _T("MS Sans Serif"));
  1122. char lpCaption[512];
  1123. ExchangeString(&ptrSectionDailog, _T("caption"), lpCaption);
  1125. if (dwId == 0)
  1126. continue;
  1127. CString strResourceName = GetResourceName(dwId);
  1129. CString strHeader; 
  1130. strHeader.Format(_T("%s DIALOGEX DISCARDABLE %i, %i, %i, %irn"), 
  1131. (LPCTSTR)strResourceName, rc.left, rc.top, rc.right, rc.bottom);
  1132. WriteString(file, strHeader);
  1134. if (dwExStyle != 0)
  1135. {
  1136. strHeader.Format(_T("EXSTYLE 0x%xrn"), dwExStyle);
  1137. WriteString(file, strHeader);
  1138. }
  1140. strHeader.Format(_T("STYLE 0x%xrn"), dwStyle);
  1141. WriteString(file, strHeader);
  1143. WriteString(file, "CAPTION ""); WriteString(file, lpCaption); WriteString(file, ""rn");
  1144. WriteString(file, "FONT 8, ""); WriteString(file, strFace); WriteString(file, ""rn");
  1146. WriteString(file, "BEGINrn");
  1148. ExportRcDialogControls(file, dwId, &ptrSectionDailog);
  1150. WriteString(file, "ENDrnrn");
  1151. }
  1152. }
  1155. void CResourceExport::ExportRc(CXTPPropExchangeXMLNode* pResources, LPCTSTR lpszOutput)
  1156. {
  1157. m_pResources = pResources;
  1159. CString lpszResourcePath = lpszOutput ? lpszOutput : _T("C:\out.rc");
  1161. CFile file;
  1162. file.Open(lpszResourcePath, CFile::modeWrite | CFile::modeCreate);
  1164. DWORD nLangId = 0;
  1165. PX_DWord(m_pResources, _T("LANGID"), nLangId);
  1167. m_pLanguageInfo = CXTPResourceManager::GetLanguageInfo(nLangId);
  1168. if (!m_pLanguageInfo)
  1169. {
  1170. WriteString(file, "Not found");
  1171. m_pResources = NULL;
  1172. return;
  1173. }
  1175. CString strHeader;
  1176. strHeader.Format(
  1177. _T("// Codejock ResourceEditor generated resource script.rn")
  1178. _T("//rnrn#include "afxres.h"rnrn")
  1179. _T("/////////////////////////////////////////////////////////////////////////////rn")
  1180. _T("// %s resourcesrnrn")
  1181. _T("#if !defined(AFX_RESOURCE_DLL)rn")
  1182. _T("#ifdef _WIN32rn")
  1183. _T("LANGUAGE %s, %srn")
  1184. _T("#pragma code_page(%i)rn")
  1185. _T("#endif //_WIN32rnrn"), m_pLanguageInfo->lpszCaption, 
  1186. m_pLanguageInfo->lpszLang, m_pLanguageInfo->lpszSubLang, m_pLanguageInfo->nCodePage);
  1188. WriteString(file, strHeader);
  1190. ExportRcDialogs(file);
  1191. ExportRcMenus(file);
  1192. ExportRcStringTable(file);
  1194. WriteString(file, "#endifrn");
  1196. file.Close();
  1198. m_pLanguageInfo = NULL;
  1199. m_pResources = NULL;
  1200. }