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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > P2P编程 > 查看源码
CategoryDownload.cpp
资源名称：GGBT.rar　[点击查看]
上传用户：lds876
上传日期：2013-05-25
资源大小：567k
文件大小：18k
源码类别：

P2P编程

开发平台：

Visual C++

CategoryDownload.cpp：源码内容
  1. // CategoryDownload1.cpp : implementation file
  2. //
  4. #include "stdafx.h"
  5. #include "testbt.h"
  6. #include "CategoryDownload.h"
  8. #include "download.h"
  9. #include "FilesListCtrl.h"
  10. #include "DlgNewDownload.h"
  11. #include "FileBase.h"
  12. #include "SetupRegister.h"
  14. #ifdef _DEBUG
  15. #define new DEBUG_NEW
  16. #undef THIS_FILE
  17. static char THIS_FILE[] = __FILE__;
  18. #endif
  21. /////////////////////////////////////////////////////////////////////////////
  22. // CCategoryDownload
  24. CCategoryDownload::CCategoryDownload()
  25. {
  26. // BOOL bRet  = DeleteDiretory("d:\复件 Downloads");
  27. m_pFilesListCtrl = 0;
  28. }
  30. CCategoryDownload::~CCategoryDownload()
  31. {
  32. }
  35. BEGIN_MESSAGE_MAP(CCategoryDownload, CTreeCtrl)
  36. //{{AFX_MSG_MAP(CCategoryDownload)
  37. ON_WM_DESTROY()
  38. //}}AFX_MSG_MAP
  39. ON_MESSAGE(DOWNLOAD_TERMINATED, OnDownloadTerminated)
  40. ON_MESSAGE(STORAGE_CHECK_COMPLETE, OnStorageCheckComplete)
  41. END_MESSAGE_MAP()
  43. /////////////////////////////////////////////////////////////////////////////
  44. // CCategoryDownload message handlers
  46. void CCategoryDownload::SetFilesListCtrl(CFilesListCtrl* pFilesListCtrl)
  47. {
  48. assert(pFilesListCtrl);
  49. m_pFilesListCtrl = pFilesListCtrl;
  50. }
  52. int CCategoryDownload::OnCreate(LPCREATESTRUCT lpCreateStruct) 
  53. {
  54. return 0;
  55. }
  57. void CCategoryDownload::GetRateTotals(long& lUpRate, long& lDownRate)
  58. {
  59. lUpRate = 0, lDownRate = 0;
  60. for (int i=0; i<m_vRuninings.size(); i++)
  61. {
  62. if (!m_vRuninings[i]->m_pDownload)
  63. {
  64. assert(false);
  65. m_vRuninings.erase(m_vRuninings.begin() + i);
  66. break;
  67. }
  69. if (m_vRuninings[i]->m_pDownload && 
  70. m_vRuninings[i]->m_pDownload->IsDownloading() && 
  71. !m_vRuninings[i]->m_pDownload->IsPause())
  72. {
  73. lUpRate += m_vRuninings[i]->m_pDownload->GetStatics().m_lUpRate;
  74. lDownRate  += m_vRuninings[i]->m_pDownload->GetStatics().m_lDownRate;
  75. }
  76. }
  77. }
  78. /**********************************************************************
  80. base .
  82. **********************************************************************/
  83. void CCategoryDownload::ContinueTheUncloseds()
  84. {
  85. for (int i=0; i<m_vUncloseds.size(); i++)
  86. {
  87. Download(CTreeCursor(m_vUncloseds[i].m_hTreeItem, this), m_vUncloseds[i].m_pFileDBItem);
  88. }
  89. m_vUncloseds.clear();
  90. }
  92. // called before save and exit.
  93. void CCategoryDownload::StopAllCompleteds() 
  94. {
  95. CCategoryDBItem* pItem = (CCategoryDBItem*)m_curDownloading.GetData();
  97. for (int i=0; i<pItem->m_vFileDBItems.size(); i++)
  98. {
  99. if (pItem->m_vFileDBItems[i]->m_pDownload)
  100. pItem->m_vFileDBItems[i]->m_bUnclosed = true;
  102. _StopDBFileItem(pItem->m_vFileDBItems[i]);
  103. StopDBFilesMoveComplete(pItem->m_vFileDBItems[i]);
  104. }
  105. }
  107. void CCategoryDownload::OnDestroy() 
  108. {
  109. // Release downloads.
  110. DeleteAllData(GetRootItem());
  112. for (int i=0; i<m_vDeleteings.size(); i++)
  113. {
  114. CDownload* pDownload = m_vDeleteings[i];
  115. delete pDownload;
  116. }
  117. m_vDeleteings.clear();
  119. CTreeCtrl::OnDestroy();
  120. }
  123. void CCategoryDownload::DeleteAllData(CTreeCursor& curDel) 
  124. {
  125. if (!curDel) return;
  127. if (curDel.HasChildren())
  128. {
  129. CTreeCursor curNext;
  130. CTreeCursor curChild = curDel.GetChild();
  131. while (curChild)
  132. {
  133. DeleteAllData(curChild);
  134. curChild = curChild.GetNext(TVGN_NEXT);
  135. }
  136. }
  138. CCategoryDBItem* pData = (CCategoryDBItem*)curDel.GetData();
  139. assert(pData);
  140. for (int i=0; i<pData->m_vFileDBItems.size(); i++)
  141. {
  142. // delete.
  143. if (pData->m_vFileDBItems[i]->m_pDownload)
  144. _StopDBFileItem(pData->m_vFileDBItems[i]);
  146. delete pData->m_vFileDBItems[i];
  147. }
  149. delete pData;
  150. // curDel.Delete();
  151. }
  153. /**********************************************************************
  155.  download object feedback message handler
  156.  parameter : 
  157. long wParam : handle to cursor.
  158. long lParam : pointer to download object.
  160. **********************************************************************/
  162. void CCategoryDownload::OnDownloadTerminated(long wParam, long lParam)
  163. {
  164. if (m_bNoNotifications)
  165. {
  166. assert(false);
  167. return;
  168. }
  170. assert(wParam && lParam);
  172. for (int i=0; i<m_vDeleteings.size(); i++)
  173. {
  174. if (m_vDeleteings[i] == (CDownload*) lParam)
  175. {
  176. CDownload* pDownload = (CDownload*) lParam;
  177. delete pDownload;
  178. m_vDeleteings.erase(m_vDeleteings.begin() + i);
  179. TRACE("rndownload terminatedrn");
  180. // m_pFilesListCtrl->OnDownloadTerminated(lParam);
  181. return;
  182. }
  183. }
  185. CFileDBItem* pBadFileDBItem = findCursorByDownloadPointer(GetRootItem(), (CDownload*) lParam);
  186. if (!pBadFileDBItem)
  187. {
  188. assert(false);
  189. return;
  190. }
  192. _StopDBFileItem(pBadFileDBItem);
  193. bool bCompletedMove = StopDBFilesMoveComplete(pBadFileDBItem);
  194. /*
  195. string strBadMsg = pBadFileDBItem->m_pDownload->GetBadMsg().data();
  196. pBadFileDBItem->m_pDownload->GetSystemMessage(pBadFileDBItem->m_vMsg);
  197. pBadFileDBItem->m_bBad = true;
  198. pBadFileDBItem->m_fComplete = 0;
  199. //*/
  201. // popup from download waiting deque, let engine start next one. refresh filelist if need.
  202. m_DownloadEngine.StopDownload(pBadFileDBItem);
  203. m_pFilesListCtrl->OnDownloadTerminated((long)pBadFileDBItem, bCompletedMove);
  205. // release download object
  206. // delete pBadFileDBItem->m_pDownload;
  207. // pBadFileDBItem->m_pDownload = 0;
  208. }
  211. void CCategoryDownload::OnStorageCheckComplete(long wParam, long lParam)
  212. {
  213. assert(lParam);
  214. m_DownloadEngine.ExcuteDownload(lParam);
  215. }
  217. CFileDBItem* CCategoryDownload::findCursorByDownloadPointer(CTreeCursor curItem, CDownload* pDownload)
  218. {
  219. CCategoryDBItem* pItem = (CCategoryDBItem*)curItem.GetData();
  220. assert(pItem && curItem);
  222. for (int i=0; i<pItem->m_vFileDBItems.size(); i++)
  223. {
  224. if (pDownload == pItem->m_vFileDBItems[i]->m_pDownload)
  225. {
  226. return pItem->m_vFileDBItems[i];
  227. }
  228. }
  230. if (curItem.HasChildren())
  231. {
  232. CTreeCursor curChild = curItem.GetChild();
  233. while (curChild)
  234. {
  235. CFileDBItem* pRet = findCursorByDownloadPointer(curChild, pDownload);
  236. if (pRet)
  237. return pRet;
  239. curChild = curChild.GetNext(TVGN_NEXT);
  240. }
  241. }
  243. return 0;
  244. }
  246. /**********************************************************************
  248.  data manipulate.
  250. **********************************************************************/
  252. bool CCategoryDownload::Download(CTreeCursor curItem, CFileDBItem* pFileDBItem)
  253. {
  254. // put the download operation in Download deque.
  255. pFileDBItem->m_bBad = false;
  257. if (m_vRuninings.size() >= m_pSetupRegister->m_lDownloadAllCount)
  258. {
  259. pFileDBItem->m_bBad = true;
  261. CString strBad;
  262. strBad.Format("已运行任务数大于全局任务数(%d), 请查看你的任务数设置", m_pSetupRegister->m_lDownloadAllCount);
  264. time_t tNow;
  265. time(&tNow);
  266. time(&pFileDBItem->m_tModifiedTime);
  267. pFileDBItem->m_vMsg.push_back(CSystemMsg(tNow, strBad.GetBuffer(0), CSystemMsg::eBad));
  268. }
  269. else
  270. {
  271. m_vRuninings.push_back(pFileDBItem);
  272. m_DownloadEngine.StartDownload(pFileDBItem, curItem);
  273. }
  275. //
  276. // Move from true category to downloading category.
  277. //
  278. if (curItem == m_curDownloading)
  279. return false;
  281. if (!_MoveItemFromto(curItem, m_curDownloading, pFileDBItem))
  282. return false;
  284. return true;
  285. }
  287. void CCategoryDownload::PauseDBFiles(CFileDBItem* pFileDBItem)
  288. {
  289. if (!pFileDBItem->m_pDownload || pFileDBItem->m_pDownload->IsPause())
  290. {
  291. assert(false);
  292. return;
  293. }
  295. if (pFileDBItem->m_pDownload->IsDownloading())
  296. {
  297. CStatics statics = pFileDBItem->m_pDownload->GetStatics();
  299. if (statics.m_bCheckingDone)
  300. {
  301. vector<long> vHaves;
  302. pFileDBItem->m_pDownload->GetFractions(vHaves);
  303. float fComplete = statics.m_fCompleted;
  305. pFileDBItem->SetHave(vHaves, fComplete);
  306. pFileDBItem->m_lPieceCount = vHaves.size();
  308. if (!pFileDBItem->m_vUnneededFileInx.empty())
  309. pFileDBItem->m_fCompletePart = statics.m_fCompletedPart;
  310. }
  311. }
  313. pFileDBItem->m_pDownload->Pause();
  314. }
  316. void CCategoryDownload::StopDBFiles(vector<CFileDBItem*> vToStopFileDBItems)
  317. {
  318. //
  319. // release from m_DownloadEngine.
  320. //
  321. m_DownloadEngine.StopDownloadArray(vToStopFileDBItems);
  323. //
  324. // truely release the download object.
  325. //
  326. for (int i=0; i<vToStopFileDBItems.size(); i++)
  327. {
  328. CFileDBItem* pFileDBItem = vToStopFileDBItems[i];
  330. if (!pFileDBItem->m_pDownload)
  331. {
  332. assert(false);
  333. continue;
  334. }
  336. _StopDBFileItem(pFileDBItem);
  338. time_t tNow;
  339. time(&tNow);
  340. pFileDBItem->m_vMsg.push_back(CSystemMsg(tNow, "用户取消了该任务", CSystemMsg::eCmd));
  341. }
  342. }
  344. void CCategoryDownload::_StopDBFileItem(CFileDBItem* pFileDBItem)
  345. {
  346. if (!pFileDBItem->m_pDownload)
  347. return;
  349. //
  350. // remove from runnning vector.
  351. //
  352. vector<CFileDBItem*>::iterator iter = find(m_vRuninings.begin(), m_vRuninings.end(), pFileDBItem);
  353. if (iter == m_vRuninings.end())
  354. assert(false);
  355. else
  356. {
  357. m_vRuninings.erase(iter);
  358. }
  361. //
  362. // if bad
  363. //
  364. if (pFileDBItem->m_pDownload->IsBad())
  365. {
  366. pFileDBItem->m_bBad = true;
  367. vector<long> vHaves;
  368. pFileDBItem->SetHave(vHaves, 0);
  369. }
  371. if (pFileDBItem->m_pDownload->IsDownloading())
  372. {
  373. CStatics statics = pFileDBItem->m_pDownload->GetStatics();
  375. // Checking and downloading means check completed.
  376. // if (!statics.m_bStorageChecking)
  377. if (statics.m_bCheckingDone)
  378. {
  379. float fComplete = statics.m_fCompleted;
  381. vector<long> vHaves;
  382. pFileDBItem->m_pDownload->GetFractions(vHaves);
  383. pFileDBItem->SetHave(vHaves, fComplete);
  384. pFileDBItem->m_lPieceCount = vHaves.size();
  386. if (!pFileDBItem->m_vUnneededFileInx.empty())
  387. pFileDBItem->m_fCompletePart = statics.m_fCompletedPart;
  388. }
  389. pFileDBItem->m_pDownload->CloseDownload();
  390. pFileDBItem->m_pDownload->GetSystemMessage(pFileDBItem->m_vMsg);
  391. m_vDeleteings.push_back(pFileDBItem->m_pDownload);
  392. }
  393. else
  394. {
  395. pFileDBItem->m_pDownload->GetSystemMessage(pFileDBItem->m_vMsg);
  396. delete pFileDBItem->m_pDownload;
  397. }
  399. pFileDBItem->m_pDownload = 0;
  400. }
  403. bool CCategoryDownload::StopDBFilesMoveComplete(CFileDBItem* pFileDBItem)
  404. {
  405. assert(pFileDBItem);
  407. if (!pFileDBItem->m_vUnneededFileInx.empty())
  408. {
  409. if (pFileDBItem->m_fCompletePart < 1)
  410. return false;
  411. }
  412. else
  413. {
  414. if (pFileDBItem->m_fComplete < 1)
  415. return false;
  416. }
  418. //
  419. // move the stoped completed item to the true category assinged.
  420. //
  421. CTreeCursor curTrueItem = findCursorByDirid(pFileDBItem->m_lDirectoryID);
  422. if (!curTrueItem)
  423. {
  424. assert(false);
  425. return false;
  426. }
  428. if (curTrueItem == m_curDownloading)
  429. return false;
  431. if (!_MoveItemFromto(m_curDownloading, curTrueItem, pFileDBItem))
  432. {
  433. assert(false);
  434. return false;
  435. }
  437. return true;
  438. }
  440. bool CCategoryDownload::DeleteDBFile(CTreeCursor curCategory, CFileDBItem* pFileDBItem, 
  441.  bool bForceDelete, bool bDelUncompleted, bool bDelCompleted)
  442. {
  443. //
  444. // Release from m_DownloadEngine.
  445. //
  446. if (pFileDBItem->m_pDownload)
  447. m_DownloadEngine.StopDownload(pFileDBItem);
  449. //
  450. // If temperory delete, just move it to recycle category.
  451. //
  452. if (curCategory != m_curRecycle && !bForceDelete)
  453. {
  454. _StopDBFileItem(pFileDBItem);
  455. // FileDBItemMoveto(curCategory, m_curRecycle, pFileDBItem, false, true);
  456. _MoveItemFromto(curCategory, m_curRecycle, pFileDBItem);
  457. return true;
  458. }
  460. //
  461. // Remove the item in current category, and release it.
  462. //
  463. CCategoryDBItem* pTrueCategory = (CCategoryDBItem*)curCategory.GetData();
  464. assert(curCategory && pTrueCategory);
  466. bool bfind = false;
  467. for (int i=0; i<pTrueCategory->m_vFileDBItems.size(); i++)
  468. {
  469. if (pTrueCategory->m_vFileDBItems[i] == pFileDBItem)
  470. {
  471. pTrueCategory->m_vFileDBItems.erase(pTrueCategory->m_vFileDBItems.begin() + i);
  472. _StopDBFileItem(pFileDBItem);
  474. if (pFileDBItem->m_fComplete >= 1) 
  475. DeleteFileDBItemFiles(pFileDBItem, bDelCompleted);
  476. else
  477. DeleteFileDBItemFiles(pFileDBItem, bDelUncompleted);
  479. delete pFileDBItem;
  480. bfind = true;
  481. break;
  482. }
  483. }
  484. assert(bfind);
  486. return true;
  487. }
  489. bool CCategoryDownload::DeleteFileDBItemFiles(CFileDBItem* pFileDBItem, bool bDelDownloaded) const
  490. {
  491. CString strTorrentFileName= (GetDBSavePath() + pFileDBItem->m_strTorrentFileName).data(); 
  492. BOOL bRet = DeleteFile(strTorrentFileName);
  493. if (!bRet)
  494. {
  495. CString strErr = WSAShowError().data();
  496. assert(false);
  497. // return false;
  498. }
  500. if (bDelDownloaded)
  501. {
  502. if (!DeleteDiretory(pFileDBItem->m_strFileName.data()))
  503. {
  504. assert(false);
  505. return false;
  506. }
  507. }
  509. return true;
  510. }
  512. bool CCategoryDownload::IsMovingFiles()
  513. {
  514. return ::IsMovingFiles() > 0;
  515. }
  517. bool CCategoryDownload::FileDBItemMovetoArray(CTreeCursor curSrc, CTreeCursor curTarget, vector<CFileDBItem*>& vFileDBItem)
  518. {
  519. if (curSrc == curTarget)
  520. return false;
  522. bool bMoveFile = false, bMoveCategory = true;
  524. //
  525. // Get running items.
  526. //
  527. vector<CFileDBItem*> vToStopFileDBItems;
  528. for (int i=0; i< vFileDBItem.size(); i++)
  529. {
  530. CFileDBItem* pFileDBItem = vFileDBItem[i];
  531. if (pFileDBItem->m_pDownload)
  532. vToStopFileDBItems.push_back(pFileDBItem);
  533. }
  535. //
  536. // Query user operations.
  537. //
  538. if (curTarget == m_curRecycle)
  539. {
  540. if (!vToStopFileDBItems.empty())
  541. {
  542. if (AfxMessageBox("有下载正在进行中, 您是否确定删除?", MB_YESNO|MB_DEFBUTTON2) != IDYES)
  543. return false;
  545. // if is downloading, popup it from starting engine deque.
  546. StopDBFiles(vToStopFileDBItems);
  548. bMoveFile = false;
  549. bMoveCategory = true;
  550. }
  551. }
  552. else
  553. {
  554. bMoveFile = false;
  555. bMoveCategory = true;
  556. // if (curSrc == m_curDownloading)
  557. // bMoveCategory = false;
  559. switch (m_pSetupRegister->m_eOperMoveToCate)
  560. {
  561. case CSetupRegister::ePromptMoveCate:
  562. {
  563. if (!vToStopFileDBItems.empty())
  564. {
  565. if (AfxMessageBox("有下载正在进行中,移动已下载文件将停止下载,您是否确定移动已下载文件?", MB_YESNO|MB_DEFBUTTON2) == IDYES)
  566. bMoveFile = true;
  567. else
  568. return false;
  570. StopDBFiles(vToStopFileDBItems);
  571. }
  572. else
  573. {
  574. if (AfxMessageBox("是否移动已下载文件?", MB_YESNO|MB_ICONQUESTION) == IDYES)
  575. bMoveFile = true;
  576. }
  578. }
  579. break;
  580. case CSetupRegister::eDontMove:
  581. {
  582. bMoveFile = false;
  583. }
  584. break;
  585. case CSetupRegister::eMove:
  586. {
  587. bMoveFile = true;
  588. }
  589. break;
  590. }
  591. }
  593. //
  594. // Move.
  595. //
  598. if (bMoveFile)
  599. {
  600. // get target path.
  601. CCategoryDBItem* pTragetItem= (CCategoryDBItem*)curTarget.GetData();
  602. CString strTargetPath = pTragetItem->m_strDefaultDirectory.data();
  604. // get move file path vector.
  605. vector<CString> vstrPathToMove;
  606. for (i=0; i< vFileDBItem.size(); i++)
  607. {
  608. CFileDBItem* pFileDBItem = vFileDBItem[i];
  609. DWORD dwAttr = GetFileAttributes(pFileDBItem->m_strFileName.data());
  610. if (dwAttr !=  0xffffffff)
  611. {
  612. string strName, strPath;
  613. SplitPathName(pFileDBItem->m_strFileName, strPath, strName);
  615. if (formatDir(pTragetItem->m_strDefaultDirectory) != formatDir(strPath))
  616. {
  617. vstrPathToMove.push_back(pFileDBItem->m_strFileName.data());
  618. }
  619. }
  620. }
  622. // call move function.
  623. if (!vstrPathToMove.empty())
  624. {
  625. if (!MoveDiretorySystem(vstrPathToMove, pTragetItem->m_strDefaultDirectory.data(), GetSafeHwnd()))
  626. {
  627. assert(false);
  628. return false;
  629. }
  630. }
  632. // change the filedbitem path.
  633. for (i=0; i< vFileDBItem.size(); i++)
  634. {
  635. CFileDBItem* pFileDBItem = vFileDBItem[i];
  637. string strName, strPath;
  638. SplitPathName(pFileDBItem->m_strFileName, strPath, strName);
  639. if (formatDir(pTragetItem->m_strDefaultDirectory) != formatDir(strPath))
  640. {
  641. pFileDBItem->m_strFileName = formatDir(pTragetItem->m_strDefaultDirectory) + strName;
  642. }
  643. }
  644. }
  646. for (i=0; i< vFileDBItem.size(); i++)
  647. {
  648. CFileDBItem* pFileDBItem = vFileDBItem[i];
  649. FileDBItemMoveto(curSrc, curTarget, pFileDBItem, bMoveFile, bMoveCategory);
  650. }
  652. return bMoveCategory;
  653. }
  655. bool CCategoryDownload::FileDBItemMoveto(CTreeCursor curSrc, CTreeCursor curTarget, CFileDBItem* pFileDBItem, bool bMoveFile, bool bMoveCategory)
  656. {
  657. CCategoryDBItem* pTragetItem= (CCategoryDBItem*)curTarget.GetData();
  658. assert(pTragetItem);
  660. if (bMoveFile)
  661. {
  662. /*
  663. DWORD dwAttr = GetFileAttributes(pFileDBItem->m_strFileName.data());
  664. if (dwAttr !=  0xffffffff)
  665. {
  666. string strName, strPath;
  667. SplitPathName(pFileDBItem->m_strFileName, strPath, strName);
  669. if (formatDir(pTragetItem->m_strDefaultDirectory) != formatDir(strPath))
  670. {
  671. if (!MoveDiretorySystem(pFileDBItem->m_strFileName.data(), pTragetItem->m_strDefaultDirectory.data(), GetSafeHwnd()))
  672. return false;
  674. pFileDBItem->m_strFileName = formatDir(pTragetItem->m_strDefaultDirectory) + strName;
  675. }
  676. }
  677. //*/
  678. }
  680. if (bMoveCategory)
  681. {
  682. if (!_MoveItemFromto(curSrc, curTarget, pFileDBItem))
  683. return false;
  684. }
  687. // change dirid to target dirid.
  688. pFileDBItem->m_lDirectoryID = pTragetItem->m_lDirectoryID;
  690. return true;
  691. }
  693. bool CCategoryDownload::FileDBItemRestore(CFileDBItem* pFileDBItem)
  694. {
  695. CTreeCursor curMove = findCursorByDirid(pFileDBItem->m_lDirectoryID);
  696. if (pFileDBItem->m_fComplete < 1)
  697. curMove = m_curDownloading;
  699. assert(curMove);
  700. _MoveItemFromto(m_curRecycle, curMove, pFileDBItem);
  701. return true;
  702. }
  704. bool CCategoryDownload::_MoveItemFromto(CTreeCursor curSrc, CTreeCursor curTarget, CFileDBItem* pFileDBItem)
  705. {
  706. if (curSrc == curTarget || !curSrc || !curTarget)
  707. {
  708. assert(false);
  709. return false;
  710. }
  712. // remove form src.
  713. bool bfind = false;
  714. CCategoryDBItem* pSrcItem= (CCategoryDBItem*)curSrc.GetData();
  715. assert(pSrcItem);
  716. for (int i=0; i<pSrcItem->m_vFileDBItems.size(); i++)
  717. {
  718. if (pSrcItem->m_vFileDBItems[i] == pFileDBItem)
  719. {
  720. pSrcItem->m_vFileDBItems.erase(pSrcItem->m_vFileDBItems.begin() + i);
  721. bfind = true;
  722. break;
  723. }
  724. }
  725. if (!bfind)
  726. {
  727. assert(false);
  728. return false;
  729. }
  731. // insert into target.
  732. CCategoryDBItem* pTragetItem= (CCategoryDBItem*)curTarget.GetData();
  733. assert(pTragetItem);
  734. pTragetItem->m_vFileDBItems.push_back(pFileDBItem);
  736. return true;
  737. }
  738. /********************************************************************
  740.   Attributes.
  742. ********************************************************************/
  744. bool CCategoryDownload::IsDownloading()
  745. {
  746. return findDownloading(GetRootItem());
  747. }
  749. bool CCategoryDownload::findDownloading(CTreeCursor curItem)
  750. {
  751. if (!curItem)
  752. {
  753. assert(false);
  754. return false;
  755. }
  757. CCategoryDBItem* pItem = (CCategoryDBItem*)curItem.GetData();
  758. assert(pItem && curItem);
  760. for (int i=0; i<pItem->m_vFileDBItems.size(); i++)
  761. {
  762. if (pItem->m_vFileDBItems[i]->m_pDownload)
  763. {
  764. return true;
  765. }
  766. }
  768. if (curItem.HasChildren())
  769. {
  770. CTreeCursor curChild = curItem.GetChild();
  771. while (curChild)
  772. {
  773. if (findDownloading(curChild))
  774. return true;
  775. curChild = curChild.GetNext(TVGN_NEXT);
  776. }
  777. }
  779. return false;
  780. }