Category

Development Platform
Home > SourceCode/Document > Windows Develop > View Code
MainDlg.cpp
Package: SCM_Editor_0911.rar　[view]
Upload User: binky88
Upload Date: 2015-05-28
Package Size: 199k
Code Size: 61k
Category:

Windows Develop

Development Platform:

Visual C++

MainDlg.cpp：Code Content
  1. // MainDlg.cpp : implementation of the CMainDlg class
  2. //
  3. /////////////////////////////////////////////////////////////////////////////
  5. #include "stdafx.h"
  6. #include "resource.h"
  8. #include "MainDlg.h"
  9. #include "static_function.h"
  10. #include "wizard.h"
  12. #define   DRAG_DELAY   60
  14. LRESULT CMainDlg::OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
  15. {
  16. // center the dialog on the screen
  17. CenterWindow();
  19. // set icons
  20. HICON hIcon = (HICON)::LoadImage(_Module.GetResourceInstance(), MAKEINTRESOURCE(IDR_MAINFRAME), 
  21. IMAGE_ICON, ::GetSystemMetrics(SM_CXICON), ::GetSystemMetrics(SM_CYICON), LR_DEFAULTCOLOR);
  22. SetIcon(hIcon, TRUE);
  23. HICON hIconSmall = (HICON)::LoadImage(_Module.GetResourceInstance(), MAKEINTRESOURCE(IDR_MAINFRAME), 
  24. IMAGE_ICON, ::GetSystemMetrics(SM_CXSMICON), ::GetSystemMetrics(SM_CYSMICON), LR_DEFAULTCOLOR);
  25. SetIcon(hIconSmall, FALSE);
  27. //  TCHAR szWindowName[255] = {0};
  28. //  LoadString(NULL, GetLangString(LS_WINDOWTITLE), szWindowName, 255);
  29. //  SetWindowText(szWindowName);
  31. m_bDragging = false;
  33. m_wndTree.SubclassWindow(GetDlgItem(IDC_RAWCODE_TREE));
  35. m_wndBlogLink.SubclassWindow(GetDlgItem(IDC_BLOG));
  36. m_wndBlogLink.SetHyperLink (_T("http://mask911.net/"));
  38. m_wndPCLink.SubclassWindow(GetDlgItem(IDC_PSPCHINA));
  39. m_wndPCLink.SetHyperLink (_T("http://bbs.pspchina.net/"));
  41. m_treeRawCode = CTreeViewCtrlEx(GetDlgItem(IDC_RAWCODE_TREE));
  42. m_image.Create(IDB_TREEIMAGE, 16, 1, RGB(255,255,255));
  43. m_treeRawCode.SetImageList(m_image.m_hImageList, TVSIL_NORMAL);
  45. m_hRoot = NULL;
  46. m_TimerTicks = 0;
  47. m_nOldY = -1;
  48. m_nClassCount = 0;
  49. m_nCodeCount = 0;
  50. m_bShouldTrigger = TRUE;
  52. SetDlgItemText(IDC_CLASS_COUNT, _T("Class Number: 0/50"));
  53. SetDlgItemText(IDC_CODE_COUNT, _T("Code Number: 0/500"));
  55. RegisterHotKey(m_treeRawCode.m_hWnd, ID_ACCELERATOR_MOVEDOWN, MOD_CONTROL, VK_DOWN);
  56. RegisterHotKey(m_treeRawCode.m_hWnd, ID_ACCELERATOR_MOVEUP, MOD_CONTROL, VK_UP);
  58. //  m_tooltip.Create(m_treeRawCode.m_hWnd);
  59. // // m_tooltip.Activate(TRUE);
  60. // // m_tooltip.AddTool(GetDlgItem(IDC_RAWCODE_TREE), _T("Tree Tool Tip"));
  61. //  m_tooltip.SetMaxTipWidth(0);
  62. // 
  63. //  m_ti.cbSize = sizeof(m_ti);
  64. //  m_ti.uFlags = TTF_IDISHWND|TTF_TRACK|TTF_ABSOLUTE|TTF_TRANSPARENT;
  65. //  m_ti.hwnd = m_treeRawCode.m_hWnd;
  66. //  m_ti.hinst = NULL;
  67. //  m_ti.uId = (UINT)m_treeRawCode.m_hWnd;
  68. //  m_ti.lpszText = LPSTR_TEXTCALLBACK;
  69. //  m_ti.rect.left = 0; 
  70. //  m_ti.rect.top = 0;
  71. //  m_ti.rect.right = 0;
  72. //  m_ti.rect.bottom = 0;
  73. // 
  74. //  m_tooltip.AddTool(&m_ti);
  75. // // m_tooltip.SendMessage(TTM_ADDTOOL, 0, (LPARAM)&m_ti);
  77. return TRUE;
  78. }
  80. LRESULT CMainDlg::OnOk(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
  81. {
  82. // TODO: Add validation code 
  83. HWND hFocus = GetFocus();
  85. if(wNotifyCode == 0)
  86.   {
  87. if(GetDlgItem(IDC_FILENAME) == hFocus)
  88. {
  89. TCHAR szFileName[MAX_PATH] = {0};
  90. GetDlgItemText(IDC_FILENAME, szFileName, MAX_PATH);
  91. m_strSCMFile = SCM_String(szFileName);
  93. if(m_strSCMFile.length() > 0 && (GetFileAttributes(m_strSCMFile.c_str()) != INVALID_FILE_ATTRIBUTES))
  94. {
  95. ClearData();
  96. LoadFile(m_strSCMFile.c_str());
  97. ::SetFocus(m_treeRawCode.m_hWnd);
  98. m_treeRawCode.SelectItem(m_hRoot);
  99. }
  100. }
  101. else if((m_treeRawCode.GetEditControl()).m_hWnd == hFocus)
  102. {
  103. m_treeRawCode.EndEditLabelNow(FALSE);
  104. }
  105. else if(m_treeRawCode.m_hWnd == hFocus)
  106. {
  107. m_treeRawCode.EditLabel(m_treeRawCode.GetSelectedItem());
  108. }
  109.   }
  110. return 0;
  111. }
  113. LRESULT CMainDlg::OnCancel(WORD /*wNotifyCode*/, WORD wID, HWND hWndCtl, BOOL& /*bHandled*/)
  114. {
  115. HWND hFocus = GetFocus();
  117. if((m_treeRawCode.GetEditControl()).m_hWnd == hFocus)
  118. {
  119. m_treeRawCode.EndEditLabelNow(TRUE);
  120. }
  121. else if(m_treeRawCode.m_hWnd == hFocus)
  122. {
  123. if(m_bDragging)
  124. {
  125. m_bDragging = FALSE;
  126. CImageList::DragLeave(m_treeRawCode.m_hWnd);
  127. CImageList::EndDrag();
  128. m_treeRawCode.SelectDropTarget(NULL);
  129. KillTimer(m_nScrollTimerID);
  131. RECT rect;
  132. m_treeRawCode.GetClientRect(&rect);
  133. m_treeRawCode.InvalidateRect(&rect, TRUE);
  134. m_treeRawCode.UpdateWindow();
  136. INPUT input;
  137. input.type = INPUT_MOUSE;
  138. input.mi.dwFlags = MOUSEEVENTF_LEFTUP;
  139. input.mi.time = 0;
  140. SendInput(1, &input, sizeof(input));
  141. }
  142. }
  143. return 0;
  144. }
  146. LRESULT CMainDlg::OnClose(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& /*bHandled*/)
  147. {
  148. // TODO: Add your message handler code here and/or call default
  150. EndDialog(wParam);
  151. return 0;
  152. }
  154. LRESULT CMainDlg::OnSelectfile(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
  155. {
  156. // TODO: Add your control notification handler code here
  157. OPENFILENAME ofn;
  158. TCHAR szFile[MAX_PATH] = {0};
  159. TCHAR szInitalDir[MAX_PATH] = {0};
  160. GetDlgItemText(IDC_FILENAME, szInitalDir, MAX_PATH);
  162. ZeroMemory(&ofn, sizeof(OPENFILENAME));
  163. ofn.lStructSize = sizeof(ofn);
  164. ofn.hwndOwner = m_hWnd;
  165. ofn.lpstrFile = szFile;
  166. ofn.lpstrFile[0] = _T('');
  167. ofn.nMaxFile = sizeof(szFile);
  168. ofn.lpstrFilter = _T("SCEP CheatMaster 0.7 Raw Code File*.scm");
  169. ofn.nFilterIndex = 1;
  170. ofn.lpstrTitle = _T("Please Open a SCEP CheatMaster 0.7 Raw Code File");
  171. ofn.lpstrInitialDir = szInitalDir;
  172. ofn.Flags = OFN_FILEMUSTEXIST | OFN_HIDEREADONLY;
  174. if(TRUE == GetOpenFileName(&ofn))
  175. {
  176. m_strSCMFile = SCM_String(ofn.lpstrFile);
  177. SetDlgItemText(IDC_FILENAME, ofn.lpstrFile);
  179. ClearData();
  180. LoadFile(m_strSCMFile.c_str());
  181. ::SetFocus(m_treeRawCode.m_hWnd);
  182. m_treeRawCode.SelectItem(m_hRoot);
  183. }
  185. return 0;
  186. }
  188. LRESULT CMainDlg::OnOpenfile(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
  189. {
  190. // TODO: Add your control notification handler code here
  191. ClearData();
  192. LoadFile(m_strSCMFile.c_str());
  193. ::SetFocus(m_treeRawCode.m_hWnd);
  194. m_treeRawCode.SelectItem(m_hRoot);
  195. return 0;
  196. }
  198. bool CMainDlg::LoadFile(LPCTSTR lpszFileName)
  199. {
  200. if(GetFileAttributes(lpszFileName) == INVALID_FILE_ATTRIBUTES)
  201. {
  202. MessageBox(_T("Please Select an exist SCEP CheatMaster 0.7 Raw Code File！"), _T("Error"), MB_OK|MB_TOPMOST);
  203. ClearData();
  204. return false;
  205. }
  207. HANDLE hRawCodeFile = CreateFile(lpszFileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, NULL, NULL);
  208. if(hRawCodeFile == INVALID_HANDLE_VALUE)
  209. {
  210. MessageBox(_T("Please Select an exist SCEP CheatMaster 0.7 Raw Code File！"), _T("Error"), MB_OK|MB_TOPMOST);
  211. ClearData();
  212. return false;
  213. }
  215. // FileName
  216. HTREEITEM hTreeItem;
  217. if(m_hRoot == NULL)
  218. m_hRoot = InsertTreeItem(lpszFileName, TVI_ROOT, TVI_ROOT);
  219. else
  220. m_treeRawCode.SetItemText(m_hRoot, lpszFileName);
  221. AddTreeNode(m_hRoot, MAX_PATH, _T(""), _T(""), _T(""), (LPTSTR)lpszFileName, NODE_TYPE_FILENAME);
  223. char szReadData[50] = {0};
  224. TCHAR szDisplayData[100] = {0};
  225. // ID
  226. readString(hRawCodeFile, szReadData, 50, NULL, 0x0A);
  227. ZeroMemory(szDisplayData, sizeof(szDisplayData));
  228. _tcscpy(szDisplayData, (s2ws(szReadData)).c_str());
  229. hTreeItem = InsertTreeItem(szDisplayData, m_hRoot, m_hRoot);
  230. AddTreeNode(hTreeItem, 12, _T(""), _T(""), _T("ID: "), szDisplayData, NODE_TYPE_GAMEINFO);
  232. // Name
  233. readString(hRawCodeFile, szReadData, 50, NULL, 0x0A);
  234. ZeroMemory(szDisplayData, sizeof(szDisplayData));
  235. _tcscpy(szDisplayData, (s2ws(szReadData)).c_str());
  236. hTreeItem = InsertTreeItem(szDisplayData, m_hRoot, hTreeItem);
  237. AddTreeNode(hTreeItem, 30, _T(""), _T(""), _T("NAME: "), szDisplayData, NODE_TYPE_GAMEINFO);
  239. // START
  240. readString(hRawCodeFile, szReadData, 50, "$", 0x0A);
  241. if(stricmp(szReadData, "START"))
  242. {
  243. MessageBox(_T("This is not a valid SCEP CheatMaster 0.7 Raw Code File！"), _T("Error"), MB_OK|MB_TOPMOST);
  244. ClearData();
  245. return false;
  246. }
  248. HTREEITEM hClassItem;
  249. HTREEITEM hCodeItem;
  250. HTREEITEM hMemoryItem;
  251. int nCodeNumber = 1;
  252. TCHAR szCodeNumber[5] = {0};
  253. DWORD dwReaded;
  254. do 
  255. {
  256. // ClassName
  257. if(!readString(hRawCodeFile, szReadData, 50, "$", '{'))
  258. break;
  260. hClassItem = InsertTreeItem((SCM_String(_T("Class Name: ")) + s2ws(szReadData)).c_str(), m_hRoot, hTreeItem);
  261. AddTreeNode(hClassItem, 19, _T(""), _T(""), _T("Class Name: "), (LPTSTR)s2ws(szReadData).c_str(), NODE_TYPE_CLASSNAME);
  262. hCodeItem = hClassItem;
  263. nCodeNumber = 1;
  265. do 
  266. {
  267. // CodeItem
  268. _itot(nCodeNumber++, szCodeNumber, 10);
  269. ZeroMemory(szDisplayData, sizeof(szDisplayData));
  270. _tcscpy(szDisplayData, (SCM_String(_T("Code ")) + SCM_String(szCodeNumber)).c_str());
  271. hCodeItem = InsertTreeItem(szDisplayData, hClassItem, hCodeItem);
  272. AddTreeNode(hCodeItem, MAX_PATH, _T(""), _T(""), _T("Code "), szCodeNumber, NODE_TYPE_RAWCODENUMBER);
  274. // CodeName
  275. readString(hRawCodeFile, szReadData, 50, "$", ' ');
  276. if (!strcmp(szReadData, " "))
  277. strcpy(szReadData, RAWCODENAMEEMPTY);
  279. hTreeItem = InsertTreeItem((SCM_String(_T("Code Name: ")) + s2ws(szReadData)).c_str(), hCodeItem, hCodeItem);
  280. AddTreeNode(hTreeItem, 9, _T(""), _T(" "), _T("Code Name: "), (LPTSTR)s2ws(szReadData).c_str(), NODE_TYPE_RAWCODENAME);
  282. // ItemStat
  283. readString(hRawCodeFile, szReadData, 50, "$", ' ');
  284. ZeroMemory(szDisplayData, sizeof(szDisplayData));
  285. switch(atoi(szReadData))
  286. {
  287. case 0:
  288. _tcscpy(szDisplayData, _T("Code Stat: Disable"));
  289. break;
  290. case 1:
  291. _tcscpy(szDisplayData, _T("Code Stat: Enable"));
  292. break;
  293. case 2:
  294. _tcscpy(szDisplayData, _T("Code Stat: Lock"));
  295.     break;
  296. default:
  297. _tcscpy(szDisplayData, _T("Code Stat: Unknown"));
  298.     break;
  299. }
  300. hTreeItem = InsertTreeItem(szDisplayData, hCodeItem, hTreeItem);
  301. AddTreeNode(hTreeItem, 1, _T("012"), _T(""), _T("Code Stat: "), (LPTSTR)s2ws(szReadData).c_str(), NODE_TYPE_RAWCODESTAT);
  303. // MemTitle
  304. ZeroMemory(szDisplayData, sizeof(szDisplayData));
  305. _tcscpy(szDisplayData, _T("Memory"));
  306. hMemoryItem = InsertTreeItem(szDisplayData, hCodeItem, hTreeItem);
  307. AddTreeNode(hMemoryItem, MAX_PATH, _T(""), _T(""), _T(""), szDisplayData, NODE_TYPE_RAWCODEMEMORY);
  309. // Mem1
  310. readString(hRawCodeFile, szReadData, 50, "$(", ' ');
  311. hTreeItem = InsertTreeItem((SCM_String(_T("Memory1: 0x")) + s2ws(szReadData)).c_str(), hMemoryItem, hMemoryItem);
  312. AddTreeNode(hTreeItem, 8, _T("0123456789ABCDEFabcdef"), _T(""), _T("Memory1: 0x"), (LPTSTR)s2ws(szReadData).c_str(), NODE_TYPE_RAWCODEMEMORYN);
  314. // Mem2
  315. readString(hRawCodeFile, szReadData, 50, NULL, ' ');
  316. hTreeItem = InsertTreeItem((SCM_String(_T("Memory2: 0x")) + s2ws(szReadData)).c_str(), hMemoryItem, hTreeItem);
  317. AddTreeNode(hTreeItem, 8, _T("0123456789ABCDEFabcdef"), _T(""), _T("Memory2: 0x"), (LPTSTR)s2ws(szReadData).c_str(), NODE_TYPE_RAWCODEMEMORYN);
  319. // Mem3
  320. readString(hRawCodeFile, szReadData, 50, NULL, ' ');
  321. hTreeItem = InsertTreeItem((SCM_String(_T("Memory3: 0x")) + s2ws(szReadData)).c_str(), hMemoryItem, hTreeItem);
  322. AddTreeNode(hTreeItem, 8, _T("0123456789ABCDEFabcdef"), _T(""), _T("Memory3: 0x"), (LPTSTR)s2ws(szReadData).c_str(), NODE_TYPE_RAWCODEMEMORYN);
  324. // Mem4
  325. readString(hRawCodeFile, szReadData, 50, NULL, ')');
  326. hTreeItem = InsertTreeItem((SCM_String(_T("Memory4: 0x")) + s2ws(szReadData)).c_str(), hMemoryItem, hTreeItem);
  327. AddTreeNode(hTreeItem, 8, _T("0123456789ABCDEFabcdef"), _T(""), _T("Memory4: 0x"), (LPTSTR)s2ws(szReadData).c_str(), NODE_TYPE_RAWCODEMEMORYN);
  329. ReadFile(hRawCodeFile, szReadData, 1, &dwReaded, NULL);
  330. if(szReadData[0] == '}')
  331. break;
  332. } while(1);
  334. } while(1);
  336. m_treeRawCode.Expand(m_hRoot, TVE_EXPAND);
  337. CloseHandle(hRawCodeFile);
  339. UpdateClassCodeCount();
  340. return true;
  341. }
  343. void CMainDlg::ClearData()
  344. {
  345. if(m_hRoot != NULL && m_treeRawCode.ItemHasChildren(m_hRoot))
  346. {
  347. HTREEITEM hNextItem;
  348. HTREEITEM hChildItem = m_treeRawCode.GetChildItem(m_hRoot);
  350. while (hChildItem != NULL)
  351. {
  352. hNextItem = m_treeRawCode.GetNextItem(hChildItem, TVGN_NEXT);
  353. m_treeRawCode.DeleteItem(hChildItem);
  354. hChildItem = hNextItem;
  355. }
  356. }
  357. if(m_vTreeNode.size() > 0)
  358. {
  359. m_vTreeNode.clear();
  360. }
  362. m_nClassCount = 0;
  363. m_nCodeCount = 0;
  364. UpdateClassCodeCount();
  365. }
  367. LRESULT CMainDlg::OnKillfocusFilename(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
  368. {
  369. // TODO: Add your control notification handler code here
  370. TCHAR szFileName[MAX_PATH] = {0};
  371. GetDlgItemText(IDC_FILENAME, szFileName, MAX_PATH);
  372. m_strSCMFile = SCM_String(szFileName);
  373. return 0;
  374. }
  375. HTREEITEM CMainDlg::InsertTreeItem(LPCTSTR lpszText, HTREEITEM hParent, HTREEITEM hAfter)
  376. {
  377. TVITEM tvi = { 0 };             // TreeView Item
  378. TVINSERTSTRUCT tvins = { 0 };   // TreeView Insert Struct
  380. tvi.mask = TVIF_TEXT;
  381. tvi.pszText = (LPTSTR)lpszText;
  382. tvi.cchTextMax = _tcslen(lpszText);
  384. tvins.item = tvi;
  385. tvins.hParent = hParent;
  386. tvins.hInsertAfter = hAfter;
  388. return TreeView_InsertItem(m_treeRawCode.m_hWnd, &tvins);
  389. }
  391. void CMainDlg::AddTreeNode(HTREEITEM hTreeItem, int nLimitLength, LPTSTR lpszValidChars, LPTSTR lpszInvalidChars, LPTSTR lpszFront,LPTSTR lpszValue, int nType, int nPos)
  392. {
  393. TreeNode treeNode;
  394. ZeroMemory(&treeNode, sizeof(TreeNode));
  395. treeNode.hItem = hTreeItem;
  396. treeNode.nLimitLength = nLimitLength;
  397. _tcsncpy(treeNode.szValidChars, lpszValidChars, 100);
  398. _tcsncpy(treeNode.szInvalidChars, lpszInvalidChars, 100);
  399. _tcsncpy(treeNode.szFront, lpszFront, 50);
  400. _tcsncpy(treeNode.szValue, lpszValue, 50);
  401. treeNode.nType = nType;
  403. if(nType == NODE_TYPE_CLASSNAME)
  404. m_nClassCount ++;
  405. else if(nType == NODE_TYPE_RAWCODENUMBER)
  406. m_nCodeCount ++;
  408. if(nPos == -1)
  409. m_vTreeNode.push_back(treeNode);
  410. else
  411. m_vTreeNode.insert(m_vTreeNode.begin()+nPos, treeNode);
  412. }
  414. LRESULT CMainDlg::OnBeginLabelEdit(int /*idCtrl*/, LPNMHDR pNMHDR, BOOL& /*bHandled*/)
  415. {
  416. LPNMTVDISPINFO pTVDispInfo = reinterpret_cast<LPNMTVDISPINFO>(pNMHDR);
  417. // TODO: Add your control notification handler code here
  418. m_nTreeNodeIndex = GetTreeNodeIndex(pTVDispInfo->item.hItem);
  419. if(m_nTreeNodeIndex != -1)
  420. {
  421. if( (m_vTreeNode[m_nTreeNodeIndex].nType == NODE_TYPE_FILENAME) || 
  422. (m_vTreeNode[m_nTreeNodeIndex].nType == NODE_TYPE_RAWCODENUMBER) ||
  423. (m_vTreeNode[m_nTreeNodeIndex].nType == NODE_TYPE_RAWCODEMEMORY))
  424. {
  425. m_treeRawCode.EndEditLabelNow(TRUE);
  426. return 0;
  427. }
  429. if(NULL != m_vTreeNode[m_nTreeNodeIndex].szFront && 0 < _tcslen(m_vTreeNode[m_nTreeNodeIndex].szFront))
  430. {
  431. TCHAR *pDest;
  432. pDest = _tcsstr(pTVDispInfo->item.pszText, m_vTreeNode[m_nTreeNodeIndex].szFront);
  433. if (NULL != pDest && _tcslen(pDest) == _tcslen(pTVDispInfo->item.pszText))
  434. {
  435. if (m_vTreeNode[m_nTreeNodeIndex].nType == NODE_TYPE_RAWCODENAME)
  436. {
  437. if (!_tcscmp((pDest + _tcslen(m_vTreeNode[m_nTreeNodeIndex].szFront)), _T(RAWCODENAMEEMPTY)))
  438. {
  439. m_treeRawCode.GetEditControl().SetWindowText(_T(""));
  440. m_strEditControlText = SCM_String(pDest + _tcslen(m_vTreeNode[m_nTreeNodeIndex].szFront));
  441. }
  442. else
  443. {
  444. m_treeRawCode.GetEditControl().SetWindowText(pDest + _tcslen(m_vTreeNode[m_nTreeNodeIndex].szFront));
  445. m_strEditControlText = SCM_String(pDest + _tcslen(m_vTreeNode[m_nTreeNodeIndex].szFront));
  446. }
  447. }
  448. else if (m_vTreeNode[m_nTreeNodeIndex].nType == NODE_TYPE_RAWCODESTAT)
  449. {
  450.   TCHAR szStat[10] = {0};
  451.   _tcscpy(szStat, pDest + _tcslen(m_vTreeNode[m_nTreeNodeIndex].szFront));
  452.   if(!_tcscmp(szStat, _T("Disable")))
  453.   _tcscpy(szStat, _T("0"));
  454.   else if(!_tcscmp(szStat, _T("Enable")))
  455.   _tcscpy(szStat, _T("1"));
  456.   else if(!_tcscmp(szStat, _T("Lock")))
  457.   _tcscpy(szStat, _T("2"));
  458.   else if(_tcslen(szStat) == 0)
  459. _tcscpy(szStat, _T(""));
  460. else
  461.   _tcscpy(szStat, _T("3"));
  462.  
  463.   m_treeRawCode.GetEditControl().SetWindowText(szStat);
  464.   m_strEditControlText = SCM_String(szStat);
  466. //  RECT rect;
  467. //  m_treeRawCode.GetItemRect(pTVDispInfo->item.hItem, &rect, TRUE);
  468. //  hComboBox = comboBox.Create(m_treeRawCode.m_hWnd, rect, NULL, WS_BORDER | WS_CHILD | WS_VISIBLE | ES_AUTOHSCROLL | ES_AUTOVSCROLL | CBS_DROPDOWNLIST | CBS_DISABLENOSCROLL);
  469. //  comboBox.AddString(_T("Disable"));
  470. //  comboBox.AddString(_T("Enable"));
  471. //  comboBox.AddString(_T("Lock"));
  472. //  comboBox.ShowDropDown();
  473. //  comboBox.SetFocus();
  474. //  ::SetWindowLong(hComboBox, GWL_WNDPROC, (LONG)ComboBoxProc);
  475. }
  476. else
  477. {
  478. m_treeRawCode.GetEditControl().SetWindowText(pDest + _tcslen(m_vTreeNode[m_nTreeNodeIndex].szFront));
  479. m_strEditControlText = SCM_String(pDest + _tcslen(m_vTreeNode[m_nTreeNodeIndex].szFront));
  480. }
  481. }
  482. else
  483. {
  484. m_strEditControlText = SCM_String(pTVDispInfo->item.pszText);
  485. }
  486. }
  488. if(m_vTreeNode[m_nTreeNodeIndex].nLimitLength != -1)
  489. m_treeRawCode.GetEditControl().LimitText(m_vTreeNode[m_nTreeNodeIndex].nLimitLength);
  490. }
  492. return 0;
  493. }
  495. LRESULT CMainDlg::OnEndLabelEdit(int /*idCtrl*/, LPNMHDR pNMHDR, BOOL& /*bHandled*/)
  496. {
  497. LPNMTVDISPINFO pTVDispInfo = reinterpret_cast<LPNMTVDISPINFO>(pNMHDR);
  498. // TODO: Add your control notification handler code here
  499. if ((pTVDispInfo->item.mask | TVIF_TEXT) != pTVDispInfo->item.mask)
  500. return 0;
  502. if(m_nTreeNodeIndex != -1)
  503. {
  504. if( (m_vTreeNode[m_nTreeNodeIndex].nType == NODE_TYPE_FILENAME) || 
  505. (m_vTreeNode[m_nTreeNodeIndex].nType == NODE_TYPE_RAWCODENUMBER) ||
  506. (m_vTreeNode[m_nTreeNodeIndex].nType == NODE_TYPE_RAWCODEMEMORY))
  507. return 0;
  509. if (NULL != m_vTreeNode[m_nTreeNodeIndex].szValidChars && 0 < _tcslen(m_vTreeNode[m_nTreeNodeIndex].szValidChars))
  510. {
  511. int nTextLen = _tcslen(pTVDispInfo->item.pszText);
  512. for (int i = 0; i < nTextLen; i++)
  513. {
  514. if(NULL == _tcschr(m_vTreeNode[m_nTreeNodeIndex].szValidChars, pTVDispInfo->item.pszText[i]))
  515. {
  516. m_treeRawCode.EditLabel(pTVDispInfo->item.hItem);
  517. if(m_vTreeNode[m_nTreeNodeIndex].nLimitLength != -1)
  518. m_treeRawCode.GetEditControl().LimitText(m_vTreeNode[m_nTreeNodeIndex].nLimitLength);
  520. m_treeRawCode.GetEditControl().SetWindowText(m_strEditControlText.c_str());
  521.   EDITBALLOONTIP ebt;
  522. ZeroMemory(&ebt, sizeof(EDITBALLOONTIP));
  523. ebt.cbStruct = sizeof(ebt);
  524. TCHAR szText[300] = _T("Your input have some invalid words, please retry!nThe valid words:"");
  525. _tcscat(szText, m_vTreeNode[m_nTreeNodeIndex].szValidChars);
  526. _tcscat(szText, _T("""));
  527. ebt.pszText = szText;
  529. m_treeRawCode.GetEditControl().ShowBalloonTip(&ebt);
  530. return 0;
  531. }
  532. }
  533. }
  535. if (NULL != m_vTreeNode[m_nTreeNodeIndex].szInvalidChars && 0 < _tcslen(m_vTreeNode[m_nTreeNodeIndex].szInvalidChars))
  536. {
  537. int nTextLen = _tcslen(m_vTreeNode[m_nTreeNodeIndex].szInvalidChars);
  538. for (int i = 0; i < nTextLen; i++)
  539. {
  540. if(NULL != _tcschr(pTVDispInfo->item.pszText, m_vTreeNode[m_nTreeNodeIndex].szInvalidChars[i]))
  541. {
  542. m_treeRawCode.EditLabel(pTVDispInfo->item.hItem);
  543. if(m_vTreeNode[m_nTreeNodeIndex].nLimitLength != -1)
  544. m_treeRawCode.GetEditControl().LimitText(m_vTreeNode[m_nTreeNodeIndex].nLimitLength);
  546. m_treeRawCode.GetEditControl().SetWindowText(m_strEditControlText.c_str());
  547. EDITBALLOONTIP ebt;
  548. ZeroMemory(&ebt, sizeof(EDITBALLOONTIP));
  549. ebt.cbStruct = sizeof(ebt);
  550. TCHAR szText[300] = _T("Your input have some invalid words, please retry!nThe invalid words:"");
  551. _tcscat(szText, m_vTreeNode[m_nTreeNodeIndex].szInvalidChars);
  552. _tcscat(szText, _T("""));
  553. ebt.pszText = szText;
  555. m_treeRawCode.GetEditControl().ShowBalloonTip(&ebt);
  556. return 0;
  557. }
  558. }
  559. }
  561. if(NULL != m_vTreeNode[m_nTreeNodeIndex].szFront && 0 < _tcslen(m_vTreeNode[m_nTreeNodeIndex].szFront))
  562. {
  563. TCHAR szText[30] = {0};
  564. if(m_vTreeNode[m_nTreeNodeIndex].nType == NODE_TYPE_RAWCODESTAT)
  565. {
  566. if(_tcslen(pTVDispInfo->item.pszText) == 0)
  567. {
  568. _tcscpy(szText, _T("Disable"));
  569. _tcscpy(pTVDispInfo->item.pszText, _T("0"));
  570. }
  571. else
  572. {
  573. switch(_ttoi(pTVDispInfo->item.pszText))
  574. {
  575. case 0:
  576. _tcscpy(szText, _T("Disable"));
  577. break;
  578. case 1:
  579. _tcscpy(szText, _T("Enable"));
  580. break;
  581. case 2:
  582. _tcscpy(szText, _T("Lock"));
  583. break;
  584. default:
  585. _tcscpy(szText, _T("Unknown"));
  586. break;
  587. }
  588. }
  589. }
  590. else if(m_vTreeNode[m_nTreeNodeIndex].nType == NODE_TYPE_RAWCODENAME)
  591. {
  592. if(_tcslen(pTVDispInfo->item.pszText) == 0)
  593. _tcscpy(szText, _T(RAWCODENAMEEMPTY));
  594. else
  595. _tcscpy(szText, pTVDispInfo->item.pszText);
  596. }
  597. else if(m_vTreeNode[m_nTreeNodeIndex].nType == NODE_TYPE_RAWCODEMEMORYN)
  598. {
  599. int nLength = _tcslen(pTVDispInfo->item.pszText);
  600. if(nLength < 8)
  601. {
  602. ZeroMemory(szText, sizeof(szText));
  603. _tcsncpy(szText, _T("00000000"), 8-nLength);
  604. _tcscat(szText, pTVDispInfo->item.pszText);
  605. }
  606. else
  607. _tcscpy(szText, pTVDispInfo->item.pszText);
  608. }
  609. else
  610. _tcscpy(szText, pTVDispInfo->item.pszText);
  612. SCM_String strText = SCM_String(m_vTreeNode[m_nTreeNodeIndex].szFront);
  613. strText += SCM_String(szText);
  614. m_treeRawCode.SetItemText(pTVDispInfo->item.hItem, strText.c_str());
  615. }
  617. if(m_vTreeNode[m_nTreeNodeIndex].nType == NODE_TYPE_GAMEINFO)
  618. {
  619. SCM_String strText = SCM_String(m_vTreeNode[m_nTreeNodeIndex].szFront);
  620. strText += SCM_String(pTVDispInfo->item.pszText);
  621. _tcscpy(m_vTreeNode[m_nTreeNodeIndex].szValue, strText.c_str());
  622. }
  623. else
  624. {
  625. _tcscpy(m_vTreeNode[m_nTreeNodeIndex].szValue, pTVDispInfo->item.pszText);
  626. }
  628. }
  629. else
  630. m_treeRawCode.SetItemText(pTVDispInfo->item.hItem, pTVDispInfo->item.pszText);
  632. m_nTreeNodeIndex = -2;
  634. return 0;
  635. }
  637. int CMainDlg::GetTreeNodeIndex(HTREEITEM hTreeItem)
  638. {
  639. for(int i = 0; i < m_vTreeNode.size(); i++)
  640. {
  641. if(hTreeItem == m_vTreeNode[i].hItem)
  642. return i;
  643. }
  644. return -1;
  645. }
  647. //LRESULT CMainDlg::OnNMDblclkRawcodeTree(int /*idCtrl*/, LPNMHDR pNMHDR, BOOL& bHandled)
  648. void CMainDlg::OnLButtonDoubleClick_Tree(UINT nFlags, CPoint point)
  649. {
  650. // TODO: Add your control notification handler code here
  651. m_bShouldTrigger = FALSE;
  653. int n = GetTreeNodeIndex(m_treeRawCode.GetSelectedItem());
  654. if(m_vTreeNode[n].nType == NODE_TYPE_RAWCODEMEMORY)
  655. {
  656. GetMemoryInfo(n);
  657. if(m_treeRawCode.GetItemState(m_treeRawCode.GetSelectedItem(), TVIS_EXPANDED) != TVIS_EXPANDED)
  658. m_treeRawCode.Expand(m_treeRawCode.GetSelectedItem(), TVE_EXPAND);
  659. return;
  660. }
  662. SetMsgHandled(FALSE);
  663. }
  665. int CMainDlg::GetMemoryInfo(int nTreeNodeIndex)
  666. {
  667. CWizardDlg dlgWizard;
  669. int nMemoryType;
  670. switch(m_vTreeNode[nTreeNodeIndex+1].szValue[0])
  671. {
  672. case '0':
  673. case '1':
  674. case '2':
  675. nMemoryType = MEMORY_DIRECT;
  676. break;
  677. case '3':
  678. nMemoryType = MEMORY_VARIABLE;
  679. break;
  680. case '4':
  681. case '8':
  682. nMemoryType = MEMORY_COMPRESS;
  683.     break;
  684. case 'D':
  685. case 'd':
  686. case 'E':
  687. case 'e':
  688. nMemoryType = MEMORY_CONDITION;
  689.     break;
  690. case '7':
  691. nMemoryType = MEMORY_CALC;
  692. break;
  693. case '5':
  694. nMemoryType = MEMORY_COPY;
  695. break;
  696. case '6':
  697. nMemoryType = MEMORY_POINTER;
  698.     break;
  699. case 'B':
  700. case 'b':
  701. case 'C':
  702. case 'c':
  703. nMemoryType = MEMORY_STOP;
  704.     break;
  705. default:
  706. nMemoryType = MEMORY_UNKNOWN;
  707.     break;
  708. }
  710. if( nMemoryType == MEMORY_DIRECT &&
  711. !_tcsicmp(m_vTreeNode[nTreeNodeIndex+1].szValue, _T("00000000")) &&
  712. !_tcsicmp(m_vTreeNode[nTreeNodeIndex+2].szValue, _T("00000000")) &&
  713. !_tcsicmp(m_vTreeNode[nTreeNodeIndex+3].szValue, _T("00000000")) &&
  714. !_tcsicmp(m_vTreeNode[nTreeNodeIndex+4].szValue, _T("00000000")))
  715. nMemoryType = MEMORY_UNKNOWN;
  718. ParseMemoryInfo(m_vTreeNode[nTreeNodeIndex+1].szValue, m_vTreeNode[nTreeNodeIndex+2].szValue, m_vTreeNode[nTreeNodeIndex+3].szValue, 
  719. m_vTreeNode[nTreeNodeIndex+4].szValue, dlgWizard.m_pType.m_memInfo);
  721. if(IDOK == dlgWizard.DoModal())
  722. MessageBox(_T("Wizard Ok"));
  723. return 0;
  724. }
  726. LRESULT CMainDlg::OnTvnKeydownRawcodeTree(int /*idCtrl*/, LPNMHDR pNMHDR, BOOL& /*bHandled*/)
  727. {
  728. LPNMTVKEYDOWN pTVKeyDown = reinterpret_cast<LPNMTVKEYDOWN>(pNMHDR);
  729. // TODO: Add your control notification handler code here
  730. if(!m_treeRawCode.GetSelectedItem())
  731. return 0;
  733. if(pTVKeyDown->wVKey == VK_DELETE)
  734. {
  735. int nType = m_vTreeNode[GetTreeNodeIndex(m_treeRawCode.GetSelectedItem())].nType;
  736. if(nType == NODE_TYPE_FILENAME || nType == NODE_TYPE_GAMEINFO)
  737. {
  738. HTREEITEM hChildItem = m_treeRawCode.GetChildItem(m_hRoot);
  739. HTREEITEM hNextItem;
  740. while(hChildItem != NULL)
  741. {
  742. if(m_vTreeNode[GetTreeNodeIndex(hChildItem)].nType != NODE_TYPE_GAMEINFO)
  743. {
  744. hNextItem = m_treeRawCode.GetNextSiblingItem(hChildItem);
  745. DeleteItemAndChild(hChildItem);
  746. hChildItem = hNextItem;
  747. }
  748. else
  749. hChildItem = m_treeRawCode.GetNextSiblingItem(hChildItem);
  750. }
  751. }
  752. else if(nType == NODE_TYPE_CLASSNAME || nType == NODE_TYPE_RAWCODENUMBER)
  753. {
  754. DeleteItemAndChild(m_treeRawCode.GetSelectedItem());
  755. }
  756. }
  757. else if(pTVKeyDown->wVKey == VK_INSERT)
  758. {
  759. if(m_treeRawCode.GetCount() > 0)
  760. {
  761. if((m_nCodeCount >= 500) || (m_nClassCount >= 50))
  762. MessageBox(_T("One file only can contain 50 Classes and 500 Raw Codes!"));
  764. int nType = m_vTreeNode[GetTreeNodeIndex(m_treeRawCode.GetSelectedItem())].nType;
  765. if(nType == NODE_TYPE_FILENAME || nType == NODE_TYPE_GAMEINFO || nType == NODE_TYPE_CLASSNAME)
  766. {
  767. AddItem(m_treeRawCode.GetSelectedItem());
  768. }
  769. }
  770. }
  771. else if(pTVKeyDown->wVKey == VK_F2)
  772. {
  773. m_treeRawCode.EditLabel(m_treeRawCode.GetSelectedItem());
  774. }
  775. else if(pTVKeyDown->wVKey == VK_APPS)
  776. {
  777. POINT point;
  778. RECT rect;
  779. if(!m_treeRawCode.GetItemRect(m_treeRawCode.GetSelectedItem(), &rect, TRUE))
  780. return 0;
  782. point.x = rect.left + (rect.bottom - rect.top)/2;
  783. point.y = rect.top + (rect.bottom - rect.top)/2;
  785. ::ClientToScreen(m_treeRawCode.m_hWnd, &point);
  786. ShowContextMenu(point);
  787. }
  788. #if defined(_DEBUG)
  789. else if(pTVKeyDown->wVKey == VK_F5)
  790. {
  791. TCHAR szType[50] = {0};
  792. FILE *fp = _tfopen(_T("c:\tree1.txt"), _T("w"));
  793. for(int i = 0; i < m_vTreeNode.size(); i++)
  794. {
  795. switch(m_vTreeNode[i].nType)
  796. {
  797. case NODE_TYPE_FILENAME:
  798. _tcscpy(szType, _T("NODE_TYPE_FILENAMEt"));
  799. break;
  800. case NODE_TYPE_GAMEINFO:
  801. _tcscpy(szType, _T("NODE_TYPE_GAMEINFOt"));
  802. break;
  803. case NODE_TYPE_CLASSNAME:
  804. _tcscpy(szType, _T("NODE_TYPE_CLASSNAMEt"));
  805.     break;
  806. case NODE_TYPE_RAWCODENUMBER:
  807. _tcscpy(szType, _T("NODE_TYPE_RAWCODENUMBERt"));
  808.     break;
  809. case NODE_TYPE_RAWCODENAME:
  810. _tcscpy(szType, _T("NODE_TYPE_RAWCODENAMEt"));
  811. break;
  812. case NODE_TYPE_RAWCODESTAT:
  813. _tcscpy(szType, _T("NODE_TYPE_RAWCODESTATt"));
  814. break;
  815. case NODE_TYPE_RAWCODEMEMORY:
  816. _tcscpy(szType, _T("NODE_TYPE_RAWCODEMEMORYt"));
  817. break;
  818. case NODE_TYPE_RAWCODEMEMORYN:
  819. _tcscpy(szType, _T("NODE_TYPE_RAWCODEMEMORYN"));
  820. break;
  821. default:
  822.     break;
  823. }
  824. _ftprintf(fp, _T("%dt%st0x%0.8xt%s%sn"), i, szType, m_vTreeNode[i].hItem, m_vTreeNode[i].szFront, m_vTreeNode[i].szValue);
  825. }
  826. fclose(fp);
  827. }
  828. #endif
  830. return 0;
  831. }
  833. void CMainDlg::DeleteItemAndChild(HTREEITEM hItem, BOOL bMoveItem)
  834. {
  835. HTREEITEM hLastItem;
  836. if(hItem != NULL && m_treeRawCode.ItemHasChildren(hItem))
  837. {
  838. HTREEITEM hNextItem;
  839. HTREEITEM hChildItem = m_treeRawCode.GetChildItem(hItem);
  841. while (hChildItem != NULL && hChildItem != hItem)
  842. {
  843. hLastItem = hChildItem;
  844. int n = GetTreeNodeIndex(hLastItem);
  845. if(!bMoveItem)
  846. if(m_vTreeNode[n].nType == NODE_TYPE_CLASSNAME)
  847. m_nClassCount --;
  848. else if(m_vTreeNode[n].nType == NODE_TYPE_RAWCODENUMBER)
  849. m_nCodeCount --;
  851. if(n != -1)
  852. m_vTreeNode.erase(m_vTreeNode.begin() + n);
  854. hNextItem = m_treeRawCode.GetChildItem(hChildItem);
  855. if(NULL != hNextItem)
  856. {
  857. hChildItem = hNextItem;
  858. }
  859. else
  860. {
  861. hNextItem = m_treeRawCode.GetNextSiblingItem(hChildItem);
  862. if(NULL == hNextItem)
  863. hNextItem = m_treeRawCode.GetParentItem(hChildItem);
  864. m_treeRawCode.DeleteItem(hChildItem);
  865. hChildItem = hNextItem;
  866. }
  867. }
  868. }
  870. if(hItem != m_hRoot)
  871. {
  872. int n = GetTreeNodeIndex(hItem);
  873. if(!bMoveItem)
  874. if(m_vTreeNode[n].nType == NODE_TYPE_CLASSNAME)
  875. m_nClassCount --;
  876. else if(m_vTreeNode[n].nType == NODE_TYPE_RAWCODENUMBER)
  877. m_nCodeCount --;
  879. if(n != -1)
  880. m_vTreeNode.erase(m_vTreeNode.begin() + n);
  881. m_treeRawCode.DeleteItem(hItem);
  882. }
  884. if(!bMoveItem)
  885. UpdateClassCodeCount();
  886. }
  888. void CMainDlg::AddItem(HTREEITEM hTreeItem)
  889. {
  890. if(hTreeItem == NULL)
  891. {
  892. HTREEITEM hTreeItem;
  893. if(m_hRoot == NULL)
  894. m_hRoot = InsertTreeItem(_T("FileName"), TVI_ROOT, TVI_ROOT);
  895. else
  896. m_treeRawCode.SetItemText(m_hRoot, _T("FileName"));
  897. AddTreeNode(m_hRoot, MAX_PATH, _T(""), _T(""), _T(""), _T("FileName"), NODE_TYPE_FILENAME);
  899. // ID
  900. hTreeItem = InsertTreeItem(_T("ID: GameID"), m_hRoot, m_hRoot);
  901. AddTreeNode(hTreeItem, 12, _T(""), _T(""), _T("ID: "), _T("ID: GameID"), NODE_TYPE_GAMEINFO);
  903. // Name
  904. hTreeItem = InsertTreeItem(_T("NAME: Game Name"), m_hRoot, hTreeItem);
  905. AddTreeNode(hTreeItem, 30, _T(""), _T(""), _T("NAME: "), _T("NAME: Game Name"), NODE_TYPE_GAMEINFO);
  907. GetDlgItem(IDC_SAVE).EnableWindow(0);
  908. m_treeRawCode.EditLabel(m_treeRawCode.GetPrevSiblingItem(hTreeItem));
  910. return;
  911. }
  913. HTREEITEM hLastItem;
  914. int nType = m_vTreeNode[GetTreeNodeIndex(m_treeRawCode.GetSelectedItem())].nType;
  915. if(nType == NODE_TYPE_FILENAME || nType == NODE_TYPE_GAMEINFO)
  916. {
  917. hLastItem = m_hRoot;
  918. if(m_hRoot != NULL && m_treeRawCode.ItemHasChildren(m_hRoot))
  919. {
  920. HTREEITEM hChildItem = m_treeRawCode.GetChildItem(m_hRoot);
  921. while (NULL != hChildItem)
  922. {
  923. hLastItem = hChildItem;
  924. hChildItem = m_treeRawCode.GetNextSiblingItem(hChildItem);
  925. }
  926. }
  928. hTreeItem = InsertTreeItem(_T("Class Name: "), m_hRoot, hLastItem);
  929. AddTreeNode(hTreeItem, 19, _T(""), _T(""), _T("Class Name: "), _T(""), NODE_TYPE_CLASSNAME, m_vTreeNode.size());
  930. m_treeRawCode.EditLabel(hTreeItem);
  931. }
  932. else if(nType == NODE_TYPE_CLASSNAME)
  933. {
  934. hLastItem = hTreeItem;
  935. int nCodeNumber = 1;
  936. TCHAR szCodeNumber[5] = {0};
  937. TCHAR szDisplayData[100] = {0};
  938. int nPos;
  939. if(hTreeItem != NULL && m_treeRawCode.ItemHasChildren(hTreeItem))
  940. {
  941. HTREEITEM hChildItem = m_treeRawCode.GetChildItem(hTreeItem);
  942. while (NULL != hChildItem)
  943. {
  944. hLastItem = hChildItem;
  945. hChildItem = m_treeRawCode.GetNextSiblingItem(hChildItem);
  946. nCodeNumber ++;
  947. }
  948. }
  950. HTREEITEM hItem = m_treeRawCode.GetNextSiblingItem(m_treeRawCode.GetParentItem(hLastItem));
  951. if(hItem == NULL)
  952. nPos = m_vTreeNode.size();
  953. else
  954. nPos = GetTreeNodeIndex(hItem);
  956. // CodeItem
  957. _itot(nCodeNumber++, szCodeNumber, 10);
  958. _tcscpy(szDisplayData, _T("Code "));
  959. _tcscat(szDisplayData, szCodeNumber);
  960. hTreeItem = InsertTreeItem(szDisplayData, hTreeItem, hLastItem);
  961. AddTreeNode(hTreeItem, MAX_PATH, _T(""), _T(""), _T("Code "), szCodeNumber, NODE_TYPE_RAWCODENUMBER, nPos++);
  963. // CodeName
  964. hLastItem = InsertTreeItem(_T("Code Name: !NoName"), hTreeItem, hLastItem);
  965. AddTreeNode(hLastItem, 9, _T(""), _T(" "), _T("Code Name: "), _T(RAWCODENAMEEMPTY), NODE_TYPE_RAWCODENAME, nPos++);
  967. // ItemStat
  968. hLastItem = InsertTreeItem(_T("Code Stat: Disable"), hTreeItem, hLastItem);
  969. AddTreeNode(hLastItem, 1, _T("012"), _T(""), _T("Code Stat: "), _T("0"), NODE_TYPE_RAWCODESTAT, nPos++);
  971. // MemTitle
  972. HTREEITEM hMemoryItem = InsertTreeItem(_T("Memory"), hTreeItem, hLastItem);
  973. AddTreeNode(hMemoryItem, MAX_PATH, _T(""), _T(""), _T(""), _T("Memory"), NODE_TYPE_RAWCODEMEMORY, nPos++);
  975. // Mem1
  976. hLastItem = InsertTreeItem(_T("Memory1: 0x00000000"), hMemoryItem, hMemoryItem);
  977. AddTreeNode(hLastItem, 8, _T("0123456789ABCDEFabcdef"), _T(""), _T("Memory1: 0x"), _T("00000000"), NODE_TYPE_RAWCODEMEMORYN, nPos++);
  979. // Mem2
  980. hLastItem = InsertTreeItem(_T("Memory2: 0x00000000"), hMemoryItem, hLastItem);
  981. AddTreeNode(hLastItem, 8, _T("0123456789ABCDEFabcdef"), _T(""), _T("Memory2: 0x"), _T("00000000"), NODE_TYPE_RAWCODEMEMORYN, nPos++);
  983. // Mem3
  984. hLastItem = InsertTreeItem(_T("Memory3: 0x00000000"), hMemoryItem, hLastItem);
  985. AddTreeNode(hLastItem, 8, _T("0123456789ABCDEFabcdef"), _T(""), _T("Memory3: 0x"), _T("00000000"), NODE_TYPE_RAWCODEMEMORYN, nPos++);
  987. // Mem4
  988. hLastItem = InsertTreeItem(_T("Memory4: 0x00000000"), hMemoryItem, hLastItem);
  989. AddTreeNode(hLastItem, 8, _T("0123456789ABCDEFabcdef"), _T(""), _T("Memory4: 0x"), _T("00000000"), NODE_TYPE_RAWCODEMEMORYN, nPos++);
  991. // m_treeRawCode.Expand(hTreeItem, TVE_EXPAND);
  992. hTreeItem = m_treeRawCode.GetChildItem(hTreeItem);
  993. m_treeRawCode.EnsureVisible(hTreeItem);
  994. m_treeRawCode.EditLabel(hTreeItem);
  995. }
  997. UpdateClassCodeCount();
  998. }
  1000. void CMainDlg::ShowContextMenu(POINT& point)
  1001. {
  1002. CMenuHandle menu;
  1003. menu.LoadMenu(IDR_CONTEXTMENU);
  1004. menu = menu.GetSubMenu(0);
  1006. if(m_treeRawCode.GetCount() <= 0)
  1007. {
  1008. MENUITEMINFO mii;
  1009. SCM_String strMenuItem;
  1011. ZeroMemory(&mii, sizeof(MENUITEMINFO));
  1012. mii.cbSize = sizeof(MENUITEMINFO);
  1013. mii.fMask |= MIIM_STRING;
  1014. mii.dwTypeData = _T("Create a New Raw Code File");
  1015. mii.cch = _tcslen(mii.dwTypeData) + 1;
  1016. menu.SetMenuItemInfo(ID_CONTEXT_INSERT, FALSE, &mii);
  1017. menu.EnableMenuItem(ID_CONTEXT_INSERT, MF_ENABLED);
  1019. menu.TrackPopupMenu(TPM_VERTICAL, point.x, point.y, m_hWnd);
  1021. return;
  1022. }
  1023. int n = GetTreeNodeIndex(m_treeRawCode.GetSelectedItem());
  1024. MENUITEMINFO mii;
  1025. SCM_String strMenuItem;
  1026. if(n != -1)
  1027. {
  1028. switch(m_vTreeNode[n].nType)
  1029. {
  1030. case NODE_TYPE_FILENAME:
  1031. ZeroMemory(&mii, sizeof(MENUITEMINFO));
  1032. mii.cbSize = sizeof(MENUITEMINFO);
  1033. mii.fMask |= MIIM_STRING;
  1034. mii.dwTypeData = _T("Insert New Raw Code Class");
  1035. mii.cch = _tcslen(mii.dwTypeData) + 1;
  1036. menu.SetMenuItemInfo(ID_CONTEXT_INSERT, FALSE, &mii);
  1037. menu.EnableMenuItem(ID_CONTEXT_INSERT, MF_ENABLED);
  1039. mii.fMask |= MIIM_STRING;
  1040. strMenuItem = _T("Clean This Raw Code File?");
  1041. mii.dwTypeData = (LPTSTR)(strMenuItem.c_str());
  1042. mii.cch = _tcslen(mii.dwTypeData) + 1;
  1043. menu.SetMenuItemInfo(ID_CONTEXT_DELETE, FALSE, &mii);
  1044. menu.EnableMenuItem(ID_CONTEXT_DELETE, MF_ENABLED);
  1045. break;
  1046. case NODE_TYPE_GAMEINFO:
  1047. ZeroMemory(&mii, sizeof(MENUITEMINFO));
  1048. mii.cbSize = sizeof(MENUITEMINFO);
  1049. mii.fMask |= MIIM_STRING;
  1050. mii.dwTypeData = _T("Insert New Raw Code Class");
  1051. mii.cch = _tcslen(mii.dwTypeData) + 1;
  1052. menu.SetMenuItemInfo(ID_CONTEXT_INSERT, FALSE, &mii);
  1053. menu.EnableMenuItem(ID_CONTEXT_INSERT, MF_ENABLED);
  1055. mii.fMask |= MIIM_STRING;
  1056. strMenuItem = _T("Clean This Raw Code File?");
  1057. mii.dwTypeData = (LPTSTR)(strMenuItem.c_str());
  1058. mii.cch = _tcslen(mii.dwTypeData) + 1;
  1059. menu.SetMenuItemInfo(ID_CONTEXT_DELETE, FALSE, &mii);
  1060. menu.EnableMenuItem(ID_CONTEXT_DELETE, MF_ENABLED);
  1061. break;
  1062. case NODE_TYPE_CLASSNAME:
  1063. ZeroMemory(&mii, sizeof(MENUITEMINFO));
  1064. mii.cbSize = sizeof(MENUITEMINFO);
  1065. mii.fMask |= MIIM_STRING;
  1066. strMenuItem = _T("Insert New Raw Code Under Class: "") + SCM_String(m_vTreeNode[n].szValue) + _T(""");
  1067. mii.dwTypeData = (LPTSTR)(strMenuItem.c_str());
  1068. mii.cch = _tcslen(mii.dwTypeData) + 1;
  1069. menu.SetMenuItemInfo(ID_CONTEXT_INSERT, FALSE, &mii);
  1070. menu.EnableMenuItem(ID_CONTEXT_INSERT, MF_ENABLED);
  1072. mii.fMask |= MIIM_STRING;
  1073. strMenuItem = _T("Delete Class: "") + SCM_String(m_vTreeNode[n].szValue) + _T(""?");
  1074. mii.dwTypeData = (LPTSTR)(strMenuItem.c_str());
  1075. mii.cch = _tcslen(mii.dwTypeData) + 1;
  1076. menu.SetMenuItemInfo(ID_CONTEXT_DELETE, FALSE, &mii);
  1077. menu.EnableMenuItem(ID_CONTEXT_DELETE, MF_ENABLED);
  1079. //  if(m_treeRawCode.GetNextSiblingItem(m_treeRawCode.GetSelectedItem()) != NULL)
  1080. //  menu.EnableMenuItem(ID_CONTEXT_MOVEDOWN, MF_ENABLED);
  1081. //  if((m_treeRawCode.GetPrevSiblingItem(m_treeRawCode.GetSelectedItem()) != NULL) && 
  1082. //  (m_treeRawCode.GetPrevSiblingItem(m_treeRawCode.GetSelectedItem())) != m_treeRawCode.GetNextSiblingItem(m_treeRawCode.GetChildItem(m_hRoot)))
  1083. //  menu.EnableMenuItem(ID_CONTEXT_MOVEUP, MF_ENABLED);
  1084. break;
  1085. case NODE_TYPE_RAWCODENUMBER:
  1086. ZeroMemory(&mii, sizeof(MENUITEMINFO));
  1087. mii.cbSize = sizeof(MENUITEMINFO);
  1088. mii.fMask |= MIIM_STRING;
  1089. strMenuItem = _T("Delete Raw Code: "") + SCM_String(m_vTreeNode[n].szValue) + _T(""?");
  1090. mii.dwTypeData = (LPTSTR)(strMenuItem.c_str());
  1091. mii.cch = _tcslen(mii.dwTypeData) + 1;
  1092. menu.SetMenuItemInfo(ID_CONTEXT_DELETE, FALSE, &mii);
  1093. menu.EnableMenuItem(ID_CONTEXT_DELETE, MF_ENABLED);
  1095. if(m_treeRawCode.GetNextSiblingItem(m_treeRawCode.GetSelectedItem()) != NULL)
  1096. menu.EnableMenuItem(ID_CONTEXT_MOVEDOWN, MF_ENABLED);
  1097. if(m_treeRawCode.GetPrevSiblingItem(m_treeRawCode.GetSelectedItem()) != NULL)
  1098. menu.EnableMenuItem(ID_CONTEXT_MOVEUP, MF_ENABLED);
  1099. break;
  1100. }
  1101. }
  1103. menu.TrackPopupMenu(TPM_VERTICAL, point.x, point.y, m_hWnd);
  1104. }
  1106. LRESULT CMainDlg::OnNMRclickRawcodeTree(int /*idCtrl*/, LPNMHDR pNMHDR, BOOL& /*bHandled*/)
  1107. {
  1108. // TODO: Add your control notification handler code here
  1109. POINT point;
  1111. if(m_treeRawCode.GetSelectedItem())
  1112. {
  1113. GetCursorPos(&point);
  1114. ScreenToClient(&point);
  1116. RECT rect;
  1117. ::GetWindowRect(m_treeRawCode.m_hWnd, &rect);
  1119. RECT rect2;
  1120. ::GetWindowRect(m_hWnd, &rect2);
  1122. point.x = point.x - (rect.left - rect2.left);
  1123. point.y = point.y - (rect.top - rect2.top) + GetSystemMetrics(SM_CYCAPTION) + 1;
  1125. UINT uFlag;
  1126. HTREEITEM h1 = m_treeRawCode.HitTest(point, &uFlag);
  1127. if(h1 == NULL)
  1128. return 0;
  1130. if(!m_treeRawCode.SelectItem(h1))
  1131. return 0;
  1132. }
  1134. GetCursorPos(&point);
  1135. ShowContextMenu(point);
  1136. return 0;
  1137. }
  1139. LRESULT CMainDlg::OnContextInsert(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
  1140. {
  1141. // TODO: Add your command handler code here
  1143. if(m_treeRawCode.GetCount() <= 0)
  1144. {
  1145. AddItem(NULL);
  1146. m_treeRawCode.SetFocus();
  1147. m_treeRawCode.Expand(m_hRoot);
  1148. }
  1149. else
  1150. {
  1151. if((m_nCodeCount >= 500) || (m_nClassCount >= 50))
  1152. MessageBox(_T("One file only can contain 50 Classes and 500 Raw Codes!"));
  1154. int nType = m_vTreeNode[GetTreeNodeIndex(m_treeRawCode.GetSelectedItem())].nType;
  1155. if(nType == NODE_TYPE_FILENAME || nType == NODE_TYPE_GAMEINFO || nType == NODE_TYPE_CLASSNAME)
  1156. {
  1157. AddItem(m_treeRawCode.GetSelectedItem());
  1158. }
  1159. }
  1160. return 0;
  1161. }
  1163. LRESULT CMainDlg::OnContextDelete(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
  1164. {
  1165. // TODO: Add your command handler code here
  1167.   int nType = m_vTreeNode[GetTreeNodeIndex(m_treeRawCode.GetSelectedItem())].nType;
  1168.   if(nType == NODE_TYPE_FILENAME || nType == NODE_TYPE_GAMEINFO)
  1169.   {
  1170. HTREEITEM hChildItem = m_treeRawCode.GetChildItem(m_hRoot);
  1171. HTREEITEM hNextItem;
  1172. while(hChildItem != NULL)
  1173. {
  1174. if(m_vTreeNode[GetTreeNodeIndex(hChildItem)].nType != NODE_TYPE_GAMEINFO)
  1175. {
  1176. hNextItem = m_treeRawCode.GetNextSiblingItem(hChildItem);
  1177. DeleteItemAndChild(hChildItem);
  1178. hChildItem = hNextItem;
  1179. }
  1180. else
  1181. hChildItem = m_treeRawCode.GetNextSiblingItem(hChildItem);
  1182. }
  1183.   }
  1184. else if(nType == NODE_TYPE_CLASSNAME || nType == NODE_TYPE_RAWCODENUMBER)
  1185. {
  1186. DeleteItemAndChild(m_treeRawCode.GetSelectedItem());
  1187. }
  1189. return 0;
  1190. }
  1192. LRESULT CMainDlg::OnContextMoveUp(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
  1193. {
  1194. // TODO: Add your command handler code here
  1195. HTREEITEM hTreeItem = m_treeRawCode.GetSelectedItem();
  1196. HTREEITEM hParent = m_treeRawCode.GetParentItem(hTreeItem);
  1197. HTREEITEM hAfter = m_treeRawCode.GetPrevSiblingItem(m_treeRawCode.GetPrevSiblingItem(hTreeItem));
  1199. if(hAfter == NULL)
  1200. hAfter = TVI_FIRST;
  1202. BOOL bExpanded = FALSE;
  1203. if(m_treeRawCode.GetItemState(hTreeItem, TVIS_EXPANDED) == TVIS_EXPANDED)
  1204. bExpanded = TRUE;
  1206. hTreeItem = MoveNode(hTreeItem, hParent, hAfter);
  1207. m_treeRawCode.SelectItem(hTreeItem);
  1209. if(bExpanded)
  1210. m_treeRawCode.Expand(hTreeItem);
  1211. return 0;
  1212. }
  1214. LRESULT CMainDlg::OnContextMoveDown(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
  1215. {
  1216. // TODO: Add your command handler code here
  1217. HTREEITEM hTreeItem = m_treeRawCode.GetSelectedItem();
  1218. HTREEITEM hParent = m_treeRawCode.GetParentItem(hTreeItem);
  1219. HTREEITEM hAfter = m_treeRawCode.GetNextSiblingItem(hTreeItem);
  1221. BOOL bExpanded = FALSE;
  1222. if(m_treeRawCode.GetItemState(hTreeItem, TVIS_EXPANDED) == TVIS_EXPANDED)
  1223. bExpanded = TRUE;
  1225. hTreeItem = MoveNode(hTreeItem, hParent, hAfter);
  1226. m_treeRawCode.SelectItem(hTreeItem);
  1228. if(bExpanded)
  1229. m_treeRawCode.Expand(hTreeItem);
  1230. return 0;
  1231. }
  1233. LRESULT CMainDlg::OnMoveUp(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
  1234. {
  1235. HTREEITEM hTreeItem;
  1236. HTREEITEM hParent;
  1237. HTREEITEM hAfter;
  1238. BOOL bExpanded = FALSE;
  1240. hTreeItem = m_treeRawCode.GetSelectedItem();
  1241. if(hTreeItem == NULL)
  1242. return FALSE;
  1244. if(m_vTreeNode[GetTreeNodeIndex(hTreeItem)].nType != NODE_TYPE_RAWCODENUMBER)
  1245. return FALSE;
  1247. if(m_treeRawCode.GetPrevSiblingItem(hTreeItem) == NULL)
  1248. return FALSE;
  1250. hParent = m_treeRawCode.GetParentItem(hTreeItem);
  1251. hAfter = m_treeRawCode.GetPrevSiblingItem(m_treeRawCode.GetPrevSiblingItem(hTreeItem));
  1253. if(m_treeRawCode.GetItemState(hTreeItem, TVIS_EXPANDED) == TVIS_EXPANDED)
  1254. bExpanded = TRUE;
  1256. if(hAfter == NULL)
  1257. hAfter = TVI_FIRST;
  1259. hTreeItem = MoveNode(hTreeItem, hParent, hAfter);
  1260. m_treeRawCode.SelectItem(hTreeItem);
  1261. if(bExpanded)
  1262. m_treeRawCode.Expand(hTreeItem);
  1264. return TRUE;
  1265. }
  1267. LRESULT CMainDlg::OnMoveDown(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
  1268. {
  1269. HTREEITEM hTreeItem;
  1270. HTREEITEM hParent;
  1271. HTREEITEM hAfter;
  1272. BOOL bExpanded = FALSE;
  1274. hTreeItem = m_treeRawCode.GetSelectedItem();
  1275. if(hTreeItem == NULL)
  1276. return FALSE;
  1278. if(m_vTreeNode[GetTreeNodeIndex(hTreeItem)].nType != NODE_TYPE_RAWCODENUMBER)
  1279. return FALSE;
  1281. if(m_treeRawCode.GetNextSiblingItem(hTreeItem) == NULL)
  1282. return FALSE;
  1284. hParent = m_treeRawCode.GetParentItem(hTreeItem);
  1285. hAfter = m_treeRawCode.GetNextSiblingItem(hTreeItem);
  1287. if(m_treeRawCode.GetItemState(hTreeItem, TVIS_EXPANDED) == TVIS_EXPANDED)
  1288. bExpanded = TRUE;
  1290. hTreeItem = MoveNode(hTreeItem, hParent, hAfter);
  1291. m_treeRawCode.SelectItem(hTreeItem);
  1292. if(bExpanded)
  1293. m_treeRawCode.Expand(hTreeItem);
  1295. return TRUE;
  1296. }
  1298. LRESULT CMainDlg::OnRebuildNumber(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
  1299. {
  1300. RebuildCodeNumber();
  1301. return TRUE;
  1302. }
  1304. void CMainDlg::OnHotKey_Tree(int nHotKeyID, UINT uModifiers, UINT uVirtKey)
  1305. {
  1306. HTREEITEM hTreeItem;
  1307. HTREEITEM hParent;
  1308. HTREEITEM hAfter;
  1309. BOOL bExpanded = FALSE;
  1310. switch(nHotKeyID)
  1311. {
  1312. case ID_ACCELERATOR_MOVEUP:
  1313. hTreeItem = m_treeRawCode.GetSelectedItem();
  1314. if(m_vTreeNode[GetTreeNodeIndex(hTreeItem)].nType != NODE_TYPE_RAWCODENUMBER)
  1315. return;
  1317. if(m_treeRawCode.GetPrevSiblingItem(hTreeItem) == NULL)
  1318. return;
  1320. hParent = m_treeRawCode.GetParentItem(hTreeItem);
  1321. hAfter = m_treeRawCode.GetPrevSiblingItem(m_treeRawCode.GetPrevSiblingItem(hTreeItem));
  1323. if(m_treeRawCode.GetItemState(hTreeItem, TVIS_EXPANDED) == TVIS_EXPANDED)
  1324. bExpanded = TRUE;
  1326. if(hAfter == NULL)
  1327. hAfter = TVI_FIRST;
  1329. hTreeItem = MoveNode(hTreeItem, hParent, hAfter);
  1330. m_treeRawCode.SelectItem(hTreeItem);
  1331. if(bExpanded)
  1332. m_treeRawCode.Expand(hTreeItem);
  1333. break;
  1334. case ID_ACCELERATOR_MOVEDOWN:
  1335. hTreeItem = m_treeRawCode.GetSelectedItem();
  1336. if(m_vTreeNode[GetTreeNodeIndex(hTreeItem)].nType != NODE_TYPE_RAWCODENUMBER)
  1337. return;
  1339. if(m_treeRawCode.GetNextSiblingItem(hTreeItem) == NULL)
  1340. return;
  1342. hParent = m_treeRawCode.GetParentItem(hTreeItem);
  1343. hAfter = m_treeRawCode.GetNextSiblingItem(hTreeItem);
  1345. if(m_treeRawCode.GetItemState(hTreeItem, TVIS_EXPANDED) == TVIS_EXPANDED)
  1346. bExpanded = TRUE;
  1348. hTreeItem = MoveNode(hTreeItem, hParent, hAfter);
  1349. m_treeRawCode.SelectItem(hTreeItem);
  1350. if(bExpanded)
  1351. m_treeRawCode.Expand(hTreeItem);
  1352.     break;
  1353. default:
  1354.     break;
  1355. }
  1356. }
  1358. LRESULT CMainDlg::OnSave(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
  1359. {
  1360. // TODO: Add your control notification handler code here
  1361. SaveFile(m_strSCMFile.c_str());
  1362. return 0;
  1363. }
  1365. LRESULT CMainDlg::OnSaveas(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
  1366. {
  1367. // TODO: Add your control notification handler code here
  1368. OPENFILENAME ofn;
  1369. TCHAR szFile[MAX_PATH] = {0};
  1370. TCHAR szInitalDir[MAX_PATH] = {0};
  1371. GetDlgItemText(IDC_FILENAME, szInitalDir, MAX_PATH);
  1373. ZeroMemory(&ofn, sizeof(OPENFILENAME));
  1374. ofn.lStructSize = sizeof(ofn);
  1375. ofn.hwndOwner = m_hWnd;
  1376. ofn.lpstrFile = szFile;
  1377. ofn.lpstrFile[0] = _T('');
  1378. ofn.nMaxFile = sizeof(szFile);
  1379. ofn.lpstrFilter = _T("SCEP CheatMaster 0.7 Raw Code File*.scm");
  1380. ofn.nFilterIndex = 1;
  1381. ofn.lpstrTitle = _T("Please Open a SCEP CheatMaster 0.7 Raw Code File");
  1382. ofn.lpstrInitialDir = szInitalDir;
  1383. ofn.Flags = OFN_OVERWRITEPROMPT | OFN_PATHMUSTEXIST | OFN_HIDEREADONLY;
  1385. if(TRUE == GetOpenFileName(&ofn))
  1386. {
  1387. m_strSCMFile = SCM_String(ofn.lpstrFile);
  1388. SetDlgItemText(IDC_FILENAME, m_strSCMFile.c_str());
  1389. m_treeRawCode.SetItemText(m_hRoot, m_strSCMFile.c_str());
  1390. _tcscpy(m_vTreeNode[GetTreeNodeIndex(m_hRoot)].szValue, m_strSCMFile.c_str());
  1391. SaveFile(SCM_String(ofn.lpstrFile).c_str());
  1393. GetDlgItem(IDC_SAVE).EnableWindow(1);
  1394. }
  1396. return 0;
  1397. }
  1399. void CMainDlg::SaveFile(LPCTSTR lpszFileName)
  1400. {
  1401. HANDLE hFile = CreateFile(lpszFileName, GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
  1402. DWORD dwWrite;
  1403. char szLine[200] = {0};
  1404. char szTemp[50] = {0};
  1405. BOOL bWrite;
  1406. int nLength;
  1408. for(int i = 0; i < m_vTreeNode.size(); i++)
  1409. {
  1410. bWrite = FALSE;
  1411. switch(m_vTreeNode[i].nType)
  1412. {
  1413. //  case NODE_TYPE_FILENAME:
  1414. //  case NODE_TYPE_RAWCODENUMBER:
  1415. //  case NODE_TYPE_RAWCODEMEMORY:
  1416. //  bWrite = FALSE;
  1417. //  break;
  1418. case NODE_TYPE_GAMEINFO:
  1419. bWrite = TRUE;
  1420. ZeroMemory(szLine, sizeof(szLine));
  1421. strcpy(szLine, ws2s(m_vTreeNode[i++].szValue).c_str());
  1422. strcat(szLine, "n");
  1423. strcat(szLine, ws2s(m_vTreeNode[i].szValue).c_str());
  1424. strcat(szLine, "n$STARTn");
  1425. break;
  1426. case NODE_TYPE_CLASSNAME:
  1427. bWrite = TRUE;
  1428. ZeroMemory(szLine, sizeof(szLine));
  1429. strcpy(szLine, "$");
  1430. strncpy(szTemp, ws2s(m_vTreeNode[i].szValue).c_str(), 19);
  1431. strcat(szLine, szTemp);
  1432. nLength = strlen(szTemp);
  1433. if(nLength < 19)
  1434. strncat(szLine, "                   ", 19-nLength);
  1435. strcat(szLine, "{n");
  1436.     break;
  1437. case NODE_TYPE_RAWCODENAME:
  1438. ZeroMemory(szLine, sizeof(szLine));
  1439. strcpy(szLine, "$");
  1440. strncpy(szTemp, ws2s(m_vTreeNode[i].szValue).c_str(), 9);
  1441. strcat(szLine, szTemp);
  1442. nLength = strlen(szTemp);
  1443. if(nLength < 9)
  1444. strncat(szLine, "         ", 9-nLength);
  1445. strcat(szLine, " ");
  1446.     break;
  1447. case NODE_TYPE_RAWCODESTAT:
  1448. strcat(szLine, "$");
  1449. strcat(szLine, ws2s(m_vTreeNode[i].szValue).c_str());
  1450. nLength = strlen(szTemp);
  1451. if(nLength < 1)
  1452. strcat(szLine, "0");
  1453. strcat(szLine, " $(");
  1454. break;
  1455. case NODE_TYPE_RAWCODEMEMORYN:
  1456. strcat(szLine, ws2s(m_vTreeNode[i].szValue).c_str());
  1457. if(i != m_vTreeNode.size()-1)
  1458. {
  1459. if(m_vTreeNode[i+1].nType == NODE_TYPE_RAWCODEMEMORYN)
  1460. strcat(szLine, " ");
  1461. else if(m_vTreeNode[i+1].nType == NODE_TYPE_RAWCODENUMBER)
  1462. {
  1463. strcat(szLine, ")n");
  1464. bWrite = TRUE;
  1465. }
  1466. else
  1467. {
  1468. strcat(szLine, ")}nn");
  1469. bWrite = TRUE;
  1470. }
  1471. }
  1472. else
  1473. {
  1474. strcat(szLine, ")}nn");
  1475. bWrite = TRUE;
  1476. }
  1477. break;
  1478. default:
  1479.     break;
  1480. }
  1482. if(bWrite)
  1483. {
  1484. dwWrite = strlen(szLine);
  1485. WriteFile(hFile, szLine, dwWrite, &dwWrite, NULL);
  1486. }
  1487. }
  1489. CloseHandle(hFile);
  1490. }
  1492. LRESULT CMainDlg::OnBeginDrag(int /*idCtrl*/, LPNMHDR pNMHDR, BOOL& bHandled)
  1493. {
  1494. LPNMTREEVIEW pNMTreeView = reinterpret_cast<LPNMTREEVIEW>(pNMHDR);
  1495. // TODO: Add your control notification handler code here
  1497. bHandled = FALSE;
  1499. //如果是无意拖曳，则放弃操作
  1500. if((GetTickCount() - m_dwDragStart) < DRAG_DELAY)
  1501. return FALSE;
  1503. POINT point;
  1504. point.x = pNMTreeView->ptDrag.x;
  1505. point.y = pNMTreeView->ptDrag.y;
  1507. UINT uFlag;
  1508. HTREEITEM h1 = m_treeRawCode.HitTest(point, &uFlag);
  1509. if(h1 == NULL)
  1510. return FALSE;
  1512. if(!m_treeRawCode.SelectItem(h1))
  1513. return FALSE;
  1515. if(m_vTreeNode[GetTreeNodeIndex(h1)].nType != NODE_TYPE_RAWCODENUMBER)
  1516. return FALSE;
  1518. m_hItemDragS = pNMTreeView->itemNew.hItem;
  1519. m_hItemDragD = NULL;
  1521. //得到用于拖动时显示的图象列表
  1522. m_pDragImage = m_treeRawCode.CreateDragImage(m_hItemDragS);
  1523. if(!m_pDragImage)
  1524. return FALSE;
  1526. m_bDragging = true;
  1527. m_pDragImage.BeginDrag(0, CPoint(8,8));
  1528. CPoint pt = pNMTreeView->ptDrag;
  1529. ClientToScreen(&pt);
  1530. m_pDragImage.DragEnter(m_treeRawCode.m_hWnd, pt);  //"this"将拖曳动作限制在该窗口
  1531. // SetCapture();
  1533. m_nScrollTimerID = SetTimer(2, 40, NULL);
  1534. return TRUE;
  1535. }
  1537. void CMainDlg::OnMouseMove_Tree(UINT nFlags, CPoint point)
  1538. {
  1539. HTREEITEM  hItem;
  1540. UINT       flags;
  1542. //检测鼠标敏感定时器是否存在,如果存在则删除,删除后再定时
  1543. if(m_nHoverTimerID)
  1544. {
  1545. KillTimer(m_nHoverTimerID);
  1546. m_nHoverTimerID = 0;
  1547. }
  1548. m_nHoverTimerID = SetTimer(1, 800, NULL);  //定时为 0.8 秒则自动展开
  1549. m_HoverPoint = point;
  1551. if(m_bDragging)
  1552. {
  1553. CPoint  pt = point;
  1554. CImageList::DragMove(pt);
  1556. //鼠标经过时高亮显示
  1557. CImageList::DragShowNolock(false);  //避免鼠标经过时留下难看的痕迹
  1558. if((hItem = m_treeRawCode.HitTest(point, &flags)) != NULL)
  1559. {
  1560. //   m_treeRawCode.SelectDropTarget(hItem);
  1561. m_hItemDragD = hItem;
  1562. RECT rect;
  1564. switch(m_vTreeNode[GetTreeNodeIndex(hItem)].nType)
  1565. {
  1566. case NODE_TYPE_RAWCODENUMBER:
  1567. if(m_treeRawCode.GetItemRect(hItem, &rect, FALSE))
  1568. {
  1569. if(pt.y >= (rect.top + (rect.bottom - rect.top)/2))
  1570. {
  1571. pt.y = rect.bottom;
  1572. m_bInsertUp = FALSE;
  1573. }
  1574. else
  1575. {
  1576. m_bInsertUp = TRUE;
  1577. pt.y = rect.top;
  1578. }
  1580. if(m_nOldY != pt.y)
  1581. {
  1582. m_treeRawCode.GetClientRect(&rect);
  1583. m_treeRawCode.InvalidateRect(&rect, TRUE);
  1584. m_treeRawCode.UpdateWindow();
  1585. DrawSplitLine(rect.left, pt.y, rect.right, pt.y);
  1586. }
  1587. }
  1588. break;
  1589. case NODE_TYPE_CLASSNAME:
  1590. if(m_treeRawCode.GetItemRect(hItem, &rect, TRUE))
  1591. {
  1592. pt.x = rect.right;
  1593. pt.y = rect.top + (rect.bottom - rect.top)/2;
  1595. if(m_nOldY != pt.y)
  1596. {
  1597. m_treeRawCode.GetClientRect(&rect);
  1598. m_treeRawCode.InvalidateRect(&rect, TRUE);
  1599. m_treeRawCode.UpdateWindow();
  1600. DrawInsertPoint(pt.x, pt.y);
  1601. }
  1602. }
  1603.     break;
  1604. default:
  1605.     break;
  1606. }
  1607. }
  1608. CImageList::DragShowNolock(true);
  1610. //  //当条目被拖曳到左边缘时，将条目放在根下
  1611. //  CRect  rect;
  1612. //  GetClientRect(&rect);
  1613. //  if( point.x < rect.left + 20 )
  1614. //  m_hItemDragD = NULL;
  1615. }
  1616. //  else
  1617. //  {
  1618. //  if((hItem = m_treeRawCode.HitTest(point, &flags)) != NULL)
  1619. //  {
  1620. //  int n = GetTreeNodeIndex(hItem);
  1621. //  if(m_vTreeNode[n].nType == NODE_TYPE_RAWCODEMEMORY)
  1622. //  {
  1623. //  SCM_String strMemoryInfo = ParseMemoryInfo(m_vTreeNode[n+1].szValue, m_vTreeNode[n+2].szValue, m_vTreeNode[n+3].szValue, m_vTreeNode[n+4].szValue);
  1624. // 
  1625. //  RECT rect;
  1626. //  m_treeRawCode.GetItemRect(hItem, &rect, TRUE);
  1627. // 
  1628. //  POINT pt;
  1629. //  TRACKMOUSEEVENT tk;
  1630. //  tk.cbSize = sizeof(tk);
  1631. //  tk.dwFlags = TME_LEAVE;
  1632. //  tk.dwHoverTime = 0;
  1633. //  tk.hwndTrack = m_treeRawCode.m_hWnd;
  1634. //  _TrackMouseEvent(&tk);
  1635. //  pt.x = rect.left - 3;
  1636. //  pt.y = rect.top - 2;
  1637. //  ClientToScreen(&pt);
  1638. //  m_tooltip.TrackPosition(pt.x, pt.y);
  1639. //  m_tooltip.TrackActivate(&m_ti, TRUE);
  1640. // 
  1641. // // m_tooltip.Up
  1642. // // m_tooltip.UpdateTipText(strMemoryInfo.c_str(), m_treeRawCode.m_hWnd);
  1643. // // m_tooltip.RelayEvent(pMsg);
  1644. // //  m_tooltip = m_treeRawCode.GetToolTips();
  1645. // //   TOOLINFO toolInfo;
  1646. // //   toolInfo.cbSize = sizeof(TOOLINFO);
  1647. // //  RECT rect;
  1648. // //  rect.left = point.x;
  1649. // //  rect.top = point.y;
  1650. // //  rect.right = point.x + 100;
  1651. // //  rect.bottom = point.y + 50;
  1652. // //  toolInfo.rect = rect;
  1653. // //   toolInfo.hwnd = m_treeRawCode.m_hWnd;
  1654. // //   toolInfo.lpszText = (LPTSTR)strMemoryInfo.c_str();
  1655. // //   m_tooltip.SetToolInfo(&toolInfo);
  1656. // //   m_treeRawCode.SetToolTips(m_tooltip.m_hWnd);
  1657. //  }
  1658. //  }
  1659. //  }
  1661. SetMsgHandled(FALSE);
  1662. }
  1664. void CMainDlg::OnLButtonUp_Tree(UINT nFlags, CPoint point)
  1665. {
  1666. SetMsgHandled(FALSE);
  1668. if(m_bDragging)
  1669. {
  1670. m_bDragging = FALSE;
  1671. CImageList::DragLeave(m_treeRawCode.m_hWnd);
  1672. CImageList::EndDrag();
  1674. RECT rect;
  1675. m_treeRawCode.GetClientRect(&rect);
  1676. m_treeRawCode.InvalidateRect(&rect, TRUE);
  1677. m_treeRawCode.UpdateWindow();
  1679. m_treeRawCode.SelectDropTarget(NULL);
  1681. if(m_hItemDragS == m_hItemDragD)
  1682. {
  1683. KillTimer(m_nScrollTimerID);
  1684. return;
  1685. }
  1686. int nType = m_vTreeNode[GetTreeNodeIndex(m_hItemDragD)].nType;
  1688. if((nType != NODE_TYPE_RAWCODENUMBER) && (nType != NODE_TYPE_CLASSNAME))
  1689. {
  1690. KillTimer(m_nScrollTimerID);
  1691. return;
  1692. }
  1694. HTREEITEM hParent;
  1695. HTREEITEM hAfter;
  1696. if(nType == NODE_TYPE_CLASSNAME)
  1697. {
  1698. m_treeRawCode.Expand(m_hItemDragD, TVE_EXPAND);
  1699. hParent = m_hItemDragD;
  1700. hAfter = m_hItemDragD;
  1701. if(m_treeRawCode.ItemHasChildren(m_hItemDragD))
  1702. {
  1703. hAfter = TVI_LAST;
  1704. }
  1705. }
  1706. else
  1707. {
  1708. hParent = m_treeRawCode.GetParentItem(m_hItemDragD);
  1709. if(m_bInsertUp) //Up
  1710. {
  1711. if(m_hItemDragD == m_treeRawCode.GetChildItem(hParent)) // First Child
  1712. hAfter = TVI_FIRST;
  1713. else
  1714. hAfter = m_treeRawCode.GetPrevSiblingItem(m_hItemDragD);
  1715. }
  1716. else
  1717. hAfter = m_hItemDragD;
  1718. }
  1720. BOOL bExpanded = FALSE;
  1721. if(m_treeRawCode.GetItemState(m_hItemDragS, TVIS_EXPANDED) == TVIS_EXPANDED)
  1722. bExpanded = TRUE;
  1724. HTREEITEM hTreeItem = MoveNode(m_hItemDragS, hParent, hAfter);
  1725. m_treeRawCode.SelectItem(hTreeItem);
  1727. if(bExpanded)
  1728. m_treeRawCode.Expand(hTreeItem);
  1730.   KillTimer(m_nScrollTimerID);
  1731. }
  1732. }
  1734. void CMainDlg::OnLButtonDown_Tree(UINT nFlags, CPoint point)
  1735. {
  1736. if(nFlags & 0x8000)
  1737. m_dwDragStart = GetTickCount();
  1738. else
  1739. {
  1740. m_bShouldTrigger = TRUE;
  1741. SetTimer(MOUSE_DOUBLE_CLICK_TIMER, GetDoubleClickTime(), 0);
  1742. }
  1744. UINT flags;
  1745. HTREEITEM hItem = m_treeRawCode.HitTest(point, &flags);
  1746. if(hItem != NULL)
  1747. {
  1748. if((flags&TVHT_ONITEMBUTTON) == TVHT_ONITEMBUTTON)
  1749. {
  1750. if(m_treeRawCode.GetItemState(hItem, TVIS_EXPANDED) == TVIS_EXPANDED)
  1751. m_treeRawCode.Expand(hItem, TVE_EXPAND);
  1752. else
  1753. m_treeRawCode.Expand(hItem, TVE_COLLAPSE);
  1754. }
  1755. else
  1756. {
  1757. int n = GetTreeNodeIndex(hItem);
  1758. if(n != -1)
  1759. {
  1760. if( (m_vTreeNode[n].nType == NODE_TYPE_FILENAME) || 
  1761. (m_vTreeNode[n].nType == NODE_TYPE_RAWCODENUMBER) ||
  1762. (m_vTreeNode[n].nType == NODE_TYPE_RAWCODEMEMORY))
  1763. {
  1764. m_treeRawCode.SelectItem(hItem);
  1765. return;
  1766. }
  1767. }
  1768. }
  1769. }
  1771. SetMsgHandled(FALSE);
  1772. }
  1774. LRESULT CMainDlg::OnTimer_Tree(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& /*bHandled*/)
  1775. {
  1776. //鼠标敏感节点
  1777. UINT nIDEvent = (UINT)wParam;
  1778. if(nIDEvent == MOUSE_DOUBLE_CLICK_TIMER)
  1779. {
  1780. KillTimer(MOUSE_DOUBLE_CLICK_TIMER);
  1781. if(m_bShouldTrigger)
  1782. PostMessage(WM_LBUTTONDOWN, MK_LBUTTON | 0x8000 , 0);
  1783. }
  1784. else if(nIDEvent == m_nHoverTimerID)
  1785. {
  1786. KillTimer(m_nHoverTimerID);
  1787. m_nHoverTimerID = 0;
  1788. HTREEITEM  trItem = 0;
  1789. UINT  uFlag = 0;
  1790. trItem = m_treeRawCode.HitTest(m_HoverPoint, &uFlag);
  1791. if(trItem && m_bDragging && (m_vTreeNode[GetTreeNodeIndex(trItem)].nType == NODE_TYPE_CLASSNAME))
  1792. {
  1793. // m_treeRawCode.SelectItem(trItem);
  1794. m_treeRawCode.Expand(trItem, TVE_EXPAND);
  1795. }
  1796. }
  1797. //处理拖曳过程中的滚动问题
  1798. else if(nIDEvent == m_nScrollTimerID)
  1799. {
  1800. m_TimerTicks++;
  1801. CPoint pt;
  1802. GetCursorPos(&pt);
  1803. CRect rect;
  1804. GetClientRect(&rect);
  1805. ClientToScreen(&rect);
  1807. HTREEITEM  hItem = m_treeRawCode.GetFirstVisibleItem();
  1809. if(pt.y < rect.top +10)
  1810. {
  1811. //向上滚动
  1812. int  slowscroll = 6 - (rect.top + 10 - pt.y)/20;
  1813. if( 0 == (m_TimerTicks % ((slowscroll > 0) ? slowscroll : 1)))
  1814. {
  1815. CImageList::DragShowNolock (false);
  1816. SendMessage(m_treeRawCode.m_hWnd, WM_VSCROLL, SB_LINEUP, NULL);
  1817. m_treeRawCode.SelectDropTarget(hItem);
  1818. m_hItemDragD = hItem;
  1819. CImageList::DragShowNolock (true);
  1820. }
  1821. }
  1822. else if(pt.y > rect.bottom - 10)
  1823. {
  1824. //向下滚动
  1825. int  slowscroll = 6 - (pt.y - rect.bottom + 10)/20;
  1826. if( 0 == (m_TimerTicks % ((slowscroll > 0) ? slowscroll : 1)))
  1827. {
  1828. CImageList::DragShowNolock (false);
  1829. SendMessage(m_treeRawCode.m_hWnd, WM_VSCROLL, SB_LINEDOWN, NULL);
  1830. int  nCount = m_treeRawCode.GetVisibleCount();
  1831. for(int i = 0; i < nCount - 1; i ++)
  1832. hItem = m_treeRawCode.GetNextVisibleItem(hItem);
  1833. if(hItem)
  1834. m_treeRawCode.SelectDropTarget(hItem);
  1835. m_hItemDragD = hItem;
  1836. CImageList::DragShowNolock (true);
  1837. }
  1838. }
  1839. }
  1840. else
  1841. SetMsgHandled(FALSE);
  1843. return TRUE;
  1844. }
  1846. void CMainDlg::DrawSplitLine(int nStart_x, int nStart_y, int nEnd_x, int nEnd_y)
  1847. {
  1848.    HDC hTreeDC = ::GetDC(m_treeRawCode.m_hWnd);
  1850.   Graphics g(hTreeDC);
  1851. SolidBrush BlackBrush(Color(255, 0, 0, 0));
  1852. Pen blackPen(&BlackBrush, 2);
  1853. nEnd_x -= 5;
  1854. nStart_x += 1;
  1855. Point LPoints[4] = {Point(nStart_x, nStart_y-5), Point(nStart_x+4, nStart_y), Point(nStart_x+4, nStart_y-1), Point(nStart_x, nStart_y+4)};
  1856. Point RPoints[4] = {Point(nEnd_x, nEnd_y-6), Point(nEnd_x-5, nEnd_y), Point(nEnd_x-5, nEnd_y-1), Point(nEnd_x, nEnd_y+5)};
  1858. g.FillPolygon(&BlackBrush, LPoints, 4);
  1859. g.FillPolygon(&BlackBrush, RPoints, 4);
  1860. g.DrawLine(&blackPen, Point(nStart_x+2, nStart_y), Point(nEnd_x-2, nEnd_y));
  1861. m_nOldY = nEnd_y;
  1862. }
  1864. void CMainDlg::DrawInsertPoint(int nPoint_x, int nPoint_y)
  1865. {
  1866. HDC hTreeDC = ::GetDC(m_treeRawCode.m_hWnd);
  1868. Graphics g(hTreeDC);
  1869. SolidBrush BlackBrush(Color(255, 0, 0, 0));
  1870. nPoint_x += 2;
  1871. Point Points[3] = {Point(nPoint_x, nPoint_y), Point(nPoint_x+5, nPoint_y+5), Point(nPoint_x+5, nPoint_y-5)};
  1873. g.FillPolygon(&BlackBrush, Points, 3);
  1874. m_nOldY = nPoint_y;
  1875. }
  1877. HTREEITEM CMainDlg::MoveNode(HTREEITEM hNodeS, HTREEITEM hNodeDParent, HTREEITEM hNodeDAfter)
  1878. {
  1879. int n = GetTreeNodeIndex(hNodeS);
  1880. std::vector <TreeNode> vTreeNode;
  1881. vTreeNode.assign(m_vTreeNode.begin() + n, m_vTreeNode.begin() + n + 8);
  1883. DeleteItemAndChild(hNodeS, TRUE);
  1885. HTREEITEM hMoveTo;
  1886. HTREEITEM hTreeItem;
  1887. if(hNodeDAfter == TVI_FIRST)
  1888. n = GetTreeNodeIndex(hNodeDParent) + 1;
  1889. else if(hNodeDAfter == TVI_LAST)
  1890. {
  1891. hTreeItem = m_treeRawCode.GetNextSiblingItem(hNodeDParent);
  1892. if(hTreeItem == NULL)
  1893. n = m_vTreeNode.size();
  1894. else
  1895. n = GetTreeNodeIndex(hTreeItem);
  1896. }
  1897. else
  1898. n = GetTreeNodeIndex(hNodeDAfter) + 8;
  1900. m_vTreeNode.insert(m_vTreeNode.begin() + n, vTreeNode.begin(), vTreeNode.end());
  1902. HTREEITEM hParent;
  1903. SCM_String string;
  1904. // CodeItem
  1905. string = SCM_String(vTreeNode[0].szFront) + SCM_String(vTreeNode[0].szValue);
  1906. hTreeItem = InsertTreeItem(string.c_str(), hNodeDParent, hNodeDAfter);
  1907. hParent = hTreeItem;
  1908. hMoveTo = hTreeItem;
  1909. m_vTreeNode[n++].hItem = hTreeItem;
  1911. // CodeName
  1912. string = SCM_String(vTreeNode[1].szFront) + SCM_String(vTreeNode[1].szValue);
  1913. hTreeItem = InsertTreeItem(string.c_str(), hParent, hTreeItem);
  1914. m_vTreeNode[n++].hItem = hTreeItem;
  1916. // ItemStat
  1917. string = SCM_String(vTreeNode[2].szFront);
  1918. switch(_ttoi(vTreeNode[2].szValue))
  1919. {
  1920. case 0:
  1921. string += SCM_String(_T("Disable"));
  1922. break;
  1923. case 1:
  1924. string += SCM_String(_T("Enable"));
  1925. break;
  1926. case 2:
  1927. string += SCM_String(_T("Lock"));
  1928. break;
  1929. default:
  1930. string += SCM_String(_T("Unknown"));
  1931. break;
  1932. }
  1933. hTreeItem = InsertTreeItem(string.c_str(), hParent, hTreeItem);
  1934. m_vTreeNode[n++].hItem = hTreeItem;
  1936. // MemTitle
  1937. string = SCM_String(vTreeNode[3].szValue);
  1938. hTreeItem = InsertTreeItem(string.c_str(), hParent, hTreeItem);
  1939. hParent = hTreeItem;
  1940. m_vTreeNode[n++].hItem = hTreeItem;
  1942. // Mem1
  1943. string = SCM_String(vTreeNode[4].szFront) + SCM_String(vTreeNode[4].szValue);
  1944. hTreeItem = InsertTreeItem(string.c_str(), hParent, hTreeItem);
  1945. m_vTreeNode[n++].hItem = hTreeItem;
  1947. // Mem2
  1948. string = SCM_String(vTreeNode[5].szFront) + SCM_String(vTreeNode[5].szValue);
  1949. hTreeItem = InsertTreeItem(string.c_str(), hParent, hTreeItem);
  1950. m_vTreeNode[n++].hItem = hTreeItem;
  1952. // Mem3
  1953. string = SCM_String(vTreeNode[6].szFront) + SCM_String(vTreeNode[6].szValue);
  1954. hTreeItem = InsertTreeItem(string.c_str(), hParent, hTreeItem);
  1955. m_vTreeNode[n++].hItem = hTreeItem;
  1957. // Mem4
  1958. string = SCM_String(vTreeNode[7].szFront) + SCM_String(vTreeNode[7].szValue);
  1959. hTreeItem = InsertTreeItem(string.c_str(), hParent, hTreeItem);
  1960. m_vTreeNode[n++].hItem = hTreeItem;
  1962. // RebuildCodeNumber();
  1963. return hMoveTo;
  1964. }
  1966. void CMainDlg::RebuildCodeNumber()
  1967. {
  1968. // Get First Class
  1969. HTREEITEM hClassName = m_treeRawCode.GetNextSiblingItem(m_treeRawCode.GetNextSiblingItem(m_treeRawCode.GetChildItem(m_hRoot)));
  1970. HTREEITEM hCodeNumber;
  1972. int i;
  1973. int n;
  1974. TCHAR szNumber[5] = {0};
  1975. TCHAR szString[50] = {0};
  1976. while(hClassName != NULL)
  1977. {
  1978. if(m_treeRawCode.ItemHasChildren(hClassName))
  1979. {
  1980. i = 1;
  1981. hCodeNumber = m_treeRawCode.GetChildItem(hClassName);
  1982. while (hCodeNumber != NULL)
  1983. {
  1984. _itot(i++, szNumber, 10);
  1985. n = GetTreeNodeIndex(hCodeNumber);
  1986. _tcscpy(m_vTreeNode[n].szValue, szNumber);
  1987. _tcscpy(szString, m_vTreeNode[n].szFront);
  1988. _tcscat(szString, szNumber);
  1989. m_treeRawCode.SetItemText(hCodeNumber, szString);
  1990. hCodeNumber = m_treeRawCode.GetNextSiblingItem(hCodeNumber);
  1991. }
  1992. }
  1994. hClassName = m_treeRawCode.GetNextSiblingItem(hClassName);
  1995. }
  1996. }
  1998. void CMainDlg::UpdateClassCodeCount()
  1999. {
  2000. TCHAR szTemp[100] = {0};
  2001. TCHAR szNumber[5] = {0};
  2002. _tcscpy(szTemp, _T("Class Number: "));
  2003. _itot(m_nClassCount, szNumber, 10);
  2004. _tcscat(szTemp, szNumber);
  2005. _tcscat(szTemp, _T("/50"));
  2006. SetDlgItemText(IDC_CLASS_COUNT, szTemp);
  2008. _tcscpy(szTemp, _T("Code Number: "));
  2009. _itot(m_nCodeCount, szNumber, 10);
  2010. _tcscat(szTemp, szNumber);
  2011. _tcscat(szTemp, _T("/500"));
  2012. SetDlgItemText(IDC_CODE_COUNT, szTemp);
  2013. }