dlgalarm.cpp

实时监控

// DlgAlarm.cpp : implementation file
//

#include "stdafx.h"
#include "..\dvrmanager.h"
#include "../toolbars/RightLogin.h"
#include "DlgAlarm.h"
#include "reg.h"
#include "ip_port.h"
#include "../utils/custom_msgs.h"
#include "../utils/common.h"

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

CString rvalarmip("alarmtypeip");

CBrush   m_pppBrush(RGB(23,108,188)) ;
/////////////////////////////////////////////////////////////////////////////
// CDlgAlarm dialog

#define TYPE(x) ((x)/16)
#define CHANNEL(x) ((x)%16)
#define CHECK_VISIBLE if(!is_visible(this)) return

void alarm_data::set_alarm(byte *al)
{
	TREC_ALARMINFO  *ptr ;
	ptr = (TREC_ALARMINFO *)al ;
	version = ptr->version ;
	alarms[0] = ptr->probe_alarm ;
	alarms[1] = ptr->motion_alarm ;
	alarms[2] = ptr->vlost_alarm ;
}

CDlgAlarm::CDlgAlarm(CWnd* pParent /* = NULL */)
	: baseclass(CDlgAlarm::IDD, pParent)
{
	//{{AFX_DATA_INIT(CDlgAlarm)
	m_remote = 0 ;
	m_sel_bun = 0;
	//m_auto = 0 ;
	m_hostver = _T("") ;
	//m_alarmbool1=FALSE;
	m_alarmbool2 = FALSE;
	m_alarmbool3 = FALSE;
	m_alarm_max = FALSE;
	//}}AFX_DATA_INIT
	init(this);
}



#define DDX(x) DDX_Control(pDX, ID_##x, m_led[TYPE(x-1)][CHANNEL(x-1)])
//##ModelId=3F90BABC0088
void CDlgAlarm::DoDataExchange(CDataExchange* pDX)
{
	baseclass::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CDlgAlarm)
	DDX(1);	DDX(2);	DDX(3);	DDX(4);
	DDX(5);	DDX(6);	DDX(7);	DDX(8);
	DDX(9);	DDX(10);DDX(11);DDX(12);
	DDX(13);DDX(14);DDX(15);DDX(16);
	DDX(17);DDX(18);DDX(19);DDX(20);
	DDX(21);DDX(22);DDX(23);DDX(24);
	DDX(25);DDX(26);DDX(27);DDX(28);
	DDX(29);DDX(30);DDX(31);DDX(32);
	DDX(33);DDX(34);DDX(35);DDX(36);
	DDX(37);DDX(38);DDX(39);DDX(40);
	DDX(41);DDX(42);DDX(43);DDX(44);
	DDX(45);DDX(46);DDX(47);DDX(48);
	DDX_Control(pDX, IDCB_REMOTE, m_cbremote);
	DDX_CBIndex(pDX, IDCB_REMOTE, m_remote);
	//DDX_Check(pDX, IDC_ALARMAUTO_CHECK, m_auto);
	DDX_Text(pDX, IDC_HOSTVER_STATIC, m_hostver);
	//DDX_Text(pDX, IDC_STATIC1, m_disk_all);
    //DDX_Text(pDX, IDC_STATIC2, m_disk_part);
	//DDX_Text(pDX, IDC_STATIC3, m_lable);
	DDX_Control(pDX, IDC_CLEARALARM, m_clearalarmbtn);
	//DDX_Control(pDX, IDC_alarm1, m_alarm1btn);
	DDX_Control(pDX, IDC_alarm2, m_alarm2btn);
	DDX_Control(pDX, IDC_elemap_alarm, m_alarm3btn);
	DDX_Control(pDX, IDC_ALARM_MAX ,m_alarm_maxctl);
	//DDX_Check(pDX, IDC_alarm1, m_alarmbool1);
	DDX_Check(pDX, IDC_alarm2, m_alarmbool2);
	DDX_Check(pDX, IDC_elemap_alarm, m_alarmbool3);
	DDX_Check(pDX, IDC_ALARM_MAX, m_alarm_max);
	//}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CDlgAlarm, baseclass)
	//{{AFX_MSG_MAP(CDlgAlarm)
	ON_WM_TIMER()
	ON_WM_SYSCOMMAND()
	ON_CBN_SELCHANGE(IDCB_REMOTE, OnSelChangeRemote)
	//ON_BN_CLICKED(IDC_ALARMAUTO_CHECK, OnAuto)
