userchangei.cpp

实时监控

    for(int m=0;m<120;m++)
	{
	  if(strcmp(m_station[m].name,m_login_client_name)) continue;
	  if(strcmp(m_station[m].dvrname,m_dvrname)) continue;
	  setting.m_loginpass=m_station[m].logindvrpass;
	}
	int m_result=setting.DoModal();
	if(m_result==IDOK) 
	{
		dbgrid();
        CChannelMap * p_channel = CChannelMap::m_channelmap;
	    if(p_channel && p_channel->m_hWnd)
		     p_channel->PostMessage(NTM_CHANNEL_MAP_UPDATE, 0 ,0 );
	}

}

////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
BEGIN_EVENTSINK_MAP(CChannelMap, CPropertyPage)
    //{{AFX_EVENTSINK_MAP(CChannelMap)
	ON_EVENT(CChannelMap, IDC_MSFLEXGRID1, -600 /* DblClick */, OnClickMsflexgrid1, VTS_NONE)
	//}}AFX_EVENTSINK_MAP
END_EVENTSINK_MAP()
void CChannelMap::UpdateMapchannel(WPARAM w, LPARAM l)
{
	if( w ) 
	{
		m_dbgrid.Clear();
        update();
	}
	else 
	{
		UpdateData(true);
		dbgrid(m_setup_name);
	}
}
void CChannelMap::Openfile()
{
	UpdateData(true);
	Cfileoperation <Machine_Channel_Setting> *m_fileoperation;
    m_file_length=m_fileoperation->openfile(m_channel_window_directory,"ab+",m_machine,300);
    
	Cfileoperation <Remote_Station_setting> *m_fileoperation1;
    m_file_length1=m_fileoperation1->openfile(m_remote_station_directory,"ab+",m_station);

	Cfileoperation <Scene_set_up> *m_fileoperation2;
    m_scene_length=m_fileoperation2->openfile(m_scene_setup_directory,"ab+",m_scene);
}

void CChannelMap::OnSetfocusdvrname() 
{
	Openfile();
	m_dvrnamectl.ResetContent();
	for(int i=0;i<m_file_length1;i++)
	{
	 if(strcmp(m_station[i].name,m_login_client_name)) continue;
	 m_dvrnamectl.AddString(m_station[i].dvrname);
	}
}

void CChannelMap::OnSelchangedvrname() 
{
	int index=m_dvrnamectl.GetCurSel();
	if (index!=CB_ERR)
	{
		m_dvrnamectl.GetLBText(index,m_dvrname);
	}
	for(int m=0;m<m_file_length1;m++)
	{
	   if(strcmp(m_station[m].name,m_login_client_name)) continue;
       if(!strcmp(m_station[m].dvrname,m_dvrname)) 
	   {
		   m_ip.Format(m_station[m].ip);
		   m_port=m_station[m].port;
		   m_loginuser.Format(m_station[m].logindvrname);
	       m_loginpass.Format(m_station[m].logindvrpass);	   
	   }
	}
	UpdateData(false);
}
void CChannelMap::OnSetfocuswindow()
{
	UpdateData(true);
	char dc[10];
	m_windowctl.ResetContent();
	if(m_dvrname.IsEmpty()) return;
	for(int i=1;i<=16;i++)
	{
	   m_windowctl.InsertString(i-1,itoa(i,dc,10));
	}
}
void CChannelMap::OnSetfocuschannel()
{
    UpdateData(true);
	m_channelctl.ResetContent();
	if(m_dvrname.IsEmpty()) return;
    int m_nub = get_chnls(m_dvrname);
    if(!m_nub) m_nub=16;
    char dc[10];
	for(int i=1;i<=m_nub; i++)
	{
	  if(i<=m_nub) m_channelctl.AddString(itoa(i,dc,10));
	}
	m_channelctl.AddString("All");

    for(int k=0;k<m_file_length;k++)
	{
	   if(strcmp(m_machine[k].name,m_login_client_name)) continue;  
       if(!strcmp(m_machine[k].scene_name,m_setup_name)) 
	   { 
		  if(!strcmp(m_machine[k].dvrname,m_dvrname))
		  {
		   int index=m_channelctl.FindString(-1,itoa(m_machine[k].channel,dc,10));
		   m_channelctl.DeleteString(index);
		  }
	   }
	}
}
void CChannelMap::OnSetfocussetup()
{
	Cfileoperation <Scene_set_up> *m_fileoperation;
    m_scene_length=m_fileoperation->openfile(m_scene_setup_directory,"ab+",m_scene);

    m_setup_namectl.ResetContent();
	for(int k=0;k<m_scene_length;k++)
	{
	  if(!strcmp(m_scene[k].name,m_login_client_name))
	  m_setup_namectl.AddString(m_scene[k].scene_name);
	}	
}
void CChannelMap::OnSelchangesetup()
{
	UpdateData(true);
    int index=m_setup_namectl.GetCurSel();
	if (index!=CB_ERR)
	{
    	m_setup_namectl.GetLBText(index,m_setup_name);
	}
    dbgrid(m_setup_name);
}

