rightbackup.cpp

实时监控

// RightBackup.cpp : implementation file
//

#include "stdafx.h"
#include "..\dvrmanager.h"
#include "RightBackup.h"
#include "../utils/common.h"
#include "../utils/FolderDlg.h"
#include "reg.h"
#include "../utils/balloonhelp.h"
#include "../utils/update_data.h"
#include "../utils/custom_msgs.h"

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

/////////////////////////////////////////////////////////////////////////////
// CRightBackup dialog
LPCTSTR rkSettings = _T("Settings");
LPCTSTR rvBackup = _T("BackupPath");

//##ModelId=3F90BAB50313
CRightBackup::CRightBackup(CWnd* pParent /*=NULL*/)
	: baseclass(CRightBackup::IDD, pParent), backuping(false),
	total_sec(0), recv_sec(0), packet_size(0)
{
	//{{AFX_DATA_INIT(CRightBackup)
	m_channel = -1;
	m_which = -1;
	m_bkdir = _T("C:\\Backup");
	//}}AFX_DATA_INIT

	ZeroMemory(&opt, sizeof(opt));
}


//##ModelId=3F90BAB600F8
void CRightBackup::DoDataExchange(CDataExchange* pDX)
{
	baseclass::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CRightBackup)
	DDX_Control(pDX, ID_RECVD, m_recvd);
	DDX_Control(pDX, ID_S, m_s);
	DDX_Control(pDX, IDPROG_BACKUP, m_prog_bk);
	DDX_Control(pDX, IDCB_WHICH, m_cbwhich);
	DDX_Control(pDX, IDCB_CHANNEL, m_cbchannel);
	DDX_Control(pDX, IDBTN_CANCEL, m_cancel);
	DDX_Control(pDX, IDBTN_BROWSE, m_btn_browse);
	DDX_Control(pDX, IDBTN_BACKUP, m_backup);
	DDX_Control(pDX, ID_TITLE, m_title);
	DDX_Control(pDX, ID_PERCENT, m_percent);
	DDX_Control(pDX, ID_8, m_8);
	DDX_Control(pDX, ID_7, m_7);
	DDX_Control(pDX, ID_5, m_5);
	DDX_Control(pDX, ID_4, m_4);
	DDX_Control(pDX, ID_3, m_3);
	DDX_Control(pDX, ID_2, m_2);
	DDX_Control(pDX, ID_1, m_1);
	DDX_CBIndex(pDX, IDCB_CHANNEL, m_channel);
	DDX_CBIndex(pDX, IDCB_WHICH, m_which);
	DDX_DateTimeCtrl(pDX, IDDATE_BACKUP, m_bkdate);
	DDX_Text(pDX, IDED_BACKUP_DIR, m_bkdir);
	DDX_DateTimeCtrl(pDX, IDTIME_FROM, m_from);
	DDX_DateTimeCtrl(pDX, IDTIME_TO, m_to);
	//}}AFX_DATA_MAP

	m_cbchannel.EnableWindow(m_cbwhich.GetCount()!=0);

	UINT show = backuping?SW_SHOW:SW_HIDE;
	m_prog_bk.ShowWindow(show);
	m_percent.ShowWindow(show);
	m_recvd.ShowWindow(show);
	
	if( show == SW_HIDE )
	{
		SetTimer(1, 100, NULL);
	}

	UINT ids[] = {IDCB_WHICH, IDCB_CHANNEL, IDDATE_BACKUP, 
	IDTIME_FROM, IDTIME_TO, IDED_BACKUP_DIR, IDBTN_BROWSE,
	IDBTN_BACKUP};

	for( int i=0; i<SIZE_OF(ids); i++ )
	{
		GetDlgItem(ids[i])->EnableWindow(!backuping);
	}
	//GetDlgItem(IDBTN_CANCEL)->EnableWindow(backuping);
}


