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

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

P2P编程

开发平台：

Visual C++

CategoryBarWnd.cpp：源码内容
  1. // CategoryBarWnd.cpp : implementation file
  2. //
  4. #include "stdafx.h"
  5. #include "testbt.h"
  6. #include "CategoryBarWnd.h"
  9. #include "CategoryNewDlg.h"
  10. #include "CategoryPropertyDlg.h"
  11. #include "BTFormat.h"
  12. #include "DlgNewDownload.h"
  13. #include "FileTorrent.h"
  14. #include "FileBase.h"
  15. #include "FilesListCtrl.h"
  16. #include "bdecode.h"
  17. #include "download.h"
  18. #include "DlgFindConditions.h"
  20. #include "SINSTANCE.H"
  21. #include "mainfrm.h"
  23. #ifdef _DEBUG
  24. #define new DEBUG_NEW
  25. #undef THIS_FILE
  26. static char THIS_FILE[] = __FILE__;
  27. #endif
  29. /////////////////////////////////////////////////////////////////////////////
  30. // CCategoryBarWnd
  32. CCategoryBarWnd::CCategoryBarWnd()
  33. {
  34. m_nIDClipFormat = RegisterClipboardFormat(_T("DaoView"));
  35. }
  37. CCategoryBarWnd::~CCategoryBarWnd()
  38. {
  39. }
  42. BEGIN_MESSAGE_MAP(CCategoryBarWnd, CCategoryDownload)
  43. //{{AFX_MSG_MAP(CCategoryBarWnd)
  44. ON_WM_CREATE()
  45. ON_WM_DESTROY()
  46. ON_WM_LBUTTONDOWN()
  47. //}}AFX_MSG_MAP
  48. ON_NOTIFY_REFLECT(NM_RCLICK,OnRightClick)
  49. ON_NOTIFY_REFLECT(TVN_SELCHANGED,OnNodeSelect)
  50. ON_COMMAND_RANGE(ID_MENUITEM_OPEN_CATEGORY, ID_MENUITEM_MOVETO_CATEGORY, OnPopupCommand)
  51. END_MESSAGE_MAP()
  54. /////////////////////////////////////////////////////////////////////////////
  55. // CCategoryBarWnd message handlers
  57. void CCategoryBarWnd::OnFileListViewInitialUpdate() 
  58. {
  59. if (!GetSafeHwnd() || !m_curDownloading)
  60. {
  61. ASSERT(FALSE);
  62. return;
  63. }
  65. m_curDownloading.Select();
  66. }
  68. int CCategoryBarWnd::OnCreate(LPCREATESTRUCT lpCreateStruct) 
  69. {
  70. if (CTreeCtrl::OnCreate(lpCreateStruct) == -1)
  71. return -1;
  74. //
  75. // Create BitmapList
  76. //
  77. HBITMAP hbm = (HBITMAP)::LoadImage(AfxGetInstanceHandle(),
  78. MAKEINTRESOURCE(IDB_IMAGELIST_CATEGORY),
  79. IMAGE_BITMAP,
  80. 0,0, // cx,cy
  81. LR_CREATEDIBSECTION); // | LR_LOADMAP3DCOLORS );
  82. CBitmap bm;
  83. bm.Attach(hbm);
  85. m_ctlImage.Create(16,15, ILC_COLOR8|ILC_MASK, 4, 4);
  86. m_ctlImage.SetBkColor(::GetSysColor(COLOR_WINDOW)); 
  87. m_ctlImage.Add(&bm, (COLORREF)RGB(255,0,255));
  89. SetImageList(&m_ctlImage);
  91. //
  92. // Create the treeCategory.
  93. //
  94. LoadDBFile();
  95. m_bNoNotifications = true;
  96. GetRootItem().Select();
  97. m_bNoNotifications = false;
  99. //
  100. // Create engine.
  101. //
  102. assert(m_pSetupRegister);
  103. m_DownloadEngine.Create(m_pSetupRegister, this);
  105. //
  106. // Create finder and Registe dragdrop.
  107. //
  108. m_FindFileByConditions.Create(this);
  109. BOOL bRet = m_dropTarget.Register(this);
  111. //
  112. // continue the unclosed.
  113. //
  114. if (m_pSetupRegister->m_bContinueUnCloseDownload)
  115. ContinueTheUncloseds();
  117. return 0;
  118. }
  121. void CCategoryBarWnd::OnDestroy() 
  122. {
  123. m_bNoNotifications = true;
  125. // Quit the instance and release hot key.
  126. AppReleaseInstance();
  127. UnregisterHotKey(AfxGetMainWnd()->GetSafeHwnd(), HOTKEY_ID);
  129. // call base function.
  130. CCategoryDownload::OnDestroy();
  131. }
  133. void CCategoryBarWnd::OnNodeSelect(NMHDR *pNotifyStruct,LRESULT *result)
  134. {
  135. if (result) *result = 0;
  137. if (m_bNoNotifications)
  138. return;
  140. assert(m_pFilesListCtrl);
  141. m_ItemSel = GetSelectedItem();
  142. m_pFilesListCtrl->LoadCatetory(m_ItemSel);
  143. m_FindFileByConditions.SetNewStartLocation(m_ItemSel, 0);
  144. }
  146. void CCategoryBarWnd::OnLButtonDown(UINT nFlags, CPoint point) 
  147. {
  149. /*
  150. UINT nFlags1;
  151. CPoint curPoint;
  152. GetCursorPos(&curPoint);
  153. ScreenToClient(&curPoint);
  154. CTreeCursor ItemSel = HitTest(curPoint, &nFlags1);
  156. if (ItemSel)
  157. ItemSel.Select();
  158. //*/
  160. CCategoryDownload::OnLButtonDown(nFlags, point);
  161. }
  163. void CCategoryBarWnd::OnRightClick(NMHDR *pNotifyStruct,LRESULT *result)
  164. {
  165. UINT nFlags;
  166. CPoint curPoint;
  167. GetCursorPos(&curPoint);
  168. ScreenToClient(&curPoint);
  169. m_ItemSel = HitTest(curPoint, &nFlags);
  171. UINT nImageID = m_ItemSel.GetImageID();
  172. switch (nImageID)
  173. {
  174. case IID_ROOT:
  175. case IID_RECYCLE:
  176. case IID_DOWNLOADING_DIRECTORY:
  177. case IID_DOWNLOADED_DIRECTORY:
  178. case IID_DIRECTORY:
  179. DoPopupMenu(IDR_MENU_CATEGORY);
  180. break;
  181. }
  182. *result = 0;
  183. }
  185. /******************************************************************
  187. context menu command and ui.
  189. ******************************************************************/
  191. void CCategoryBarWnd::DoPopupMenu(UINT nMenuID)
  192. {
  193. CMenu popMenu;
  194. popMenu.LoadMenu(nMenuID);
  196. //
  197. // command ui. 
  198. //
  199. bool bOpenSubCategory = true;
  200. bool bNewSubCategory = true;
  201. bool bMoveTo = true;
  202. bool bDeleted = true;
  204. if (m_ItemSel == m_curRoot || m_ItemSel == m_curDownloading || 
  205. m_ItemSel == m_curDownloaded || m_ItemSel == m_curRecycle)
  206. {
  207. bDeleted = false;
  208. bMoveTo = false;
  209. }
  211. if (m_ItemSel == m_curDownloading || m_ItemSel == m_curRecycle)
  212. bOpenSubCategory = false;
  214. // downloading can't create sub category.
  215. if (m_ItemSel == m_curDownloading)
  216. bNewSubCategory = false;
  218. popMenu.EnableMenuItem(ID_MENUITEM_OPEN_CATEGORY, MF_BYCOMMAND | 
  219. (bOpenSubCategory ? MF_ENABLED : (MF_DISABLED | MF_GRAYED)));
  221. popMenu.EnableMenuItem(ID_MENUITEM_PORPERTY_CATEGORY, MF_BYCOMMAND | 
  222. (bOpenSubCategory ? MF_ENABLED : (MF_DISABLED | MF_GRAYED)));
  225. popMenu.EnableMenuItem(ID_MENUITEM_DEL_CATEGORY, MF_BYCOMMAND | 
  226. (bDeleted ? MF_ENABLED : (MF_DISABLED | MF_GRAYED)));
  228. popMenu.EnableMenuItem(ID_MENUITEM_MOVETO_CATEGORY, MF_BYCOMMAND | 
  229. (bDeleted ? MF_ENABLED : (MF_DISABLED | MF_GRAYED)));
  231. popMenu.EnableMenuItem(ID_MENUITEM_NEW_CATEGORY, MF_BYCOMMAND | 
  232. (bNewSubCategory? MF_ENABLED : (MF_DISABLED | MF_GRAYED)));
  234. CPoint posMouse;
  235. GetCursorPos(&posMouse);
  236. popMenu.GetSubMenu(0)->TrackPopupMenu(TPM_LEFTALIGN |TPM_RIGHTBUTTON, posMouse.x,posMouse.y,this);
  237. }
  239. void CCategoryBarWnd::OnUpdateMenuitem(CCmdUI* pCmdUI) 
  240. {
  241. if (!GetSafeHwnd()) return;
  243. //
  244. // command ui. 
  245. //
  246. bool bNewSubCategory = true;
  247. bool bMoveTo = true;
  248. bool bDeleted = true;
  250. if (GetSelectedItem()== m_curRoot || GetSelectedItem() == m_curDownloading || 
  251. GetSelectedItem() == m_curDownloaded || GetSelectedItem() == m_curRecycle)
  252. {
  253. bDeleted = false;
  254. bMoveTo = false;
  255. }
  257. // downloading can't create sub category.
  258. if (GetSelectedItem() == m_curDownloading)
  259. bNewSubCategory = false;
  261. if (!GetSelectedItem())
  262. {
  263. bNewSubCategory = false;
  264. bDeleted = false;
  265. bMoveTo = false;
  266. }
  268. switch (pCmdUI->m_nID)
  269. {
  270. case ID_MENUITEM_FIND_NEXT:
  271.  pCmdUI->Enable(m_FindFileByConditions.CanFindNext());
  272. break;
  273. case ID_MENUITEM_OPEN_CATEGORY:
  274. pCmdUI->Enable(bNewSubCategory);
  275. break;
  276. case ID_MENUITEM_MOVETO_CATEGORY:
  277. pCmdUI->Enable(bMoveTo);
  278. break;
  279. case ID_MENUITEM_NEW_CATEGORY:
  280. pCmdUI->Enable(bNewSubCategory);
  281. break;
  282. case ID_MENUITEM_DEL_CATEGORY:
  283. pCmdUI->Enable(bDeleted);
  284. break;
  285. case ID_MENUITEM_PORPERTY_CATEGORY:
  286. pCmdUI->Enable(bDeleted);
  287. break;
  288. }
  289. }
  292. void CCategoryBarWnd::OnCommandMenuitem(UINT iID) 
  293. {
  294. m_ItemSel = GetSelectedItem();
  295. assert(m_ItemSel);
  296. OnPopupCommand(iID);
  297. }
  299. void CCategoryBarWnd::OnPopupCommand(UINT nMenuID)
  300. {
  301. assert(m_ItemSel);
  302. switch (nMenuID)
  303. {
  304. case ID_MENUITEM_OPEN_CATEGORY:
  305. {
  306. // m_pFilesListCtrl->LoadCatetory(m_ItemSel);
  307. CCategoryDBItem* pItem = (CCategoryDBItem*)m_ItemSel.GetData();
  308. assert(pItem);
  309. HINSTANCE iRet = ShellExecute(NULL, "open" , pItem->m_strDefaultDirectory.data(), 0, 0, SW_SHOW);
  310. if ((UINT)iRet <= HINSTANCE_ERROR)
  311. AfxMessageBox(WSAShowError().data());
  312. }
  313. break;
  315. case ID_MENUITEM_NEW_CATEGORY:
  316. {
  317. assert(m_ItemSel != m_curDownloading);
  319. CCategoryNewDlg dlg(&m_ctlImage, this, true, m_ItemSel);
  320. /*
  321. dlg.m_pctlImage = &m_ctlImage;
  322. dlg.m_ItemSel = m_ItemSel;
  323. dlg.m_pCategoryBarWnd = this;
  324. //*/
  325. if (dlg.DoModal() == IDOK)
  326. {
  327. CTreeCursor curItem(dlg.m_ItemSel, this);
  328. CTreeCursor curNew = curItem.AddTail(dlg.m_strCategoryName, IID_DIRECTORY);
  329. curNew.SetData((long) new CCategoryDBItem(dlg.m_strCategoryDir.GetBuffer(0), m_lDirectoryIDMax++));
  330. curItem.Expand();
  331. }
  332. break;
  333. }
  334. case ID_MENUITEM_PORPERTY_CATEGORY:
  335. {
  336. bool bChangeName = true;
  337. if (m_ItemSel == m_curRoot || m_ItemSel == m_curDownloading || 
  338. m_ItemSel == m_curDownloaded || m_ItemSel == m_curRecycle)
  339. {
  340. bChangeName = false;
  341. }
  343. long lCategories = 0, lTotalFiles = 0;
  344. GetChildCount(m_ItemSel, lCategories, lTotalFiles);
  346. CCategoryPropertyDlg dlg;
  347. dlg.m_bChangeName = bChangeName;
  348. dlg.m_lSubCategory = lCategories;
  349. dlg.m_lTotalFiles = lTotalFiles;
  350. dlg.m_strCategoryName = m_ItemSel.GetText();
  352. CCategoryDBItem* pItem = (CCategoryDBItem*)m_ItemSel.GetData();
  353. dlg.m_strCategoryDir = pItem->m_strDefaultDirectory.data();
  354. if (dlg.DoModal() == IDOK)
  355. {
  356. if (bChangeName)
  357. m_ItemSel.SetText(dlg.m_strCategoryName);
  358. pItem->m_strDefaultDirectory = dlg.m_strCategoryDir;
  359. }
  360. }
  361. break;
  363. case ID_MENUITEM_DEL_CATEGORY:
  364. {
  365. int iRet = AfxMessageBox("删除该类别以及包括的子类别和文件?", MB_OKCANCEL|MB_ICONQUESTION);
  366. if (iRet == IDOK)
  367. {
  368. DeleteAllData(m_ItemSel);
  369. m_ItemSel.Delete();
  370. }
  371. }
  372. break;
  374. case ID_MENUITEM_MOVETO_CATEGORY:
  375. {
  376. CCategoryNewDlg dlg(&m_ctlImage, this, false, m_ItemSel);
  377. /*
  378. dlg.m_pctlImage = &m_ctlImage;
  379. dlg.m_ItemSel = m_ItemSel;
  380. dlg.m_bNewOrMoveto = false;
  381. dlg.m_pCategoryBarWnd = this;
  382. //*/
  383. if (dlg.DoModal() == IDOK)
  384. {
  385. CTreeCursor curMovetoItem(dlg.m_ItemSel, this);
  386. if (!MoveTreeEx(m_ItemSel, curMovetoItem))
  387. AfxMessageBox("Can't move Category");
  388. }
  389. }
  390. break;
  391. }
  393. SetFocus();
  394. }
  396. /**************************************************************
  398.   catogory manipulate helper function.
  400. **************************************************************/
  402. bool CCategoryBarWnd::CreateNewCategory(CTreeCursor curSel, CTreeCursor& curNew)
  403. {
  404. CCategoryNewDlg dlg(&m_ctlImage, this, true, curSel);
  405. if (dlg.DoModal() == IDOK)
  406. {
  407. CTreeCursor curItem(dlg.m_ItemSel, this);
  408. curNew = curItem.AddTail(dlg.m_strCategoryName, CCategoryBarWnd::IID_DIRECTORY);
  409. curNew.SetData((long) new CCategoryDBItem(dlg.m_strCategoryDir.GetBuffer(0), m_lDirectoryIDMax++));
  410. return true;
  411. }
  412. return false;
  413. }
  415. CTreeCursor CCategoryBarWnd::MoveTree(CTreeCursor curSrc, CTreeCursor curTarget)
  416. {
  417. CTreeCursor curTemp = curTarget.AddTail(curSrc.GetText(), curSrc.GetImageID());
  418. curTemp.SetData(curSrc.GetData());
  420. if (curSrc.HasChildren())
  421. {
  422. CTreeCursor curChild = curSrc.GetChild();
  423. while (curChild)
  424. {
  425. MoveTree(curChild, curTemp);
  426. curChild = curChild.GetNext(TVGN_NEXT);
  427. }
  428. }
  429. return curTemp;
  430. }
  432. bool CCategoryBarWnd::MoveTreeEx(CTreeCursor curSrc, CTreeCursor curTarget)
  433. {
  435. if (IsChild(curTarget, curSrc))
  436. return false;
  438. MoveTree(curSrc, curTarget).Select();
  439. curSrc.Delete();
  440. return true;
  441. }
  444. bool CCategoryBarWnd::GetChildCount(CTreeCursor& curSrc, long& lCategoryCount, long& lFilesCount)
  445. {
  446. if (curSrc == m_curDownloading)
  447. return false;
  449. lCategoryCount ++;
  450. CCategoryDBItem* pItem = (CCategoryDBItem*)curSrc.GetData();
  451. lFilesCount += pItem->m_vFileDBItems.size();
  453. if (curSrc.HasChildren())
  454. {
  455. CTreeCursor curChild = curSrc.GetChild();
  456. while (curChild)
  457. {
  458. GetChildCount(curChild, lCategoryCount, lFilesCount);
  459. curChild = curChild.GetNext(TVGN_NEXT);
  460. }
  461. }
  463. return true;
  464. }
  466. bool CCategoryBarWnd::IsChild(CTreeCursor curSrc, CTreeCursor curTarget)
  467. {
  468. if (curTarget == curSrc)
  469. return true;
  471. if (curTarget.HasChildren())
  472. {
  473. CTreeCursor curChild = curTarget.GetChild();
  474. while (curChild)
  475. {
  476. if (IsChild(curSrc, curChild))
  477. return true;
  478. curChild = curChild.GetNext(TVGN_NEXT);
  479. }
  480. }
  482. return false;
  483. }
  486. /************************************************************************
  488.   filedbitem drag and drop.
  490. ************************************************************************/
  492. DROPEFFECT CCategoryBarWnd::OnDragEnter(COleDataObject* pDataObject, DWORD dwKeyState, CPoint point)
  493. {
  494. if (pDataObject->IsDataAvailable(m_nIDClipFormat))
  495. return DROPEFFECT_MOVE;
  497. return DROPEFFECT_NONE;
  498. }
  501. DROPEFFECT CCategoryBarWnd::OnDragOver(COleDataObject* pDataObject, DWORD dwKeyState, CPoint point)
  502. {
  503. if (!pDataObject->IsDataAvailable(m_nIDClipFormat))
  504. return DROPEFFECT_NONE;
  506. UINT nFlags;
  507. CPoint curPoint;
  508. GetCursorPos(&curPoint);
  509. ScreenToClient(&curPoint);
  510. CTreeCursor curHit = HitTest(curPoint, &nFlags);
  512. if (!(HTREEITEM)curHit || curHit == m_curDownloading)
  513. return DROPEFFECT_NONE;
  515. return DROPEFFECT_MOVE;
  516. }
  518. BOOL CCategoryBarWnd::OnDrop(COleDataObject* pDataObject, DROPEFFECT dropEffect, CPoint point)
  519. {
  520. if (!pDataObject->IsDataAvailable(m_nIDClipFormat))
  521. return FALSE;
  523. UINT nFlags;
  524. CPoint curPoint;
  525. GetCursorPos(&curPoint);
  526. ScreenToClient(&curPoint);
  527. CTreeCursor curHit = HitTest(curPoint, &nFlags);
  529. if (!(HTREEITEM)curHit || curHit == m_curDownloading)
  530. return FALSE;
  532. if (m_pFilesListCtrl->m_curCursor == curHit)
  533. return FALSE;
  535. return FileDBItemMovetoArray(m_pFilesListCtrl->m_curCursor, curHit, m_pFilesListCtrl->m_vDragFileDBItems);
  536. /*
  537. //
  538. // if target category is recycle, don't move file. else prompt user.
  539. //
  540. bool bMoveFile = false;
  541. if (curHit == m_curRecycle)
  542. {
  543. vector<CFileDBItem*> vToStopFileDBItems;
  545. for (int i=0; i< m_pFilesListCtrl->m_vDragFileDBItems.size(); i++)
  546. {
  547. CFileDBItem* pFileDBItem = m_pFilesListCtrl->m_vDragFileDBItems[i];
  548. if (pFileDBItem->m_pDownload)
  549. vToStopFileDBItems.push_back(pFileDBItem);
  550. }
  552. if (!vToStopFileDBItems.empty())
  553. {
  554. if (AfxMessageBox("有下载正在进行中, 您是否确定删除?", MB_YESNO) != IDYES)
  555. return FALSE;
  556. }
  558. // if is downloading, popup it from starting engine deque.
  559. StopDBFiles(vToStopFileDBItems);
  560. }
  561. else
  562. {
  563. if (AfxMessageBox("是否移动已下载文件?", MB_YESNO|MB_ICONQUESTION) == IDYES)
  564. bMoveFile = true;
  565. }
  567. bool bMoveCategory = true;
  568. if (m_pFilesListCtrl->m_curCursor == m_curDownloading && curHit != m_curRecycle)
  569. bMoveCategory = false;
  571. assert(m_pFilesListCtrl->m_curCursor);
  573. for (int i=0; i< m_pFilesListCtrl->m_vDragFileDBItems.size(); i++)
  574. {
  575. CFileDBItem* pFileDBItem = m_pFilesListCtrl->m_vDragFileDBItems[i];
  576. FileDBItemMoveto(m_pFilesListCtrl->m_curCursor, curHit, pFileDBItem, bMoveFile, bMoveCategory);
  577. }
  579. return bMoveCategory;
  580. //*/
  581. }
  583. /************************************************************************
  584. OpenTorrentFile()
  586. paramerter :
  587. bOverwrite - if called by makemetafile() then don't alert user, if exist
  588.  only overwrite silently.
  589. ************************************************************************/
  591. void CCategoryBarWnd::OpenTorrentFile(string strTorrentFileName, HTREEITEM hItemSel, string strDirectorySave, bool bOverwrite)
  592. {
  593. assert(!strTorrentFileName.empty());
  595. try
  596. {
  597. string strComment;
  598. int iStartMode = 0; // start immediately.
  599. vector<CSize> vNoNeededFileInxs;
  602. CFileTorrent filetorrent;
  603. if (!filetorrent.OpenFile(strTorrentFileName))
  604. {
  605. CString strBadMsg = filetorrent.GetBadMsg().data();
  606. if (!strBadMsg.IsEmpty())
  607. AfxMessageBox(strBadMsg);
  608. return;
  609. }
  610. filetorrent.QueryDir();
  612. CFileDBItem* pExistFileDBItem = 0;
  613. CTreeCursor curExistFileCategory = findFileExist(GetRootItem(), filetorrent.GetInfohashString(), pExistFileDBItem);
  614. if (curExistFileCategory)
  615. {
  616. assert(pExistFileDBItem);
  617. m_bNoNotifications = true;
  618. curExistFileCategory.Select();
  619. curExistFileCategory.EnsureVisible();
  620. m_pFilesListCtrl->LoadCatetory(curExistFileCategory, pExistFileDBItem);
  621. m_bNoNotifications = false;
  623. bool bContinue = false;
  624. if (bOverwrite)
  625. {
  626. if (AfxMessageBox("该下载已存在，是否覆盖", MB_YESNO) == IDYES)
  627. bContinue = true;
  628. }
  629. else
  630. AfxMessageBox("该下载已存在");
  632. if (!bContinue)
  633. return;
  634. }
  636. if (hItemSel)
  637. {
  638. DWORD dwAttr = GetFileAttributes(strDirectorySave.data());
  639. if (dwAttr ==  0xffffffff)
  640. {
  641. assert(false);
  642. return;
  643. }
  644. }
  645. else
  646. {
  647. CDlgNewDownload dlg(&m_ctlImage, &filetorrent, this, true);
  648. if (dlg.DoModal() != IDOK)
  649. return;
  651. hItemSel = dlg.m_ItemSel;
  652. strDirectorySave = dlg.m_strDirectorySave;
  653. iStartMode = dlg.m_iStartMode;
  654. vNoNeededFileInxs = dlg.m_treeSubFiles.m_vChecks;
  655. strComment = dlg.m_strComment.GetBuffer(0);
  656. }
  658. string strTorrentFileNameNoPath = filetorrent.GetInfohashString();
  659. if (!CopyFileTorrent(strTorrentFileName, strTorrentFileNameNoPath))
  660. {
  661. AfxMessageBox("import torrent to db path error");
  662. return;
  663. }
  665. // if param Overwrite is set, only overwrite torrent file then return so don't add new filedbitem.
  666. if (curExistFileCategory && bOverwrite)
  667. {
  668. if (!pExistFileDBItem)
  669. {
  670. assert(false);
  671. return;
  672. }
  674. pExistFileDBItem->m_fComplete = 1;
  675. pExistFileDBItem->m_strTorrentFileName = strTorrentFileNameNoPath;
  676. pExistFileDBItem->m_strFileName = strDirectorySave;
  677. m_pFilesListCtrl->LoadCatetory(curExistFileCategory, pExistFileDBItem);
  678. return;
  679. }
  681. //
  682. // Create new filedbitem
  683. //
  684. time_t tnow;
  685. time(&tnow);
  686. float fComplete = bOverwrite ? 1 : 0;
  688. CTreeCursor curItem(hItemSel, this);
  689. CCategoryDBItem* pItem = (CCategoryDBItem*)curItem.GetData();
  690. assert(pItem);
  692. CFileDBItem* pNewFileDBItem = new CFileDBItem(
  693. strTorrentFileNameNoPath,
  694. strDirectorySave,
  695. filetorrent.GetFileLength(), fComplete, tnow, 
  696. filetorrent.GetInfohashString(), pItem->m_lDirectoryID, tnow, 
  697. filetorrent.GetPieces().size(), strComment);
  699. pNewFileDBItem->m_vUnneededFileInx = vNoNeededFileInxs;
  700. int iii = pNewFileDBItem->m_vUnneededFileInx.size();
  702. //
  703. // Append the new create filedbitem in downloading category.
  704. //
  706. if (curItem != m_curDownloading)
  707. {
  708. CCategoryDBItem* pDownloadingItem = (CCategoryDBItem*)m_curDownloading.GetData();
  709. pDownloadingItem->m_vFileDBItems.push_back(pNewFileDBItem);
  710. }
  711. // pItem->m_vFileDBItems.push_back(pNewFileDBItem);
  714. //
  715. // if download immediately, start it.
  716. //
  717. if (iStartMode == 0) // start immediately.
  718. Download(m_curDownloading, pNewFileDBItem);
  720. //
  721. // show downloading category.
  722. //
  724. m_bNoNotifications = true;
  725. m_curDownloading.Select();
  726. m_curDownloading.EnsureVisible();
  727. m_pFilesListCtrl->LoadCatetory(m_curDownloading, pNewFileDBItem);
  728. m_bNoNotifications = false;
  730. }
  731. catch (string& e)
  732. {
  733. AfxMessageBox(e.data());
  734. return;
  735. }
  736. }
  739. bool CCategoryBarWnd::CopyFileTorrent(string strTorrentFileName, string& strTorrentFileNameNoPath)
  740. {
  741. // copy file to db directory.
  742. assert(strTorrentFileNameNoPath.size() == 40);
  745. char drive[_MAX_DRIVE];
  746. char dir[_MAX_DIR];
  747. char fname[_MAX_FNAME];
  748. char ext[_MAX_EXT];
  749. _splitpath(strTorrentFileName.data(), drive, dir, fname, ext);
  750. // strTorrentFileNameNoPath = string(fname) + ext;
  752. string strName = fname;
  753. strName = strName.substr(0, MAX_PATH - 100);
  754. strTorrentFileNameNoPath = strName + "(" + strTorrentFileNameNoPath + ").torrent";
  756. if (_access(GetDBSavePath().data(), 0))
  757. {
  758. if (!MakeDirecotry(GetDBSavePath().data()))
  759. {
  760. AfxMessageBox(("create db direcotry (" + GetDBSavePath()+ ")failed").data());
  761. return false;
  762. }
  763. }
  765. string strTargetFileName = formatDir(GetDBSavePath().data()) + strTorrentFileNameNoPath;
  766. if (!CopyFile(strTorrentFileName.data(), strTargetFileName.data(), false))
  767. {
  768. if (_access(strTargetFileName.data(), 0))
  769. {
  770. DWORD dwerr = GetLastError();
  771. return false;
  772. }
  773. }
  775. return true;
  776. }
  778. /************************************************************************
  780.   find files.
  782. ************************************************************************/
  784. void CCategoryBarWnd::OnFindFile() 
  785. {
  786. CDlgFindConditions dlg;
  787. if (dlg.DoModal() == IDOK)
  788. {
  789. if (dlg.m_strFindCondition.IsEmpty())
  790. return ;
  792. findFileByConditions(true, dlg.m_strFindCondition.GetBuffer(0));
  793. }
  794. return ;
  796. }
  797. void CCategoryBarWnd::OnFindNext() 
  798. {
  799. findFileByConditions(false);
  800. }
  802. CTreeCursor CCategoryBarWnd::findFileExist(CTreeCursor& curItem, string strInfohash, CFileDBItem*& pExistFileDBItem)
  803. {
  805. CCategoryDBItem* pItem = (CCategoryDBItem*)curItem.GetData();
  806. assert(pItem && curItem);
  808. for (int i=0; i<pItem->m_vFileDBItems.size(); i++)
  809. {
  810. if (strInfohash == pItem->m_vFileDBItems[i]->m_strHash)
  811. {
  812. // if (IsLinkFileDBItem(curItem, pItem->m_vFileDBItems[i]))
  813. // continue;
  815. pExistFileDBItem = pItem->m_vFileDBItems[i];
  816. return curItem;
  817. }
  818. }
  820. if (curItem.HasChildren())
  821. {
  822. CTreeCursor curChild = curItem.GetChild();
  823. while (curChild)
  824. {
  825. CTreeCursor curRet = findFileExist(curChild, strInfohash, pExistFileDBItem);
  826. if (curRet)
  827. return curRet;
  829. curChild = curChild.GetNext(TVGN_NEXT);
  830. }
  831. }
  833. return CTreeCursor();
  834. }
  836. void CCategoryBarWnd::findFileByConditions(bool bRefind, string strFindContion)
  837. {
  838. int iRet = m_FindFileByConditions.findFileByConditions(bRefind, strFindContion);
  839. if (!iRet)
  840. {
  841. AfxMessageBox("can't find files");
  842. m_pFilesListCtrl->SetFocus();
  843. return;
  844. }
  846. if (!m_FindFileByConditions.m_curLast)
  847. {
  848. assert(false);
  849. return;
  850. }
  852. m_bNoNotifications = true;
  853. m_FindFileByConditions.m_curLast.Select();
  854. m_FindFileByConditions.m_curLast.EnsureVisible();
  855. m_pFilesListCtrl->LoadCatetory(m_FindFileByConditions.m_curLast, m_FindFileByConditions.m_pFileItem);
  856. m_bNoNotifications = false;
  858. if (iRet == 2)
  859. {
  860. AfxMessageBox("can't find files");
  861. m_pFilesListCtrl->SetFocus();
  862. }
  863. }
  865. ///////////////////////////////////////////////////////////////////
  866. //  CFindFileByConditions
  868. CCategoryBarWnd::CFindFileByConditions::CFindFileByConditions()
  869. {
  870. m_pCategoryBarWnd = 0;
  871. m_bStart = false;
  872. m_pFileItem = 0;
  873. }
  875. void CCategoryBarWnd::CFindFileByConditions::Create(CCategoryBarWnd* pCategoryBarWnd)
  876. {
  877. m_pCategoryBarWnd = pCategoryBarWnd;
  878. }
  880. void CCategoryBarWnd::CFindFileByConditions::SetNewStartLocation(CTreeCursor curLocate, CFileDBItem* pFileDBItem)
  881. {
  882. m_curLast = curLocate;
  883. m_pFileItem = pFileDBItem;
  884. }
  886. bool CCategoryBarWnd::CFindFileByConditions::CanFindNext()
  887. {
  888. return !m_strCondition.empty();
  889. }
  891. int CCategoryBarWnd::CFindFileByConditions::findFileByConditions(bool bRefind, string strCondition )
  892. {
  893. if (bRefind)
  894. {
  895. // m_curLast = CTreeCursor();
  896. // m_pFileItem = 0;
  897. CString strUpper = strCondition.data();
  898. strUpper.MakeUpper();
  899. m_strCondition = strUpper;
  900. }
  902. if (m_strCondition.empty())
  903. return false;
  905. m_bStart = bRefind = !m_pFileItem && !m_curLast;
  907. if (!findFileByConditionsrec(m_pCategoryBarWnd->GetRootItem(), m_strCondition))
  908. {
  909. if (bRefind)
  910. return false;
  912. CFileDBItem* pOldItem = m_pFileItem;
  913. CTreeCursor curOld = m_curLast;
  914. if (findFileByConditionsrec(m_pCategoryBarWnd->GetRootItem(), m_strCondition))
  915. {
  916. if (pOldItem == m_pFileItem && curOld == m_curLast)
  917. return 2;
  918. }
  919. else
  920. {
  921. m_curLast = CTreeCursor();
  922. m_pFileItem = 0;
  923. return false;
  924. }
  925. }
  927. return true;
  928. }
  930. CTreeCursor CCategoryBarWnd::CFindFileByConditions::findFileByConditionsrec(CTreeCursor& curItem, string strCondition)
  931. {
  932. CCategoryDBItem* pItem = (CCategoryDBItem*)curItem.GetData();
  933. assert(pItem && curItem);
  935. bool bCategory = m_bStart;
  936. if (!m_bStart)
  937. {
  938. assert(m_curLast);
  939. if (curItem == m_curLast )
  940. {
  941. bCategory = true;
  942. if (!m_pFileItem)
  943. m_bStart = true;
  944. }
  945. }
  947. if (bCategory)
  948. {
  949. for (int i=0; i<pItem->m_vFileDBItems.size(); i++)
  950. {
  951. if (!m_bStart)
  952. {
  953. assert(m_curLast);
  954. assert(curItem == m_curLast);
  955. assert(m_pFileItem);
  957. if (m_pFileItem == pItem->m_vFileDBItems[i])
  958. m_bStart = true;
  959. continue;
  960. }
  962. CFileDBItem* pFileDBItem = pItem->m_vFileDBItems[i];
  964. CString strFileNameUpper = pFileDBItem->m_strFileName.data();
  965. CString strTorrentFileNameUpper = pFileDBItem->m_strTorrentFileName.data();
  966. CString strHashUpper = pFileDBItem->m_strHash.data();
  967. strFileNameUpper.MakeUpper();
  968. strTorrentFileNameUpper.MakeUpper();
  969. strHashUpper.MakeUpper();
  971. if (strFileNameUpper.Find(strCondition.data()) != -1 ||
  972. strTorrentFileNameUpper.Find(strCondition.data()) != -1 ||
  973. strHashUpper.Find(strCondition.data()) != -1 )
  974. {
  975. m_curLast = curItem;
  976. m_pFileItem = pItem->m_vFileDBItems[i];
  977. return curItem;
  978. }
  979. }
  980. }
  982. if (curItem.HasChildren())
  983. {
  984. CTreeCursor curChild = curItem.GetChild();
  985. while (curChild)
  986. {
  987. CTreeCursor curRet = findFileByConditionsrec(curChild, strCondition);
  988. if (curRet)
  989. return curRet;
  991. curChild = curChild.GetNext(TVGN_NEXT);
  992. }
  993. }
  995. return CTreeCursor();
  996. }