queuectrl.cpp

一个FTP下载的源代码。代码质量非常高

// FileZilla - a Windows ftp client

// Copyright (C) 2002 - Tim Kosse <[e-mail]>

// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

// QueueCtrl.cpp: Implementierungsdatei
//

#include "stdafx.h"
#include "filezilla.h"
#include "QueueCtrl.h"
#include "queueview.h"
#include "mainfrm.h"
#include "ftplistctrl.h"
#include "commandqueue.h"
#include "FileExistsDlg.h"
#include "StatusView.h"
#include "FtpTreeView.h"
#include "LocalView2.h"
#include "misc\MarkupSTL.h"
#include "AsyncRequestQueue.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

CQueueData::CQueueData()
{
	bActive = FALSE;
	nOpen = 0;
	nState = 0;
	priority = 0;
	pTransferStatus = NULL;
	retrycount = 0;
	pTransferApi = NULL;
	bStop = FALSE;
	nAutoUsePrimary = 0;
	bTransferStarted = FALSE;
	bPaused = FALSE;
	bAbort = FALSE;
	nProgressOffset = 260;
	nListItemState = 0;
	pProgressControl = NULL;
}

CQueueData::~CQueueData()
{
}

/////////////////////////////////////////////////////////////////////////////
// CQueueCtrl

CQueueCtrl::CQueueCtrl()
{
	m_nProcessQueue = 0;
	m_bMayUsePrimaryConnection = FALSE;
	m_nActiveCount = 0;
	m_nMaxApiCount = COptions::GetOptionVal(OPTION_TRANSFERAPICOUNT);
	m_bPrimaryConnectionTransferInProgress = FALSE;
	m_bUseMultiple = COptions::GetOptionVal(OPTION_TRANSFERUSEMULTIPLE);
	m_bQuit = FALSE;
	m_nQuitCount = 0;
}

CQueueCtrl::~CQueueCtrl()
{
	if (!m_bQuit)
	{
		for (UINT i=0; i<m_TransferApiArray.size(); i++)
		{
			m_TransferApiArray[i].pTransferApi->Destroy();
			delete m_TransferApiArray[i].pTransferApi;
			delete m_TransferApiArray[i].pLastActiveTime;
		}
	}
	m_TransferApiArray.clear();

	for (t_QueueVector::iterator iter = m_QueueItems.begin(); iter != m_QueueItems.end(); iter++)
	{
		delete iter->pTransferStatus;
		delete iter->pProgressControl;
	}
}

BEGIN_MESSAGE_MAP(CQueueCtrl, CListCtrl)
	//{{AFX_MSG_MAP(CQueueCtrl)
	ON_WM_CREATE()
	ON_NOTIFY_REFLECT(LVN_GETDISPINFO, OnGetdispinfo)
	ON_WM_DESTROY()
	ON_WM_CONTEXTMENU()
	ON_COMMAND(ID_QUEUECONTEXT_MOVEDOWN, OnQueuecontextMovedown)
	ON_COMMAND(ID_QUEUECONTEXT_MOVETOBOTTOM, OnQueuecontextMovetobottom)
	ON_COMMAND(ID_QUEUECONTEXT_MOVETOTOP, OnQueuecontextMovetotop)
	ON_COMMAND(ID_QUEUECONTEXT_MOVEUP, OnQueuecontextMoveup)
	ON_COMMAND(ID_QUEUECONTEXT_PROCESSQUEUE, OnQueuecontextProcessqueue)
	ON_COMMAND(ID_QUEUECONTEXT_REMOVEFROMQUEUE, OnQueuecontextRemovefromqueue)
	ON_COMMAND(ID_QUEUECONTEXT_RESETSTATUS, OnQueuecontextResetstatus)
	ON_WM_KEYDOWN()
	ON_WM_DROPFILES()
	ON_WM_TIMER()
	ON_WM_PAINT()
	ON_WM_ERASEBKGND()
	ON_COMMAND(ID_QUEUECONTEXT_ABORT, OnQueuecontextAbort)
	ON_COMMAND(ID_QUEUECONTEXT_PAUSE, OnQueuecontextPause)
	ON_COMMAND(ID_QUEUECONTEXT_RESUME, OnQueuecontextResume)
	ON_NOTIFY_REFLECT(LVN_ITEMCHANGED, OnItemchanged)
	ON_WM_CHAR()
	ON_NOTIFY_REFLECT(LVN_ODSTATECHANGED, OnOdstatechanged)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// Behandlungsroutinen f黵 Nachrichten CQueueCtrl 