BEGIN_MESSAGE_MAP(CRightBackup, baseclass)
	//{{AFX_MSG_MAP(CRightBackup)
	ON_BN_CLICKED(IDBTN_BACKUP, OnBackup)
	ON_BN_CLICKED(IDBTN_BROWSE, OnBrowse)
	ON_CBN_SELCHANGE(IDCB_WHICH, OnSelchangeWhich)
	ON_CBN_SELCHANGE(IDCB_CHANNEL, OnSelchangeChannel)
	ON_BN_CLICKED(IDBTN_CANCEL, OnBtnCancel)
	ON_WM_TIMER()
	ON_WM_DESTROY()
	//}}AFX_MSG_MAP
	ON_MESSAGE(WM_UPDATE_DATA, on_update_data)
	MSG2(NTM_BK_CANCELED, on_bk_canceled)
	MSG2(NTM_BK_EMPTY, on_bk_empty)
	MSG2(NTM_BK_FAILED, on_bk_failed)
	MSG2(NTM_BK_FINISHED, on_bk_finished)
	MSG2(NTM_BK_BEGIN, on_bk_begin)
	MSG2(NTM_BK_PROGRESS, on_bk_progress)
	MSG2(WM_LOGGED_OUT, on_logged_out)
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CRightBackup message handlers

//##ModelId=3F90BAB60134
BOOL CRightBackup::OnInitDialog() 
{
	baseclass::OnInitDialog();
	m_bkdate = CTime::GetCurrentTime() ;
	m_from   = CTime::GetCurrentTime() ;
	m_to     = CTime::GetCurrentTime() ;
	
	init_title(m_title);
	init_label(m_1);
	init_label(m_3);
	init_label(m_5);
	init_label(m_7);
	init_label(m_8);
	init_label(m_recvd);
	init_label(m_percent);
	
	CRect rc;
	m_backup.GetWindowRect(rc);
//	m_cancel.MoveWindow(rc);

	m_bkdir = read_string(rkSettings, rvBackup);
	UpdateData(FALSE);

	return TRUE ;
}

//##ModelId=3F90BAB50287
void CRightBackup::on_join()
{
	m_cbwhich.ResetContent();
	fill_combo(&m_cbwhich);
	m_cbchannel.EnableWindow(FALSE);
}

#include "msgbox.h"
//##ModelId=3F90BAB5031E
bool CRightBackup::can_leave()
{
	if( backuping )
	{
		msgbox(IDS_BK_LEAVE, IDS_INFO, MB_OK | MB_ICONWARNING, this);
		return false;
	}
	
	return true;
}

//##ModelId=3F90BAB50291
void CRightBackup::on_leave()
{
	//m_cbchannel.ResetContent();
}

//##ModelId=3F90BAB60167
void CRightBackup::OnBtnCancel() 
{
	GET_ALIAS;

	stop_bk(alias) ;

	backuping = false;
}

//##ModelId=3F90BAB60149
void CRightBackup::OnBrowse() 
{
	UpdateData();

	CString title;
	title.LoadString(IDS_BK_BROWSE);
	CFolderDialog dlg(title, m_bkdir, this);
	if( dlg.DoModal() != IDOK )
		return;

	m_bkdir = dlg.GetFolderPath();
	UpdateData(FALSE);

	write_string(rkSettings, rvBackup, m_bkdir);
}

//##ModelId=3F90BAB5029B
CString CRightBackup::get_alias()
{
	CString alias;
	
	UpdateData();
	if( m_which == -1 )
		return CString();
	
	m_cbwhich.GetLBText(m_which, alias);
	return alias;
}

//##ModelId=3F90BAB60153
void CRightBackup::OnSelchangeWhich() 
{
	GET_ALIAS;

	fill_combo_chnls(alias, &m_cbchannel);

	m_channel = 0;
	UpdateData(FALSE);
}

//##ModelId=3F90BAB6015D
void CRightBackup::OnSelchangeChannel() 
{
	UpdateData();
}

// rightlocal.cpp
extern void add_backslash(CString& str);
extern void remove_backslash(CString& str);

//##ModelId=3F90BAB6013F
void CRightBackup::OnBackup() 
{
	GET_ALIAS
	ULONG ip;
	USHORT port;
	get_addr(alias, ip, port);
    if(!check_popedom(ip, port, m_channel+1, 13)) return;
    
	CString m_logfile;
    m_logfile.Format(IDS_BACKUP_DATA,alias,m_channel+1);
    write_log_file(m_logfile);

	packet_size = 0;

	opt.year = m_bkdate.GetYear()-2000;
	opt.month = m_bkdate.GetMonth();
	opt.day = m_bkdate.GetDay();

	opt.bgn_hour = m_from.GetHour();
	opt.bgn_minute = m_from.GetMinute();
	opt.bgn_second = m_from.GetSecond();

	opt.end_hour = m_to.GetHour();
	opt.end_minute = m_to.GetMinute();
	opt.end_second = m_to.GetSecond();

	opt.channel = m_channel;
	
	CString path(m_bkdir);
	add_backslash(path);

	CString bkdir;
	bkdir.Format(IDString(IDS_PORT_FMT), m_channel+1);
	bkdir.Insert(0, path);

	memcpy(opt.sBackDir, (LPCTSTR)bkdir, bkdir.GetLength()+1);
	add_backslash(bkdir);
	recursive_create_dir(bkdir);

	start_bk(alias, &opt, m_hWnd);

	CTimeSpan ts = m_to - m_from;
	total_sec = ts.GetTotalSeconds();
	recv_sec = 0;
}

