wnddownloads.cpp

p2p软件

	pCmdUI->Enable( m_bSelDownload );
}

void CDownloadsWnd::OnDownloadsMoveDown() 
{
	m_wndDownloads.MoveSelected( 1 );
}

void CDownloadsWnd::OnUpdateTransfersConnect(CCmdUI* pCmdUI) 
{
	Prepare();
	pCmdUI->Enable( m_bSelIdleSource );
}

void CDownloadsWnd::OnTransfersConnect() 
{
	CSingleLock pLock( &Transfers.m_pSection, TRUE );
	
	for ( POSITION pos = Downloads.GetIterator() ; pos ; )
	{
		CDownload* pDownload = Downloads.GetNext( pos );
		
		for ( CDownloadSource* pSource = pDownload->GetFirstSource() ; pSource != NULL ; pSource = pSource->m_pNext )
		{
			if ( pSource->m_bSelected && pSource->m_pTransfer == NULL )
			{
				if ( pSource->m_nProtocol != PROTOCOL_ED2K )
				{
					pSource->m_pDownload->Resume();

					if ( pSource->m_bPushOnly )
					{
						pSource->PushRequest();
					}
					else if ( CDownloadTransfer* pTransfer = pSource->CreateTransfer() )
					{
						pTransfer->Initiate();
					}
				}
			}
		}
	}
	
	Update();
}

void CDownloadsWnd::OnUpdateTransfersDisconnect(CCmdUI* pCmdUI) 
{
	Prepare();
	pCmdUI->Enable( m_bSelActiveSource );
}

void CDownloadsWnd::OnTransfersDisconnect() 
{
	CSingleLock pLock( &Transfers.m_pSection, TRUE );
	
	for ( POSITION pos = Downloads.GetIterator() ; pos ; )
	{
		CDownload* pDownload = Downloads.GetNext( pos );
		
		for ( CDownloadSource* pSource = pDownload->GetFirstSource() ; pSource != NULL ; )
		{
			CDownloadSource* pNext = pSource->m_pNext;
			
			if ( pSource->m_bSelected && pSource->m_pTransfer != NULL )
			{
				pSource->m_pTransfer->Close( TS_TRUE );
			}
			
			pSource = pNext;
		}
	}
	
	Update();
}

void CDownloadsWnd::OnUpdateTransfersForget(CCmdUI* pCmdUI) 
{
	Prepare();
	pCmdUI->Enable( m_bSelSource );
}

void CDownloadsWnd::OnTransfersForget() 
{
	CSingleLock pLock( &Transfers.m_pSection, TRUE );
	
	for ( POSITION pos = Downloads.GetIterator() ; pos ; )
	{
		CDownload* pDownload = Downloads.GetNext( pos );
		
		for ( CDownloadSource* pSource = pDownload->GetFirstSource() ; pSource != NULL ; )
		{
			CDownloadSource* pNext = pSource->m_pNext;
			if ( pSource->m_bSelected ) pSource->Remove( TRUE, TRUE );
			pSource = pNext;
		}
	}
	
	Update();
}

void CDownloadsWnd::OnUpdateTransfersChat(CCmdUI* pCmdUI) 
{
	if ( ! Settings.Community.ChatEnable )
	{
		pCmdUI->Enable( FALSE );
		return;
	}
	
	Prepare();
	pCmdUI->Enable( m_bSelHttpSource );
}

void CDownloadsWnd::OnTransfersChat() 
{
	CSingleLock pLock( &Transfers.m_pSection, TRUE );
	
	for ( POSITION pos = Downloads.GetIterator() ; pos ; )
	{
		CDownload* pDownload = Downloads.GetNext( pos );
		
		for ( CDownloadSource* pSource = pDownload->GetFirstSource() ; pSource != NULL ; pSource = pSource->m_pNext )
		{
			if ( pSource->m_bSelected && pSource->m_nProtocol == PROTOCOL_HTTP )
			{
				ChatWindows.OpenPrivate( NULL, &pSource->m_pAddress, pSource->m_nPort,
					pSource->m_bPushOnly );
			}
		}
	}
}

void CDownloadsWnd::OnUpdateBrowseLaunch(CCmdUI* pCmdUI) 
{
	Prepare();
	pCmdUI->Enable( m_bSelHttpSource );
}