void CChannelMap::OnClickMsflexgrid1() 
{
	long m_row=m_dbgrid.GetRowSel();
	m_setup_name=m_dbgrid.GetTextMatrix(m_row,1);
	m_window=m_dbgrid.GetTextMatrix(m_row,2);
	m_dvrname=m_dbgrid.GetTextMatrix(m_row,3);
	m_ip=m_dbgrid.GetTextMatrix(m_row,4);
    m_channel=m_dbgrid.GetTextMatrix(m_row,5);
	m_connect=m_dbgrid.GetTextMatrix(m_row,6);
	m_nettype=m_dbgrid.GetTextMatrix(m_row,7);
	UpdateData(false);
}
bool CChannelMap::check_if()
{
  for(int i=0;i<=m_file_length;i++)
  {
     if(!strcmp(m_machine[i].name,m_login_client_name)&&!strcmp(m_machine[i].scene_name,m_setup_name))
	 {
		 //if(m_machine[i].window==atoi(m_window))  return false;
		 if(!strcmp(m_machine[i].dvrname,m_dvrname))
			 if(m_machine[i].channel==atoi(m_channel))
			 {
				 return false;
			 }
	 }
  }
  return true;
}

bool CChannelMap::check_add()
{
  for(int i=0;i<m_file_length;i++)
  {
     if(!strcmp(m_machine[i].name,m_login_client_name)&&!strcmp(m_machine[i].scene_name,m_setup_name))
	 {
		 if(!strcmp(m_machine[i].dvrname,m_dvrname))
		 if(m_machine[i].channel==m_machine[m_file_length].channel)
		 {
				 return false;
		 }
	 }
  }
  return true;
}
bool CChannelMap::legal_name_add(CString m_scene_name, CString m_dvrname)
{
	for(int k=0;k<m_scene_length;k++)
	{
	  if(!strcmp(m_scene[k].name,m_login_client_name) && !strcmp(m_scene[k].scene_name, m_scene_name))
	  {
	     for(int m=0;m<m_file_length1;m++)
		 {
	         if(!strcmp(m_station[m].name,m_login_client_name) && !strcmp(m_station[m].dvrname,m_dvrname))
				 return true;
		 }
	  }
	}
    return false;
}
void CChannelMap::Onadd() 
{
	char dc[10];
	UpdateData(true);
	if(m_setup_name.IsEmpty()||m_dvrname.IsEmpty()||m_channel.IsEmpty()||m_window.IsEmpty())
		return;

	Openfile();
	if(!check_if())
	{
		AfxMessageBox(IDS_SAME_VALUE);
		return;
	}
	if(!legal_name_add(m_setup_name, m_dvrname))
	{
	    AfxMessageBox(IDS_LAWLESS_DATA);
		return;
	}

	for(int m=0;m<m_file_length1;m++)
	{
	   if(strcmp(m_station[m].name,m_login_client_name)) continue;
       if(!strcmp(m_station[m].dvrname,m_dvrname)) 
	   {
		   m_ip.Format(m_station[m].ip);
		   m_port=m_station[m].port;
		   m_loginuser.Format(m_station[m].logindvrname);
	       m_loginpass.Format(m_station[m].logindvrpass);	   
	   }
	}

	int m_nub=0;
	
	if(!strcmp(m_channel,"All"))
	{
		if(get_chnls(m_dvrname)) m_nub=get_chnls(m_dvrname);
	    else m_nub=9;
		for(int i=0 ; i<m_nub; i++)
			addfile(itoa(i+1, dc,10));
	}
	else 
	{
		if(atoi(m_channel) > get_chnls(m_dvrname))
		{
			AfxMessageBox("通道号超过主机通道数");
			m_channel = "";
			UpdateData(FALSE);
			return;
		}
		addfile(m_channel);
	}
	savefile();	
}

void CChannelMap::savefile()
{
	Cfileoperation <Machine_Channel_Setting> *m_fileoperation;
    m_fileoperation->savefilename(m_channel_window_directory,"wb+",m_machine,m_file_length);
	dbgrid(m_setup_name);
	//update();
}