//	ON_BN_CLICKED(IDC_alarm1, Onsensor_alarm)
	ON_BN_CLICKED(IDC_alarm2, Onmotion_alarm)
	ON_BN_CLICKED(IDC_CLEARALARM, Onclear_alarm)
	ON_BN_CLICKED(IDC_elemap_alarm, Onelemap_alarm)
	ON_BN_CLICKED(IDC_ALARM_MAX, onmax)
//	ON_WM_ERASEBKGND()
	ON_WM_CTLCOLOR()
	//}}AFX_MSG_MAP

END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CDlgAlarm message handlers

void CDlgAlarm::OnOK() 
{
	hide() ;
	AfxGetMainWnd()->SendMessage(WM_HIDE_ALARM, TRUE) ;
}
void CDlgAlarm::OnCancel()
{
	OnOK() ;
}


void CDlgAlarm::Onclear_alarm()
{
	int selno = m_cbremote.GetCurSel() ;
	if (selno >= al.size())
		return ;
	alarm_data& ref = al[selno] ;
    clear_all_alarm(ref.ip,ref.port);

	CString m_str;
    ip_port ipp(ref.ip,ref.port);
	m_str.Format(ID_CLEAR_ALARM,ipp.str_ip());
	write_log_file(m_str);
}


BOOL CDlgAlarm::OnInitDialog() 
{
	baseclass::OnInitDialog() ;
	showing = false ;

	CString m_str,m_str2,m_str3,m_str4;
	m_str.Format("alarmtypeip");
    //m_str1.Format("rvalarmtypesensor");
	m_str2.Format("rvalarmtypemotion");
	m_str3.Format("rvalarmshowwindowmax");
	m_str4.Format("rvalarmelemap");

    //m_alarmbool1=read_dword(m_str,m_str1,0);
	m_alarmbool2=read_dword(m_str,m_str2,0);
	m_alarm_max=read_dword(m_str,m_str3,0);
	m_alarmbool3=read_dword(rvalarmip, m_str4,0);

	UpdateData(false);
	return TRUE ;
}

void CDlgAlarm::add_alarm(ULONG _ip, USHORT _port, LPCTSTR alias, byte *masks, bool m_bool)
{
	//检查该主机是否已在列表中, 是则更新
	for (int i=0;i<al.size();i++)  
	{
		alarm_data& ref = al[i] ;
		if (ref.ip == _ip && ref.port == _port)  
		{
			ref.set_alarm(masks) ;
			break ;
		}
	}
	// 否则添加
	if (i >= al.size())  {
		al.push_back(alarm_data(_ip, _port, alias, masks)) ;
	}
	if(m_bool) m_sel_bun  = i;
	
	// 更新状态
	if (showing)  {
        m_remote = m_sel_bun;
		m_cbremote.SetCurSel(i) ;
		UpdateData(false);
		update_status(m_sel_bun) ;
	}
	/*else if (i == m_remote)  {
		update_status(i) ;
	}*/
}

void CDlgAlarm::checkip()
{
	CRightLogin* l = CRightLogin::the_one();
    for (int k=0;k<al.size();k++)  
	{
	   alarm_data& ref = al[k] ;
	   if(l->checkloginip(ref.ip, ref.port)) continue;
	   else  remove_alarm(ref.ip, ref.port);
	}
}
void CDlgAlarm::remove_alarm(ULONG _ip, USHORT _port)
{
	for (int i=0;i<al.size();i++)  {
		alarm_data& ref = al[i] ;
		if (ref.ip == _ip && ref.port == _port)  {
			al.erase(al.begin()+i) ;
			break ;
		}
	}
	update_status(i) ;
}