void CDownloadsWnd::OnBrowseLaunch() 
{
	CSingleLock pLock( &Transfers.m_pSection, TRUE );
	
	for ( POSITION pos = Downloads.GetIterator() ; pos ; )
	{
		CDownload* pDownload = Downloads.GetNext( pos );
		
		for ( CDownloadSource* pSource = pDownload->GetFirstSource() ; pSource != NULL ; pSource = pSource->m_pNext )
		{
			if ( pSource->m_bSelected && pSource->m_nProtocol == PROTOCOL_HTTP )
			{
				new CBrowseHostWnd( &pSource->m_pAddress, pSource->m_nPort,
					pSource->m_bPushOnly, &pSource->m_pGUID );
			}
		}
	}
}

void CDownloadsWnd::OnUpdateDownloadsShowSources(CCmdUI* pCmdUI) 
{
	pCmdUI->SetCheck( Settings.Downloads.ShowSources );
}

void CDownloadsWnd::OnDownloadsShowSources() 
{
	Settings.Downloads.ShowSources = ! Settings.Downloads.ShowSources;
	Update();
}

void CDownloadsWnd::OnUpdateDownloadsFileDelete(CCmdUI* pCmdUI) 
{
	Prepare();
	if ( CCoolBarItem* pcCmdUI = CCoolBarItem::FromCmdUI( pCmdUI ) )
		pcCmdUI->Show( m_bSelCompleted );
	pCmdUI->Enable( m_bSelCompleted );
}

void CDownloadsWnd::OnDownloadsFileDelete() 
{
	CSingleLock pLock( &Transfers.m_pSection, TRUE );
	CList<CDownload*> pList;
	
	for ( POSITION pos = Downloads.GetIterator() ; pos ; )
	{
		CDownload* pDownload = Downloads.GetNext( pos );
		if ( pDownload->m_bSelected ) pList.AddTail( pDownload );
	}
	
	while ( ! pList.IsEmpty() )
	{
		CDownload* pDownload = pList.RemoveHead();
		
		if ( Downloads.Check( pDownload ) && pDownload->IsCompleted() )
		{
			CDeleteFileDlg dlg;
			dlg.m_sName		= pDownload->m_sRemoteName;
			CString strPath	= pDownload->m_sLocalName;
			
			pLock.Unlock();
			if ( dlg.DoModal() != IDOK ) break;
			
			if ( CLibraryFile* pFile = LibraryMaps.LookupFileByPath( strPath, TRUE ) )
			{
				dlg.Apply( pFile );
				Library.Unlock();
			}
			
			pLock.Lock();
			if ( Downloads.Check( pDownload ) ) pDownload->Remove( TRUE );
		}
	}
	
	Update();
}

void CDownloadsWnd::OnUpdateDownloadsRate(CCmdUI* pCmdUI) 
{
	Prepare();
	pCmdUI->Enable( m_bSelCompleted );
}

void CDownloadsWnd::OnDownloadsRate() 
{
	CSingleLock pLock( &Transfers.m_pSection, TRUE );
	CFilePropertiesSheet dlg;
	CStringList pList;
	
	for ( POSITION pos = Downloads.GetIterator() ; pos ; )
	{
		CDownload* pDownload = Downloads.GetNext( pos );
		if ( pDownload->m_bSelected && pDownload->IsCompleted() )
			pList.AddTail( pDownload->m_sLocalName );
	}
	
	pLock.Unlock();
	
	while ( ! pList.IsEmpty() )
	{
		CString strPath = pList.RemoveHead();
		
		if ( CLibraryFile* pFile = LibraryMaps.LookupFileByPath( strPath, TRUE ) )
		{
			dlg.Add( pFile->m_nIndex );
			Library.Unlock();
		}
	}
	
	dlg.DoModal( 2 );
	Update();
}

void CDownloadsWnd::OnDownloadsClearCompleted() 
{
	CSingleLock pLock( &Transfers.m_pSection, TRUE );
	Downloads.ClearCompleted();
	Update();
}

void CDownloadsWnd::OnDownloadsClearPaused() 
{
	CString strMessage;
	LoadString( strMessage, IDS_DOWNLOAD_CONFIRM_CLEAR_PAUSED );
	
	if ( AfxMessageBox( strMessage, MB_ICONQUESTION|MB_YESNO|MB_DEFBUTTON2 ) == IDYES )
	{
		Downloads.ClearPaused();
		Update();
	}
}

void CDownloadsWnd::OnUpdateDownloadsAutoClear(CCmdUI* pCmdUI) 
{
	pCmdUI->SetCheck( Settings.Downloads.AutoClear );
}

void CDownloadsWnd::OnDownloadsAutoClear() 
{
	Settings.Downloads.AutoClear = ! Settings.Downloads.AutoClear;
	if ( Settings.Downloads.AutoClear ) OnTimer( 4 );
}

