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

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

P2P编程

开发平台：

Visual C++

FilesListCtrl.cpp：源码内容
  1. // FilesListCtrl.cpp : implementation file
  2. //
  4. #include "stdafx.h"
  5. #include "testbt.h"
  6. #include "FilesListCtrl.h"
  9. #include "FileDB.h"
  10. #include "FileTorrent.h"
  11. #include "Download.h"
  12. #include "MonitorWnd.h"
  13. #include "FileBase.h"
  15. #include "DlgNewDownload.h"
  16. #include "CategoryNewDlg.h"
  17. #include "CategoryBarWnd.h"
  18. #include "SetupRegister.h"
  19. #include "DlgRunParameters.h"
  20. #include "DlgDeleteFileDBItem.h"
  22. #ifdef _DEBUG
  23. #define new DEBUG_NEW
  24. #undef THIS_FILE
  25. static char THIS_FILE[] = __FILE__;
  26. #endif
  28. #define DISPLAY_TIMEOUT_ID 1 
  29. #define DISPLAY_TIMEOUT 3000
  30. #define ID_MENUITEM_SHOW_COLUMN 52826
  33. /////////////////////////////////////////////////////////////////////////////
  34. // CFilesListCtrl
  36. CFilesListCtrl::CFilesListCtrl() : 
  37. CListCtrlBaseEx("filelistctrl", true), m_menuspawnPopup(true)
  38. {
  39. m_bDeleteing = false;
  40. m_iSortedCol = eModifiedTime + 1;
  41. m_pMonitorWnd = 0;
  42. m_pCategoryBarWnd = 0;
  43. m_pSetupRegister = 0;
  46. //
  47. // column infos.
  48. //
  49. CString m_strArrToolTip[eAllSize];
  50. CString m_strArrFieldNames[eAllSize];
  51. bool m_bColumnNumeric[eAllSize];
  53. m_strArrToolTip[eIcon] = "箭头向下:下载没有完成.rn箭头向上:下载已经完成,正在做种.rn灰色:尚未连接到服务器rn红色:没有连接到到其他下载者rn蓝色:在你连接的其他客户端中没有种子rn黄色:你没有收到任何外部连接,可能是内网rn绿色:运行良好";
  54. m_strArrToolTip[eFileName] = "文件名";
  55. m_strArrToolTip[eCompleted] = "已下载完成数据的比例";
  56. m_strArrToolTip[eFilesize] = "文件大小";
  57. m_strArrToolTip[eTimeleft] = "完全完成下载的剩余时间";
  58. m_strArrToolTip[eTimerunned] = "已经运行的时间";
  59. m_strArrToolTip[eDownloadrate] = "下载速度";
  60. m_strArrToolTip[eUploadrate] = "上传速度";
  61. m_strArrToolTip[eSeeds] = "种子数量/所有连接数量";
  62. m_strArrToolTip[eCreateTime] = "创建时间";
  63. m_strArrToolTip[eModifiedTime] = "最后一次运行的时间";
  66. m_strArrFieldNames[eIcon] = "状态";
  67. m_strArrFieldNames[eFileName] = "文件名";
  68. m_strArrFieldNames[eCompleted] = "已完成";
  69. m_strArrFieldNames[eFilesize] = "文件大小";
  70. m_strArrFieldNames[eTimeleft] = "剩余时间";
  71. m_strArrFieldNames[eTimerunned] = "已运行时间";
  72. m_strArrFieldNames[eDownloadrate] = "下载速度";
  73. m_strArrFieldNames[eUploadrate] = "上传速度";
  74. m_strArrFieldNames[eSeeds] = "种子/连接";
  75. m_strArrFieldNames[eCreateTime] = "创建时间";
  76. m_strArrFieldNames[eModifiedTime] = "修改时间";
  78. m_bColumnNumeric[eIcon] = false;
  79. m_bColumnNumeric[eFileName] = false;
  80. m_bColumnNumeric[eCompleted] = true;
  81. m_bColumnNumeric[eFilesize] = true;
  82. m_bColumnNumeric[eTimeleft] = true;
  83. m_bColumnNumeric[eTimerunned] = true;
  84. m_bColumnNumeric[eDownloadrate] = true;
  85. m_bColumnNumeric[eUploadrate] = true;
  86. m_bColumnNumeric[eSeeds] = true;
  87. m_bColumnNumeric[eCreateTime] = false;
  88. m_bColumnNumeric[eModifiedTime] = false;
  90. for (int i=0; i<eAllSize; i++)
  91. AddColumn(m_strArrFieldNames[i], m_bColumnNumeric[i], 100, m_strArrToolTip[i]);
  93. }
  95. CFilesListCtrl::~CFilesListCtrl()
  96. {
  97. }
  100. BEGIN_MESSAGE_MAP(CFilesListCtrl, CListCtrlBaseEx)
  101. //{{AFX_MSG_MAP(CFilesListCtrl)
  102. ON_WM_CREATE()
  103. ON_WM_CONTEXTMENU()
  104. ON_COMMAND(ID_MENUITEM_DEL, OnMenuitemDel)
  105. ON_COMMAND(ID_MENUITEM_DOWNLOAD, OnMenuitemDownload)
  106. ON_NOTIFY_REFLECT(LVN_ITEMCHANGED, OnItemchanged)
  107. ON_COMMAND(ID_MENUITEM_STOP, OnMenuitemStop)
  108. ON_WM_TIMER()
  109. ON_WM_DESTROY()
  110. ON_COMMAND(ID_MENUITEM_MOVETO, OnMenuitemMoveto)
  111. ON_COMMAND(ID_MENUITEM_FILE_PROPERTY, OnMenuitemFileProperty)
  112. ON_COMMAND(ID_MENUITEM_COPY_TORRENT_FILE_PATH, OnMenuitemCopyTorrentFilePath)
  113. ON_WM_MEASUREITEM()
  114. ON_WM_DRAWITEM()
  115. //}}AFX_MSG_MAP
  116. // ON_NOTIFY_REFLECT(HDN_ITEMCLICK, OnItemclickSort)
  117. // ON_NOTIFY(HDN_ITEMCLICK, 0, OnItemclickSort) 
  118. ON_NOTIFY_REFLECT(NM_DBLCLK, OnItemDblclk)
  119. // ON_NOTIFY_REFLECT_EX(LVN_COLUMNCLICK, OnItemclickSort)
  120. ON_NOTIFY_REFLECT(LVN_BEGINDRAG, OnBegindrag)
  121. ON_COMMAND(ID_MENUITEM_PAUSE, OnMenuitemPause)
  122. ON_COMMAND(ID_MENUITEM_OPEN_DOWNLOADED_FILE, OnMenuitemOpenDownloadedFile)
  123. ON_COMMAND(ID_MENUITEM_RUN_PARAMETERS, OnMenuitemRunParamter)
  124. ON_COMMAND(ID_MENUITEM_OPEN_DOWNLOADED_DIRECTORY, OnMenuitemOpenDownloadedDirectory)
  125. ON_COMMAND(ID_MENUITEM_RESTORE, OnMenuitemRestore)
  126. ON_COMMAND_RANGE(ID_MENUITEM_MONITOR_INFORMATION, ID_MENUITEM_MONITOR_LOGS, OnMenuitemMonitorSub)
  127. ON_COMMAND_RANGE(ID_MENUITEM_SHOW_COLUMN, ID_MENUITEM_SHOW_COLUMN + eAllSize, OnMenuitemShowColumn)
  128. ON_NOTIFY_REFLECT(NM_CUSTOMDRAW, OnCustomDraw)
  129. // ON_MESSAGE(DOWNLOAD_TERMINATED, OnDownloadTerminated)
  130. // ON_COMMAND(ID_MENUITEM_LOCATE_CATEGORY, OnMenuitemLocateCategory)
  131. // ON_COMMAND(ID_MENUITEM_DEL_LINK, OnMenuitemDelLink)
  132. END_MESSAGE_MAP()
  134. /////////////////////////////////////////////////////////////////////////////
  135. // CFilesListCtrl message handlers
  137. void CFilesListCtrl::OnShowColumn(int iItem)
  138. {
  139. ShowFileDBItemText(iItem);
  140. ShowFileDBItemActive(iItem);
  141. }
  143. void CFilesListCtrl::SetSetupParameter()
  144. {
  145. assert(m_pSetupRegister);
  146. BOOL bRet = KillTimer(DISPLAY_TIMEOUT_ID);
  147. assert(bRet);
  148. bRet = SetTimer(DISPLAY_TIMEOUT_ID, m_pSetupRegister->m_lDisplayItval, 0);
  149. assert(bRet);
  150. }
  152. BOOL CFilesListCtrl::CreateEx(CWnd *pParent, CRect &rc, long lParam, CMonitorWnd* pMonitorWnd, CCategoryBarWnd* pCategoryBarWnd, CSetupRegister* pSetupRegister)
  153. {
  154. assert(pMonitorWnd && pMonitorWnd->GetSafeHwnd() && pCategoryBarWnd && pSetupRegister);
  156. m_pCategoryBarWnd = pCategoryBarWnd;
  157. m_pCategoryBarWnd->SetFilesListCtrl(this);
  159. m_pMonitorWnd = pMonitorWnd;
  160. m_pMonitorWnd->SetCateGoryBarWnd(m_pCategoryBarWnd);
  162. m_pSetupRegister = pSetupRegister;
  164. return Create(WS_VISIBLE|WS_CHILD|WS_BORDER|LVS_REPORT|LVS_SHOWSELALWAYS, rc, pParent, 10025);
  165. // return Create(WS_VISIBLE|WS_CHILD|WS_BORDER|LVS_REPORT, rc, pParent, 10025);
  166. // return Create(WS_VISIBLE|WS_CHILD|WS_BORDER|LVS_REPORT|LVS_OWNERDRAWFIXED, rc, pParent, 10025);
  167. }
  169. int CFilesListCtrl::OnCreate(LPCREATESTRUCT lpCreateStruct) 
  170. {
  171. if (CListCtrlBaseEx::OnCreate(lpCreateStruct) == -1)
  172. return -1;
  175. //
  176. // for bitmap menu
  177. //
  178. ULONG ulCmdID[] = {CMenuSpawn::eUnusedImgCmdID, 
  179. CMenuSpawn::eUnusedImgCmdID, 
  180. CMenuSpawn::eUnusedImgCmdID, 
  181. CMenuSpawn::eUnusedImgCmdID,
  182. ID_MENUITEM_DOWNLOAD,
  183. ID_MENUITEM_PAUSE,
  184. ID_MENUITEM_STOP,
  185. ID_MENUITEM_DEL,
  186. CMenuSpawn::eUnusedImgCmdID,
  187. CMenuSpawn::eUnusedImgCmdID,
  188. CMenuSpawn::eNormalImgCmdID
  189. };
  191. m_menuspawnPopup.Create(IDB_IMAGELIST_MENU, IDB_IMAGELIST_MENU_DISABLED, sizeof(ulCmdID)/sizeof(ULONG), ulCmdID);
  193. //
  194. // Modify style.
  195. //
  196. SetExtendedStyle(LVS_EX_FULLROWSELECT ); // | LVS_EX_HEADERDRAGDROP);
  198. //
  199. // ImageList.
  200. //
  201. m_ctlImageDelete.Create(16, 17, ILC_COLOR8|ILC_MASK, 4, 4);
  202. m_ctlImageDelete.Add(AfxGetApp()->LoadIcon(IDI_ICON_DELETE));
  204. HBITMAP hbm = (HBITMAP)::LoadImage(AfxGetInstanceHandle(),
  205. MAKEINTRESOURCE(IDB_IMAGELIST_DOWNLOAD),
  206. IMAGE_BITMAP,
  207. 0,0, 
  208. LR_CREATEDIBSECTION);
  209. CBitmap bm;
  210. bm.Attach(hbm);
  212. m_ctlImage.Create(16, 17, ILC_COLOR8|ILC_MASK, 11, 4);
  213. m_ctlImage.SetBkColor(::GetSysColor(COLOR_WINDOW)); 
  214. m_ctlImage.Add(&bm, (COLORREF)RGB(255,0,255));
  216. SetImageList(&m_ctlImage, LVSIL_SMALL);
  218. SetSortColumn(eIcon + 1);
  221. //
  222. // Set Timer.
  223. //
  224. SetTimer(DISPLAY_TIMEOUT_ID, m_pSetupRegister->m_lDisplayItval, 0);
  225. return 0;
  226. }
  228. void CFilesListCtrl::OnDestroy() 
  229. {
  230. assert(!m_bDeleteing);
  231. m_bDeleteing = true;
  232. CListCtrlBaseEx::OnDestroy();
  233. }
  235. void CFilesListCtrl::OnItemchanged(NMHDR* pNMHDR, LRESULT* pResult) 
  236. {
  237. *pResult = 0;
  239. if (m_bDeleteing)
  240. return;
  242. NM_LISTVIEW* pNMListView = (NM_LISTVIEW*)pNMHDR;
  243. if (pNMListView->uChanged == LVIF_STATE && 
  244. pNMListView->uNewState & LVIS_FOCUSED && 
  245. !(pNMListView->uOldState & LVIS_FOCUSED))
  246. {
  247. int nItem = pNMListView->iItem;
  248. CFileDBItem* pItem  = (CFileDBItem*)GetItemData(nItem);
  249. m_pMonitorWnd->Monitor(pItem);
  250. }
  251. }
  253. void CFilesListCtrl::OnItemDblclk(NMHDR* pNMHDR, LRESULT* pResult) 
  254. {
  255. *pResult = 0;
  256. if (!m_pSetupRegister)
  257. {
  258. assert(false);
  259. return;
  260. }
  262. if (GetSelectedCount() == 1)
  263. {
  264. switch (m_pSetupRegister->m_eOperDbclickItem)
  265. {
  266. case CSetupRegister::eProperty:
  267. {
  268. OnMenuitemFileProperty();
  269. }
  270. break;
  271. case CSetupRegister::eRunning:
  272. {
  273. POSITION pos = GetFirstSelectedItemPosition();
  274. if (!pos)
  275. {
  276. assert(false);
  277. return;
  278. }
  279. int index = GetNextSelectedItem(pos);
  280. CFileDBItem* pItem = (CFileDBItem*)GetItemData(index);
  281. if (!pItem)
  282. {
  283. assert(false);
  284. return;
  285. }
  286. if (pItem->m_pDownload && !pItem->m_pDownload->IsPause())
  287. {
  288. OnMenuitemPause();
  289. }
  290. else
  291. {
  292. OnMenuitemDownload();
  293. }
  294. }
  295. break;
  296. default:
  297. assert(false);
  298. break;
  299. }
  300. }
  301. }
  303. /**********************************************************************
  305. refresh if some download corrupt and the download in current view.
  306. parameter:
  307. lParam : pointer to download object.
  309. **********************************************************************/
  310. void CFilesListCtrl::OnDownloadTerminated(long lParam, bool bCompletedMove)
  311. {
  312. bool bfind = false;
  313. for (int i=0; i<GetItemCount(); i++)
  314. {
  315. CFileDBItem* pItem = (CFileDBItem*)GetItemData(i);
  316. if (pItem && pItem == (CFileDBItem*)lParam)
  317. {
  318. if (bCompletedMove)
  319. {
  320. DeleteItem(i);
  321. }
  322. else
  323. {
  324. bfind = true;
  325. ShowFileDBItemText(i);
  326. m_pMonitorWnd->Monitor(pItem);
  327. }
  328. break;
  329. }
  330. }
  332. if (!bfind)
  333. {
  334. m_pMonitorWnd->Monitor(0);
  335. }
  336. // assert(bfind);
  337. }
  339. void CFilesListCtrl::LoadCatetory(CTreeCursor curItem, CFileDBItem* pFileDBItemSel) //const vector<CFileDBItem*>& vFileDBItems)
  340. {
  341. if (!GetSafeHwnd())
  342. return;
  344. m_curCursor = curItem;
  345. if (!m_curCursor)
  346. {
  347. assert(false);
  348. return;
  349. }
  351. // begin load.
  352. assert(!m_bDeleteing);
  353. m_bDeleteing = true;
  354. SetRedraw(false);
  355. DeleteAllItems();
  357. int iMonitorItem = -1;
  358. // m_pMonitorWnd->Monitor(0);
  360. CCategoryBarWnd::CCategoryDBItem* pItem = (CCategoryBarWnd::CCategoryDBItem*)m_curCursor.GetData();
  361. assert(pItem);
  362. vector<CFileDBItem*>& vFileDBItems = pItem->m_vFileDBItems;
  364. for (int i=0; i<vFileDBItems.size(); i++)
  365. {
  366. CFileDBItem* pItem = vFileDBItems[i];
  368. InsertItem(i, ""); // ctime(&pItem->m_tTime)); //, iImageID);
  369. SetItemData(i, (long)pItem);
  370. ShowFileDBItemText(i);
  372. if (pFileDBItemSel && pFileDBItemSel == pItem)
  373. iMonitorItem = i;
  374. }
  376. if (iMonitorItem != -1)
  377. {
  378. ClearSelectItems();
  380. CFileDBItem* pItem = (CFileDBItem*)GetItemData(iMonitorItem);
  381. if (pItem)
  382. {
  383. SetItemState(iMonitorItem, LVIS_SELECTED|LVIS_FOCUSED, LVIS_SELECTED|LVIS_FOCUSED);
  384. EnsureVisible(iMonitorItem, true);
  385. m_pMonitorWnd->Monitor(pItem);
  386. }
  387. }
  389. SortItems(Compare1, m_iSortedCol);
  391. if (iMonitorItem == -1)
  392. {
  393. if (!vFileDBItems.empty())
  394. {
  395. iMonitorItem = 0;
  396. CFileDBItem* pItem = (CFileDBItem*)GetItemData(iMonitorItem);
  397. if (pItem)
  398. {
  399. SetItemState(iMonitorItem, LVIS_SELECTED|LVIS_FOCUSED, LVIS_SELECTED|LVIS_FOCUSED);
  400. EnsureVisible(iMonitorItem, true);
  401. m_pMonitorWnd->Monitor(pItem);
  402. }
  403. }
  404. else
  405. {
  406. m_pMonitorWnd->Monitor(0);
  407. }
  408. }
  410. // refresh the status.
  411. OnTimer(DISPLAY_TIMEOUT_ID);
  412. SetRedraw(true);
  414. if (pFileDBItemSel)
  415. SetFocus();
  418. m_bDeleteing = false;
  420. }
  423. /************************************************************
  425. popup context menu, and menu command handler.
  427. *************************************************************/
  429. void CFilesListCtrl::OnUpdateMenuitem(CCmdUI* pCmdUI) 
  430. {
  431. bool bstart = false, 
  432. bstop = false, 
  433. bPause = false,
  434. bdelete = false, 
  435. bMoveto = false, 
  436. bProperty = false;
  438. int iSelectedCount = 0;
  439. int iFocusItem = -1;
  441. POSITION pos = GetFirstSelectedItemPosition();
  442. while (pos)
  443. {
  444. int index = GetNextSelectedItem(pos);
  445. if (GetItemState(index, LVIS_FOCUSED) & LVIS_FOCUSED)
  446. iFocusItem = index;
  447. iSelectedCount++;
  449. CFileDBItem* pItem = (CFileDBItem*)GetItemData(index);
  450. if (pItem->m_pDownload)
  451. {
  452. bstop = true;
  454. if (!pItem->m_pDownload->IsPause())
  455. bPause = true;
  456. else
  457. bstart = true;
  458. }
  459. else
  460. {
  461. bstart = true;
  462. }
  464. bdelete = true;
  465. bMoveto = true;
  467. }
  468. if (iSelectedCount == 1)
  469. bProperty = true;
  471. if (m_curCursor == m_pCategoryBarWnd->m_curRecycle)
  472. bstart = bstop = bPause = false;
  474. switch (pCmdUI->m_nID)
  475. {
  476. case ID_MENUITEM_DOWNLOAD:
  477. pCmdUI->Enable(bstart);
  478. break;
  479. case ID_MENUITEM_PAUSE:
  480. pCmdUI->Enable(bPause);
  481. break;
  482. case ID_MENUITEM_STOP:
  483. pCmdUI->Enable(bstop);
  484. break;
  485. case ID_MENUITEM_DEL:
  486. pCmdUI->Enable(bdelete);
  487. break;
  488. case ID_MENUITEM_FILE_PROPERTY:
  489. pCmdUI->Enable(bProperty);
  490. case ID_MENUITEM_OPEN_DOWNLOADED_FILE:
  491. case ID_MENUITEM_OPEN_DOWNLOADED_DIRECTORY:
  492. pCmdUI->Enable(bProperty);
  493. break;
  494. case ID_MENUITEM_MOVETO:
  495. pCmdUI->Enable(bMoveto);
  496. break;
  497. case ID_MENUITEM_RUN_PARAMETERS:
  498. pCmdUI->Enable(bProperty);
  499. break;
  500. case ID_MENUITEM_COPY_TORRENT_FILE_PATH:
  501. pCmdUI->Enable(bProperty);
  502. break;
  504. break;
  506. }
  507. }
  509. bool CFilesListCtrl::OnContextMenuRecycle(CWnd* pWnd, CPoint point) 
  510. {
  511. if (m_curCursor != m_pCategoryBarWnd->m_curRecycle)
  512. return false;
  515. bool bEnable = GetSelectedCount() > 0;
  517. CMenu menu;
  518. if (menu.CreatePopupMenu())
  519. {
  520. menu.AppendMenu(MF_STRING, ID_MENUITEM_RESTORE, "还原(&O)");
  521. menu.AppendMenu(MF_STRING, ID_MENUITEM_DEL, "删除(&D)tDel");
  522. menu.AppendMenu(MF_STRING, ID_MENUITEM_MOVETO, "移动到(&M)...");
  523. menu.AppendMenu(MF_STRING, ID_MENUITEM_FILE_PROPERTY, "属性(&R)");
  525. menu.EnableMenuItem(ID_MENUITEM_RESTORE, MF_BYCOMMAND | 
  526. (bEnable  ? MF_ENABLED : (MF_DISABLED | MF_GRAYED)));
  527. menu.EnableMenuItem(ID_MENUITEM_DEL, MF_BYCOMMAND | 
  528. (bEnable  ? MF_ENABLED : (MF_DISABLED | MF_GRAYED)));
  529. menu.EnableMenuItem(ID_MENUITEM_MOVETO, MF_BYCOMMAND | 
  530. (bEnable  ? MF_ENABLED : (MF_DISABLED | MF_GRAYED)));
  531. menu.EnableMenuItem(ID_MENUITEM_FILE_PROPERTY, MF_BYCOMMAND | 
  532. (bEnable  ? MF_ENABLED : (MF_DISABLED | MF_GRAYED)));
  534. menu.TrackPopupMenu(TPM_LEFTALIGN |TPM_RIGHTBUTTON, point.x, 
  535. point.y, this);
  536. }
  538. return true;
  539. }
  541. void CFilesListCtrl::OnContextMenu(CWnd* pWnd, CPoint point) 
  542. {
  543. if (CListCtrlBaseEx::OnContextMenu(pWnd, point))
  544. return;
  546. if (OnContextMenuRecycle(pWnd, point))
  547. return;
  549. bool bstart = false,
  550. bPause = false,
  551. bstop = false, 
  552. bdelete = false, 
  553. bMoveto = false, 
  554. bProperty = false;
  556. int iSelectedCount = 0;
  557. int iFocusItem = -1;
  559. POSITION pos = GetFirstSelectedItemPosition();
  560. while (pos)
  561. {
  562. int index = GetNextSelectedItem(pos);
  563. if (GetItemState(index, LVIS_FOCUSED) & LVIS_FOCUSED)
  564. iFocusItem = index;
  565. iSelectedCount++;
  567. CFileDBItem* pItem = (CFileDBItem*)GetItemData(index);
  568. if (pItem->m_pDownload)
  569. {
  570. bstop = true;
  571. if (!pItem->m_pDownload->IsPause())
  572. bPause = true;
  573. else
  574. bstart = true;
  575. }
  576. else
  577. {
  578. bstart = true;
  579. }
  581. bdelete = true;
  582. bMoveto = true;
  584. }
  585. if (iSelectedCount == 1)
  586. bProperty = true;
  588. if (m_curCursor == m_pCategoryBarWnd->m_curRecycle)
  589. bstart = bstop = bPause = false;
  591. // trackpopupmenu.
  592. CMenu menu_bar;
  593. menu_bar.LoadMenu(IDR_MENU_CATEGORY);
  594. CMenu* file_menu = menu_bar.GetSubMenu(1);
  597. CMenu* pMonitorMenu = file_menu->GetSubMenu(6);
  598. pMonitorMenu->EnableMenuItem(ID_MENUITEM_MONITOR_INFORMATION, MF_BYCOMMAND | 
  599. (bProperty ? MF_ENABLED : (MF_DISABLED | MF_GRAYED)));
  600. pMonitorMenu->EnableMenuItem(ID_MENUITEM_MONITOR_SUBFILES, MF_BYCOMMAND | 
  601. (bProperty ? MF_ENABLED : (MF_DISABLED | MF_GRAYED)));
  602. pMonitorMenu->EnableMenuItem(ID_MENUITEM_MONITOR_RUNSTATICS, MF_BYCOMMAND | 
  603. (bProperty ? MF_ENABLED : (MF_DISABLED | MF_GRAYED)));
  604. pMonitorMenu->EnableMenuItem(ID_MENUITEM_MONITOR_PEERS, MF_BYCOMMAND | 
  605. (bProperty ? MF_ENABLED : (MF_DISABLED | MF_GRAYED)));
  606. pMonitorMenu->EnableMenuItem(ID_MENUITEM_MONITOR_LOGS, MF_BYCOMMAND | 
  607. (bProperty ? MF_ENABLED : (MF_DISABLED | MF_GRAYED)));
  609. //
  610. // command ui. 
  611. //
  612. file_menu->EnableMenuItem(ID_MENUITEM_DOWNLOAD, MF_BYCOMMAND | 
  613. (bstart ? MF_ENABLED : (MF_DISABLED | MF_GRAYED)));
  615. file_menu->EnableMenuItem(ID_MENUITEM_PAUSE, MF_BYCOMMAND | 
  616. (bPause ? MF_ENABLED : (MF_DISABLED | MF_GRAYED)));
  618. file_menu->EnableMenuItem(ID_MENUITEM_STOP, MF_BYCOMMAND | 
  619. (bstop ? MF_ENABLED : (MF_DISABLED | MF_GRAYED)));
  621. file_menu->EnableMenuItem(ID_MENUITEM_DEL, MF_BYCOMMAND | 
  622. (bdelete ? MF_ENABLED : (MF_DISABLED | MF_GRAYED)));
  624. file_menu->EnableMenuItem(ID_MENUITEM_MOVETO, MF_BYCOMMAND | 
  625. (bMoveto? MF_ENABLED : (MF_DISABLED | MF_GRAYED)));
  627. file_menu->EnableMenuItem(ID_MENUITEM_MONITOR, MF_BYCOMMAND | 
  628. (bProperty? MF_ENABLED : (MF_DISABLED | MF_GRAYED)));
  630. file_menu->EnableMenuItem(ID_MENUITEM_COPY_TORRENT_FILE_PATH, MF_BYCOMMAND | 
  631. (bProperty? MF_ENABLED : (MF_DISABLED | MF_GRAYED)));
  633. file_menu->EnableMenuItem(ID_MENUITEM_FILE_PROPERTY, MF_BYCOMMAND | 
  634. (bProperty? MF_ENABLED : (MF_DISABLED | MF_GRAYED)));
  636. file_menu->EnableMenuItem(ID_MENUITEM_RUN_PARAMETERS, MF_BYCOMMAND | 
  637. (bProperty? MF_ENABLED : (MF_DISABLED | MF_GRAYED)));
  639. // shell excute
  640. file_menu->EnableMenuItem(ID_MENUITEM_OPEN_DOWNLOADED_FILE, MF_BYCOMMAND | 
  641. (bProperty? MF_ENABLED : (MF_DISABLED | MF_GRAYED)));
  643. file_menu->EnableMenuItem(ID_MENUITEM_OPEN_DOWNLOADED_DIRECTORY, MF_BYCOMMAND | 
  644. (bProperty? MF_ENABLED : (MF_DISABLED | MF_GRAYED)));
  646. if (iFocusItem != -1)
  647. {
  648. CFileDBItem* pItem  = (CFileDBItem*)GetItemData(iFocusItem);
  649. long lCount = GetSelectedCount();
  650. if (lCount == 1 && pItem->m_pDownload)
  651. file_menu->EnableMenuItem(ID_MENUITEM_MONITOR, MF_BYCOMMAND | MF_ENABLED);
  652. else
  653. file_menu->EnableMenuItem(ID_MENUITEM_MONITOR, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
  654. }
  656. m_menuspawnPopup.RemapMenuEx(file_menu);
  658. file_menu->TrackPopupMenu(TPM_LEFTALIGN |TPM_RIGHTBUTTON, point.x, 
  659. point.y, this);
  660. }
  662. //
  663. // for bitmap menu trackpopupmenu.
  664. //
  665. void CFilesListCtrl::OnMeasureItem(int nIDCtl, LPMEASUREITEMSTRUCT lpMeasureItemStruct) 
  666. {
  667. if (!m_menuspawnPopup.MeasureItem(lpMeasureItemStruct))
  668. CListCtrlBaseEx::OnMeasureItem(nIDCtl, lpMeasureItemStruct);
  669. }
  671. void CFilesListCtrl::OnDrawItem(int nIDCtl, LPDRAWITEMSTRUCT lpDrawItemStruct) 
  672. {
  673. if (!m_menuspawnPopup.DrawItem(lpDrawItemStruct))
  674. CListCtrlBaseEx::OnDrawItem(nIDCtl, lpDrawItemStruct);
  675. }
  678. void CFilesListCtrl::OnCommandMenuitem(UINT iID) 
  679. {
  680. switch (iID)
  681. {
  682. case ID_MENUITEM_DOWNLOAD:
  683. OnMenuitemDownload();
  684. break;
  685. case ID_MENUITEM_PAUSE:
  686. OnMenuitemPause();
  687. break;
  688. case ID_MENUITEM_STOP:
  689. OnMenuitemStop();
  690. break;
  691. case ID_MENUITEM_DEL:
  692. OnMenuitemDel();
  693. break;
  694. case ID_MENUITEM_FILE_PROPERTY:
  695. OnMenuitemFileProperty();
  696. break;
  697. case ID_MENUITEM_OPEN_DOWNLOADED_FILE:
  698. OnMenuitemOpenDownloadedFile();
  699. break;
  700. case ID_MENUITEM_OPEN_DOWNLOADED_DIRECTORY:
  701. OnMenuitemOpenDownloadedDirectory();
  702. break;
  703. case ID_MENUITEM_MOVETO:
  704. OnMenuitemMoveto();
  705. break;
  706. case ID_MENUITEM_RUN_PARAMETERS:
  707. OnMenuitemRunParamter();
  708. break;
  709. case ID_MENUITEM_COPY_TORRENT_FILE_PATH:
  710. OnMenuitemCopyTorrentFilePath();
  711. break;
  712. }
  713. }
  715. void CFilesListCtrl::OnMenuitemRestore() 
  716. {
  717. assert(m_curCursor == m_pCategoryBarWnd->m_curRecycle);
  718. //
  719. // Get move items.
  720. //
  721. long lCount = GetSelectedCount();
  722. if (lCount <= 0) return;
  724. int* index = new int[lCount];
  725. int i = 0;
  726. bool bMonitorChange = false;
  728. POSITION pos = GetFirstSelectedItemPosition();
  729. while (pos)
  730. {
  731. int nItem = GetNextSelectedItem(pos);
  732. index[i++] = nItem;
  733. }
  735. //
  736. // Move items.
  737. //
  738. for (i=lCount-1; i>=0; i--)
  739. {
  740. CFileDBItem* pItem = (CFileDBItem*)GetItemData(index[i]);
  741. assert(pItem && m_curCursor && m_pCategoryBarWnd);
  743. CTreeCursor curMove = m_pCategoryBarWnd->findCursorByDirid(pItem->m_lDirectoryID);
  744. assert(curMove);
  745. m_pCategoryBarWnd->FileDBItemRestore(pItem);
  746. }
  748. m_bDeleteing = true;
  749. for (i=lCount-1; i>=0; i--)
  750. {
  751. BOOL bRet = DeleteItem(index[i]);
  752. assert(bRet);
  753. }
  754. m_bDeleteing = false;
  756. delete index;
  757. }
  759. void CFilesListCtrl::OnMenuitemMonitorSub(UINT uID) 
  760. {
  761. if (uID >= ID_MENUITEM_MONITOR_INFORMATION && 
  762. uID <= ID_MENUITEM_MONITOR_LOGS)
  763. {
  764. POSITION pos = GetFirstSelectedItemPosition();
  765. if (pos)
  766. {
  767. int index = GetNextSelectedItem(pos);
  768. CFileDBItem* pItem = (CFileDBItem*)GetItemData(index);
  769. m_pMonitorWnd->Monitor(pItem, uID - ID_MENUITEM_MONITOR_INFORMATION);
  770. }
  771. }
  772. }
  774. void CFilesListCtrl::OnMenuitemPause()
  775. {
  776. POSITION pos = GetFirstSelectedItemPosition();
  777. while (pos)
  778. {
  779. int nItem = GetNextSelectedItem(pos);
  781. CFileDBItem* pItem = (CFileDBItem*)GetItemData(nItem);
  782. if (pItem->m_pDownload && !pItem->m_pDownload->IsPause())
  783. {
  784. m_pCategoryBarWnd->PauseDBFiles(pItem);
  785. // pItem->m_pDownload->Pause();
  786. ShowFileDBItemText(nItem);
  787. }
  788. }
  789. }
  791. void CFilesListCtrl::OnMenuitemDel() 
  792. {
  793. DeleteSelectedItem(false) ;
  794. }
  796. void CFilesListCtrl::DeleteSelectedItem(bool bForceDelete) 
  797. {
  798. bool bDownloading = false;
  799. POSITION pos = GetFirstSelectedItemPosition();
  800. while (pos)
  801. {
  802. int nItem = GetNextSelectedItem(pos);
  803. CFileDBItem* pItem = (CFileDBItem*)GetItemData(nItem);
  804. if (pItem && pItem->m_pDownload)
  805. {
  806. bDownloading = true;
  807. break;
  808. }
  809. }
  811. bool bDelUncompleted = false, bDelCompleted = false;
  812. if (m_curCursor == m_pCategoryBarWnd->m_curRecycle || bForceDelete)
  813. {
  815. CDlgDeleteFileDBItem dlg;
  816. if (dlg.DoModal() != IDOK)
  817. {
  818. SetFocus();
  819. return;
  820. }
  822. bForceDelete = true;
  823. bDelUncompleted = dlg.m_bDelUncompleted != 0;
  824. bDelCompleted = dlg.m_bDelCompleted != 0;
  825. }
  826. else if (bDownloading)
  827. {
  828. if (AfxMessageBox("有下载正在进行中, 您是否确定删除?", MB_YESNO) != IDYES) //Are you sure you wish to permanently delete these item(s)?", MB_YESNO) != IDYES)
  829. {
  830. SetFocus();
  831. return;
  832. }
  833. }
  836. // get index to be deleted arrray. and to stop vector.
  837. long lCount = GetSelectedCount();
  838. if (lCount <= 0) return;
  839. int* index = new int[lCount];
  840. int i = 0;
  841. bool bMonitorChange = false;
  843. vector<CFileDBItem*> vToStopFileDBItems;
  845. pos = GetFirstSelectedItemPosition();
  846. while (pos)
  847. {
  848. int nItem = GetNextSelectedItem(pos);
  849. index[i++] = nItem;
  851. if (GetItemState(nItem, LVIS_FOCUSED) & LVIS_FOCUSED)
  852. {
  853. bMonitorChange = true;
  854. m_pMonitorWnd->Monitor(0);
  855. }
  857. CFileDBItem* pItem = (CFileDBItem*)GetItemData(nItem);
  858. if (pItem->m_pDownload)
  859. vToStopFileDBItems.push_back(pItem);
  860. }
  862. // if is downloading, popup it from starting engine deque.
  863. m_pCategoryBarWnd->StopDBFiles(vToStopFileDBItems);
  865. // delete items.
  866. assert(!m_bDeleteing);
  867. m_bDeleteing = true;
  868. for (i=lCount-1; i>=0; i--)
  869. {
  870. CFileDBItem* pItem = (CFileDBItem*)GetItemData(index[i]);
  871. assert(pItem && m_curCursor && m_pCategoryBarWnd);
  873. m_pCategoryBarWnd->DeleteDBFile(m_curCursor, pItem, bForceDelete, bDelUncompleted, bDelCompleted);
  875. BOOL bRet = DeleteItem(index[i]);
  876. assert(bRet);
  877. }
  878. m_bDeleteing = false;
  879. delete index;
  881. if (bMonitorChange && GetItemCount())
  882. {
  883. CFileDBItem* pItem = (CFileDBItem*)GetItemData(0);
  884. if (pItem)
  885. m_pMonitorWnd->Monitor(pItem);
  886. }
  888. SetFocus();
  889. }
  891. void CFilesListCtrl::OnMenuitemDownload() 
  892. {
  893. vector<long> vToDelIndexs;
  895. POSITION pos = GetFirstSelectedItemPosition();
  896. while (pos)
  897. {
  898. int nItem = GetNextSelectedItem(pos);
  899. CFileDBItem* pItem  = (CFileDBItem*)GetItemData(nItem);
  900. if (!pItem->m_pDownload)
  901. {
  902. SetItem(nItem, 0, LVIF_IMAGE, 0, IID_PREPARE, 0, 0, 0);
  903. SetItemTextEx(nItem, eCompleted, "Waiting...");
  905. if (!m_pCategoryBarWnd->Download(m_curCursor, pItem))
  906. continue;
  908. vToDelIndexs.push_back(nItem);
  909. }
  910. else
  911. {
  912. if (pItem->m_pDownload->IsPause())
  913. {
  914. pItem->m_pDownload->Pause(false);
  915. ShowFileDBItemActive(nItem);
  916. }
  917. }
  918. }
  920. //
  921. // if download , move to downloading category.
  922. //
  923. for (int i=vToDelIndexs.size()-1; i>=0; i--)
  924. {
  925. BOOL bRet = DeleteItem(vToDelIndexs[i]);
  926. assert(bRet);
  927. }
  928. }
  930. void CFilesListCtrl::OnMenuitemStop() 
  931. {
  932. if (AfxMessageBox("你确定要停止吗?", MB_YESNO) == IDNO)
  933. return;
  935. vector<CFileDBItem*> vToStopFileDBItems;
  936. vector<long> vToStopIndexs;
  939. CFileDBItem* pMonitorItem = 0;
  940. POSITION pos = GetFirstSelectedItemPosition();
  941. while (pos)
  942. {
  943. int nItem = GetNextSelectedItem(pos);
  945. CFileDBItem* pItem  = (CFileDBItem*)GetItemData(nItem);
  946. if (!pItem) {ASSERT(pItem); return;}
  947. if (pItem->m_pDownload)
  948. {
  949. vToStopIndexs.push_back(nItem);
  950. vToStopFileDBItems.push_back(pItem);
  951. }
  953. if (GetItemState(nItem, LVIS_FOCUSED) & LVIS_FOCUSED)
  954. pMonitorItem = pItem;
  955. }
  957. //
  958. // stop download object.
  959. //
  960. m_pCategoryBarWnd->StopDBFiles(vToStopFileDBItems);
  962. //
  963. // if completed, move it to category assigned.
  964. //
  965. m_bDeleteing = true;
  966. for (int i=vToStopIndexs.size()-1; i>=0; i--)
  967. {
  968. CFileDBItem* pItem = (CFileDBItem*)GetItemData(vToStopIndexs[i]);
  969. assert(pItem && m_pCategoryBarWnd);
  971. if (!m_pCategoryBarWnd->StopDBFilesMoveComplete(pItem))
  972. {
  973. ShowFileDBItemText(vToStopIndexs[i]);
  974. }
  975. else
  976. {
  977. BOOL bRet = DeleteItem(vToStopIndexs[i]);
  978. assert(bRet);
  980. if (pMonitorItem == pItem) pMonitorItem = 0;
  982. }
  983. }
  984. m_bDeleteing = false;
  987. // refresh the item monitored and not moved.
  988. if (pMonitorItem)
  989. m_pMonitorWnd->Monitor(pMonitorItem);
  990. else
  991. {
  992. for (int i=0; i<GetItemCount(); i++)
  993. {
  994. CFileDBItem* pItem  = (CFileDBItem*)GetItemData(i);
  995. if (!pItem) {ASSERT(pItem); return;}
  997. if (GetItemState(i, LVIS_FOCUSED) & LVIS_FOCUSED)
  998. {
  999. pMonitorItem = pItem;
  1000. break;
  1001. }
  1002. }
  1004. if (pMonitorItem)
  1005. m_pMonitorWnd->Monitor(pMonitorItem);
  1006. else
  1007. m_pMonitorWnd->Monitor(0);
  1008. }
  1009. }
  1012. void CFilesListCtrl::OnMenuitemMoveto() 
  1013. {
  1014. CTreeCursor curSelected = m_curCursor;
  1015. POSITION pos = GetFirstSelectedItemPosition();
  1016. if (pos)
  1017. {
  1018. int nItem = GetNextSelectedItem(pos);
  1019. CFileDBItem* pItem = (CFileDBItem*)GetItemData(nItem);
  1020. assert(pItem);
  1021. CTreeCursor curRet = m_pCategoryBarWnd->findCursorByDirid(pItem->m_lDirectoryID);
  1022. if (curRet) curSelected = curRet;
  1023. }
  1025. CCategoryNewDlg dlg(&m_pCategoryBarWnd->m_ctlImage, m_pCategoryBarWnd, false, curSelected);
  1026. if (dlg.DoModal() != IDOK)
  1027. return;
  1029. //
  1030. // if move to self, cancel operation.
  1031. //
  1032. CTreeCursor curMovetoItem(dlg.m_ItemSel, m_pCategoryBarWnd);
  1033. if (curMovetoItem == m_curCursor)
  1034. return;
  1036. if (curMovetoItem == m_pCategoryBarWnd->m_curRecycle)
  1037. {
  1038. DeleteSelectedItem(false);
  1039. return;
  1040. }
  1042. //
  1043. // Get move items.
  1044. //
  1045. long lCount = GetSelectedCount();
  1046. if (lCount <= 0) return;
  1048. int* index = new int[lCount];
  1049. int i = 0;
  1050. bool bMonitorChange = false;
  1052. pos = GetFirstSelectedItemPosition();
  1053. while (pos)
  1054. {
  1055. int nItem = GetNextSelectedItem(pos);
  1056. index[i++] = nItem;
  1058. // if monitoring, cancel it.
  1059. if (GetItemState(nItem, LVIS_FOCUSED) & LVIS_FOCUSED)
  1060. {
  1061. bMonitorChange = true;
  1062. m_pMonitorWnd->Monitor(0);
  1063. }
  1064. }
  1066. //
  1067. // Move items.
  1068. //
  1069. vector<CFileDBItem*> vFileDBItems;
  1070. for (i=lCount-1; i>=0; i--)
  1071. {
  1072. CFileDBItem* pItem = (CFileDBItem*)GetItemData(index[i]);
  1073. assert(pItem && m_curCursor && m_pCategoryBarWnd);
  1074. vFileDBItems.push_back(pItem);
  1075. }
  1077. bool bRet = m_pCategoryBarWnd->FileDBItemMovetoArray(m_curCursor, curMovetoItem, vFileDBItems);
  1078. if (bRet)
  1079. {
  1080. m_bDeleteing = true;
  1081. for (i=lCount-1; i>=0; i--)
  1082. {
  1083. BOOL bRet = DeleteItem(index[i]);
  1084. assert(bRet);
  1085. }
  1086. m_bDeleteing = false;
  1087. }
  1089. delete index;
  1091. //
  1092. // Monitor next item.
  1093. //
  1094. if (bMonitorChange && GetItemCount())
  1095. {
  1096. CFileDBItem* pItem = (CFileDBItem*)GetItemData(0);
  1097. if (pItem)
  1098. m_pMonitorWnd->Monitor(pItem);
  1099. }
  1100. }
  1102. void CFilesListCtrl::OnMenuitemCopyTorrentFilePath() 
  1103. {
  1104. assert(GetSelectedCount() == 1);
  1106. POSITION pos = GetFirstSelectedItemPosition();
  1107. if (pos)
  1108. {
  1109. int index = GetNextSelectedItem(pos);
  1110. CFileDBItem* pItem = (CFileDBItem*)GetItemData(index);
  1111. assert(pItem);
  1113. CString strSource = (m_pCategoryBarWnd->GetDBSavePath() + pItem->m_strTorrentFileName).data(); 
  1114. if (!CopyTextToClipboard(strSource))
  1115. AfxMessageBox("复制Torrent路径失败");
  1116. }
  1117. }
  1119. void CFilesListCtrl::OnMenuitemFileProperty() 
  1120. {
  1121. assert(GetSelectedCount() == 1);
  1123. POSITION pos = GetFirstSelectedItemPosition();
  1124. if (pos)
  1125. {
  1126. int index = GetNextSelectedItem(pos);
  1127. CFileDBItem* pItem = (CFileDBItem*)GetItemData(index);
  1128. assert(pItem);
  1130. try
  1131. {
  1132. CFileTorrent filetorrent;
  1133. if (!filetorrent.OpenFile(m_pCategoryBarWnd->GetDBSavePath() + pItem->m_strTorrentFileName))
  1134. {
  1135. AfxMessageBox(filetorrent.GetBadMsg().data());
  1136. return;
  1137. }
  1138. filetorrent.QueryDir();
  1140. CDlgNewDownload dlg(&m_pCategoryBarWnd->m_ctlImage,
  1141. &filetorrent,
  1142. m_pCategoryBarWnd,
  1143. false, pItem, 
  1144. pItem->m_lDirectoryID,
  1145. pItem->m_strFileName);
  1147. if (dlg.DoModal() == IDOK)
  1148. {
  1149. //
  1150. // if download immediately, start it.
  1151. //
  1152. pItem->m_strComment = dlg.m_strComment.GetBuffer(0);
  1154. if (dlg.m_iStartMode == 0) // start immediately.
  1155. {
  1156. if (!pItem->m_pDownload)
  1157. {
  1158. SetItem(index, 0, LVIF_IMAGE, 0, IID_PREPARE, 0, 0, 0);
  1159. SetItemTextEx(index, eCompleted, "Waiting...");
  1161. if (m_pCategoryBarWnd->Download(m_curCursor, pItem))
  1162. {
  1163. BOOL bRet = DeleteItem(index);
  1164. ASSERT(bRet);
  1165. }
  1166. }
  1167. }
  1168. }
  1169. }
  1170. catch (string e)
  1171. {
  1172. AfxMessageBox(e.data());
  1173. return;
  1174. }
  1175. }
  1176. }
  1178. void CFilesListCtrl::OnMenuitemRunParamter()
  1179. {
  1180. POSITION pos = GetFirstSelectedItemPosition();
  1181. if (pos)
  1182. {
  1183. int index = GetNextSelectedItem(pos);
  1184. CFileDBItem* pItem = (CFileDBItem*)GetItemData(index);
  1185. if (!pItem)
  1186. {
  1187. assert(false);
  1188. return;
  1189. }
  1191. CDlgRunParameters dlgParamters(pItem, m_pSetupRegister);
  1192. dlgParamters.DoModal();
  1193. m_pMonitorWnd->Monitor(pItem);
  1194. }
  1195. }
  1197. void CFilesListCtrl::OnMenuitemOpenDownloadedFile()
  1198. {
  1199. POSITION pos = GetFirstSelectedItemPosition();
  1200. while (pos)
  1201. {
  1202. int index = GetNextSelectedItem(pos);
  1204. if (GetItemState(index, LVIS_FOCUSED) & LVIS_FOCUSED)
  1205. {
  1206. CFileDBItem* pItem = (CFileDBItem*)GetItemData(index);
  1208. HINSTANCE iRet = ShellExecute(NULL, "open" , pItem->m_strFileName.data(), 0, 0, SW_SHOW);
  1209. if ((UINT)iRet <= HINSTANCE_ERROR)
  1210. AfxMessageBox(WSAShowError().data());
  1211. break;
  1212. }
  1213. }
  1215. }
  1217. void CFilesListCtrl::OnMenuitemOpenDownloadedDirectory()
  1218. {
  1219. POSITION pos = GetFirstSelectedItemPosition();
  1220. while (pos)
  1221. {
  1222. int index = GetNextSelectedItem(pos);
  1224. if (GetItemState(index, LVIS_FOCUSED) & LVIS_FOCUSED)
  1225. {
  1226. CFileDBItem* pItem = (CFileDBItem*)GetItemData(index);
  1228. // Get Parent folder as the directory, no matter that the fileitem is dir or file.
  1229. char drive[_MAX_DRIVE];
  1230. char dir[_MAX_DIR];
  1231. char fname[_MAX_FNAME];
  1232. char ext[_MAX_EXT];
  1233. _splitpath(pItem->m_strFileName.data(), drive, dir, fname, ext);
  1234. string strPath = string(drive) + dir;
  1236. HINSTANCE iRet = ShellExecute(NULL, "open" , strPath.data(), 0, 0, SW_SHOW);
  1237. if ((UINT)iRet <= HINSTANCE_ERROR)
  1238. AfxMessageBox(WSAShowError().data());
  1239. break;
  1240. }
  1241. }
  1242. }
  1245. /************************************************************
  1247. show file filedbitem
  1249. *************************************************************/
  1251. void CFilesListCtrl::OnTimer(UINT nIDEvent) 
  1252. {
  1253. if (DISPLAY_TIMEOUT_ID != nIDEvent)
  1254. return;
  1256. int iCount = GetItemCount();
  1258. for (int i=0; i<GetItemCount(); i++)
  1259. {
  1260. ShowFileDBItemActive(i);
  1261. }
  1263. m_pMonitorWnd->Refresh();
  1265. // CListCtrl::OnTimer(nIDEvent);
  1266. }
  1268. void CFilesListCtrl::ShowFileDBItemText(int iItem)
  1269. {
  1270. CFileDBItem* pItem  = (CFileDBItem*)GetItemData(iItem);
  1272. string strName;
  1273. string strSavePath;
  1274. SplitPathName(pItem->m_strFileName, strSavePath, strName);
  1276. SetItemTextEx(iItem, eFileName, strName.data());
  1278. char szText[1024] = {0};
  1280. sprintf(szText, "%d%%", (long)((pItem->m_fComplete)*100));
  1281. SetItemTextEx(iItem, eCompleted, szText);
  1283. sprintf(szText, "%s", FormatSize(pItem->m_lFileSize).data());
  1284. SetItemTextEx(iItem, eFilesize, szText);
  1286. SetItemTextEx(iItem, eTimeleft, "");
  1287. SetItemTextEx(iItem, eTimerunned, "");
  1288. SetItemTextEx(iItem, eDownloadrate, "");
  1289. SetItemTextEx(iItem, eUploadrate, "");
  1290. SetItemTextEx(iItem, eSeeds, "");
  1292. CTime tCreatedTime(pItem->m_tTime);
  1293. CString strCreatedTime = tCreatedTime.Format("%Y-%m-%d %H:%M");
  1294. SetItemTextEx(iItem, eCreateTime, strCreatedTime); // ctime(&pItem->m_tTime));
  1296. tCreatedTime = pItem->m_tModifiedTime;
  1297. strCreatedTime = tCreatedTime.Format("%Y-%m-%d %H:%M");
  1298. SetItemTextEx(iItem, eModifiedTime, strCreatedTime); // ctime(&pItem->m_tTime));
  1302. int iImageID = (pItem->m_fComplete>= 1) ? IID_COMPLETE : IID_UNCOMPLETE;
  1303. if (!pItem->m_vUnneededFileInx.empty())
  1304. {
  1305. iImageID = (pItem->m_fCompletePart >= 1) ? IID_COMPLETE : IID_UNCOMPLETE;
  1306. }
  1308. if (pItem->m_pDownload && pItem->m_pDownload->IsPause())
  1309. iImageID = IID_PAUSE;
  1311. if (pItem->m_bBad == true)
  1312. iImageID = IID_BAD;
  1314. SetItem(iItem, 0, LVIF_IMAGE, 0, iImageID, 0, 0, 0);
  1315. }
  1317. void CFilesListCtrl::ShowFileDBItemActive(int iItem)
  1318. {
  1319. if (iItem > GetItemCount() || iItem < 0)
  1320. {
  1321. assert(false);
  1322. return;
  1323. }
  1325. int i = iItem;
  1326. CFileDBItem* pItem  = (CFileDBItem*)GetItemData(i);
  1327. if (!pItem)
  1328. {
  1329. assert(false);
  1330. return;
  1331. }
  1333. if (pItem->m_pDownload)
  1334. {
  1335. // the download is terminated.
  1336. if (pItem->m_pDownload->IsBad())
  1337. {
  1338. SetItem(i, 0, LVIF_IMAGE, 0, IID_BAD, 0, 0, 0);
  1339. return;
  1340. }
  1342. if (pItem->m_pDownload->IsPause())
  1343. {
  1344. SetItem(i, 0, LVIF_IMAGE, 0, IID_PAUSE, 0, 0, 0);
  1345. return;
  1346. }
  1348. // download maybe not begin yet.
  1349. if (!pItem->m_pDownload->IsDownloading())
  1350. {
  1351. SetItem(i, 0, LVIF_IMAGE, 0, IID_PREPARE, 0, 0, 0);
  1352. SetItemTextEx(i, eCompleted, "Waiting...");
  1353. return;
  1354. }
  1357. CStatics statics = pItem->m_pDownload->GetStatics();
  1358. char szText[1024] = {0};
  1360. if (statics.m_bAllocating)
  1361. {
  1362. SetItem(i, 0, LVIF_IMAGE, 0, IID_PREPARE, 0, 0, 0);
  1363. sprintf(szText, "Allocate(%.2f)", statics.m_fAllocatingPercent);
  1364. SetItemTextEx(i, eCompleted, szText);
  1365. }
  1366. else 
  1367. {
  1368. if (statics.m_bStorageChecking)
  1369. {
  1370. SetItem(i, 0, LVIF_IMAGE, 0, IID_PREPARE, 0, 0, 0);
  1371. sprintf(szText, "Checking(%.2f)", statics.m_fCheckingPercent);
  1372. SetItemTextEx(i, eCompleted, szText);
  1373. }
  1374. else
  1375. {
  1376. float fCompleted = statics.m_fCompleted;
  1377. if (!pItem->m_vUnneededFileInx.empty())
  1378. fCompleted = statics.m_fCompletedPart;
  1380. sprintf(szText, "%d%%", (long)((fCompleted)*100));
  1381. SetItemTextEx(i, eCompleted, szText);
  1383. if (statics.m_tTimeLeft < 0)
  1384. {
  1385. SetItemTextEx(i, eTimeleft, "-");
  1386. }
  1387. else
  1388. {
  1389. CTimeSpan TimeLeft(statics.m_tTimeLeft);
  1390. SetItemTextEx(i, eTimeleft, TimeLeft.Format("%D:%H:%M:%S"));
  1391. }
  1393. CTimeSpan TimeRunned(statics.m_tTimeRunned);
  1394. SetItemTextEx(i, eTimerunned, TimeRunned.Format("%D:%H:%M:%S"));
  1396. sprintf(szText, "%s", FormatSize(statics.m_lDownRate).data());
  1397. SetItemTextEx(i, eDownloadrate, szText);
  1399. sprintf(szText, "%s", FormatSize(statics.m_lUpRate).data());
  1400. SetItemTextEx(i, eUploadrate, szText);
  1402. sprintf(szText, "%d/%d", statics.m_lSeedsCount, statics.m_lPeersCount);
  1403. SetItemTextEx(i, eSeeds, szText);
  1406. // set data
  1407. // pItem->m_fComplete = statics.m_fCompleted;
  1409. //  set image
  1410. bool bCompleted = fCompleted >= 1;
  1411. int iImageID = 0;
  1412. if (!statics.m_bTrackerConnected)
  1413. {
  1414. iImageID = bCompleted ? IID_UPLOAD_TRACKER : IID_DOWNLOAD_TRACKER;
  1415. }
  1416. else if(statics.m_lPeersCount == 0)
  1417. {
  1418. iImageID = bCompleted ? IID_UPLOAD_OTHERS: IID_DOWNLOAD_OTHERS;
  1419. }
  1420. else if (statics.m_bFired)
  1421. {
  1422. iImageID = bCompleted ? IID_UPLOAD_FIRE: IID_DOWNLOAD_FIRE;
  1423. }
  1424. else if (statics.m_lSeedsCount == 0)
  1425. {
  1426. iImageID = bCompleted ? IID_UPLOAD_SEED : IID_DOWNLOAD_SEED;
  1427. }
  1428. else
  1429. {
  1430. iImageID = bCompleted ? IID_UPLOAD : IID_DOWNLOAD;
  1431. }
  1432. SetItem(i, 0, LVIF_IMAGE, 0, iImageID, 0, 0, 0);
  1434. }
  1435. }
  1437. } // end if (pItem->m_pDownload)
  1438. else
  1439. {
  1440. LV_ITEM lvItem;
  1441. lvItem.iItem = i;
  1442. lvItem.iSubItem = 0;
  1443. lvItem.mask = LVIF_TEXT | LVIF_IMAGE;
  1444. lvItem.cchTextMax = 0;
  1445. lvItem.pszText = "";
  1446. GetItem(&lvItem);
  1448. if (lvItem.iImage != IID_COMPLETE &&
  1449. lvItem.iImage != IID_UNCOMPLETE &&
  1450. lvItem.iImage != IID_BAD)
  1451. {
  1452. ShowFileDBItemText(i);
  1453. }
  1454. }
  1455. }
  1458. /************************************************************
  1460. sort item.
  1462. *************************************************************/
  1464. void CFilesListCtrl::OnColumnSort(int iColumn)
  1465. {
  1466. assert(abs(iColumn) <= eAllSize && abs(iColumn) > 0);
  1467. m_iSortedCol = iColumn;
  1468. SortItems(Compare1, m_iSortedCol);
  1469. }
  1471. void CFilesListCtrl::OnItemclickSort(NMHDR* pNMHDR, LRESULT* pResult)
  1472. {
  1473. *pResult = 0;
  1475. NMLISTVIEW* pNMListView = reinterpret_cast<NMLISTVIEW*>(pNMHDR);
  1476. int iSubItem = GetLogicalIndex(pNMListView->iSubItem);
  1477. if (iSubItem == -1)
  1478. {
  1479. assert(false);
  1480. return;
  1481. }
  1483. int nAbsSortColumn = abs(m_iSortedCol);
  1485. if (nAbsSortColumn > 0)
  1486. {
  1487. if (iSubItem == nAbsSortColumn-1)
  1488. m_iSortedCol = -m_iSortedCol;
  1489. else
  1490. m_iSortedCol = iSubItem + 1;
  1491. }
  1492. else
  1493. m_iSortedCol= iSubItem + 1;
  1495. SortItems(Compare1, m_iSortedCol);
  1496. }
  1499. int CALLBACK CFilesListCtrl::Compare1(LPARAM lParam1, LPARAM lParam2, LPARAM 
  1500.  lParamSort)
  1501. {
  1502. CFileDBItem* pItem1 = (CFileDBItem*) lParam1;
  1503. CFileDBItem* pItem2 = (CFileDBItem*) lParam2;
  1504. if (!pItem1 || !pItem2)
  1505. {
  1506. ASSERT(pItem1 && pItem2);
  1507. return 0;
  1508. }
  1510. long sOrder = lParamSort < 0 ? -1 : 1; 
  1511. eColumns eCol = (eColumns)((lParamSort * sOrder) - 1);
  1513. ////////////////////////////////////////////////////////////
  1514. // for dynamic data.
  1516. CStatics statics1, statics2;
  1517. int iStat1 = 0, iStat2 = 0;
  1520. if ((eCol >= eTimeleft && eCol <= eSeeds) || (eCol == eIcon))
  1521. {
  1522. if (!pItem1->m_pDownload - !pItem2->m_pDownload)
  1523. {
  1524. return (!pItem1->m_pDownload - !pItem2->m_pDownload) * sOrder * -1;
  1525. }
  1527. if (pItem1->m_pDownload && !pItem1->m_pDownload->IsBad() && // !pItem1->m_pDownload->IsPause() &&
  1528. pItem1->m_pDownload->IsDownloading())
  1529. {
  1530. statics1 = pItem1->m_pDownload->GetStatics();
  1531. iStat1 = 1;
  1533. }
  1535. if (pItem2->m_pDownload && !pItem2->m_pDownload->IsBad() && // !pItem2->m_pDownload->IsPause() && 
  1536. pItem2->m_pDownload->IsDownloading())
  1537. {
  1538. statics2 = pItem2->m_pDownload->GetStatics();
  1539. iStat2 = 1; 
  1540. }
  1542. // if start and silent then return; 
  1543. int idif = (iStat1 -iStat2) * sOrder;
  1544. if (idif) return idif;
  1546. // both silent .
  1547. if (!iStat1 && eCol != eIcon)
  1548. return 0;
  1550. // both running
  1551. if (iStat1 && iStat2)
  1552. {
  1553. idif = pItem1->m_pDownload->IsPause() - pItem2->m_pDownload->IsPause();
  1554. if (idif) return -idif * sOrder;
  1555. }
  1556. }
  1558. ////////////////////////////////////////////////////////////////
  1559. // compare sort column.
  1561. switch (eCol)
  1562. {
  1563. case eIcon:
  1564. {
  1565. if (!iStat1 && !iStat2)
  1566. sOrder *= -1;
  1568. return (pItem1->m_fComplete - pItem2->m_fComplete) * 100 * sOrder;
  1569. }
  1570. break;
  1572. case eFileName:
  1573. return strcmp(pItem1->m_strFileName.data(), pItem2->m_strFileName.data()) * sOrder;
  1574. break;
  1576. case eCompleted:
  1577. return (pItem1->m_fComplete - pItem2->m_fComplete) * 100 * sOrder;
  1578. break;
  1580. case eFilesize:
  1581. return (pItem1->m_lFileSize - pItem2->m_lFileSize) * sOrder;
  1582. break;
  1584. case eTimeleft:
  1585. // return (pItem1->t< pItem1->m_lFileSize) * sOrder;
  1586. return (statics1.m_tTimeLeft - statics2.m_tTimeLeft) * sOrder;
  1587. break;
  1589. case eTimerunned:
  1590. return (statics1.m_tTimeRunned - statics2.m_tTimeRunned) * sOrder;
  1591. break;
  1593. case eDownloadrate:
  1594. return (statics1.m_lDownRate - statics2.m_lDownRate) * sOrder;
  1595. break;
  1597. case eUploadrate:
  1598. return (statics1.m_lUpRate - statics2.m_lUpRate) * sOrder;
  1599. break;
  1601. case eSeeds:
  1602. return (statics1.m_lSeedsCount - statics2.m_lSeedsCount) * sOrder;
  1603. break;
  1605. case eCreateTime:
  1606. return (pItem1->m_tTime - pItem2->m_tTime) * sOrder;
  1607. break;
  1609. case eModifiedTime:
  1610. return (pItem1->m_tModifiedTime - pItem2->m_tModifiedTime) * sOrder;
  1611. break;
  1613. default:
  1614. assert(false);
  1615. break;
  1616. }
  1618. return 0;
  1619. }
  1621. /************************************************************
  1623. drag and drop
  1625. *************************************************************/
  1626. void CFilesListCtrl::OnBegindrag(NMHDR* pNMHDR, LRESULT* pResult) 
  1627. {
  1628. *pResult = 0;
  1630. //
  1631. // if is downloading or no selected item return.
  1632. //
  1633. // if (m_curCursor == m_pCategoryBarWnd->m_curDownloading)
  1634. // return;
  1636. long lCount = GetSelectedCount();
  1637. if (lCount <= 0) return;
  1639. //
  1640. // Get selected items.
  1641. //
  1642. int* indexarr = new int[lCount];
  1643. auto_ptr<int> auarr(indexarr);
  1644. int i=0;
  1645. bool bStopMonitor = false;
  1647. m_vDragFileDBItems.clear();
  1648. POSITION pos = GetFirstSelectedItemPosition();
  1649. while (pos)
  1650. {
  1651. int index = GetNextSelectedItem(pos);
  1652. indexarr[i++] = index;
  1654. if (GetItemState(index, LVIS_FOCUSED) & LVIS_FOCUSED)
  1655. bStopMonitor = true;
  1657. CFileDBItem* pItem = (CFileDBItem*)GetItemData(index);
  1658. m_vDragFileDBItems.push_back(pItem);
  1659. }
  1661. //
  1662. // Register clipboard data.
  1663. //
  1664. CSharedFile globFile;
  1665. globFile.Write("1", 1);
  1666. COleDataSource srcItem;
  1667. srcItem.CacheGlobalData(m_pCategoryBarWnd->m_nIDClipFormat, globFile.Detach()); 
  1669. DWORD dwRet = srcItem.DoDragDrop();
  1670. if (dwRet & DROPEFFECT_MOVE)
  1671. {
  1672. if (bStopMonitor)
  1673. m_pMonitorWnd->Monitor(0);
  1675. assert(!m_bDeleteing);
  1676. m_bDeleteing = true;
  1677. for (i=lCount-1; i>=0; i--)
  1678. DeleteItem(indexarr[i]);
  1679. m_bDeleteing = false;
  1680. }
  1681. m_vDragFileDBItems.clear();
  1682. }
  1684. /************************************************************
  1686. handler hot key.
  1688. *************************************************************/
  1690. BOOL CFilesListCtrl::PreTranslateMessage(MSG* pMsg) 
  1691. {
  1692. if (pMsg->message == WM_KEYDOWN)
  1693. {
  1694. switch (pMsg->wParam)
  1695. {
  1696. case VK_DELETE:
  1697. {
  1698. DeleteSelectedItem(GetKeyState(VK_SHIFT) < 0);
  1699. return true;
  1700. }
  1701. break;
  1702. }
  1703. }
  1704. return CListCtrlBaseEx::PreTranslateMessage(pMsg);
  1705. }
  1708. void CFilesListCtrl::OnCustomDraw(NMHDR* pNMHDR, LRESULT* pResult)
  1709. {
  1710. LPNMLVCUSTOMDRAW  lplvcd = (LPNMLVCUSTOMDRAW)pNMHDR;
  1712. switch(lplvcd->nmcd.dwDrawStage)
  1713. {
  1714. case CDDS_PREPAINT:
  1715. *pResult = CDRF_NOTIFYITEMDRAW;          // ask for subitem notifications.
  1716. break;
  1718. case CDDS_ITEMPREPAINT:
  1719. {
  1720. *pResult = CDRF_NOTIFYSUBITEMDRAW | CDRF_NOTIFYPOSTPAINT;
  1721. }
  1722. break;
  1723. case CDDS_ITEMPREPAINT|CDDS_SUBITEM: // recd when CDRF_NOTIFYSUBITEMDRAW is returned in
  1724. {                                    // response to CDDS_ITEMPREPAINT.
  1725. *pResult = CDRF_SKIPDEFAULT;
  1726. *pResult = CDRF_NOTIFYPOSTPAINT;
  1727. }
  1728. break;
  1729. case CDDS_ITEMPOSTPAINT|CDDS_SUBITEM:
  1730. {
  1731. *pResult = CDRF_DODEFAULT;
  1733. int iCol = lplvcd->iSubItem;
  1734. int iRow = lplvcd->nmcd.dwItemSpec;
  1737. CRect rc;
  1738. if (iCol == 0)
  1739. {
  1740. CFileDBItem* pItem  = (CFileDBItem*)lplvcd->nmcd.lItemlParam;
  1741. if (!pItem)
  1742. {
  1743. assert(false);
  1744. return;
  1745. }
  1746. if (pItem->m_vUnneededFileInx.size())
  1747. {
  1748. *pResult = CDRF_SKIPDEFAULT;
  1750. CDC dc;
  1751. dc.Attach(lplvcd->nmcd.hdc);
  1753. GetSubItemRect(iRow, iCol, LVIR_ICON, rc);
  1754. CPoint pt(rc.left , rc.top);
  1755. pt.Offset(5, 5);
  1756. m_ctlImageDelete.Draw(&dc, 0, pt, ILD_TRANSPARENT);
  1758. dc.Detach();
  1759. }
  1760. }
  1761. }
  1763. default:// it wasn't a notification that was interesting to us.
  1764. *pResult = CDRF_DODEFAULT;
  1765. }
  1766. }