void CChannelMap::Ondel() 
{
	UpdateData(true);
	Openfile();
	delfile(m_dvrname,m_setup_name,m_channel,m_window);
	savefile();	
	update();
}

void CChannelMap::Onupdate()
{
   UpdateData(true);
   for(int i=0;i<m_file_length;i++)
   {
     if(!strcmp(m_machine[i].name,m_login_client_name)&&!strcmp(m_machine[i].scene_name,m_setup_name))
	 {
		 if(!strcmp(m_machine[i].dvrname,m_dvrname))
		 {
		  if(m_machine[i].window==atoi(m_window)&&m_machine[i].channel==atoi(m_channel))  
		  if(!strcmp(m_connect,"YES")) m_machine[i].connect=TRUE;
			else m_machine[i].connect=FALSE;
		  if(!strcmp(m_nettype,"LAN")) m_machine[i].nettype=1;
			else m_machine[i].nettype=0;
		 }
	 }
   }
   savefile();	
}

void CChannelMap::update()
{
  	m_setup_name=_T("");
	m_window=_T("");
	m_dvrname=_T("");
	m_ip=_T("");
    m_channel=_T("");
	m_connect="YES";
	m_nettype="LAN";
	UpdateData(false);

}
void CChannelMap::addfile(CString m_chl)
{
	UpdateData(true);
	if(m_file_length >= 300)
	{
		AfxMessageBox(IDS_ADD_WINDOW_OVER);
		return;
	}
	strcpy(m_machine[m_file_length].name,m_login_client_name);
	strcpy(m_machine[m_file_length].scene_name,m_setup_name);
	strcpy(m_machine[m_file_length].dvrname,m_dvrname);
	strcpy(m_machine[m_file_length].ip,m_ip);
	m_machine[m_file_length].port = m_port;
	strcpy(m_machine[m_file_length].logindvrname,m_loginuser);
    strcpy(m_machine[m_file_length].logindvrpass,m_loginpass);
	m_machine[m_file_length].channel=atoi(m_chl);
	m_machine[m_file_length].window=atoi(m_window);
	if(!strcmp(m_connect,"YES")) m_machine[m_file_length].connect=TRUE;
	else m_machine[m_file_length].connect=FALSE;
	if(!strcmp(m_nettype,"LAN")) m_machine[m_file_length].nettype=1;
	else m_machine[m_file_length].nettype=0;
	if(check_add()) m_file_length++;
}
void CChannelMap::delfile(CString m_str1,CString m_str2,CString m_str3,CString m_str4)
{
    for(int m=0;m<m_file_length;m++)
	{
       if(!strcmp(m_machine[m].name,m_login_client_name)&&!strcmp(m_machine[m].dvrname,m_str1))
	   { 
		   if(!strcmp(m_machine[m].scene_name,m_str2))
		   if(m_machine[m].channel==atoi(m_str3)&&m_machine[m].window==atoi(m_str4))
			  strcpy(m_machine[m].name ,"");
	   }   
	}
}