void CDownloadsWnd::OnDownloadsFilterMenu() 
{
	CMenu* pMenu = Skin.GetMenu( _T("CDownloadsWnd.Filter") );
	m_wndToolBar.ThrowMenu( ID_DOWNLOADS_FILTER_MENU, pMenu, NULL, FALSE, TRUE );
}

void CDownloadsWnd::OnUpdateDownloadsFilterAll(CCmdUI* pCmdUI) 
{
	pCmdUI->SetCheck( ( Settings.Downloads.FilterMask & DLF_ALL ) == DLF_ALL );
}

void CDownloadsWnd::OnDownloadsFilterAll() 
{
	Settings.Downloads.FilterMask |= DLF_ALL;
	Update();
}

void CDownloadsWnd::OnUpdateDownloadsFilterActive(CCmdUI* pCmdUI) 
{
	pCmdUI->SetCheck( ( Settings.Downloads.FilterMask & DLF_ACTIVE ) > 0 );
}

void CDownloadsWnd::OnDownloadsFilterActive() 
{
	Settings.Downloads.FilterMask ^= DLF_ACTIVE;
	Update();
}

void CDownloadsWnd::OnUpdateDownloadsFilterQueued(CCmdUI* pCmdUI) 
{
	pCmdUI->SetCheck( ( Settings.Downloads.FilterMask & DLF_QUEUED ) > 0 );
}

void CDownloadsWnd::OnDownloadsFilterQueued() 
{
	Settings.Downloads.FilterMask ^= DLF_QUEUED;
	Update();
}

void CDownloadsWnd::OnUpdateDownloadsFilterSources(CCmdUI* pCmdUI) 
{
	pCmdUI->SetCheck( ( Settings.Downloads.FilterMask & DLF_SOURCES ) > 0 );
}

void CDownloadsWnd::OnDownloadsFilterSources() 
{
	Settings.Downloads.FilterMask ^= DLF_SOURCES;
	Update();
}

void CDownloadsWnd::OnUpdateDownloadsFilterPaused(CCmdUI* pCmdUI) 
{
	pCmdUI->SetCheck( ( Settings.Downloads.FilterMask & DLF_PAUSED ) > 0 );
}

void CDownloadsWnd::OnDownloadsFilterPaused() 
{
	Settings.Downloads.FilterMask ^= DLF_PAUSED;
	Update();
}

void CDownloadsWnd::OnDownloadsSettings() 
{
	CSettingsManagerDlg::Run( _T("CDownloadsSettingsPage") );
}

void CDownloadsWnd::OnUpdateDownloadGroupShow(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable( Settings.General.GUIMode != GUI_BASIC );
	pCmdUI->SetCheck( Settings.General.GUIMode != GUI_BASIC && Settings.Downloads.ShowGroups );
}

void CDownloadsWnd::OnDownloadGroupShow() 
{
	Settings.Downloads.ShowGroups = ! Settings.Downloads.ShowGroups;
	
	CRect rc;
	GetClientRect( &rc );
	OnSize( SIZE_RESTORED, rc.right, rc.bottom );
	
	Update();
}

void CDownloadsWnd::OnDownloadsHelp() 
{
	CSingleLock pLock( &Transfers.m_pSection, TRUE );
	CDownload* pDownload = NULL;
	
	for ( POSITION pos = Downloads.GetIterator() ; pos ; )
	{
		pDownload = Downloads.GetNext( pos );
		if ( pDownload->m_bSelected ) break;
		pDownload = NULL;
	}
	
	if ( pDownload == NULL )
	{
		CHelpDlg::Show( _T("DownloadHelp.Select") );
	}
	else if ( pDownload->IsMoving() )
	{
		if ( pDownload->IsCompleted() )
			CHelpDlg::Show( _T("DownloadHelp.Completed") );
		else
			CHelpDlg::Show( _T("DownloadHelp.Moving") );
	}
	else if ( pDownload->IsPaused() )
	{
		if ( pDownload->m_bDiskFull )
			CHelpDlg::Show( _T("DownloadHelp.DiskFull") );
		else
			CHelpDlg::Show( _T("DownloadHelp.Paused") );
	}
	else if ( pDownload->GetProgress() == 1.0f && pDownload->IsStarted() )
	{
		CHelpDlg::Show( _T("DownloadHelp.Verifying") );
	}
	else if ( pDownload->IsDownloading() )
	{
		CHelpDlg::Show( _T("DownloadHelp.Downloading") );
	}
	else if ( pDownload->GetSourceCount() > 0 )
	{
		CHelpDlg::Show( _T("DownloadHelp.Pending") );
	}
	else if ( pDownload->m_nSize == SIZE_UNKNOWN )
	{
		CHelpDlg::Show( _T("DownloadHelp.Searching") );
	}
	else if ( pDownload->m_bBTH && pDownload->IsTasking() )
	{
		CHelpDlg::Show( _T("DownloadHelp.Creating") );
	}
	else if ( pDownload->m_bTorrentTrackerError )
	{
		CHelpDlg::Show( _T("DownloadHelp.Tracker") );
	}
	else
	{
		CHelpDlg::Show( _T("DownloadHelp.Searching") );
	}
}

