D:/opendownloadmanager/ODM-1.x/Downloads

00001 /*
00002   Free Download Manager Copyright (c) 2003-2007 FreeDownloadManager.ORG
00003   Open Download Manager Copyright (c) 2008-2010 OpenDownloadManager.ORG
00004 */      
00005 
00006 #include "stdafx.h"
00007 #include "FdmApp.h"
00008 #include "Downloads_Tasks.h"
00009 #include "DownloadsWnd.h"
00010 #include "fsDownloadMgr.h"
00011 #include "inetutil.h"
00012 #include "misc.h"
00013 #include "plugincmds.h"
00014 #include "ShedulerWnd.h"
00015 #include "list.h"
00016 #include "ScheduleSheet.h"
00017 #include "MainFrm.h"
00018 #include "CreateBatchDownload.h"
00019 #include "Dlg_UnpackSettings.h"
00020 #include "Dlg_UnpackProgress.h"
00021 #include "Dlg_CheckFileIntegrity.h"
00022 #include "Dlg_CheckFileIntegrity_Progress.h"
00023 #include "Dlg_CheckFileIntegrity_Result.h"
00024 #include "FolderBrowser.h"
00025 #include "Dlg_Download.h"
00026 
00027 #ifdef _DEBUG
00028 #define new DEBUG_NEW
00029 #undef THIS_FILE
00030 static char THIS_FILE[] = __FILE__;
00031 #endif
00032 
00033 extern CShedulerWnd* _pwndScheduler;
00034 extern CDownloadsWnd* _pwndDownloads;      
00035 
00036 CDownloads_Tasks::CDownloads_Tasks()
00037 {
00038         m_pActiveDownload = NULL;
00039         m_sortModeSupport = LCSM_DESCENDING_NOTSUPPORTED;
00040         m_bAddingDownloads = false;
00041 }
00042 
00043 CDownloads_Tasks::~CDownloads_Tasks()
00044 {
00045 }  
00046 
00047 BEGIN_MESSAGE_MAP(CDownloads_Tasks, CListCtrlEx)
00048         //{{AFX_MSG_MAP(CDownloads_Tasks)
00049         ON_WM_RBUTTONDOWN()
00050         ON_WM_LBUTTONDBLCLK()
00051         ON_COMMAND(ID_DLDCREATE, OnDldcreate)
00052         ON_COMMAND(ID_DLDDELETE, OnDlddelete)
00053         ON_COMMAND(ID_DLDPROPERTIES, OnDldproperties)
00054         ON_COMMAND(ID_DLDSTART, OnDldstart)
00055         ON_COMMAND(ID_DLDSTOP, OnDldstop)
00056         ON_COMMAND(ID_DLDLAUNCH, OnDldlaunch)
00057         ON_COMMAND(ID_DLDOPENFOLDER, OnDldopenfolder)
00058         ON_COMMAND(ID_DLDSCHEDULE, OnDldschedule)
00059         ON_COMMAND(ID_DLDAUTOSTART, OnDldautostart)
00060         ON_WM_DRAWITEM()
00061         ON_WM_MEASUREITEM()
00062         ON_COMMAND(ID_DLDADDSECTION, OnDldaddsection)
00063         ON_COMMAND(ID_DLDDELSECTION, OnDlddelsection)
00064         ON_COMMAND(ID_DLDRESTART, OnDldrestart)
00065         ON_WM_KEYDOWN()
00066         ON_WM_CHAR()
00067         ON_COMMAND(ID_DLDQSIZE, OnDldqsize)
00068         ON_COMMAND(ID_DLDCREATEBATCH, OnDldcreatebatch)
00069         ON_WM_CREATE()
00070         ON_COMMAND(ID_DLDCHECKVIR, OnDldcheckvir)
00071         ON_COMMAND(ID_DLDFIND, OnDldfind)
00072         ON_COMMAND(ID_DLDFINDNEXT, OnDldfindnext)
00073         ON_COMMAND(ID_DLDUNPACK, OnDldunpack)
00074         ON_COMMAND(ID_DLDMOVEDOWN, OnDldmovedown)
00075         ON_COMMAND(ID_DLDMOVEUP, OnDldmoveup)
00076         ON_COMMAND(ID_DLDCHECKINTEGRITY, OnDldcheckintegrity)
00077         ON_COMMAND(ID_DLDMOVETOFOLDER, OnDldmovetofolder)
00078         ON_COMMAND(ID_DLDMOVEBOTTOM, OnDldmovebottom)
00079         ON_COMMAND(ID_DLDMOVETOP, OnDldmovetop)
00080         ON_COMMAND(ID_DLDSCHEDULESTOP, OnDldschedulestop)
00081         ON_COMMAND(ID_DLDGRANTBANDWIDTHFORDLD, OnDldgrantbandwidthfordld)
00082         ON_COMMAND(ID_DLDSHOWPROGRESSDLG, OnDldshowprogressdlg)
00083         ON_COMMAND(ID_DLDCONVERT, OnDldconvert)
00084         ON_WM_TIMER()
00085         ON_NOTIFY_REFLECT(LVN_GETDISPINFO, OnGetdispinfo)
00086         ON_COMMAND(ID_DLDENABLESEEDING, OnDldenableseeding)
00087         //}}AFX_MSG_MAP
00088 END_MESSAGE_MAP()      
00089 
00090 BOOL CDownloads_Tasks::Create(CWnd *pParent)
00091 {
00092         CRect rc (0, 0, 50, 50);
00093 
00094         
00095         if (FALSE == CListCtrlEx::Create (HDS_DRAGDROP | LVS_REPORT | 
00096                         LVS_OWNERDRAWFIXED | LVS_SHOWSELALWAYS | LVS_OWNERDATA ,
00097                         rc, pParent, 0x56789))
00098                 return FALSE;
00099 
00100         SetExtendedStyle (LVS_EX_FULLROWSELECT|LVS_EX_HEADERDRAGDROP|
00101                 LVS_EX_INFOTIP|0x00004000);
00102 
00103         m_images.Create (16, 17, ILC_COLOR24 | ILC_MASK, 7, 1);
00104         CBitmap bmp;
00105         bmp.Attach (SBMP (IDB_DOWNLOADSTASKS));
00106         
00107         m_images.Add (&bmp, RGB (255, 0, 255));
00108         SetImageList (&m_images, LVSIL_SMALL);
00109 
00110         m_selimages.Create (16, 17, ILC_COLOR24 | ILC_MASK, 7, 1);
00111         CBitmap bmp2;
00112         bmp2.Attach (SBMP (IDB_DOWNLOADSTASKS_SEL));
00113         m_selimages.Add (&bmp2, RGB (255, 0, 255));
00114         SetSelectedImages (&m_selimages);
00115 
00116         InsertColumn (0, "", LVCFMT_LEFT, 200, 0);
00117         InsertColumn (1, "", LVCFMT_LEFT, 50, 0);
00118         InsertColumn (2, "", LVCFMT_LEFT, 100, 0);
00119         InsertColumn (3, "", LVCFMT_LEFT, 60, 0);
00120         InsertColumn (4, "", LVCFMT_LEFT, 58, 0);
00121         InsertColumn (5, "", LVCFMT_LEFT, 70, 0);
00122         InsertColumn (6, "", LVCFMT_LEFT, 200, 0);
00123         InsertColumn (7, "", LVCFMT_LEFT, 120, 0);
00124 
00125         ReadState ("DownloadsList");
00126         InitSortImages ();      
00127 
00128         ShowWindow (SW_SHOW);
00129 
00130         return TRUE;
00131 }
00132 
00133 void CDownloads_Tasks::AddDownloadToList(vmsDownloadSmartPtr dld, BOOL bSelThisDld, bool bPlaceToTop)
00134 {
00135         m_mxAddDel.Lock ();
00136 
00137         size_t nDldIndex;
00138 
00139         
00140         if (bPlaceToTop == false)
00141         {
00142                 nDldIndex = m_vDownloads.size ();
00143                 m_vDownloads.push_back (dld);
00144         }
00145         else
00146         {
00147                 nDldIndex = 0;
00148                 m_vDownloads.insert (m_vDownloads.begin (), dld);
00149         }
00150         VirtualView_ItemWillBeAdded (GetSysColor (COLOR_WINDOW), GetSysColor (COLOR_WINDOWTEXT), bPlaceToTop ? TRUE : FALSE);
00151         if (m_bAddingDownloads == false)
00152                 SetItemCountEx (m_vDownloads.size (), LVSICF_NOINVALIDATEALL | LVSICF_NOSCROLL);
00153 
00154         m_mxAddDel.Unlock ();
00155 
00156         UpdateDownload (nDldIndex, FALSE);
00157 
00158         if (bSelThisDld)
00159                 SelectDownload (dld);
00160 }
00161 
00162 void CDownloads_Tasks::UpdateDownload(vmsDownloadSmartPtr dld, BOOL bRedraw)
00163 {
00164         int iItem = FindItem (dld);
00165         if (iItem != -1)
00166                 UpdateDownload (iItem, bRedraw);
00167 }
00168 
00169 void CDownloads_Tasks::OnClick()
00170 {
00171         UpdateActiveDownload (0);
00172 }
00173 
00174 void CDownloads_Tasks::OnRClick()
00175 {
00176         CMenu menu;
00177         menu.LoadMenu (IDM_DOWNLOADS);
00178         ApplyLanguageToMenu (&menu);
00179         CMenu *pPopup = menu.GetSubMenu (0);
00180         
00181         UpdateActiveDownload (0);
00182         
00183         UpdateMenu (pPopup);
00184 
00185         ClientToScreen (&m_rbPt);
00186 
00187         m_odmenu.Attach (&menu, FALSE);
00188         
00189         m_odmenu.SetImageList (&((CMainFrame*)AfxGetApp ()->m_pMainWnd)->m_imgsMenu, &((CMainFrame*)AfxGetApp ()->m_pMainWnd)->m_dimgsMenu);
00190         fsSetImage *pImages;
00191         int cImages;
00192         CDownloadsWnd::Plugin_GetMenuImages (&pImages, &cImages);
00193         m_odmenu.SetImages (pImages, cImages);
00194 
00195         fsSetImage img (11, 0, 0);
00196         m_odmenu.SetImages (&img, 3, NULL, TRUE);  
00197         
00198         pPopup->TrackPopupMenu (TPM_RIGHTBUTTON | TPM_TOPALIGN | TPM_LEFTALIGN, m_rbPt.x, m_rbPt.y, this);
00199         m_odmenu.Detach ();
00200 
00201         menu.DestroyMenu ();
00202 
00203         _pwndDownloads->m_wndDownloads.m_info.m_progress.set_FullRedraw ();
00204 }
00205 
00206 void CDownloads_Tasks::OnDeleteItem(NM_LISTVIEW *pNM)
00207 {
00208         if (pNM->lParam == (LONG)(fsDownload*) m_pActiveDownload)
00209         {
00210                 m_pActiveDownload = NULL;
00211                 m_pDownloadsWnd->SetActiveDownload (NULL);
00212         }
00213 }
00214 
00215 void CDownloads_Tasks::OnDeleteAllItems()
00216 {
00217         m_pActiveDownload = NULL;
00218         m_pDownloadsWnd->SetActiveDownload (NULL);
00219         m_sortMode = LCSM_NONE;
00220 }
00221 
00222 vmsDownloadSmartPtr CDownloads_Tasks::GetActiveDownload()
00223 {
00224         return m_pActiveDownload;
00225 }
00226 
00227 void CDownloads_Tasks::OnKeyDown(WORD wVK)
00228 {
00229         switch (wVK)
00230         {
00231                 case VK_DELETE:
00232                         
00233                         DeleteSelected (GetKeyState (VK_SHIFT) & 0x8000);
00234                         break;
00235 
00236                 case VK_RETURN:
00237                         if (GetKeyState (VK_MENU) & 0x8000)
00238                                 OnDldproperties ();
00239                         else
00240                                 CallSelectedDownload ();
00241                         break;
00242 
00243                 case VK_APPS:
00244                         CalcCoordsForCurSel ();
00245                         OnRClick ();
00246                         break;
00247 
00248                 case VK_TAB:
00249                         
00250                         _pwndDownloads->m_wndGroups.SetFocus ();
00251                         break;                  
00252         }
00253 }
00254 
00255 void CDownloads_Tasks::UpdateActiveDownload(int adjSelected)
00256 {
00257         try {
00258         
00259         POSITION pos = GetFirstSelectedItemPosition ();
00260         vmsDownloadSmartPtr dld;        
00261 
00262         
00263         if (pos && GetSelectedCount () == 1)
00264         {
00265                 int iItem = GetNextSelectedItem (pos);
00266 
00267                 iItem += adjSelected;   
00268                 if (iItem < 0)
00269                         iItem = 0;
00270                 else if (iItem >= GetItemCount ())
00271                         iItem = GetItemCount () - 1;
00272 
00273                 dld = m_vDownloads [iItem];
00274         }
00275         else
00276         {
00277                 int iItem = GetSelectionMark ();
00278 
00279                 if (iItem == -1)
00280                         dld = NULL;     
00281                 else
00282                 {
00283                         iItem += adjSelected;   
00284 
00285                         if (iItem < 0)
00286                                 iItem = 0;
00287                         else if (iItem >= GetItemCount ())
00288                                 iItem = GetItemCount () - 1;
00289 
00290                         dld = m_vDownloads [iItem];
00291                 }
00292         }
00293         
00294         if (dld != m_pActiveDownload)
00295         {
00296                 m_pActiveDownload = dld;
00297                 m_pDownloadsWnd->SetActiveDownload (m_pActiveDownload);
00298         }
00299 
00300         }
00301         catch (...) {}
00302 }
00303 
00304 int CDownloads_Tasks::FindItem(vmsDownloadSmartPtr dld)
00305 {
00306         for (size_t i = 0; i < m_vDownloads.size (); i++)
00307         {
00308                 if (m_vDownloads [i] == dld)
00309                         return i;
00310         }
00311 
00312         return -1;
00313 }
00314 
00315 void CDownloads_Tasks::DeleteSelected(BOOL bDontConfirmFileDeleting)
00316 {
00317         POSITION pos = GetFirstSelectedItemPosition ();
00318         if (pos == NULL)
00319                 return;
00320 
00321         if (bDontConfirmFileDeleting || _App.Deleted_ConfirmDeletion ())
00322                 if (IDNO == MessageBox (bDontConfirmFileDeleting ? LS (L_DLDWBDELETEDFROMDISK) : LS (L_AREYOUSURE), LS (L_CONFIRMATION), MB_YESNO|MB_ICONQUESTION))
00323         {
00324                 SetFocus ();
00325                 return;
00326         }
00327 
00328         pos = GetFirstSelectedItemPosition ();
00329         if (pos == NULL)
00330                 return;
00331         
00332         fs::list <_sRecordInfo> vDlds;
00333         
00334         while (pos)
00335         {
00336                 _sRecordInfo s;
00337 
00338                 s.iIndex = GetNextSelectedItem (pos);
00339                 s.dld = m_vDownloads [s.iIndex];
00340 
00341                 vDlds.add (s);
00342         }
00343 
00344         DLDS_LIST vpDlds;
00345         for (int i = 0; i < vDlds.size (); i++)
00346                 vpDlds.push_back (vDlds [i].dld);
00347         
00348         ShowWindow (SW_HIDE);
00349 
00350         try {
00351                 _DldsMgr.DeleteDownloads (vpDlds, TRUE, bDontConfirmFileDeleting);
00352         }catch (...) {}
00353 
00354         ShowWindow (SW_SHOW);
00355 
00356         for (i = 0; i < vDlds.size (); i++)
00357         {
00358                 if (vDlds [i].iIndex >= m_vDownloads.size ())
00359                         break;
00360                 SetItemState (vDlds [i].iIndex, 0, LVIS_SELECTED);
00361         }
00362 
00363         _pwndDownloads->UpdateTrayIconPlusOthers ();
00364         UpdateActiveDownload (0);
00365         SetFocus ();
00366 }
00367 
00368 void CDownloads_Tasks::OnRButtonDown(UINT nFlags, CPoint point) 
00369 {
00370         m_rbPt = point;
00371         
00372         CListCtrlEx::OnRButtonDown(nFlags, point);
00373 }
00374 
00375 void CDownloads_Tasks::OnLButtonDblClk(UINT nFlags, CPoint point) 
00376 {
00377         CListCtrlEx::OnLButtonDblClk(nFlags, point);
00378         CallSelectedDownload ();
00379 }
00380 
00381 void CDownloads_Tasks::OnDldcreate() 
00382 {
00383         m_pDownloadsWnd->OnDownloadCreate ();
00384         SetFocus ();
00385 }
00386 
00387 void CDownloads_Tasks::OnDlddelete() 
00388 {
00389         DeleteSelected ();
00390         SetFocus ();
00391 }
00392 
00393 void CDownloads_Tasks::OnDldproperties() 
00394 {
00395         POSITION pos = GetFirstSelectedItemPosition ();
00396         DLDS_LIST vDlds;
00397         DLDS_LIST vBtDlds;
00398 
00399         if (pos == NULL)
00400                 return;
00401 
00402         while (pos)
00403         {
00404                 int iItem = GetNextSelectedItem (pos);
00405                 vmsDownloadSmartPtr dld = m_vDownloads [iItem];
00406                 if (dld->pMgr->GetDownloadMgr () != NULL)
00407                         vDlds.push_back (dld);
00408                 else if (dld->pMgr->GetBtDownloadMgr () != NULL)
00409                         vBtDlds.push_back (dld);
00410         }
00411 
00412         if (vDlds.size () >= vBtDlds.size ())
00413                 m_pDownloadsWnd->OnDownloadProperties (vDlds);
00414         else
00415                 m_pDownloadsWnd->OnBtDownloadProperties (vBtDlds);
00416 
00417         SetFocus ();
00418 }
00419 
00420 void CDownloads_Tasks::OnDldstart() 
00421 {
00422         POSITION pos = GetFirstSelectedItemPosition ();
00423         DLDS_LIST vDlds;
00424         
00425         while (pos)
00426         {
00427                 vmsDownloadSmartPtr dld = m_vDownloads [GetNextSelectedItem (pos)];
00428                 if (dld->pMgr->IsRunning () == FALSE && dld->pMgr->IsDone () == FALSE)
00429                         vDlds.push_back (dld);
00430         }
00431 
00432         _DldsMgr.StartDownloads (vDlds, TRUE);
00433 }
00434 
00435 void CDownloads_Tasks::OnDldstop() 
00436 {
00437         POSITION pos = GetFirstSelectedItemPosition ();
00438         DLDS_LIST vDlds;
00439 
00440         if (pos == NULL)
00441                 return;
00442         
00443         while (pos)
00444         {
00445                 vmsDownloadSmartPtr dld = m_vDownloads [GetNextSelectedItem (pos)];
00446                 if (dld->pMgr->IsRunning ())
00447                         vDlds.push_back (dld);
00448                 else if (dld->bAutoStart)
00449                 {
00450                         dld->bAutoStart = FALSE;
00451                         UpdateDownload (dld);
00452                 }
00453         }       
00454 
00455         if (vDlds.size ())
00456                 _DldsMgr.StopDownloads (vDlds, TRUE);
00457 }
00458 
00459 void CDownloads_Tasks::OnDldlaunch() 
00460 {
00461         POSITION pos = GetFirstSelectedItemPosition ();
00462         
00463         while (pos)
00464         {
00465                 vmsDownloadSmartPtr dld = m_vDownloads [GetNextSelectedItem (pos)];
00466                 if (dld->pMgr->IsDone ())
00467                         _DldsMgr.LaunchDownload (dld);
00468         }       
00469 }
00470 
00471 void CDownloads_Tasks::WillBeDeleted(vmsDownloadSmartPtr dld)
00472 {
00473         UnscheduleDownload (dld->nID);
00474         DeleteDownload (dld);
00475 }
00476 
00477 void CDownloads_Tasks::OnDldopenfolder() 
00478 {
00479         fs::list <CString> vOpened;
00480         POSITION pos = GetFirstSelectedItemPosition ();
00481 
00482         while (pos)
00483         {
00484                 vmsDownloadSmartPtr dld = m_vDownloads [GetNextSelectedItem (pos)];
00485                 CString strFileName = dld->pMgr->get_OutputFilePathName ();
00486         
00487                 for (int i = vOpened.size () - 1; i >= 0; i--)
00488                 {
00489                         if (vOpened [i] == strFileName)
00490                                 break;
00491                 }
00492                 if (i != -1)
00493                         continue; 
00494 
00495                 dld->pMgr->Do_OpenFolder ();
00496                 vOpened.add (strFileName);
00497         }       
00498 }
00499 
00500 void CDownloads_Tasks::UpdateMenu(CMenu *pPopup)
00501 {
00502         try{
00503         if (_pwndDownloads->Get_DWWN () != DWWN_LISTOFDOWNLOADS || GetSelectedCount () == 0)
00504         {
00505                 pPopup->EnableMenuItem (ID_DLDSTART, MF_BYCOMMAND | MF_GRAYED);
00506                 pPopup->EnableMenuItem (ID_DLDSTOP, MF_BYCOMMAND | MF_GRAYED);
00507                 pPopup->EnableMenuItem (ID_DLDRESTART, MF_BYCOMMAND | MF_GRAYED);
00508                 pPopup->EnableMenuItem (ID_DLDADDSECTION, MF_BYCOMMAND | MF_GRAYED);
00509                 pPopup->EnableMenuItem (ID_DLDDELSECTION, MF_BYCOMMAND | MF_GRAYED);
00510                 pPopup->EnableMenuItem (ID_DLDDELETE, MF_BYCOMMAND | MF_GRAYED);
00511                 pPopup->EnableMenuItem (ID_DLDOPENFOLDER, MF_BYCOMMAND | MF_GRAYED);
00512                 pPopup->EnableMenuItem (ID_DLDPROPERTIES, MF_BYCOMMAND | MF_GRAYED);
00513                 pPopup->EnableMenuItem (ID_DLDLAUNCH, MF_BYCOMMAND | MF_GRAYED);
00514                 pPopup->EnableMenuItem (ID_DLDAUTOSTART, MF_BYCOMMAND | MF_GRAYED);
00515                 pPopup->EnableMenuItem (ID_DLDSCHEDULE, MF_BYCOMMAND | MF_GRAYED);
00516                 pPopup->EnableMenuItem (ID_DLDQSIZE, MF_BYCOMMAND | MF_GRAYED);
00517                 pPopup->EnableMenuItem (ID_DLDCHECKVIR, MF_BYCOMMAND | MF_GRAYED);
00518                 pPopup->EnableMenuItem (ID_DLDUNPACK, MF_BYCOMMAND | MF_GRAYED);
00519                 pPopup->EnableMenuItem (ID_DLDCONVERT, MF_BYCOMMAND | MF_GRAYED);
00520                 pPopup->EnableMenuItem (ID_DLDMOVEUP, MF_BYCOMMAND | MF_GRAYED);
00521                 pPopup->EnableMenuItem (ID_DLDMOVEDOWN, MF_BYCOMMAND | MF_GRAYED);
00522                 pPopup->EnableMenuItem (ID_DLDMOVETOP, MF_BYCOMMAND | MF_GRAYED);
00523                 pPopup->EnableMenuItem (ID_DLDMOVEBOTTOM, MF_BYCOMMAND | MF_GRAYED);
00524                 pPopup->EnableMenuItem (ID_DLDCHECKINTEGRITY, MF_BYCOMMAND | MF_GRAYED);
00525                 pPopup->EnableMenuItem (ID_DLDMOVETOFOLDER, MF_BYCOMMAND | MF_GRAYED);
00526                 pPopup->EnableMenuItem (ID_DLDSCHEDULESTOP, MF_BYCOMMAND | MF_GRAYED);
00527                 pPopup->EnableMenuItem (ID_DLDGRANTBANDWIDTHFORDLD, MF_BYCOMMAND | MF_GRAYED);
00528                 pPopup->EnableMenuItem (ID_DLDSHOWPROGRESSDLG, MF_BYCOMMAND | MF_GRAYED);
00529                 pPopup->EnableMenuItem (ID_DLDENABLESEEDING, MF_BYCOMMAND | MF_GRAYED);
00530         }
00531         else
00532         {
00533                 POSITION pos = GetFirstSelectedItemPosition ();
00534                 
00535                 int iAutoStart = 3; 
00536                 
00537                 BOOL bRunning = FALSE;
00538                 
00539                 BOOL bStopped = FALSE; 
00540                 
00541                 BOOL bCanQuery = FALSE;
00542                 
00543                 BOOL bDone = FALSE;
00544                 BOOL b1stDone = FALSE;
00545                 bool b1st = true;
00546                 bool b1stGranted = false;
00547                 bool bHasEnableSeedingDlds = false;
00548                 bool bHasBtDlds = false;
00549                 
00550                 while (pos)
00551                 {
00552                         int iItem = GetNextSelectedItem (pos);
00553                         vmsDownloadSmartPtr dld = m_vDownloads [iItem];
00554 
00555                         if (b1st) {
00556                                 b1stDone = dld->pMgr->IsDone ();
00557                                 b1st = false;
00558                                 b1stGranted = dld == _DldsMgr.get_HighestPriorityDownload ();
00559                         }
00560 
00561                         if (bHasEnableSeedingDlds == false && dld->pMgr->IsBittorrent ())
00562                         {
00563                                 bHasBtDlds = true;
00564 
00565                                 if ((dld->pMgr->GetBtDownloadMgr ()->get_Flags () & BTDF_DISABLE_SEEDING) == 0 ||
00566                                                 dld->pMgr->GetBtDownloadMgr ()->get_State () == BTDSE_SEEDING)
00567                                         bHasEnableSeedingDlds = true;
00568                         }  
00569 
00570                         if (iAutoStart == 3)
00571                                 iAutoStart = dld->bAutoStart ? 1 : 0;
00572                         else if (iAutoStart == 1 && dld->bAutoStart == FALSE || iAutoStart == 0 && dld->bAutoStart)
00573                                 iAutoStart = 2; 
00574 
00575                         if (bRunning == FALSE && dld->pMgr->IsRunning ())
00576                                 bRunning = TRUE;
00577 
00578                         if (bStopped == FALSE && dld->pMgr->IsRunning () == FALSE && dld->pMgr->IsDone () == FALSE)
00579                                 bStopped = TRUE;
00580 
00581                         if (bDone == FALSE && dld->pMgr->IsDone ())
00582                                 bDone = TRUE;
00583         
00584                         if (bCanQuery == FALSE && dld->pMgr->GetNumberOfSections () == 0)
00585                                 bCanQuery = TRUE;
00586                 }
00587                 
00588                 if (bRunning == FALSE)
00589                 {
00590                         if (iAutoStart == 0)
00591                                 pPopup->EnableMenuItem (ID_DLDSTOP, MF_BYCOMMAND | MF_GRAYED);
00592                         pPopup->EnableMenuItem (ID_DLDADDSECTION, MF_BYCOMMAND | MF_GRAYED);
00593                         pPopup->EnableMenuItem (ID_DLDDELSECTION, MF_BYCOMMAND | MF_GRAYED);
00594                         pPopup->EnableMenuItem (ID_DLDGRANTBANDWIDTHFORDLD, MF_BYCOMMAND | MF_GRAYED);
00595                         pPopup->EnableMenuItem (ID_DLDSHOWPROGRESSDLG, MF_BYCOMMAND | MF_GRAYED);
00596                 }
00597                 else if (GetSelectedCount () != 1)
00598                 {
00599                         pPopup->EnableMenuItem (ID_DLDGRANTBANDWIDTHFORDLD, MF_BYCOMMAND | MF_GRAYED);
00600                 }
00601 
00602                 
00603                 if (bStopped == FALSE)
00604                 {
00605                         pPopup->EnableMenuItem (ID_DLDSTART, MF_BYCOMMAND | MF_GRAYED);
00606                         if (bDone == FALSE)
00607                                 pPopup->EnableMenuItem (ID_DLDRESTART, MF_BYCOMMAND | MF_GRAYED);
00608                         pPopup->EnableMenuItem (ID_DLDQSIZE, MF_BYCOMMAND | MF_GRAYED);
00609                 }
00610 
00611                 
00612                 if (bRunning == FALSE && bStopped == FALSE)
00613                 {
00614                         pPopup->EnableMenuItem (ID_DLDSCHEDULE, MF_BYCOMMAND | MF_GRAYED);
00615                         pPopup->EnableMenuItem (ID_DLDSCHEDULESTOP, MF_BYCOMMAND | MF_GRAYED);
00616                 }
00617 
00618                 
00619                 if (bDone == FALSE)
00620                 {
00621                         pPopup->EnableMenuItem (ID_DLDLAUNCH, MF_BYCOMMAND | MF_GRAYED);
00622                         pPopup->EnableMenuItem (ID_DLDCHECKVIR, MF_BYCOMMAND | MF_GRAYED);
00623                 }
00624 
00625                 
00626                 if (bCanQuery == FALSE)
00627                         pPopup->EnableMenuItem (ID_DLDQSIZE, MF_BYCOMMAND | MF_GRAYED);
00628 
00629                 
00630                 if (iAutoStart == 1)
00631                         pPopup->CheckMenuItem (ID_DLDAUTOSTART, MF_CHECKED | MF_BYCOMMAND);
00632 
00633                 m_bAutoStart = iAutoStart != 1;
00634 
00635                 if (GetSelectedCount () != 1 || b1stDone == FALSE) {
00636                         pPopup->EnableMenuItem (ID_DLDUNPACK, MF_BYCOMMAND | MF_GRAYED);
00637                         pPopup->EnableMenuItem (ID_DLDCONVERT, MF_BYCOMMAND | MF_GRAYED);
00638                         pPopup->EnableMenuItem (ID_DLDCHECKINTEGRITY, MF_BYCOMMAND | MF_GRAYED);
00639                 }
00640 
00641                 if (GetSelectedCount () == 1 && b1stGranted)
00642                         pPopup->CheckMenuItem (ID_DLDGRANTBANDWIDTHFORDLD, MF_CHECKED | MF_BYCOMMAND);
00643 
00644                 m_bHasEnableSeedingDlds = bHasEnableSeedingDlds;
00645                 if (bHasBtDlds == false)
00646                         pPopup->EnableMenuItem (ID_DLDENABLESEEDING, MF_BYCOMMAND | MF_GRAYED);
00647                 else if (bHasEnableSeedingDlds)
00648                         pPopup->CheckMenuItem (ID_DLDENABLESEEDING, MF_CHECKED | MF_BYCOMMAND);
00649         }
00650         } catch (...) {
00651                 UpdateMenu (pPopup);
00652         }
00653 }
00654 
00655 void CDownloads_Tasks::AddDownload(vmsDownloadSmartPtr dld, BOOL bSelThisDld)
00656 {
00657         if (FindItem (dld) == -1)
00658                 AddDownloadToList (dld, bSelThisDld);
00659 }
00660 
00661 void CDownloads_Tasks::DeleteDownload(vmsDownloadSmartPtr dld)
00662 {
00663         m_mxAddDel.Lock ();
00664 
00665         int iIndex = FindItem (dld);
00666 
00667         if (iIndex != -1)
00668         {
00669                 VirtualView_ItemWillBeDeleted (iIndex);
00670                 m_vDownloads.erase (m_vDownloads.begin () + iIndex);
00671                 SetItemCount (m_vDownloads.size ());
00672         }
00673 
00674         m_mxAddDel.Unlock ();
00675 }
00676 
00677 void CDownloads_Tasks::OnDldschedule() 
00678 {
00679         ScheduleSelectedDlds (TRUE);
00680 }
00681 
00682 int CDownloads_Tasks::GetDownloadImage(vmsDownloadSmartPtr dld)
00683 {
00684         if (dld->pMgr->IsDone ())
00685         {
00686                 if (dld->pMgr->IsBittorrent () && 
00687                                 dld->pMgr->GetBtDownloadMgr ()->get_State () == BTDS_SEEDING)
00688                         return 7;       
00689                 return 1;       
00690         }
00691 
00692         if (dld->pMgr->IsRunning ())
00693         {
00694                 if (dld->pMgr->GetDownloadingSectionCount ())
00695                         return 3;       
00696                 else
00697                         return 4;       
00698         }
00699 
00700         if (_pwndScheduler && _pwndScheduler->GetMgr ()->IsDownloadScheduled (dld))
00701                 return 2;       
00702 
00703         return dld->bAutoStart ? 5 : 0; 
00704 }
00705 
00706 void CDownloads_Tasks::UpdateAllDownloads()
00707 {
00708         RedrawItems (0, GetItemCount ()-1);
00709         UpdateWindow ();
00710 }
00711 
00712 void CDownloads_Tasks::UnscheduleDownload(UINT nID)
00713 {
00714         fsScheduleMgr *mgr = _pwndScheduler->GetMgr ();
00715 
00716         
00717         for (int i = mgr->GetTaskCount () - 1; i >= 0; i--)
00718         {
00719                 fsSchedule *task = mgr->GetTask (i);
00720                 if (task->wts.enType == WTS_STARTDOWNLOAD || task->wts.enType == WTS_STOPDOWNLOAD)
00721                 {
00722                         for (int j = task->wts.pvIDs->size () - 1; j >= 0; j--)
00723                         {
00724                                 
00725                                 if (task->wts.pvIDs->at (j) == nID)
00726                                 {
00727                                         
00728                                         task->wts.pvIDs->del (j);
00729                                         if (task->wts.pvIDs->size () == 0)
00730                                                 mgr->DeleteTask (task); 
00731                                         break;
00732                                 }
00733                         }
00734                 }
00735         }
00736 }
00737 
00738 void CDownloads_Tasks::OnForceUpdate()
00739 {
00740         RedrawItems (0, GetItemCount ()-1);
00741 }
00742 
00743 void CDownloads_Tasks::OnDldautostart() 
00744 {
00745         POSITION pos = GetFirstSelectedItemPosition     ();
00746 
00747         while (pos)
00748         {
00749                 vmsDownloadSmartPtr dld = m_vDownloads [GetNextSelectedItem (pos)];
00750                 dld->bAutoStart = m_bAutoStart;
00751                 UpdateDownload (dld);
00752         }
00753 
00754         _DldsMgr.ProcessDownloads ();
00755 }
00756 
00757 int CDownloads_Tasks::OnUpdateToolBar(UINT nID)
00758 {
00759         BOOL bEnabled = TRUE;   
00760         BOOL bChecked = FALSE;  
00761 
00762         
00763         if (nID == ID_DLD_VID_PLAY || nID == ID_DLD_VID_PAUSE ||
00764                 nID == ID_DLD_VID_STOP || nID == ID_DLD_VID_MUTE     )
00765         {
00766                 _pwndDownloads->m_wndDownloads.m_info.m_video.UpdateCommand (nID,
00767                         &bEnabled, &bChecked);
00768 
00769                 int iState = bEnabled ? WGP_CMDITEMSTATE_ENABLED : WGP_CMDITEMSTATE_DISABLED;
00770                 if (bChecked) iState |= WGP_CMDITEMSTATE_CHECKED;
00771                 return iState;
00772         }
00773 
00774         if (GetSelectedCount () == 0)
00775         {
00776                 switch (nID)
00777                 {
00778                         case ID_DLDSTART:
00779                         case ID_DLDSTOP:
00780                         case ID_DLDDELETE:
00781                         case ID_DLDOPENFOLDER:
00782                         case ID_DLDPROPERTIES:
00783                         case ID_DLDLAUNCH:
00784                         case ID_DLDCHECKVIR:
00785                         case ID_DLDAUTOSTART:
00786                         case ID_DLDSCHEDULE:
00787                         case ID_DLDMOVEUP:
00788                         case ID_DLDMOVEDOWN:
00789                         case ID_DLDMOVETOP:
00790                         case ID_DLDMOVEBOTTOM:
00791                         case ID_DLDSCHEDULESTOP:
00792                         case ID_DLDSHOWPROGRESSDLG:
00793                                 bEnabled = FALSE;
00794                         break;
00795                 }
00796         }
00797         else
00798         {
00799 
00800                 POSITION pos = GetFirstSelectedItemPosition ();
00801                 int iAutoStart = 3; 
00802                 BOOL bRunning = FALSE;
00803                 BOOL bStopped = FALSE;
00804 
00805                 while (pos)
00806                 {
00807                         try {
00808                                 int iItem = GetNextSelectedItem (pos);
00809                                 vmsDownloadSmartPtr dld = m_vDownloads [iItem];
00810                                 if (dld->pMgr->IsRunning ())
00811                                         bRunning = TRUE;
00812                                 else if (dld->pMgr->IsDone () == FALSE)
00813                                         bStopped = TRUE;
00814 
00815                                 if (iAutoStart == 3)
00816                                         iAutoStart = dld->bAutoStart ? 1 : 0;
00817                                 else if (iAutoStart == 1 && dld->bAutoStart == FALSE || iAutoStart == 0 && dld->bAutoStart)
00818                                         iAutoStart = 2; 
00819                         }
00820                         catch (...) {}
00821                 }
00822 
00823                 switch (nID)
00824                 {
00825                         case ID_DLDSTART:
00826                                         if (bStopped == FALSE)
00827                                                         bEnabled = FALSE;
00828                                 break;
00829 
00830                         case ID_DLDSTOP:
00831                                 if (bRunning == FALSE && iAutoStart == 0)
00832                                         bEnabled = FALSE;
00833                         break;
00834 
00835                         case ID_DLDSCHEDULE:
00836                         case ID_DLDSCHEDULESTOP:
00837                                         if (bRunning == FALSE && bStopped == FALSE)
00838                                                 bEnabled = FALSE;
00839                                 break;
00840                 }
00841 
00842                 if (nID == ID_DLDAUTOSTART && iAutoStart == 1)
00843                         bChecked = TRUE;
00844         }
00845 
00846         int iState = bEnabled ? WGP_CMDITEMSTATE_ENABLED : WGP_CMDITEMSTATE_DISABLED;
00847         if (bChecked) iState |= WGP_CMDITEMSTATE_CHECKED;
00848 
00849         return iState;
00850 }
00851 
00852 void CDownloads_Tasks::OnDrawItem(int , LPDRAWITEMSTRUCT lpDrawItemStruct) 
00853 {
00854         m_odmenu.OnDrawItem (lpDrawItemStruct);
00855 }
00856 
00857 void CDownloads_Tasks::OnMeasureItem(int , LPMEASUREITEMSTRUCT lpMeasureItemStruct) 
00858 {
00859         m_odmenu.OnMeasureItem (lpMeasureItemStruct);
00860 }
00861 
00862 void CDownloads_Tasks::ApplyLanguageToMenu(CMenu *menu)
00863 {
00864         menu->ModifyMenu (0, MF_BYPOSITION|MF_STRING, 0, LS (L_DOWNLOADS));
00865         
00866         CString str = LS (L_NEWDL); str += "\tCtrl+N";
00867         menu->ModifyMenu (ID_DLDCREATE, MF_BYCOMMAND|MF_STRING, ID_DLDCREATE, str);
00868 
00869         menu->ModifyMenu (ID_DLDCREATEBATCH, MF_BYCOMMAND|MF_STRING, ID_DLDCREATEBATCH, LS (L_CREATEBATCHDLD));
00870         
00871         str = LS (L_STARTDLDS); str += "\tShift+S";
00872         menu->ModifyMenu (ID_DLDSTART, MF_BYCOMMAND|MF_STRING, ID_DLDSTART, str);
00873         str = LS (L_STOPDLDS); str += "\tShift+O";
00874         menu->ModifyMenu (ID_DLDSTOP, MF_BYCOMMAND|MF_STRING, ID_DLDSTOP, str);
00875 
00876         str = LS (L_QUERYSIZE); str += "\tShift+Q";
00877         menu->ModifyMenu (ID_DLDQSIZE, MF_BYCOMMAND|MF_STRING, ID_DLDQSIZE, str);
00878 
00879         menu->GetSubMenu (0)->ModifyMenu (9, MF_BYPOSITION|MF_STRING, 0, LS (L_ADVANCED));
00880         str = LS (L_RESTARTDL); str += "\tShift+R";
00881         menu->ModifyMenu (ID_DLDRESTART, MF_BYCOMMAND|MF_STRING, ID_DLDRESTART, str);
00882         str = LS (L_ADDONEMORESECT); str += "\t+";
00883         menu->ModifyMenu (ID_DLDADDSECTION, MF_BYCOMMAND|MF_STRING, ID_DLDADDSECTION, str);
00884         str = LS (L_DELSECTION); str += "\t-";
00885         menu->ModifyMenu (ID_DLDDELSECTION, MF_BYCOMMAND|MF_STRING, ID_DLDDELSECTION, str);
00886         
00887         menu->GetSubMenu (0)->ModifyMenu (11, MF_BYPOSITION|MF_STRING, 0, LS (L_SCHEDULE));
00888         menu->ModifyMenu (ID_DLDSCHEDULE, MF_BYCOMMAND|MF_STRING, ID_DLDSCHEDULE, LS (L_SCHEDULE_START));
00889         menu->ModifyMenu (ID_DLDSCHEDULESTOP, MF_BYCOMMAND|MF_STRING, ID_DLDSCHEDULESTOP, LS (L_SCHEDULE_STOP));
00890         
00891         str = LS (L_DELETEDLD); str += "\tDel (Shift+Del)";
00892         menu->ModifyMenu (ID_DLDDELETE, MF_BYCOMMAND|MF_STRING, ID_DLDDELETE, str);
00893 
00894         menu->ModifyMenu (ID_DLDLAUNCH, MF_BYCOMMAND|MF_STRING, ID_DLDLAUNCH, LS (L_LAUNCHFILE));
00895         menu->ModifyMenu (ID_DLDOPENFOLDER, MF_BYCOMMAND|MF_STRING, ID_DLDOPENFOLDER, LS (L_OPENFOLDER));
00896         
00897         str = LS (L_AUTOSTARTDLD); str += '\t';
00898         menu->ModifyMenu (ID_DLDAUTOSTART, MF_BYCOMMAND|MF_STRING, ID_DLDAUTOSTART, str);
00899 
00900         menu->ModifyMenu (ID_DLDCHECKVIR, MF_BYCOMMAND|MF_STRING, ID_DLDCHECKVIR, LS (L_PERFVIRCHECK));
00901 
00902         str = LS (L_DLDPROP); str += "\tAlt+Enter";
00903         menu->ModifyMenu (ID_DLDPROPERTIES, MF_BYCOMMAND|MF_STRING, ID_DLDPROPERTIES, str);
00904 
00905         str = LS (L_FIND); str += "\tCtrl+F";
00906         menu->ModifyMenu (ID_DLDFIND, MF_BYCOMMAND|MF_STRING, ID_DLDFIND, str);
00907         
00908         str = LS (L_FINDNEXT); str += "\tF3";
00909         menu->ModifyMenu (ID_DLDFINDNEXT, MF_BYCOMMAND|MF_STRING, ID_DLDFINDNEXT, str);
00910 
00911         menu->ModifyMenu (ID_DLDUNPACK, MF_BYCOMMAND|MF_STRING, ID_DLDUNPACK, LS (L_EXTRACTARCHIVE));
00912         menu->ModifyMenu (ID_DLDCONVERT, MF_BYCOMMAND|MF_STRING, ID_DLDCONVERT, LS (L_CONVERT_MEDIA_FILE));
00913 
00914         str = LS (L_MOVEUP); str += "\tShift+U";
00915         menu->ModifyMenu (ID_DLDMOVEUP, MF_BYCOMMAND|MF_STRING, ID_DLDMOVEUP, str);
00916 
00917         str = LS (L_MOVEDOWN); str += "\tShift+D";
00918         menu->ModifyMenu (ID_DLDMOVEDOWN, MF_BYCOMMAND|MF_STRING, ID_DLDMOVEDOWN, str);
00919 
00920         str = LS (L_CHECKFILEINTEGRITY); str += "\tShift+I";
00921         menu->ModifyMenu (ID_DLDCHECKINTEGRITY, MF_BYCOMMAND|MF_STRING, ID_DLDCHECKINTEGRITY, str);
00922 
00923         str = LS (L_MOVEDLDFILETOFOLDER); str += "\tShift+M";
00924         menu->ModifyMenu (ID_DLDMOVETOFOLDER, MF_BYCOMMAND|MF_STRING, ID_DLDMOVETOFOLDER, str);
00925 
00926         str = LS (L_MOVETOP); str += "\tShift+T";
00927         menu->ModifyMenu (ID_DLDMOVETOP, MF_BYCOMMAND|MF_STRING, ID_DLDMOVETOP, str);
00928 
00929         str = LS (L_MOVEBOTTOM); str += "\tShift+B";
00930         menu->ModifyMenu (ID_DLDMOVEBOTTOM, MF_BYCOMMAND|MF_STRING, ID_DLDMOVEBOTTOM, str);
00931 
00932         menu->ModifyMenu (ID_DLDGRANTBANDWIDTHFORDLD, MF_BYCOMMAND|MF_STRING, ID_DLDGRANTBANDWIDTHFORDLD, LS (L_GRANTBANDWIDTHFORDLD));
00933 
00934         menu->ModifyMenu (ID_DLDSHOWPROGRESSDLG, MF_BYCOMMAND|MF_STRING, ID_DLDSHOWPROGRESSDLG, LS (L_DLDSHOWPROGRESSDLG));
00935 
00936         menu->ModifyMenu (ID_DLDENABLESEEDING, MF_BYCOMMAND|MF_STRING, ID_DLDENABLESEEDING, LS (L_ENABLE_SEEDING));
00937 }
00938 
00939 void CDownloads_Tasks::ApplyLanguage()
00940 {
00941         SetColumnText (0, LS (L_FILENAME));
00942         SetColumnText (1, LS (L_SIZE));
00943         SetColumnText (2, LS (L_DOWNLOADED));
00944         SetColumnText (3, LS (L_TIMELEFT));
00945         SetColumnText (4, LS (L_SECTIONS));
00946         SetColumnText (5, LS (L_SPEED));
00947         SetColumnText (6, LS (L_COMMENT));
00948         SetColumnText (7, LS (L_ADDED));
00949 }
00950 
00951 void CDownloads_Tasks::CalcCoordsForCurSel()
00952 {
00953 
00954         int iCurSel = GetSelectionMark ();      
00955         if (iCurSel == -1)
00956         {
00957                 
00958                 POSITION pos = GetFirstSelectedItemPosition ();
00959                 if (pos)
00960                         iCurSel = GetNextSelectedItem (pos);
00961         }
00962 
00963         if (iCurSel != -1)
00964         {
00965                 RECT rc;
00966                 GetItemRect (iCurSel, &rc, LVIR_BOUNDS);
00967                 m_rbPt.x = rc.left + 30;
00968                 m_rbPt.y = rc.top;
00969         }
00970         else
00971                 m_rbPt.x = m_rbPt.y = 30;       
00972 }
00973 
00974 void CDownloads_Tasks::OnDldaddsection() 
00975 {
00976         POSITION pos = GetFirstSelectedItemPosition ();
00977         while (pos)
00978         {
00979                 vmsDownloadSmartPtr dld = m_vDownloads [GetNextSelectedItem (pos)];
00980                 if (dld->pMgr->IsRunning ())
00981                         dld->pMgr->CreateOneMoreSection ();
00982         }
00983 }
00984 
00985 void CDownloads_Tasks::OnDlddelsection() 
00986 {
00987         POSITION pos = GetFirstSelectedItemPosition ();
00988         while (pos)
00989         {
00990                 vmsDownloadSmartPtr dld = m_vDownloads [GetNextSelectedItem (pos)];
00991                 if (dld->pMgr->IsRunning ())
00992                         dld->pMgr->StopSection ();
00993         }       
00994 }
00995 
00996 void CDownloads_Tasks::OnDldrestart() 
00997 {
00998         POSITION pos = GetFirstSelectedItemPosition ();
00999 
01000         if (pos)
01001         {
01002                 if (MessageBox (LS (L_AREYOUSURE_WILLSTARTFROM0), LS (L_CONFIRMATION), MB_ICONQUESTION | MB_YESNO) == IDNO)
01003                         return;
01004         }
01005 
01006         DLDS_LIST vpDlds;
01007 
01008         while (pos)
01009                 vpDlds.push_back (m_vDownloads [GetNextSelectedItem (pos)]);
01010 
01011         for (size_t i = 0; i < vpDlds.size (); i++)
01012                 _pwndDownloads->RestartDownload (vpDlds [i], i == vpDlds.size () - 1);
01013 }
01014 
01015 void CDownloads_Tasks::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) 
01016 {
01017         BOOL bShift = GetKeyState (VK_SHIFT) & 0x8000;
01018         BOOL bCtrl = GetKeyState (VK_CONTROL) & 0x8000;
01019 
01020         switch (nChar)
01021         {
01022                 case 'S':
01023                         if (bShift)
01024                         {
01025                                 OnDldstart ();
01026                                 return;
01027                         }
01028                         break;
01029 
01030                 case 'O':
01031                         if (bShift)
01032                         {
01033                                 OnDldstop ();
01034                                 return;
01035                         }
01036                         break;
01037 
01038                 case 'Q':
01039                         if (bShift)
01040                         {
01041                                 OnDldqsize ();
01042                                 return;
01043                         }
01044                         break;
01045 
01046                 case VK_ADD:
01047                         OnDldaddsection ();
01048                         return;
01049 
01050                 case VK_SUBTRACT:
01051                         OnDlddelsection ();
01052                         return;
01053 
01054                 case 'R':
01055                         if (bShift)
01056                         {
01057                                 OnDldrestart ();
01058                                 return;
01059                         }
01060                         break;
01061 
01062                 case 'A':
01063                         if (bCtrl)
01064                         {
01065                                 int cItems = GetItemCount ();
01066                                 for (int i = cItems-1; i >= 0; i--)
01067                                         SetItemState (i, LVIS_SELECTED, LVIS_SELECTED);
01068                                 return;
01069                         }
01070                         break;
01071 
01072                 case 'U':
01073                         if (bShift)
01074                         {
01075                                 OnDldmoveup ();
01076                                 return;
01077                         }
01078                         break;
01079 
01080                 case 'D':
01081                         if (bShift)
01082                         {
01083                                 OnDldmovedown ();
01084                                 return;
01085                         }
01086                         break;
01087 
01088                 case 'T':
01089                         if (bShift)
01090                         {
01091                                 OnDldmovetop ();
01092                                 return;
01093                         }
01094                         break;
01095 
01096                 case 'B':
01097                         if (bShift)
01098                         {
01099                                 OnDldmovebottom ();
01100                                 return;
01101                         }
01102                         break;
01103 
01104                 case 'I':
01105                         if (bShift)
01106                         {
01107                                 OnDldcheckintegrity ();
01108                                 return;
01109                         }
01110                         break;
01111 
01112                 case 'M':
01113                         if (bShift)
01114                         {
01115                                 OnDldmovetofolder ();
01116                                 return;
01117                         }
01118                         break;
01119         }
01120         
01121         CListCtrl::OnKeyDown(nChar, nRepCnt, nFlags);
01122 }
01123 
01124 void CDownloads_Tasks::OnChar(UINT nChar, UINT nRepCnt, UINT nFlags) 
01125 {
01126         switch (nChar)
01127         {
01128                 case 'S':
01129                 case 'O':
01130                 case 'R':
01131                 case 'Q':
01132                 case 'U':
01133                 case 'D':
01134                 case 'I':
01135                 case 'M':
01136                 case 'T':
01137                 case 'B':
01138                         if (GetKeyState (VK_SHIFT) & 0x8000)
01139                                 return;
01140         
01141                 case '+':
01142                 case '-':
01143                         return;
01144         }
01145         
01146         CListCtrlEx::OnChar(nChar, nRepCnt, nFlags);
01147 }
01148 
01149 void CDownloads_Tasks::OnDldqsize() 
01150 {
01151         POSITION pos = GetFirstSelectedItemPosition ();
01152         while (pos)
01153         {
01154                 int iItem = GetNextSelectedItem (pos);
01155                 vmsDownloadSmartPtr dld = m_vDownloads [iItem];
01156                 if (dld->pMgr->GetDownloadMgr () != NULL)
01157                 {
01158                         if (dld->pMgr->IsRunning () == FALSE && dld->pMgr->IsDone () == FALSE && 
01159                                         dld->pMgr->GetDownloadMgr ()->IsQueringSize () == FALSE &&
01160                                         dld->pMgr->GetNumberOfSections () == 0)
01161                                 dld->pMgr->GetDownloadMgr ()->QuerySize2 ();
01162                 }
01163         }
01164 }
01165 
01166 void CDownloads_Tasks::OnDldcreatebatch() 
01167 {
01168         CCreateBatchDownload dlg;
01169         _DlgMgr.OnDoModal (&dlg);
01170         dlg.DoModal ();
01171         _DlgMgr.OnEndDialog (&dlg);
01172 }
01173 
01174 void CDownloads_Tasks::OnSortModeChanged()
01175 {
01176         Sort ();
01177 }
01178 
01179 void CDownloads_Tasks::Sort()
01180 {
01181         if (m_sortMode != LCSM_NONE)
01182         {
01183                 SortDownloads ();
01184                 m_sortMode = LCSM_NONE;
01185         }
01186 }
01187 
01188 void CDownloads_Tasks::GetFileName(vmsDownloadSmartPtr dld, LPSTR pszFileName)
01189 {
01190         if (dld->pMgr->GetBtDownloadMgr ())
01191         {
01192                 CString str = dld->pMgr->get_OutputFilePathName ();
01193                 
01194                 
01195                 if (str.IsEmpty ())
01196                 {       
01197                         *pszFileName = 0;
01198                         return;
01199                 }
01200                 if (str [str.GetLength () - 1] != '\\')
01201                 {
01202                         LPCSTR psz = strrchr (str, '\\');
01203                         if (psz)
01204                                 str     = psz + 1;
01205                 }
01206                 else
01207                 {
01208                         str = dld->pMgr->GetBtDownloadMgr ()->get_TorrentName ();
01209                 }
01210                 lstrcpy (pszFileName, str);
01211                 return;
01212         }
01213 
01214         if (dld->pMgr->GetDownloadMgr ())
01215         {
01216                 fsDownloadMgr *pMgr = dld->pMgr->GetDownloadMgr ();
01217 
01218                 CString strFile = dld->pMgr->get_OutputFilePathName ();
01219                 int fl = strFile.GetLength ();
01220 
01221                 ASSERT (fl > 0);
01222 
01223                 
01224                 if (strFile [fl-1] == '\\' || strFile [fl-1] == '/')
01225                 {
01226                         LPCSTR psz = pMgr->GetDownloader ()->Get_FileName ();
01227 
01228                         if (psz && *psz)
01229                                 strcpy (pszFileName, psz);
01230                         else
01231                         {
01232                                 
01233                                 fsFileNameFromUrlPath (pMgr->GetDNP ()->pszPathName, 
01234                                         pMgr->GetDNP ()->enProtocol == NP_FTP, TRUE, pszFileName, 10000);
01235                         }
01236                 }
01237                 else
01238                 {
01239                         
01240                         
01241                         fsGetFileName (strFile, pszFileName);
01242                         if (pMgr->GetDP ()->pszAdditionalExt && *pMgr->GetDP ()->pszAdditionalExt)
01243                         {
01244                                 char* pszAddExt = pszFileName;
01245                                 while (TRUE)
01246                                 {
01247                                         pszAddExt = strstr (pszAddExt, pMgr->GetDP ()->pszAdditionalExt);
01248                                         if (pszAddExt == NULL)
01249                                                 break;
01250 
01251                                         if (*(pszAddExt-1) == '.' && *(pszAddExt + strlen (pMgr->GetDP ()->pszAdditionalExt)) == 0)
01252                                                 break;
01253 
01254                                         pszAddExt++;
01255                                 }
01256 
01257                                 if (pszAddExt)
01258                                         *(pszAddExt-1) = 0;
01259                         }
01260                 }
01261 
01262                 if (*pszFileName == 0)  
01263                         strcpy (pszFileName, "index.html");     
01264         }
01265 }
01266 
01267 int CDownloads_Tasks::OnCreate(LPCREATESTRUCT lpCreateStruct) 
01268 {
01269         if (CListCtrlEx::OnCreate(lpCreateStruct) == -1)
01270                 return -1;
01271         
01272         m_drop.Register (this);
01273         
01274         return 0;
01275 }
01276 
01277 void CDownloads_Tasks::CallSelectedDownload()
01278 {
01279         POSITION pos = GetFirstSelectedItemPosition ();
01280         if (pos == NULL)
01281                 return;
01282 
01283         vmsDownloadSmartPtr dld = m_vDownloads [GetNextSelectedItem (pos)];
01284 
01285         if (pos == NULL && dld->pMgr->IsDone ())
01286         {
01287                 OnDldlaunch ();
01288         }
01289         else if (pos == NULL && dld->pMgr->IsRunning () && _App.DownloadDialog_Use ())
01290         {
01291                 if (dld->pdlg)
01292                 {
01293                         dld->pdlg->BringWindowToTop ();
01294                         dld->pdlg->SetFocus ();
01295                 }
01296                 else
01297                 {
01298                         dld->AddRef ();
01299                         _pwndDownloads->PostMessage (WM_DW_CREATEDLDDIALOG, 1, (LPARAM)(fsDownload*)dld);
01300                 }
01301         }
01302         else
01303         {
01304                 OnDldproperties ();
01305         }
01306 }
01307 
01308 void CDownloads_Tasks::SelectDownload(vmsDownloadSmartPtr dld)
01309 {
01310         int iItem = FindItem (dld);
01311 
01312         if (iItem == -1)
01313                 return;
01314 
01315         POSITION pos = GetFirstSelectedItemPosition ();
01316         
01317         while (pos)
01318                 SetItemState (GetNextSelectedItem (pos), 0, LVIS_SELECTED | LVIS_FOCUSED);
01319 
01320         
01321         SetItemState (iItem, LVIS_FOCUSED | LVIS_SELECTED, LVIS_FOCUSED | LVIS_SELECTED);
01322         SetSelectionMark (iItem);
01323         EnsureVisible (iItem, FALSE);
01324         UpdateActiveDownload (0);
01325 }
01326 
01327 void CDownloads_Tasks::OnDldcheckvir() 
01328 {
01329         POSITION pos = GetFirstSelectedItemPosition ();
01330         
01331         while (pos)
01332         {
01333                 vmsDownloadSmartPtr dld = m_vDownloads [GetNextSelectedItem (pos)];
01334                 if (dld->pMgr->IsDone ())
01335                         _DldsMgr.PerformVirusCheck (dld, FALSE, FALSE);
01336         }       
01337 }
01338 
01339 void CDownloads_Tasks::OnDldfind() 
01340 {
01341         AfxGetApp ()->m_pMainWnd->PostMessage (WM_COMMAND, ID_FIND);
01342 }
01343 
01344 void CDownloads_Tasks::OnDldfindnext() 
01345 {
01346         AfxGetApp ()->m_pMainWnd->PostMessage (WM_COMMAND, ID_FINDNEXT);
01347 }
01348 
01349 void CDownloads_Tasks::LockList()
01350 {
01351         m_mxAddDel.Lock ();
01352 }
01353 
01354 void CDownloads_Tasks::UnlockList()
01355 {
01356         m_mxAddDel.Unlock ();
01357 }
01358 
01359 void CDownloads_Tasks::OnGetdispinfo(NMHDR *pNMHDR, LRESULT *pResult)
01360 {
01361         LV_DISPINFO* pDispInfo = (LV_DISPINFO*)pNMHDR;
01362         LV_ITEM* pItem = &(pDispInfo)->item;
01363 
01364         try{
01365 
01366         vmsDownloadSmartPtr dld = m_vDownloads [pItem->iItem];
01367 
01368         if (pItem->mask & LVIF_IMAGE)
01369         {
01370         pItem->iImage = GetDownloadImage (dld);
01371                 UpdateDownload (dld, FALSE);
01372         }
01373 
01374         if (pItem->mask & LVIF_TEXT)
01375         {
01376                 int nSubItem = SubItemToSubItem (pItem->iSubItem);
01377                 if (nSubItem != -1)
01378                         lstrcpy (pItem->pszText, GetDownloadText (dld, nSubItem));
01379         }
01380 
01381         }catch (...) {}
01382 }
01383 
01384 CString CDownloads_Tasks::GetDownloadText(vmsDownloadSmartPtr dld, int nSubItem)
01385 {
01386         
01387         if (nSubItem == 0)
01388         {
01389                 CHAR szFile [10000];    
01390                 GetFileName (dld, szFile);
01391                 if (lstrlen (szFile) > 233)
01392                 {
01393                         szFile [233] = 0;
01394                         lstrcat (szFile, "...");
01395                 }
01396                 return szFile;
01397         }
01398 
01399         
01400         if (nSubItem == 1)
01401         {
01402                 if (dld->pMgr->IsBittorrent () == FALSE && dld->pMgr->GetNumberOfSections () == 0)
01403                         return "";
01404 
01405                 UINT64 uSize = dld->pMgr->GetLDFileSize ();
01406 
01407                 if (uSize != _UI64_MAX)
01408                         return BytesToString (uSize);
01409                 else
01410                         return "?";     
01411         }
01412 
01413         
01414         if (nSubItem == 2)
01415         {
01416                 if (dld->pMgr->IsBittorrent () == FALSE && dld->pMgr->GetNumberOfSections () == 0)
01417                         return "";
01418 
01419                 if (dld->pMgr->IsReservingDiskSpace ())
01420                 {
01421                         CString str;
01422                         if (dld->pMgr->get_ReservingDiskSpaceProgress () == -1)
01423                                 return "RD";
01424                         str.Format ("RD: %d%%", dld->pMgr->get_ReservingDiskSpaceProgress ());
01425                         return str;
01426                 }
01427 
01428                 CString str;
01429                 UINT64 uSize = dld->pMgr->GetLDFileSize ();
01430                 UINT64 uDone = dld->pMgr->GetDownloadedBytesCount ();
01431 
01432                 if (_pwndDownloads->IsSizesInBytes () == FALSE)
01433                 {
01434                         float val;
01435                         char szDim [10];
01436                         BytesToXBytes (uDone, &val, szDim);
01437                         if (uSize != _UI64_MAX)
01438                                 str.Format ("%d%% [%.*g %s]", (int)((double)(INT64)uDone / (INT64)uSize * 100), val > 999 ? 4 : 3, val, szDim);
01439                         else
01440                                 str.Format ("%.*g %s", val > 999 ? 4 : 3, val, szDim);
01441                 }
01442                 else
01443                 {
01444                         CString s = fsBytesToStr (uDone);
01445                         if (uSize != _UI64_MAX)
01446                                 str.Format ("%d%% [%s]", (int)((double)(INT64)uDone / (INT64)uSize * 100), s);
01447                         else
01448                                 str = s;
01449                 }
01450 
01451                 return str;
01452         }
01453         
01454         if (nSubItem == 3)
01455         {
01456                 if (dld->pMgr->IsRunning () == FALSE)
01457                         return "";
01458                 
01459                 UINT64 uSpeed = dld->pMgr->GetSpeed ();
01460                 if (uSpeed == 0)
01461                         return "";              
01462 
01463                 UINT64 uLeft = dld->pMgr->GetBytesLeft ();
01464                 if (uLeft == _UI64_MAX)
01465                         return "";
01466 
01467                 return fsTimeInSecondsToStr (UINT (uLeft / uSpeed));
01468         }
01469         
01470         if (nSubItem == 4)
01471         {
01472                 CString str;
01473                 str.Format ("%d/%d", dld->pMgr->GetDownloadingSectionCount (), 
01474                         dld->pMgr->GetNumberOfSections ());
01475                 return str;
01476         }
01477 
01478         
01479         if (nSubItem == 5)
01480         {
01481                 if (dld->pMgr->IsRunning () == FALSE)
01482                 {
01483                         if (dld->pMgr->IsBittorrent () && 
01484                                         dld->pMgr->GetBtDownloadMgr ()->get_State () == BTDS_SEEDING)
01485                         {
01486                                 CString str;
01487                                 str.Format ("%s/%s", BytesToString (dld->pMgr->GetBtDownloadMgr ()->GetUploadSpeed ()), LS (L_S));
01488                                 return str;
01489                         }
01490 
01491                         return "";
01492                 }
01493 
01494                 CString str;
01495                 str.Format ("%s/%s", BytesToString (dld->pMgr->GetSpeed ()), LS (L_S));
01496                 return str;
01497         }
01498         
01499         if (nSubItem == 6)
01500         {
01501                 CString str = dld->strComment;
01502                 str.Replace ("\r", " ");
01503                 str.Replace ("\n", " ");
01504                 return str;
01505         }
01506         
01507         if (nSubItem == 7)
01508         {
01509                 char szDate [100], szTime [100];
01510                 FileTimeToStr (&dld->dateAdded, szDate, szTime, TRUE);
01511                 CString str = szDate; str += ", "; str += szTime;
01512                 return str;
01513         }
01514 
01515         return "";
01516 }
01517 
01518 void CDownloads_Tasks::DeleteAllItems()
01519 {
01520         VirtualView_AllItemsWillBeDeleted ();
01521         SetItemCount (0);
01522         m_vDownloads.clear ();
01523         UpdateActiveDownload (0);
01524 }
01525 
01526 int CDownloads_Tasks::_compareDownloads(vmsDownloadSmartPtr dld1, vmsDownloadSmartPtr dld2, int nColumn)
01527 {
01528         switch (nColumn)
01529         {
01530                 case 0:
01531                         char szFile1 [10000];  char szFile2 [10000];
01532                         GetFileName (dld1, szFile1);
01533                         GetFileName (dld2, szFile2);
01534                         return lstrcmpi (szFile1, szFile2);
01535                 
01536                 case 1:
01537                         UINT64 size1;
01538                         UINT64 size2;
01539                         size1 = dld1->pMgr->GetLDFileSize ();
01540                         size2 = dld2->pMgr->GetLDFileSize ();
01541                         
01542                         if (size1 == _UI64_MAX)
01543                                 return size2 == _UI64_MAX ? 0 : 1;
01544 
01545                         if (size2 == _UI64_MAX)
01546                                 return size1 == _UI64_MAX ? 0 : -1;
01547 
01548                         if (size1 == size2)
01549                                 return 0;
01550 
01551                         return size1 > size2 ? -1 : 1;
01552 
01553                 case 2:
01554                         UINT64 done1;
01555                         UINT64 done2;
01556                         done1 = dld1->pMgr->GetDownloadedBytesCount ();
01557                         done2 = dld2->pMgr->GetDownloadedBytesCount ();
01558 
01559                         if (done1 == done2)
01560                                 return 0;
01561 
01562                         return done1 > done2 ? -1 : 1;
01563 
01564                 case 3:
01565                 {
01566                         UINT64 size1;
01567                         UINT64 size2;
01568                         size1 = dld1->pMgr->GetLDFileSize ();
01569                         size2 = dld2->pMgr->GetLDFileSize ();
01570 
01571                         UINT speed1, speed2;
01572                         speed1 = dld1->pMgr->GetSpeed ();
01573                         speed2 = dld2->pMgr->GetSpeed ();
01574 
01575                         if (speed1 == 0 || size1 == _UI64_MAX)
01576                                 return speed2 == 0 || size2 == _UI64_MAX ? 0 : 1;
01577 
01578                         if (speed2 == 0 || size2 == _UI64_MAX)
01579                                 return speed1 == 0 || size1 == _UI64_MAX ? 0 : -1;
01580 
01581                         UINT64 pr1, pr2;
01582                         pr1 = dld1->pMgr->GetBytesLeft () / speed1;
01583                         pr2 = dld2->pMgr->GetBytesLeft () / speed2;
01584 
01585                         if (pr1 == pr2)
01586                                 return 0;
01587 
01588                         return pr1 < pr2 ? 1 : -1;
01589                 }
01590 
01591                 case 4:
01592                         UINT sects1, sects2;
01593 
01594                         sects1 = dld1->pMgr->GetNumberOfSections ();
01595                         sects2 = dld2->pMgr->GetNumberOfSections ();
01596 
01597                         if (sects1 == sects2)
01598                         {
01599                                 sects1 = dld1->pMgr->GetDownloadingSectionCount ();
01600                                 sects2 = dld2->pMgr->GetDownloadingSectionCount ();
01601 
01602                                 if (sects1 == sects2)
01603                                         return 0;
01604 
01605                                 return sects1 > sects2 ? -1 : 1;
01606                         }
01607 
01608                         return sects1 > sects2 ? -1 : 1;
01609 
01610                 case 5:
01611                         UINT speed1, speed2;
01612 
01613                         speed1 = dld1->pMgr->GetSpeed ();
01614                         speed2 = dld2->pMgr->GetSpeed ();
01615 
01616                         if (speed1 == speed2)
01617                                 return 0;
01618 
01619                         return speed1 > speed2 ? -1 : 1;
01620 
01621                 case 6:
01622                         return lstrcmpi (dld1->strComment, dld2->strComment);
01623 
01624                 case 7:
01625                         return CompareFileTime (&dld1->dateAdded, &dld2->dateAdded);
01626         }
01627 
01628         return 0;
01629 }
01630 
01631 void CDownloads_Tasks::SortDownloads()
01632 {
01633         int N = m_vDownloads.size ();
01634 
01635         if (N < 2)
01636                 return;
01637 
01638         vmsDownloadSmartPtr *pDlds = new vmsDownloadSmartPtr [N];
01639 
01640         for (int i = 0; i < N; i++)
01641                 pDlds [i] = m_vDownloads [i];
01642 
01643         _downloadsQuickSort (pDlds, N - 1, m_iSortCol);
01644 
01645         DLDS_LIST vOld = m_vDownloads;
01646 
01647         m_vDownloads.clear ();
01648 
01649         for (i = 0; i < N; i++)
01650                 m_vDownloads.push_back (pDlds [i]);
01651 
01652         delete [] pDlds;
01653 
01654         _DldsMgr.ReorderDownloads (vOld, m_vDownloads, true);
01655 
01656         RedrawItems (0, GetItemCount ()-1);
01657 }
01658 
01659 void CDownloads_Tasks::_downloadsQuickSort(vmsDownloadSmartPtr *a, int N, int nCol)
01660 {
01661         int i = 0, j = N;
01662         vmsDownloadSmartPtr t, p;
01663 
01664         int Nh = N >> 1;
01665         p = a [Nh];
01666 
01667         do {
01668                 while (i != Nh && _compareDownloads (a [i], p, nCol) < 0) 
01669                         i++;
01670 
01671                 while (j != Nh && _compareDownloads (a [j], p, nCol) > 0)
01672                         j--;
01673 
01674                 if (i <= j)
01675                 {
01676                         t = a [i]; a [i] = a [j]; a [j] = t;
01677                         i++; j--;
01678                 }
01679         }
01680         while (i <= j);
01681 
01682         if (j > 0)
01683                 _downloadsQuickSort (a, j, nCol);
01684         if (N > i)
01685                 _downloadsQuickSort (a + i, N - i, nCol);
01686 }
01687 
01688 vmsDownloadSmartPtr CDownloads_Tasks::GetItemData(int nItem)
01689 {
01690         return m_vDownloads [nItem];
01691 }
01692 
01693 void CDownloads_Tasks::OnItemChanged(NM_LISTVIEW *pLV)
01694 {
01695         if (pLV->uNewState != pLV->uOldState) 
01696                 UpdateActiveDownload (0);
01697 }
01698 
01699 void CDownloads_Tasks::OnDldunpack() 
01700 {
01701         POSITION pos = GetFirstSelectedItemPosition ();
01702         if (pos == NULL)
01703                 return;
01704 
01705         vmsDownloadSmartPtr dld = m_vDownloads [GetNextSelectedItem (pos)];
01706 
01707         if (dld->pMgr->IsDone () == FALSE)
01708                 return;
01709 
01710         if (dld->pMgr->GetBtDownloadMgr () != NULL &&
01711                         dld->pMgr->GetBtDownloadMgr ()->get_FileCount () > 1)
01712                 return;
01713         
01714         CString strArchive = dld->pMgr->get_OutputFilePathName ();
01715 
01716         if (GetFileAttributes (strArchive) == DWORD (-1))
01717                 return;
01718 
01719         CDlg_UnpackSettings dlgS;
01720 
01721         dlgS.m_strDstFolder = strArchive;
01722         dlgS.m_strDstFolder.Replace ('/', '\\');
01723 
01724         LPCSTR pszE = strrchr (dlgS.m_strDstFolder, '\\');
01725         if (pszE)
01726                 dlgS.m_strDstFolder.Insert (pszE - dlgS.m_strDstFolder + 1, "_extracted\\");
01727         dlgS.m_strDstFolder += ".extracted\\";
01728 
01729         if (IDCANCEL == _DlgMgr.DoModal (&dlgS))
01730                 return;
01731 
01732         CDlg_UnpackProgress dlgP;
01733 
01734         dlgP.m_strArchive = strArchive;
01735         dlgP.m_strDstFolder = dlgS.m_strDstFolder;
01736 
01737         _DlgMgr.DoModal (&dlgP);
01738 }
01739 
01740 void CDownloads_Tasks::OnDldmovedown() 
01741 {
01742         MoveSelectedDownloads (MT_DOWN);
01743         ScheduleProcessDownloads ();
01744 }
01745 
01746 void CDownloads_Tasks::OnDldmoveup() 
01747 {
01748         MoveSelectedDownloads (MT_UP);
01749         ScheduleProcessDownloads ();
01750 }
01751 
01752 void CDownloads_Tasks::MoveSelectedDownloads(vmsMoveType enMT)
01753 {
01754         if (m_sortMode != LCSM_NONE)
01755                 return;
01756 
01757         DLDS_LIST vDlds;
01758         fs::list <int> vIndxs;
01759         
01760         int nIndxDldPos = -1;
01761         POSITION pos = GetFirstSelectedItemPosition ();
01762         while (pos)
01763         {
01764                 int nItem = GetNextSelectedItem (pos);
01765 
01766                 vmsDownloadSmartPtr dld = GetItemData (nItem);
01767                 if (enMT == MT_UP && nItem == 0)
01768                         nIndxDldPos = 0;
01769                 else if (enMT == MT_DOWN && nItem == GetItemCount () - 1)
01770                         nIndxDldPos = nItem;
01771                 else {
01772                         vDlds.push_back (dld);
01773                         vIndxs.add (nItem);
01774                 }
01775                 
01776                 if (nIndxDldPos == -1)
01777                 {
01778                         if (enMT == MT_TOP)
01779                                 nIndxDldPos = 0;
01780                         else if (enMT == MT_BOTTOM)
01781                                 nIndxDldPos = GetItemCount () - 1;
01782                         else if (enMT == MT_UP)
01783                                 nIndxDldPos = nItem - 1;        
01784                         else if (enMT == MT_DOWN && pos == NULL)
01785                                 nIndxDldPos = nItem + 1;        
01786                 }
01787         }
01788 
01789         if (vDlds.size () == 0)
01790                 return;
01791 
01792         vmsDownloadSmartPtr dld;
01793         if (enMT == MT_TOP)
01794                 dld = _DldsMgr.GetDownload (0);
01795         else if (enMT == MT_BOTTOM)
01796                 dld = _DldsMgr.GetDownload (_DldsMgr.GetCount () - 1);
01797         else
01798                 dld = GetItemData (nIndxDldPos);
01799 
01800         _DldsMgr.MoveDownloads (vDlds, dld, enMT == MT_UP || enMT == MT_TOP);
01801 
01802         
01803 
01804         for (int i = vIndxs.size () - 1; i >= 0; i--)
01805                 m_vDownloads.erase (m_vDownloads.begin () + vIndxs [i]);
01806         if (enMT == MT_DOWN || enMT == MT_BOTTOM)
01807                 nIndxDldPos -= vDlds.size () - 1;
01808 
01809         for (i = 0; i < (int)vDlds.size (); i++)
01810                 m_vDownloads.insert (m_vDownloads.begin () + nIndxDldPos + i, vDlds [i]);
01811 
01812         
01813         RedrawItems (0, GetItemCount () - 1);
01814 
01815         pos = GetFirstSelectedItemPosition ();
01816         
01817         while (pos)
01818                 SetItemState (GetNextSelectedItem (pos), 0, LVIS_SELECTED | LVIS_FOCUSED);
01819         EnsureVisible (enMT == MT_UP || enMT == MT_TOP ? nIndxDldPos : nIndxDldPos+vDlds.size ()-1, FALSE);
01820         for (i = 0; i < (int)vDlds.size (); i++)        
01821                 SetItemState (nIndxDldPos+i, LVIS_FOCUSED | LVIS_SELECTED, LVIS_FOCUSED | LVIS_SELECTED);
01822 }
01823 
01824 void CDownloads_Tasks::OnDldcheckintegrity() 
01825 {
01826         POSITION pos = GetFirstSelectedItemPosition ();
01827         if (pos == NULL)
01828                 return;
01829 
01830         vmsDownloadSmartPtr dld = m_vDownloads [GetNextSelectedItem (pos)];
01831 
01832         if (dld->pMgr->IsDone () == FALSE)
01833                 return;
01834 
01835         ASSERT (dld->pMgr->GetDownloadMgr () != NULL);
01836         if (dld->pMgr->GetDownloadMgr () == NULL)
01837                 return;
01838 
01839         LPCSTR pszFile = dld->pMgr->GetDownloadMgr ()->GetDP ()->pszFileName;
01840 
01841         if (GetFileAttributes (pszFile) == DWORD (-1))
01842                 return;
01843 
01844         CDlg_CheckFileIntegrity dlg;
01845         if (*dld->pMgr->GetDownloadMgr ()->GetDP ()->pszCheckSum)
01846         {
01847                 dlg.m_strChecksum = dld->pMgr->GetDownloadMgr ()->GetDP ()->pszCheckSum;
01848                 dlg.m_nAlgorithm = LOWORD (dld->pMgr->GetDownloadMgr ()->GetDP ()->dwIntegrityCheckAlgorithm);
01849                 dlg.m_nSHA2Strength = HIWORD (dld->pMgr->GetDownloadMgr ()->GetDP ()->dwIntegrityCheckAlgorithm);
01850         }
01851         if (IDCANCEL == _DlgMgr.DoModal (&dlg))
01852                 return;
01853 
01854         SAFE_DELETE_ARRAY (dld->pMgr->GetDownloadMgr ()->GetDP ()->pszCheckSum);
01855         dld->pMgr->GetDownloadMgr ()->GetDP ()->pszCheckSum = new char [dlg.m_strChecksum.GetLength () + 1];
01856         lstrcpy (dld->pMgr->GetDownloadMgr ()->GetDP ()->pszCheckSum, dlg.m_strChecksum);
01857         dld->pMgr->GetDownloadMgr ()->GetDP ()->dwIntegrityCheckAlgorithm = MAKELONG (dlg.m_nAlgorithm, dlg.m_nSHA2Strength);
01858 
01859         CDlg_CheckFileIntegrity_Progress dlg2;
01860         dlg2.m_enHashAlgorithm = (vmsHashAlgorithm) dlg.m_nAlgorithm;
01861         dlg2.m_enSHA2Strength = (vmsHash_SHA2Strength) dlg.m_nSHA2Strength;
01862         dlg2.m_strFile = pszFile;
01863         dlg2.m_strValidHashResult = dlg.m_strChecksum;
01864         if (IDCANCEL == _DlgMgr.DoModal (&dlg2))
01865                 return;
01866 
01867         if (dlg2.is_CheckingSucceeded () == false || 
01868                         _App.View_DontShowHashCheckResultIfOK () == FALSE)
01869         {
01870                 CDlg_CheckFileIntegrity_Result dlg3;
01871                 dlg3.m_bResultOK = dlg2.is_CheckingSucceeded ();
01872                 char sz [MY_MAX_PATH];
01873                 fsGetFileName (dld->pMgr->GetDownloadMgr ()->GetDP ()->pszFileName, sz);
01874                 dlg3.m_strFileName = sz;
01875                 dlg3.m_strUrl = dld->pMgr->GetDownloadMgr ()->GetDownloader ()->get_URL ();
01876                 dlg3.m_strValidHash = dlg.m_strChecksum;
01877                 dlg3.m_strResultHash = dlg2.m_strHashResult;
01878                 if (IDC_RESTARTDOWNLOAD == _DlgMgr.DoModal (&dlg3))
01879                         _pwndDownloads->RestartDownload (dld, TRUE);
01880         }
01881 }  
01882 
01883 void CDownloads_Tasks::OnDldmovetofolder() 
01884 {
01885         DLDS_LIST vDlds;
01886         POSITION pos = GetFirstSelectedItemPosition ();
01887         while (pos)
01888         {
01889                 int iItem = GetNextSelectedItem (pos);
01890                 vmsDownloadSmartPtr dld = m_vDownloads [iItem];
01891                 vDlds.push_back (dld);
01892         }
01893 
01894         if (vDlds.size () == 0)
01895                 return;
01896 
01897         CFolderBrowser *fb = CFolderBrowser::Create (LS (L_CHOOSEOUTFOLDER), 
01898                 _App.View_LastDldMoveToFolder (), NULL, this);
01899         if (fb == NULL)
01900                 return;
01901 
01902         _App.View_LastDldMoveToFolder (fb->GetPath ());
01903 
01904         for (size_t i = 0; i < vDlds.size (); i++)
01905                 vDlds [i]->pMgr->MoveToFolder (fb->GetPath ());
01906 }
01907 
01908 void CDownloads_Tasks::OnDldmovebottom() 
01909 {
01910         MoveSelectedDownloads (MT_BOTTOM);
01911         ScheduleProcessDownloads ();
01912 }
01913 
01914 void CDownloads_Tasks::OnDldmovetop() 
01915 {
01916         MoveSelectedDownloads (MT_TOP); 
01917         ScheduleProcessDownloads ();
01918 }
01919 
01920 void CDownloads_Tasks::OnDldschedulestop() 
01921 {
01922         ScheduleSelectedDlds (FALSE);
01923 }
01924 
01925 void CDownloads_Tasks::ScheduleSelectedDlds(BOOL bStart)
01926 {
01927         POSITION pos = GetFirstSelectedItemPosition ();
01928         DLDS_LIST vDlds;
01929         fsScheduleMgr *mgr = _pwndScheduler->GetMgr ();
01930 
01931         
01932         while (pos)
01933         {
01934                 int iItem = GetNextSelectedItem (pos);
01935                 vmsDownloadSmartPtr dld = m_vDownloads [iItem];
01936                 if (dld->pMgr->IsDone () == FALSE)
01937                         vDlds.push_back (dld);
01938         }
01939 
01940         if (vDlds.size () == 0)
01941                 return;
01942 
01943         fsSchedule task;
01944         
01945         fsSchedule* pTask = mgr->GetScheduleDLTask (vDlds, bStart);
01946         BOOL bCreate = pTask == NULL;   
01947 
01948         if (pTask == NULL)      
01949         {
01950                 
01951                 
01952                 task.hts.enType = HTS_ONCE;
01953                 task.hts.last.dwHighDateTime = task.hts.last.dwLowDateTime = UINT_MAX;
01954                 task.dwFlags = SCHEDULE_ENABLED;
01955                 SYSTEMTIME time;
01956                 GetLocalTime (&time);
01957                 if (++time.wHour > 23)
01958                         time.wHour = 0;
01959                 time.wMinute = 0;
01960                 SystemTimeToFileTime (&time, &task.hts.next);
01961                 task.uWaitForConfirmation = 0;
01962                 pTask = &task;
01963         }
01964 
01965         CScheduleSheet sheet (LS (bStart ? L_SCHEDULE_DLDSTART : L_SCHEDULE_DLDSTOP), this);
01966         sheet.Init (pTask, FALSE);
01967         _DlgMgr.OnDoModal (&sheet);     
01968         UINT uIDRet = sheet.DoModal ();
01969         _DlgMgr.OnEndDialog (&sheet);
01970 
01971         if (uIDRet == IDOK)
01972         {
01973                 if (bCreate)    
01974                 {
01975                          
01976                         pTask->wts.enType = bStart ? WTS_STARTDOWNLOAD : WTS_STOPDOWNLOAD;
01977                         fsnew1 (pTask->wts.pvIDs, fs::list <UINT>);
01978                         for (size_t i = 0; i < vDlds.size (); i++)
01979                                 pTask->wts.pvIDs->add (vDlds [i]->nID);
01980 
01981                         _pwndScheduler->AddTask (pTask);
01982                 }
01983                 else
01984                 {
01985                         
01986                         if (sheet.IsNeedRecalculateStartTime ())
01987                                 mgr->CalculateStartTime (pTask);
01988                         _pwndScheduler->GetMgr ()->OnTaskUpdated (pTask);
01989                 }
01990 
01991         }
01992          
01993     SetFocus ();
01994 }
01995 
01996 void CDownloads_Tasks::BeginAddDownloads()
01997 {
01998         LockList ();
01999         m_bAddingDownloads = true;
02000 }
02001 
02002 void CDownloads_Tasks::EndAddDownloads()
02003 {
02004         m_bAddingDownloads = false;
02005         UnlockList ();
02006         SetItemCountEx (m_vDownloads.size (), LVSICF_NOINVALIDATEALL);
02007 }
02008 
02009 void CDownloads_Tasks::UpdateDownload(size_t nIndex, BOOL bRedraw)
02010 {
02011         COLORREF clr;
02012 
02013         if (m_vDownloads [nIndex]->pMgr->GetBtDownloadMgr ())
02014         {
02015                 clr = RGB (0, 100, 0); 
02016         }
02017         else if (m_vDownloads [nIndex]->pMgr->GetDownloadMgr () && 
02018                 m_vDownloads [nIndex]->pMgr->GetDownloadMgr ()->GetDownloader ()->is_WasAccessedAtLeastOnce ())
02019         {
02020                 switch (m_vDownloads [nIndex]->pMgr->IsResumeSupported ())
02021                 {
02022                 case RST_NONE:
02023                         clr = RGB (160, 0, 0);
02024                         break;
02025 
02026                 case RST_PRESENT:
02027                         clr = RGB (0, 100, 0);
02028                         break;
02029 
02030                 case RST_UNKNOWN:
02031                         clr = RGB (150, 150, 0);
02032                         break;
02033 
02034                 default:
02035                         clr = RGB (0, 0, 0);
02036                         break;
02037                 }
02038         }
02039         else
02040         {
02041                 ASSERT (m_vDownloads [nIndex]->pMgr->GetDownloadMgr () != NULL ||
02042                         m_vDownloads [nIndex]->pMgr->GetBtDownloadMgr () != NULL);
02043                 clr = RGB (0, 0, 0);
02044         }
02045 
02046         SetItemColor (nIndex, clr, FALSE);
02047 
02048         if (bRedraw)
02049                 RedrawItems (nIndex, nIndex);
02050 }  
02051 
02052 void CDownloads_Tasks::OnDldgrantbandwidthfordld() 
02053 {
02054         POSITION pos = GetFirstSelectedItemPosition ();
02055         if (pos == NULL)
02056                 return;
02057 
02058         vmsDownloadSmartPtr dld = m_vDownloads [GetNextSelectedItem (pos)];
02059         if (dld == _DldsMgr.get_HighestPriorityDownload ())
02060                 dld = NULL;
02061 
02062         _DldsMgr.set_HighestPriorityDownload (dld);
02063 }
02064 
02065 void CDownloads_Tasks::OnDldshowprogressdlg() 
02066 {
02067         POSITION pos = GetFirstSelectedItemPosition ();
02068 
02069         while (pos)
02070         {
02071                 vmsDownloadSmartPtr dld = m_vDownloads [GetNextSelectedItem (pos)];
02072 
02073                 if (dld->pMgr->IsRunning ())
02074                 {
02075                         if (dld->pdlg == NULL)
02076                         {
02077                                 dld->pdlg = new CDlg_Download;
02078                                 dld->pdlg->Create (dld);
02079                         }
02080                         dld->pdlg->ShowWindow (SW_SHOW);
02081                         dld->pdlg->BringWindowToTop ();
02082                         dld->pdlg->SetFocus ();
02083                 }
02084         }
02085 }  
02086 
02087 void CDownloads_Tasks::OnDldconvert() 
02088 {
02089         _pwndDownloads->m_wndDownloads.m_info.m_video.Convert ();       
02090 }
02091 
02092 void CDownloads_Tasks::ScheduleProcessDownloads()
02093 {
02094         KillTimer (1);
02095         SetTimer (1, 1000, NULL);
02096 }
02097 
02098 void CDownloads_Tasks::OnTimer(UINT nIDEvent) 
02099 {
02100         if (nIDEvent == 1)
02101         {
02102                 KillTimer (1);
02103                 _DldsMgr.ProcessDownloads ();
02104         }
02105         
02106         CListCtrlEx::OnTimer(nIDEvent);
02107 }
02108 
02109 void CDownloads_Tasks::OnDldenableseeding() 
02110 {
02111         POSITION pos = GetFirstSelectedItemPosition ();
02112         while (pos)
02113         {
02114                 vmsDownloadSmartPtr dld = m_vDownloads [GetNextSelectedItem (pos)];
02115                 if (dld->pMgr->IsBittorrent ())
02116                 {
02117                         dld->pMgr->GetBtDownloadMgr ()->EnableSeeding (!m_bHasEnableSeedingDlds);
02118                         UpdateDownload (dld, TRUE);
02119                 }
02120         }
02121 }
D:/opendownloadmanager/ODM-1.x/Downloads_Tasks.cpp