int CQueueCtrl::OnCreate(LPCREATESTRUCT lpCreateStruct) 
{
	if (CListCtrl::OnCreate(lpCreateStruct) == -1)
		return -1;

	SetCallbackMask(LVIS_SELECTED);
	
	CString str;
	str.LoadString(IDS_HEADER_LOCALNAME);
	InsertColumn(0, str, LVCFMT_LEFT, 200);
	str.LoadString(IDS_HEADER_SIZE);
	InsertColumn(1, str, LVCFMT_RIGHT, 70);
	str.LoadString(IDS_HEADER_DIRECTION);
	InsertColumn(2, str, LVCFMT_CENTER, 65);
	str.LoadString(IDS_HEADER_REMOTENAME);
	InsertColumn(3, str, LVCFMT_LEFT, 200);
	str.LoadString(IDS_HEADER_HOST);
	InsertColumn(4, str, LVCFMT_LEFT, 100);
	str.LoadString(IDS_HEADER_STATUS);
	InsertColumn(5, str, LVCFMT_LEFT, 200);

	CMutex mutex(FALSE, _T("FileZilla Queue Mutex"), 0);
	CSingleLock mLock(&mutex, TRUE);
	
	CMarkupSTL *pMarkup;
	//First try to read queue items from filezilla.xml
	if (COptions::LockXML(&pMarkup))
	{
		pMarkup->ResetPos();
		if (pMarkup->FindChildElem( _T("TransferQueue") ))
		{
			pMarkup->IntoElem();
			while (pMarkup->FindChildElem( _T("QueueItem") ))
			{
				pMarkup->IntoElem();
				t_transferfile transferfile;

				if (!pMarkup->FindChildElem( _T("File") ))
				{
					pMarkup->OutOfElem();
					continue;
				}

				transferfile.localfile = pMarkup->GetChildAttrib( _T("Localfile") );
				transferfile.remotefile = pMarkup->GetChildAttrib( _T("Remotefile") );
				transferfile.remotepath.SetSafePath(pMarkup->GetChildAttrib( _T("Remotepath") ));
				transferfile.size = _ttoi64(pMarkup->GetChildAttrib( _T("Size") ));

				if (!pMarkup->FindChildElem( _T("Data") ))
				{
					pMarkup->OutOfElem();
					continue;
				}

				CQueueData queueData;

				queueData.retrycount=_ttoi(pMarkup->GetChildAttrib( _T("RetryCount") ));
				transferfile.nType=_ttoi(pMarkup->GetChildAttrib( _T("Transfermode") ));
				transferfile.get=_ttoi(pMarkup->GetChildAttrib( _T("Get") ));
				queueData.nOpen=_ttoi(pMarkup->GetChildAttrib( _T("Open") ));

				if (!COptions::LoadServer(pMarkup, transferfile.server))
				{
					pMarkup->OutOfElem();
					continue;
				}

				pMarkup->OutOfElem();

				queueData.transferFile = transferfile;

				if (transferfile.localfile=="" || transferfile.remotefile=="" || transferfile.remotepath.IsEmpty())
					AfxMessageBox( _T("Error, can't reload queue item!") );
				else
					AddItem(transferfile);
			}
			pMarkup->OutOfElem();
			pMarkup->RemoveChildElem();
		}
		COptions::UnlockXML();
	}

	HKEY key;
	if (RegOpenKey(HKEY_CURRENT_USER, _T("Software\\FileZilla\\Queue\\"), &key)==ERROR_SUCCESS)
	{
		TCHAR buffer[MAX_PATH + 1];
		

		int index=0;
		//First try to read the queue items sequential
		while (TRUE)
		{
			CString subkey;
			subkey.Format(_T("%d"), index);
			HKEY key2;
			if (RegOpenKey(HKEY_CURRENT_USER, _T("Software\\FileZilla\\Queue\\")+subkey,&key2)!=ERROR_SUCCESS)
				break;

			t_transferfile transferfile;
			COptions::GetKey(key2, "Localfile", transferfile.localfile);
			COptions::GetKey(key2, "Remotefile", transferfile.remotefile);
			CString value;
			COptions::GetKey(key2, "Remotepath",value);
			transferfile.remotepath.SetSafePath(value);
			COptions::GetKey(key2, "Transfer mode", transferfile.nType);
			COptions::GetKey(key2, "Get", transferfile.get);
			COptions::GetKey(key2, "Size", transferfile.size);
			CQueueData queueData;
			COptions::GetKey(key2, "Retry Count", queueData.retrycount);
			COptions::GetKey(key2, "Open", queueData.nOpen);
			
			if (!COptions::LoadServer(key2, transferfile.server))
			{
				RegCloseKey(key2);
				RegDeleteKey(HKEY_CURRENT_USER, _T("Software\\FileZilla\\QUEUE\\")+subkey);
				break;
			}
			
			queueData.transferFile = transferfile;
			if (transferfile.localfile=="" || transferfile.remotefile=="" || transferfile.remotepath.IsEmpty())
			{
				AfxMessageBox( _T("Error, can't reload queue item!") );
			}
			else
			{
				int index2=AddItem(transferfile);
			}
			RegCloseKey(key2);
			RegDeleteKey(HKEY_CURRENT_USER, _T("Software\\FileZilla\\QUEUE\\")+subkey);
			index++;
		}

		//Now try to find out-of-order queue items
		index=0;
		while (RegEnumKey(key, index, buffer, MAX_PATH+1)==ERROR_SUCCESS)
		{
			t_transferfile transferfile;
			CString str=buffer;
			HKEY key2;
			if (RegOpenKey(HKEY_CURRENT_USER,"Software\\FileZilla\\Queue\\"+str,&key2)==ERROR_SUCCESS)
			{
				COptions::GetKey(key2, "Localfile", transferfile.localfile);
				COptions::GetKey(key2, "Remotefile", transferfile.remotefile);
				CString value;
				COptions::GetKey(key2, "Remotepath",value);
				transferfile.remotepath.SetSafePath(value);
				COptions::GetKey(key2, "Transfer mode", transferfile.nType);
				COptions::GetKey(key2, "Get", transferfile.get);
				COptions::GetKey(key2, "Size", transferfile.size);
				CQueueData queueData;
				COptions::GetKey(key2, "Retry Count", queueData.retrycount);
				COptions::GetKey(key2, "Open", queueData.nOpen);
				
				queueData.transferFile = transferfile;
				if (!COptions::LoadServer(key2, transferfile.server))
				{
					RegCloseKey(key2);
					RegDeleteKey(HKEY_CURRENT_USER, _T("Software\\FileZilla\\QUEUE\\")+str);
					break;
				}
				
				if (transferfile.localfile=="" || transferfile.remotefile=="" || transferfile.remotepath.IsEmpty())
					AfxMessageBox( _T("Error, can't reload queue item!") );
				else
					AddItem(transferfile);
				RegCloseKey(key2);
			}
			if (RegDeleteKey(HKEY_CURRENT_USER, _T("Software\\FileZilla\\QUEUE\\")+str)!=ERROR_SUCCESS) 
				index++;
		}
		RegCloseKey(key);
	}
	mLock.Unlock();
	DragAcceptFiles(TRUE);

	SetExtendedStyle(LVS_EX_INFOTIP);

	t_TransferApi api={0};
	m_TransferApiArray.resize(m_nMaxApiCount);
	for (UINT i = 0;i < m_nMaxApiCount; i++)
	{
		api.pTransferApi = new CFileZillaApi();
		if (!api.pTransferApi)
			return -1;
		if (api.pTransferApi->Init(GetSafeHwnd(), WM_APP + 10 + i)!=FZ_REPLY_OK)
			return -1;
		api.pTransferApi->SetDebugLevel(COptions::GetOptionVal(OPTION_DEBUGTRACE)?4:0);
		m_TransferApiArray[i]=api;
	}

	m_nTimerID = SetTimer(1234, 1000, 0);
	
	return 0;
}