void CDlgAlarm::update_combo()
{
	//刷新主机列表
	//CString  x ;
	//m_cbremote.GetWindowText(x) ;
	m_cbremote.ResetContent() ;
	checkip();
	for (int i=0;i<al.size();i++)  {
		alarm_data& ref = al[i] ;
		int idx = m_cbremote.AddString(ref.alias) ;
		m_cbremote.SetItemData(idx, ref.ip) ;
	}
	/*if (m_cbremote.GetCount() != 0)  {
		int idx = m_cbremote.FindString(-1, x) ;
		if (idx != -1)  {
			m_remote = idx ;
		}
		m_remote = m_cbremote.GetCount()-1 ;
		UpdateData(FALSE) ;
	}*/
}
void CDlgAlarm::onmax()
{
	UpdateData(true);
    	CString m_str;
	m_str.Format("rvalarmshowwindowmax");
	write_dword(rvalarmip,m_str,m_alarm_max);

	CString m_mstr;
	m_mstr.Format(ID_ALARM_WINDOW);
	write_log_file(m_mstr);
}

/*void CDlgAlarm::Onsensor_alarm()
{
  UpdateData(true);
  CString str("rvalarmtypesensor");
  write_dword(rvalarmip,str,m_alarmbool1);

  CString m_mstr;
  m_mstr.Format(ID_ALARM_WINDOW);
  write_log_file(m_mstr);
}*/
void CDlgAlarm::Onmotion_alarm()
{
  UpdateData(true);
  CString str("rvalarmtypemotion");
  write_dword(rvalarmip,str,m_alarmbool2);

  CString m_mstr;
  m_mstr.Format(ID_ALARM_WINDOW);
  write_log_file(m_mstr);
}
void CDlgAlarm::Onelemap_alarm()
{
  UpdateData(true);
  CString str("rvalarmelemap");
  write_dword(rvalarmip,str,m_alarmbool3);
}

void CDlgAlarm::update_status()
{
	if (!showing)
		return ;
	int  i, m, n, selno ;
	selno = m_cbremote.GetCurSel() ;
	if (selno >= al.size())
		return ;

	alarm_data& ref = al[selno] ;
	//ref.version
	//get_disk_info(ref.ip , ref.port);

	version_class *pver = (version_class *)&(ref.version) ;
	m_hostver.Format("Ver: %d.%d Build%02d%02d%0d", pver->v2, pver->v1,pver->year,pver->month, pver->day) ;
	//alarm info
	for (i=0;i<LEDS;i++)  {
		m = TYPE(i) ;  n = CHANNEL(i) ;
		CLed& led = m_led[m][n] ;
		if ((ref.alarms[m]) & (1<<n)) {  //alarm
			led.SetLed(CLed::LED_COLOR_RED, CLed::LED_ON, CLed::LED_ROUND);
		}
		else  {
			led.SetLed(CLed::LED_COLOR_GREEN, CLed::LED_OFF, CLed::LED_ROUND);
		}
	}
	UpdateData(FALSE) ;
}

void CDlgAlarm::update_status(int selno)
{
	if (!showing)
		return ;
	int  i, m, n ;
	if (selno >= al.size())
		return ;
	alarm_data& ref = al[selno] ;
	//ref.version
	//get_disk_info(ref.ip , ref.port);
	version_class *pver = (version_class *)&(ref.version) ;
	m_hostver.Format("Ver: %d.%d Build%02d%02d%02d", pver->v2, pver->v1, pver->year, pver->month, pver->day) ;
	//alarm info
	for (i=0;i<LEDS;i++)  {
		m = TYPE(i) ;  n = CHANNEL(i) ;
		CLed& led = m_led[m][n] ;
		if ((ref.alarms[m]) & (1<<n)) {  //alarm
			led.SetLed(CLed::LED_COLOR_RED, CLed::LED_ON, CLed::LED_ROUND);
		}
		else  {
			led.SetLed(CLed::LED_COLOR_GREEN, CLed::LED_OFF, CLed::LED_ROUND);
		}
	}
	UpdateData(FALSE) ;
}
void CDlgAlarm::set_disk_info(DISK_SPACE *m_disk)
{
	/*CString m_str,m_str2,m_str1[MAX_DISK_NUM],m_str3;
	m_str.Format(IDS_DISK_ALL_INFO, m_disk->nDiskNum, m_disk->nDiskSpace, m_disk->nDiskFree);

    DISK_INFO   *p=m_disk->Disk_Info;
	for(int i=0; i<MAX_DISK_NUM;i++)
	{
		if(!p->nPartNum) continue;
	    m_str1[i].Format(IDS_DISK_PART_INFO,p->nPartNum,p->nDiskCapacity,p->nDiskFree);
		if(p->Part_Info->nCurWriting) m_str2.Format(IDS_DISK_LABLE_WRITE, i,p->Part_Info->label);
		p++;
		m_str3=m_str3+m_str1[i];
	}
   m_disk_all = m_str;
   m_disk_part = m_str3;
   m_lable = m_str2;
   UpdateData(false);*/
}