/////////////////////////////////////////////////////////////////////////////
// CDownloadsWnd drag and drop

void CDownloadsWnd::DragDownloads(CPtrList* pList, CImageList* pImage, const CPoint& ptScreen)
{
	ASSERT( m_pDragList == NULL );
	
	m_pDragList		= pList;
	m_pDragImage	= pImage;
	
	CRect rcClient;
	GetClientRect( &rcClient );
	ClientToScreen( &rcClient );
	
	ClipCursor( &rcClient );
	SetCapture();
	SetFocus();
	UpdateWindow();
	
	OnSetCursor( NULL, 0, 0 );
	
	CPoint ptStart( ptScreen );
	ScreenToClient( &ptStart );
	
	CRect rcList;
	m_wndDownloads.GetWindowRect( &rcList );
	ScreenToClient( &rcList );
	m_pDragOffs = rcList.TopLeft();
	m_pDragOffs.y -= 4;
	
	m_pDragImage->DragEnter( this, ptStart + m_pDragOffs );
}

void CDownloadsWnd::CancelDrag()
{
	if ( m_pDragList == NULL ) return;
	
	ClipCursor( NULL );
	ReleaseCapture();
	
	m_pDragImage->DragLeave( this );
	m_pDragImage->EndDrag();
	delete m_pDragImage;
	m_pDragImage = NULL;
	
	delete m_pDragList;
	m_pDragList = NULL;
	
	CPoint point( 0, 0 );
	m_wndTabBar.DropObjects( NULL, point );
	m_wndDownloads.DropObjects( NULL, point );
}

void CDownloadsWnd::OnMouseMove(UINT nFlags, CPoint point) 
{
	if ( m_pDragList != NULL )
	{
		m_pDragImage->DragMove( point + m_pDragOffs );
		ClientToScreen( &point );
		m_wndTabBar.DropShowTarget( m_pDragList, point );
		m_wndDownloads.DropShowTarget( m_pDragList, point );
	}
	
	CPanelWnd::OnMouseMove( nFlags, point );
}

void CDownloadsWnd::OnLButtonUp(UINT nFlags, CPoint point) 
{
	if ( m_pDragList != NULL )
	{
		ClipCursor( NULL );
		ReleaseCapture();
		
		m_pDragImage->DragLeave( this );
		m_pDragImage->EndDrag();
		delete m_pDragImage;
		m_pDragImage = NULL;
		
		ClientToScreen( &point );
		m_wndTabBar.DropObjects( m_pDragList, point );
		m_wndDownloads.DropObjects( m_pDragList, point );
		
		delete m_pDragList;
		m_pDragList = NULL;
		
		Update();
	}
	
	CPanelWnd::OnLButtonUp( nFlags, point );
}

void CDownloadsWnd::OnRButtonDown(UINT nFlags, CPoint point) 
{
	if ( m_pDragList != NULL )
	{
		CancelDrag();
		return;
	}
	
	CPanelWnd::OnRButtonDown( nFlags, point );
}

void CDownloadsWnd::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) 
{
	if ( nChar == VK_ESCAPE ) CancelDrag();
	if ( m_pDragList != NULL ) OnSetCursor( NULL, 0, 0 );
	CPanelWnd::OnKeyDown( nChar, nRepCnt, nFlags );
}

void CDownloadsWnd::OnKeyUp(UINT nChar, UINT nRepCnt, UINT nFlags) 
{
	if ( m_pDragList ) OnSetCursor( NULL, 0, 0 );
	CPanelWnd::OnKeyUp( nChar, nRepCnt, nFlags );
}

BOOL CDownloadsWnd::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message) 
{
	if ( m_pDragList != NULL )
	{
		if ( GetAsyncKeyState( VK_CONTROL ) & 0x8000 )
			SetCursor( m_hCursCopy );
		else
			SetCursor( m_hCursMove );
		
		return TRUE;
	}
	
	return CPanelWnd::OnSetCursor( pWnd, nHitTest, message );
}