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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > DirextX编程 > 查看源码
CopyFilesDlg.cpp
资源名称：DXGuide.zip　[点击查看]
上传用户：wymy58
上传日期：2007-01-07
资源大小：2086k
文件大小：14k
源码类别：

DirextX编程

开发平台：

Visual C++

CopyFilesDlg.cpp：源码内容
  1. // CopyFilesDlg.cpp : implementation file
  2. //
  4. #include "stdafx.h"
  5. #include <direct.h>
  6. #include "PFM.h"
  7. #include "CopyFilesDlg.h"
  8. #include "MainFrm.h"
  10. #ifdef _DEBUG
  11. #define new DEBUG_NEW
  12. #undef THIS_FILE
  13. static char THIS_FILE[] = __FILE__;
  14. #endif
  16. /////////////////////////////////////////////////////////////////////////////
  17. // CCopyFilesDlg dialog
  20. CCopyFilesDlg::CCopyFilesDlg(CWnd* pParent /*=NULL*/)
  21. : CDialog(CCopyFilesDlg::IDD, pParent)
  22. {
  23. //{{AFX_DATA_INIT(CCopyFilesDlg)
  24. //}}AFX_DATA_INIT
  25. }
  28. void CCopyFilesDlg::DoDataExchange(CDataExchange* pDX)
  29. {
  30. CDialog::DoDataExchange(pDX);
  31. //{{AFX_DATA_MAP(CCopyFilesDlg)
  32. DDX_Control(pDX, IDC_STATIC2, m_prompt);
  33. DDX_Control(pDX, IDC_STATIC1, m_percent);
  34. DDX_Control(pDX, IDC_PROGRESS, m_prog);
  35. DDX_Control(pDX, IDC_ANIMATE, m_avi);
  36. //}}AFX_DATA_MAP
  37. }
  40. BEGIN_MESSAGE_MAP(CCopyFilesDlg, CDialog)
  41. //{{AFX_MSG_MAP(CCopyFilesDlg)
  42. //}}AFX_MSG_MAP
  43. END_MESSAGE_MAP()
  45. /////////////////////////////////////////////////////////////////////////////
  46. // CCopyFilesDlg message handlers
  48. BOOL CCopyFilesDlg::OnInitDialog() 
  49. {
  50. CDialog::OnInitDialog();
  52. // TODO: Add extra initialization here
  53. m_avi.ModifyStyle(WS_VISIBLE,0);
  54. m_prog.ModifyStyle(WS_VISIBLE,0);
  55. m_prompt.SetWindowText("是否要拷贝选择的文件？");
  57. return TRUE;  // return TRUE unless you set the focus to a control
  58.               // EXCEPTION: OCX Property Pages should return FALSE
  59. }
  61. void CCopyFilesDlg::OnOK() 
  62. {
  63. // TODO: Add extra validation here
  64. m_avi.ModifyStyle(0, WS_VISIBLE);
  65. m_prog.ModifyStyle(WS_BORDER, WS_VISIBLE);
  66. m_prompt.SetWindowText("");
  67. GetDlgItem(IDOK)->EnableWindow(FALSE);
  68. GetDlgItem(IDCANCEL)->EnableWindow(FALSE);
  69. m_avi.Open(IDR_FILECOPY);
  70. m_avi.Play(0, -1, -1);
  71. if (gCurPan)
  72. {
  73. m_flSrc = gRightPan; m_strSrc = gRightPath;
  74. m_flDest = gLeftPan; m_strDest = gLeftPath;
  75. }
  76. else
  77. {
  78. m_flSrc = gLeftPan; m_strSrc = gLeftPath;
  79. m_flDest = gRightPan; m_strDest = gRightPath;
  80. }
  82. if (m_flSrc->GetFastFileManager())
  83. {
  84. if (m_flDest->GetFastFileManager())
  85. CopyFF();
  86. else
  87. CopyFD();
  88. }
  89. else
  90. {
  91. if (m_flDest->GetFastFileManager())
  92. CopyDF();
  93. else
  94. CopyDD();
  95. }
  96. CDialog::OnOK();
  97. }
  99. void CCopyFilesDlg::SearchDirectory(LPCTSTR strPath, BOOL bCreateDest)
  100. {
  101. CString curPath, strName;
  102. char drive[_MAX_DRIVE];
  103. char dir[_MAX_DIR];
  104. char fname[_MAX_FNAME];
  105. char ext[_MAX_EXT];
  107. if (bCreateDest)
  108. {
  109. curPath = m_strDest + strPath;
  110. _mkdir(curPath);
  111. }
  113. curPath = strPath;
  114. curPath += "\";
  116. BOOL bLoop;
  117. char sName[MAX_PATH];
  118. CFileFind ff;
  119. bLoop = ff.FindFile(curPath+"*.*");
  120. while (bLoop)
  121. {
  122. bLoop = ff.FindNextFile();
  123. strName = ff.GetFileName();
  124. if (ff.IsDots())
  125. continue;
  126. if (ff.IsDirectory())
  127. SearchDirectory(curPath+strName, bCreateDest);
  128. else
  129. {
  130. GetShortPathName(m_strSrc+curPath+strName, sName,MAX_PATH);
  131. _splitpath(sName,drive,dir,fname,ext);
  132. strName = fname;
  133. strName += ext;
  134. m_map.SetAt(strName, ff.GetFilePath());
  135. m_dwSize += ff.GetLength();
  136. }
  137. }
  138. }
  140. void CCopyFilesDlg::UpdateProg(DWORD dwSize)
  141. {
  142. DWORD dwPct = 100*dwSize/m_dwSize;
  143. m_prog.SetPos(dwPct);
  144. CString strPct;
  145. strPct.Format("%d%%", dwPct);
  146. m_percent.SetWindowText(strPct);
  147. }
  149. void CCopyFilesDlg::CopyFF()
  150. {
  151. LPWIN32_FIND_DATA pFd;
  152. LVITEM lvi;
  153. CFastFileManager *pFfmSrc = m_flSrc->GetFastFileManager();
  154. CFastFileManager *pFfmDest = m_flDest->GetFastFileManager();
  155. m_map.RemoveAll();
  157. m_dwSize = 0;
  158. // add src list items
  159. int nItem = m_flSrc->GetNextItem(-1, LVNI_ALL|LVNI_SELECTED);
  160. while (nItem != -1)
  161. {
  162. pFd = (LPWIN32_FIND_DATA)m_flSrc->GetItemData(nItem);
  163. if (pFd->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
  164. ;
  165. else
  166. {
  167. m_map.SetAt(pFd->cFileName, "Src");
  168. m_dwSize += pFd->nFileSizeLow;
  169. }
  170. lvi.mask = LVIF_STATE;
  171. lvi.iItem = nItem;
  172. lvi.iSubItem = 0;
  173. lvi.stateMask = 0xFFFF;
  174. // get all state flags
  175. m_flSrc->GetItem(&lvi);
  176. lvi.state ^= LVIS_SELECTED;
  177. m_flSrc->SetItem(&lvi);
  178. nItem = m_flSrc->GetNextItem(nItem, LVNI_ALL|LVNI_SELECTED);
  179. }
  181. // add Dest list items
  182. nItem = m_flDest->GetNextItem(-1, LVNI_ALL);
  183. while (nItem != -1)
  184. {
  185. pFd = (LPWIN32_FIND_DATA)m_flDest->GetItemData(nItem);
  186. if (pFd->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
  187. ;
  188. else
  189. {
  190. m_map.SetAt(pFd->cFileName, "Dest");
  191. m_dwSize += pFd->nFileSizeLow;
  192. }
  193. nItem = m_flDest->GetNextItem(nItem, LVNI_ALL);
  194. }
  196. CString strDest = m_strDest.Left(
  197. m_strDest.ReverseFind('\')+1);
  199. CFile fPf;
  200. FILE_ENTRY *pFe;
  201. PACK_FILE_HEAD pfh;
  203. if (!fPf.Open(strDest+"$$$$$$$$.$$$", CFile::modeCreate|CFile::modeWrite|CFile::typeBinary))
  204. {
  205. MessageBox("包文件创建失败！","PackFile Maker", MB_OK|MB_ICONSTOP);
  206. return;
  207. }
  208. pfh.dwEntryCount = m_map.GetCount();
  209. memcpy(&pfh.dwFlag, "DXGF", 4);
  210. pfh.dwHeadSize = sizeof(PACK_FILE_HEAD);
  211. pfh.wMajorVersion = 0x1;
  212. pfh.wMinorVersion = 0x0;
  213. strcpy(pfh.szDescription, "This file is created by DirectX Guide");
  215. pFe = NULL;
  216. pFe = new FILE_ENTRY[pfh.dwEntryCount+1];
  217. if (pFe == NULL)
  218. {
  219. MessageBox("内存申请失败！", "PackFile Maker", MB_OK|MB_ICONSTOP);
  220. return;
  221. }
  223. DWORD dwCnt = 0;
  224. CString key, val;
  225. POSITION ps;
  226. ps = m_map.GetStartPosition();
  227. while (ps)
  228. {
  229. m_map.GetNextAssoc(ps, key, val);
  230. strcpy(pFe[dwCnt].szFileName, key);
  231. dwCnt++;
  232. }
  234. qsort(pFe, pfh.dwEntryCount, sizeof(FILE_ENTRY), Compare);
  236. LONG lOffset = sizeof(PACK_FILE_HEAD) + (pfh.dwEntryCount+1)*sizeof(FILE_ENTRY);
  237. CFastFile fin;
  239. DWORD dwSize = 0;
  240. for (dwCnt=0; dwCnt<pfh.dwEntryCount; dwCnt++)
  241. {
  242. if(!m_map.Lookup(pFe[dwCnt].szFileName, val))
  243. {
  244. MessageBox("文件目录出错！", "PackFile Maker");
  245. delete [] pFe;
  246. return;
  247. }
  249. if (!fin.Open(val=="Src"?pFfmSrc:pFfmDest, pFe[dwCnt].szFileName))
  250. {
  251. MessageBox("文件打开失败！", "PackFile Maker", MB_OK|MB_ICONSTOP);
  252. fPf.Close();
  253. delete [] pFe;
  254. return;
  255. }
  256. pFe[dwCnt].lOffset = lOffset;
  257. memcpy(&(pFe[dwCnt].ftCreationTime), &(fin.m_pFE->ftCreationTime), sizeof(FILETIME));
  258. memcpy(&(pFe[dwCnt].ftWriteTime), &(fin.m_pFE->ftWriteTime), sizeof(FILETIME));
  259. // strcpy(pFe[dwCnt].szFileName, key);
  260. fPf.Seek(lOffset, CFile::begin);
  261. fPf.Write(fin.GetPtr(), fin.GetFileSize());
  262. lOffset += fin.GetFileSize();
  263. dwSize += fin.GetFileSize();
  264. UpdateProg(dwSize);
  265. //fin.Close();
  266. }
  267. strcpy(pFe[pfh.dwEntryCount].szFileName, "-[The  End]-");
  268. pFe[pfh.dwEntryCount].lOffset = lOffset;
  269. pfh.dwFileSize = lOffset;
  271. fPf.Seek(0, CFile::begin);
  272. fPf.Write(&pfh, sizeof(pfh));
  273. fPf.Write(pFe, (pfh.dwEntryCount+1)*sizeof(FILE_ENTRY));
  274. fPf.Close();
  275. delete [] pFe;
  276. m_flDest->Unload();
  277. CFile::Remove(m_strDest);
  278. CFile::Rename(strDest+"$$$$$$$$.$$$", m_strDest);
  279. m_flSrc->LoadFastfile(m_strSrc);
  280. m_flDest->LoadFastfile(m_strDest);
  281. }
  283. void CCopyFilesDlg::CopyFD()
  284. {
  285. LPWIN32_FIND_DATA pFd;
  286. LVITEM lvi;
  287. m_dwSize = 0;
  288. m_map.RemoveAll();
  289. int nItem = m_flSrc->GetNextItem(-1, LVNI_ALL|LVNI_SELECTED);
  290. while (nItem != -1)
  291. {
  292. pFd = (LPWIN32_FIND_DATA)m_flSrc->GetItemData(nItem);
  293. m_dwSize += pFd->nFileSizeLow;
  294. m_map.SetAt(pFd->cFileName, "");
  295. lvi.mask = LVIF_STATE;
  296. lvi.iItem = nItem;
  297. lvi.iSubItem = 0;
  298. lvi.stateMask = 0xFFFF;
  299. // get all state flags
  300. m_flSrc->GetItem(&lvi);
  301. lvi.state ^= LVIS_SELECTED;
  302. m_flSrc->SetItem(&lvi);
  303. nItem = m_flSrc->GetNextItem(nItem, LVNI_ALL|LVNI_SELECTED);
  304. }
  306. CFastFile fin;
  307. CFile fout;
  308. DWORD dwSize = 0;
  309. CString key, val;
  310. POSITION ps;
  311. ps = m_map.GetStartPosition();
  312. while (ps)
  313. {
  314. m_map.GetNextAssoc(ps, key, val);
  315. if (fin.Open(m_flSrc->GetFastFileManager(), key))
  316. if (fout.Open(m_strDest+key, CFile::modeCreate|CFile::modeWrite|CFile::typeBinary))
  317. fout.Write(fin.GetPtr(), fin.GetFileSize());
  318. SetFileTime((HANDLE)fout.m_hFile, &(fin.m_pFE->ftCreationTime),
  319. &(fin.m_pFE->ftWriteTime), &(fin.m_pFE->ftWriteTime));
  320. fout.Close();
  321. dwSize += fin.GetFileSize();
  322. UpdateProg(dwSize);
  323. }
  324. m_flSrc->LoadFastfile(m_strSrc);
  325. m_flDest->LoadDirectory(m_strDest);
  326. }
  328. void CCopyFilesDlg::CopyDF()
  329. {
  330. char buf[1024];
  331. FILETIME ft;
  332. LPWIN32_FIND_DATA pFd;
  333. CFastFileManager *pFfmSrc = m_flSrc->GetFastFileManager();
  334. CFastFileManager *pFfmDest = m_flDest->GetFastFileManager();
  335. m_map.RemoveAll();
  337. m_dwSize = 0;
  338. // add Dest list items
  339. int nItem = m_flDest->GetNextItem(-1, LVNI_ALL);
  340. while (nItem != -1)
  341. {
  342. pFd = (LPWIN32_FIND_DATA)m_flDest->GetItemData(nItem);
  343. if (pFd->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
  344. ;
  345. else
  346. {
  347. m_map.SetAt(pFd->cFileName, "nDestn");
  348. m_dwSize += pFd->nFileSizeLow;
  349. }
  350. nItem = m_flDest->GetNextItem(nItem, LVNI_ALL);
  351. }
  353. char drive[_MAX_DRIVE];
  354. char dir[_MAX_DIR];
  355. char fname[_MAX_FNAME];
  356. char ext[_MAX_EXT];
  357. CString strName;
  358. LVITEM lvi;
  359. char sPath[14];
  360. nItem = m_flSrc->GetNextItem(-1, LVNI_ALL|LVNI_SELECTED);
  361. while (nItem != -1)
  362. {
  363. pFd = (LPWIN32_FIND_DATA)m_flSrc->GetItemData(nItem);
  364. _splitpath(pFd->cFileName,drive,dir,fname,ext);
  365. strName = fname;
  366. strName += ext;
  367. if (pFd->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
  368. {
  369. if (strName != "..")
  370. SearchDirectory(strName, FALSE);
  371. }
  372. else
  373. {
  374. GetShortPathName(strName, sPath,14);
  375. m_map.SetAt(sPath, (gCurPan?gRightPath:gLeftPath)+strName);
  376. }
  377. lvi.mask = LVIF_STATE;
  378. lvi.iItem = nItem;
  379. lvi.iSubItem = 0;
  380. lvi.stateMask = 0xFFFF;
  381. // get all state flags
  382. m_flSrc->GetItem(&lvi);
  383. lvi.state ^= LVIS_SELECTED;
  384. m_flSrc->SetItem(&lvi);
  385. //SetItemState( nItem,LVIS_SELECTED , LVIS_SELECTED);
  386. nItem = m_flSrc->GetNextItem(nItem, LVNI_ALL|LVNI_SELECTED);
  387. }
  389. CString strDest = m_strDest.Left(
  390. m_strDest.ReverseFind('\')+1);
  392. CFile fPf;
  393. FILE_ENTRY *pFe;
  394. PACK_FILE_HEAD pfh;
  396. if (!fPf.Open(strDest+"$$$$$$$$.$$$", CFile::modeCreate|CFile::modeWrite|CFile::typeBinary))
  397. {
  398. MessageBox("包文件创建失败！","PackFile Maker", MB_OK|MB_ICONSTOP);
  399. return;
  400. }
  401. pfh.dwEntryCount = m_map.GetCount();
  402. memcpy(&pfh.dwFlag, "DXGF", 4);
  403. pfh.dwHeadSize = sizeof(PACK_FILE_HEAD);
  404. pfh.wMajorVersion = 0x1;
  405. pfh.wMinorVersion = 0x0;
  406. strcpy(pfh.szDescription, "This file is created by DirectX Guide");
  408. pFe = NULL;
  409. pFe = new FILE_ENTRY[pfh.dwEntryCount+1];
  410. if (pFe == NULL)
  411. {
  412. MessageBox("内存申请失败！", "PackFile Maker", MB_OK|MB_ICONSTOP);
  413. return;
  414. }
  416. DWORD dwCnt = 0;
  417. CString key, val;
  418. POSITION ps;
  419. ps = m_map.GetStartPosition();
  420. while (ps)
  421. {
  422. m_map.GetNextAssoc(ps, key, val);
  423. strcpy(pFe[dwCnt].szFileName, key);
  424. dwCnt++;
  425. }
  427. qsort(pFe, pfh.dwEntryCount, sizeof(FILE_ENTRY), Compare);
  429. LONG lOffset = sizeof(PACK_FILE_HEAD) + (pfh.dwEntryCount+1)*sizeof(FILE_ENTRY);
  431. CFile fin;
  432. CFastFile ffin;
  434. DWORD dwSize = 0;
  435. for (dwCnt=0; dwCnt<pfh.dwEntryCount; dwCnt++)
  436. {
  437. if(!m_map.Lookup(pFe[dwCnt].szFileName, val))
  438. {
  439. MessageBox("文件目录出错！", "PackFile Maker");
  440. delete [] pFe;
  441. return;
  442. }
  444. if (val == "nDestn")
  445. {
  446. if (!ffin.Open(val=="Src"?pFfmSrc:pFfmDest, pFe[dwCnt].szFileName))
  447. {
  448. MessageBox("文件打开失败！", "PackFile Maker", MB_OK|MB_ICONSTOP);
  449. fPf.Close();
  450. delete [] pFe;
  451. return;
  452. }
  453. pFe[dwCnt].lOffset = lOffset;
  454. memcpy(&(pFe[dwCnt].ftCreationTime), &(ffin.m_pFE->ftCreationTime), sizeof(FILETIME));
  455. memcpy(&(pFe[dwCnt].ftWriteTime), &(ffin.m_pFE->ftWriteTime), sizeof(FILETIME));
  456. fPf.Seek(lOffset, CFile::begin);
  457. fPf.Write(ffin.GetPtr(), ffin.GetFileSize());
  458. lOffset += ffin.GetFileSize();
  459. dwSize += ffin.GetFileSize();
  460. }
  461. else
  462. {
  463. if (!fin.Open(val, CFile::modeRead|CFile::shareDenyNone|CFile::typeBinary))
  464. {
  465. MessageBox("文件打开失败！", "PackFile Maker", MB_OK|MB_ICONSTOP);
  466. fPf.Close();
  467. delete [] pFe;
  468. return;
  469. }
  470. pFe[dwCnt].lOffset = lOffset;
  471. GetFileTime((HANDLE)fin.m_hFile, &(pFe[dwCnt].ftCreationTime), &ft, &(pFe[dwCnt].ftWriteTime));
  472. fPf.Seek(lOffset, CFile::begin);
  473. int nRead;
  474. do
  475. {
  476. nRead = fin.Read(buf, 1024);
  477. fPf.Write(buf, nRead);
  478. }while (nRead == 1024);
  479. lOffset += fin.GetLength();
  480. dwSize += fin.GetLength();
  481. fin.Close();
  482. }
  483. UpdateProg(dwSize);
  484. }
  485. strcpy(pFe[pfh.dwEntryCount].szFileName, "-[The  End]-");
  486. pFe[pfh.dwEntryCount].lOffset = lOffset;
  487. pfh.dwFileSize = lOffset;
  489. fPf.Seek(0, CFile::begin);
  490. fPf.Write(&pfh, sizeof(pfh));
  491. fPf.Write(pFe, (pfh.dwEntryCount+1)*sizeof(FILE_ENTRY));
  492. fPf.Close();
  493. delete [] pFe;
  494. m_flDest->Unload();
  495. CFile::Remove(m_strDest);
  496. CFile::Rename(strDest+"$$$$$$$$.$$$", m_strDest);
  497. m_flSrc->LoadDirectory(m_strSrc);
  498. m_flDest->LoadFastfile(m_strDest);
  499. }
  501. void CCopyFilesDlg::CopyDD()
  502. {
  503. LPWIN32_FIND_DATA pFd;
  504. DWORD dwSize = 0;
  505. LVITEM lvi;
  506. char drive[_MAX_DRIVE];
  507. char dir[_MAX_DIR];
  508. char fname[_MAX_FNAME];
  509. char ext[_MAX_EXT];
  510. char buf[1024];
  511. CString strName;
  512. m_map.RemoveAll();
  514. m_dwSize = 0;
  515. int nItem = m_flSrc->GetNextItem(-1, LVNI_ALL|LVNI_SELECTED);
  516. while (nItem!=-1)
  517. {
  518. pFd = (LPWIN32_FIND_DATA)m_flSrc->GetItemData(nItem);
  519. _splitpath(pFd->cFileName,drive,dir,fname,ext);
  520. strName = fname;
  521. strName += ext;
  522. if (pFd->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
  523. {
  524. if (strName != "..")
  525. SearchDirectory(strName, TRUE);
  526. }
  527. else
  528. {
  529. m_map.SetAt(strName, strName);
  530. m_dwSize += pFd->nFileSizeLow;
  531. }
  532. lvi.mask = LVIF_STATE;
  533. lvi.iItem = nItem;
  534. lvi.iSubItem = 0;
  535. lvi.stateMask = 0xFFFF;
  536. // get all state flags
  537. m_flSrc->GetItem(&lvi);
  538. lvi.state ^= LVIS_SELECTED;
  539. m_flSrc->SetItem(&lvi);
  540. nItem = m_flSrc->GetNextItem(nItem, LVNI_ALL|LVNI_SELECTED);
  541. }
  543. DWORD dwCnt = 0;
  544. CFile fin, fout;
  545. CString key, val;
  546. POSITION ps;
  547. ps = m_map.GetStartPosition();
  548. while (ps)
  549. {
  550. m_map.GetNextAssoc(ps, key, val);
  551. if (fin.Open(m_strSrc+val, CFile::modeRead|CFile::shareDenyNone|CFile::typeBinary))
  552. {
  553. if (fout.Open(m_strDest+val, CFile::modeCreate|CFile::modeWrite|CFile::typeBinary))
  554. {
  555. int nRead;
  556. do
  557. {
  558. nRead = fin.Read(buf, 1024);
  559. fout.Write(buf, nRead);
  560. dwSize += nRead;
  561. UpdateProg(dwSize);
  562. }while (nRead == 1024);
  563. CFileStatus status;
  564. fin.GetStatus(status);
  565. fin.Close();
  566. fout.Close();
  567. CFile::SetStatus(m_strDest+val, status);
  568. }
  569. }
  570. }
  571. }
  573. void CCopyFilesDlg::OnCancel() 
  574. {
  575. // TODO: Add extra cleanup here
  577. CDialog::OnCancel();
  578. }