//void CRightBackup::on_bk_begin()
MSG3(on_bk_begin, CRightBackup)
{
	reset_state();
	backuping = true;

	PostMessage(WM_UPDATE_DATA);

	info_balloon(IDS_BK_STARTED);
	return 0;
}

//void CRightBackup::on_bk_failed()
MSG3(on_bk_failed, CRightBackup)
{
	reset_state();

	PostMessage(WM_UPDATE_DATA);

	warning_balloon(IDS_BK_DENY);
	return 0;
}

//void CRightBackup::on_bk_end()
MSG3(on_bk_finished, CRightBackup)
{
	reset_state();

	PostMessage(WM_UPDATE_DATA);
	info_balloon(IDS_BK_FINISH);
	return 0;
}

MSG3(on_bk_empty, CRightBackup)
{
	reset_state();
	PostMessage(WM_UPDATE_DATA);
	info_balloon(IDS_BK_EMPTY);
//	MessageBox(IDString(IDS_BK_EMPTY), IDString(IDS_WARNING), MB_ICONWARNING|MB_OK);
	return 0;
}

//void CRightBackup::on_bk_canceled()
MSG3(on_bk_canceled, CRightBackup)
{
	backuping = false;

	PostMessage(WM_UPDATE_DATA);
	info_balloon(IDS_BK_CANCEL);
	return 0;
}
extern CString add_comma(DWORD x, TCHAR comma = _T(','));
//void CRightBackup::on_bk_progress(ULONG recvd, ULONG total)
MSG3(on_bk_progress, CRightBackup)
{
	if (l > 0)  
	{  //total bytes ;
		static LPCTSTR UNITS[] = {_T(""), _T("K"), _T("M"), _T("G"), _T("T")};
		int u = 0;
		// 每100K显示一次字节数
		if( l - packet_size > 102400 )
		{
			packet_size = l;

			// 计算单位
			for(; l>99999; u++)
			{
				l /= 1024;
			}

			CString rcvd;
			rcvd.Format(IDS_RECVD_FMT, add_comma(l), UNITS[u]);
			m_recvd.SetText(rcvd);
		}
		return 0 ;
	}

	if( total_sec == 0 )
		return 0;

	recv_sec += 5;

	int prg = recv_sec*100/total_sec;
	if( prg > 100 )
		prg = 100;

	if( prg == m_prog_bk.GetPos() )
		return 0;

	m_prog_bk.SetPos(prg);

	CString str;
	str.Format(IDS_PROG_FMT, prg);
	m_percent.SetText(str);

	return 0;
}

//##ModelId=3F90BAB60116
LRESULT CRightBackup::on_update_data(WPARAM w, LPARAM)
{
	UpdateData(w);
	return 0;
}

void parent_redraw(CWnd* x)
{
	if( !IsWindow(x->m_hWnd))
		return;
	CWnd* p = x->GetParent();
	if( !p )
		return;
	if( !p )
		return;
	p = p->GetParent();
	
	CRect rc;
	x->GetWindowRect(rc);
	p->ScreenToClient(rc);
	p->RedrawWindow(rc);
}

//##ModelId=3F90BAB60170
void CRightBackup::OnTimer(UINT nIDEvent) 
{
	KillTimer(nIDEvent);
	parent_redraw(&m_recvd);
	parent_redraw(&m_prog_bk);
	parent_redraw(&m_percent);
	baseclass::OnTimer(nIDEvent);
}

//##ModelId=3F90BAB50309
void CRightBackup::reset_state()
{
	backuping = false;
	m_recvd.SetText(_T(""));
	m_prog_bk.SetPos(0);
	m_percent.SetText(_T(""));
}

ON_LOGGED_OUT(CRightBackup);

void CRightBackup::OnDestroy() 
{
	UpdateData();
	write_string(rkSettings, rvBackup, m_bkdir);

	baseclass::OnDestroy();
}