BOOL CChannelMap::OnInitDialog() 
{
	CPropertyPage::OnInitDialog();
	init_label(m_lable1);
	init_label(m_lable2);
	init_label(m_lable3);
	init_label(m_lable4);
	init_label(m_lable5);
	init_label(m_lable6);
	init_label(m_lable7);
	m_connectctl.SetCurSel(1);
	m_nettypectl.SetCurSel(1);
	return TRUE;  // return TRUE unless you set the focus to a control
	              // EXCEPTION: OCX Property Pages should return FALSE
}
void CChannelMap::dbgrid(CString m_scene)
{
	Cfileoperation <Machine_Channel_Setting> *m_fileoperation;
    m_file_length=m_fileoperation->openfile(m_channel_window_directory,"ab+",m_machine,300);
	
    CString m_temstr;
	m_dbgrid.Clear();
    m_dbgrid.SetRow(0);
	m_dbgrid.SetCol(0);
	m_dbgrid.SetColAlignment(0 , 4);
	m_temstr.Format(IDS_NUMBER);
	m_dbgrid.SetText(m_temstr);
	m_dbgrid.SetCol(1);
	m_dbgrid.SetColAlignment(1 , 4);
	m_temstr.Format(IDS_SET_SCENE);
	m_dbgrid.SetText(m_temstr);
	m_dbgrid.SetCol(2);
	m_dbgrid.SetColAlignment(2 , 4);
	m_temstr.Format(IDS_WINDOW);
	m_dbgrid.SetText(m_temstr);
	m_dbgrid.SetCol(3);
	m_dbgrid.SetColAlignment(3 , 4);
	m_temstr.Format(IDS_DVR_NAME);
	m_dbgrid.SetText(m_temstr);
    m_dbgrid.SetCol(4);
	m_dbgrid.SetColAlignment(4 , 4);
	m_dbgrid.SetColWidth(4,1500);
	m_temstr.Format(IDS_DVR_IP);
	m_dbgrid.SetText(m_temstr);
	m_dbgrid.SetCol(5);
	m_dbgrid.SetColAlignment(5 , 4);
	m_temstr.Format(IDS_CHANNEL);
	m_dbgrid.SetText(m_temstr);
	m_dbgrid.SetCol(6);
	m_dbgrid.SetColAlignment(6 , 4);
	m_temstr.Format(IDS_DVR_CONNECT_OK);
	m_dbgrid.SetText(m_temstr);
	m_dbgrid.SetCol(7);
	m_dbgrid.SetColAlignment(7 , 4);
	m_temstr="网络状态";
	m_dbgrid.SetText(m_temstr);
	
	
	long m_row=0;
	for(int m=0;m<m_file_length;m++)
	{
	  if(strcmp(m_machine[m].name,m_login_client_name)) continue;
	  if(strcmp(m_machine[m].scene_name,m_scene)) continue;
	  else m_row++;
	  char m_dc[10];
	  if(m_row>19)
	  m_dbgrid.SetRows(m_row+1);
	  m_dbgrid.SetRow(m_row);
	  m_dbgrid.SetCol(0);
      m_dbgrid.SetText(itoa(m_row,m_dc,10));
	  m_dbgrid.SetCol(1);
      m_dbgrid.SetText(m_machine[m].scene_name);
      m_dbgrid.SetCol(2);
      m_dbgrid.SetText(itoa(m_machine[m].window,m_dc,10));
	  m_dbgrid.SetCol(3);
      m_dbgrid.SetText(m_machine[m].dvrname);
	  m_dbgrid.SetCol(4);
      m_dbgrid.SetText(m_machine[m].ip);
	  m_dbgrid.SetCol(5);
      m_dbgrid.SetText(itoa(m_machine[m].channel,m_dc,10));
	  m_dbgrid.SetCol(6);
	  if(m_machine[m].connect) m_dbgrid.SetText("YES");
	  else m_dbgrid.SetText("NO");
	  m_dbgrid.SetCol(7);
	  if(m_machine[m].nettype==1) m_dbgrid.SetText("LAN");
	  else m_dbgrid.SetText("Internet");
	}

}


HBRUSH CChannelMap::OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor) 
{
	HBRUSH hbr = CPropertyPage::OnCtlColor(pDC, pWnd, nCtlColor);
	
	if (nCtlColor==CTLCOLOR_DLG) 
	return (HBRUSH)m_brush .GetSafeHandle( ) ;
	return hbr;
}
HBRUSH CLoginSet::OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor) 
{
	HBRUSH hbr = CPropertyPage::OnCtlColor(pDC, pWnd, nCtlColor);
	
	if (nCtlColor==CTLCOLOR_DLG) 
	return (HBRUSH)m_brush .GetSafeHandle( ) ;
	return hbr;
}
HBRUSH CUserChangeI::OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor) 
{
	HBRUSH hbr = CPropertyPage::OnCtlColor(pDC, pWnd, nCtlColor);
	
	if (nCtlColor==CTLCOLOR_DLG) 
	return (HBRUSH)m_brush .GetSafeHandle( ) ;
	return hbr;
}
////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////


CSetUp::CSetUp() : CPropertyPage(CSetUp::IDD)
{
	//{{AFX_DATA_INIT(CSetUp)
		// NOTE: the ClassWizard will add member initialization here
	m_brush.CreateSolidBrush(RGB(117, 200, 146));
	//}}AFX_DATA_INIT
}

CSetUp::~CSetUp()
{
}

void CSetUp::DoDataExchange(CDataExchange* pDX)
{
	CPropertyPage::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CLoginSet)
	DDX_Control(pDX, ID_GROUP1, m_grp1);
	DDX_Control(pDX, IDC_lable2, m_lable2);
	DDX_Control(pDX, IDC_lable1, m_lable1);
    DDX_Control(pDX, IDC_del, m_del);
	DDX_Control(pDX, IDC_add, m_add);
	DDX_Control(pDX, IDC_update1, m_update);
	DDX_Control(pDX, IDC_MSFLEXGRID1, m_dbgrid);
	DDX_Text(pDX, IDC_setup_name, m_setup_name);