bool CDlgAlarm::alarms_present() const
{
	for( int i=0; i<al.size(); i++ )
	{
		const alarm_data& ref = al[i];
		for( int j=0; j<3; j++ )
		{
			if( ref.alarms[j] )
				return true;
		}
	}
	return false;
}

void CDlgAlarm::OnSysCommand(UINT nID, LPARAM lParam)
{
	if( nID == SC_CLOSE )
	{
		OnOK();
		return;
	}
	baseclass::OnSysCommand(nID, lParam) ;
}

void CDlgAlarm::show(CWnd* parent)
{
	baseclass::show(parent) ;
	showing = true ;
	update_combo() ;
	m_remote = m_sel_bun;
    UpdateData(false) ;
	update_status(m_sel_bun) ;
}
void CDlgAlarm::hide()
{
	showing = false ;
	baseclass::hide() ;
}
void CDlgAlarm::OnSelChangeRemote()
{
	UpdateData() ;
	int  i = m_cbremote.GetCurSel() ;
	update_status(i) ;
}
BOOL CDlgAlarm::AutoShow()
{
	UpdateData() ;
	return true ;
}
/*void CDlgAlarm::OnAuto()
{
	m_auto = TRUE;
}*/
/*
BOOL CDlgAlarm::OnEraseBkgnd(CDC* pDC)
{
	CRect rc ;
	GetClientRect(rc) ;
	pDC->FillRect(rc, &CBrush(RGB(23,108,188)));
	GetDlgItem(IDC_ALARMCAMERA_STATIC)->ModifyStyleEx(0,WS_EX_TRANSPARENT) ;
	RedrawWindow();
	return TRUE ;
}
*/
HBRUSH CDlgAlarm::OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor) 
{
	HBRUSH hbr = CDialog::OnCtlColor(pDC, pWnd, nCtlColor);
	
	switch (nCtlColor)  {
		case CTLCOLOR_STATIC :
			pDC->SetTextColor(RGB(255,255,249)) ;
			pDC->SetBkMode(TRANSPARENT) ;
			return (HBRUSH)(m_pppBrush.GetSafeHandle()) ;
		case CTLCOLOR_DLG :
			pDC->SetBkMode(TRANSPARENT) ;
			return (HBRUSH)(m_pppBrush.GetSafeHandle()) ;
		case CTLCOLOR_LISTBOX :
			pDC->SetBkMode(TRANSPARENT) ;
			return (HBRUSH)(m_pppBrush.GetSafeHandle()) ;
		case CTLCOLOR_BTN :
			pDC->SetBkMode(TRANSPARENT) ;
			return (HBRUSH)(m_pppBrush.GetSafeHandle()) ;
		case CTLCOLOR_EDIT :
			pDC->SetTextColor(RGB(55,19,81)) ;
			pDC->SetBkColor(RGB(136,138,140)) ;
			pDC->SetBkMode(TRANSPARENT) ;
			return (HBRUSH)(m_pppBrush.GetSafeHandle()) ;
		default :
			return hbr;
	}
	return hbr;
}