int CQueueCtrl::AddItem(t_transferfile transferfile, BOOL stdtransfer /*=FALSE*/, int nOpen /*=0*/)
{
	CQueueData queueData;

	queueData.priority = stdtransfer?2:1;
	queueData.nOpen = nOpen;
	
	m_bMayUsePrimaryConnection = IsQueueEmpty();

	queueData.transferFile = transferfile;
	queueData.transferFile.nUserData = nOpen;

	m_QueueItems.insert(FindValidIndex(queueData.priority), queueData);
	SetItemCount(m_QueueItems.size() + m_nActiveCount);
	UpdateStatusbar();
	return 1;
}

int CQueueCtrl::AddItem(CQueueData queueData)
{
	queueData.transferFile.nUserData = queueData.nOpen;

	if (!queueData.priority)
		queueData.priority = 1;
	
	m_bMayUsePrimaryConnection = IsQueueEmpty();

	m_QueueItems.insert(FindValidIndex(queueData.priority), queueData);
	SetItemCount(m_QueueItems.size() + m_nActiveCount);
	UpdateStatusbar();
	
	return 1;
}

void CQueueCtrl::OnDestroy() 
{
	if (m_bQuit)
	{
		CListCtrl::OnDestroy();
		return;
	}

	for (UINT i=0; i<m_TransferApiArray.size(); i++)
	{
		m_TransferApiArray[i].pTransferApi->Destroy();
		delete m_TransferApiArray[i].pTransferApi;
		delete m_TransferApiArray[i].pLastActiveTime;
	}
	m_TransferApiArray.clear();

	KillTimer(m_nTimerID);

	CMutex mutex(FALSE, _T("FileZilla Queue Mutex"), 0);
	CSingleLock mLock(&mutex, TRUE);
	
	CMarkupSTL *pMarkup;

	if (COptions::LockXML(&pMarkup))
	{
		pMarkup->ResetPos();
		if (!pMarkup->FindChildElem( _T("TransferQueue") ))
			pMarkup->AddChildElem( _T("TransferQueue") );

		pMarkup->IntoElem();
		
		for (t_QueueVector::iterator iter = m_QueueItems.begin(); iter != m_QueueItems.end(); iter++)
		{
			const CQueueData &queueData = *iter;
			if (!queueData.priority && !queueData.bPaused)
				continue;

			pMarkup->AddChildElem( _T("QueueItem") );
			pMarkup->IntoElem();
			pMarkup->AddChildElem( _T("File") );
			pMarkup->AddChildAttrib( _T("Localfile"), queueData.transferFile.localfile);
			pMarkup->AddChildAttrib( _T("Size"), queueData.transferFile.size);
			pMarkup->AddChildAttrib( _T("Remotefile"), queueData.transferFile.remotefile);
			pMarkup->AddChildAttrib( _T("Remotepath"), queueData.transferFile.remotepath.GetSafePath());
			
			pMarkup->AddChildElem( _T("Data") );
			pMarkup->AddChildAttrib( _T("Transfermode"), queueData.transferFile.nType);
			pMarkup->AddChildAttrib( _T("Get"), queueData.transferFile.get);
			pMarkup->AddChildAttrib( _T("RetryCount"), queueData.retrycount);
			pMarkup->AddChildAttrib( _T("Open"), queueData.nOpen);

			COptions::SaveServer(pMarkup, queueData.transferFile.server);

			pMarkup->OutOfElem();
		}
		COptions::UnlockXML();
	}
	else
	{
		
		int j=0;
		TCHAR buffer[1000];
		HKEY key;
		if (RegOpenKey(HKEY_CURRENT_USER, _T("Software\\FileZilla\\Queue\\") ,&key)==ERROR_SUCCESS)
		{
			while (RegEnumKey(key,j,buffer,1000)==ERROR_SUCCESS)
			{
				j++;
			}
			RegCloseKey(key);
		}
		
		for (t_QueueVector::iterator iter = m_QueueItems.begin(); iter != m_QueueItems.end(); iter++)
		{
			const CQueueData &queueData = *iter;
			if (!queueData.priority && !queueData.bPaused)
				continue;
			
			CString str;
			str.Format(_T("%d"), j);
			HKEY key2;
			if (RegCreateKeyEx(HKEY_CURRENT_USER,"Software\\FileZilla\\Queue\\"+str, 0, 0, REG_OPTION_NON_VOLATILE, KEY_WRITE, 0, &key2, NULL)==ERROR_SUCCESS)
			{