海康、大华、onvif相关插件及接口

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgAES.h

@@ -0,0 +1,56 @@
+#if !defined(AFX_DLGAES_H__BD7F5970_76EF_41B6_9AC0_64E13AC172B4__INCLUDED_)
+#define AFX_DLGAES_H__BD7F5970_76EF_41B6_9AC0_64E13AC172B4__INCLUDED_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif // _MSC_VER > 1000
+// DlgAES.h : header file
+//
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgAES dialog
+
+class CDlgAES : public CDialog
+{
+// Construction
+public:
+	CDlgAES(CWnd* pParent = NULL);   // standard constructor
+
+	LONG m_lUSerID;
+	DWORD m_dwDeviceIndex;
+
+// Dialog Data
+	//{{AFX_DATA(CDlgAES)
+	enum { IDD = IDD_DLG_AES };
+	CComboBox	m_comboState;
+	CString	m_csKey;
+	//}}AFX_DATA
+
+
+// Overrides
+	// ClassWizard generated virtual function overrides
+	//{{AFX_VIRTUAL(CDlgAES)
+	protected:
+	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
+	//}}AFX_VIRTUAL
+
+// Implementation
+protected:
+
+	// Generated message map functions
+	//{{AFX_MSG(CDlgAES)
+	afx_msg void OnButtonUpdateKey();
+	afx_msg void OnButtonSetSdkKey();
+	afx_msg void OnButtonSetState();
+	virtual BOOL OnInitDialog();
+	afx_msg void OnButtonGetState();
+	afx_msg void OnButtonExit();
+	afx_msg void OnBtnSetCodeKey();
+	//}}AFX_MSG
+	DECLARE_MESSAGE_MAP()
+};
+
+//{{AFX_INSERT_LOCATION}}
+// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
+
+#endif // !defined(AFX_DLGAES_H__BD7F5970_76EF_41B6_9AC0_64E13AC172B4__INCLUDED_)

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgAcsPhoneDoorRightCfg.cpp

@@ -0,0 +1,585 @@
+// DlgAcsPhoneDoorRightCfg.cpp : implementation file
+//
+
+#include "stdafx.h"
+#include "clientdemo.h"
+#include "DlgAcsPhoneDoorRightCfg.h"
+
+#ifdef _DEBUG
+#define new DEBUG_NEW
+#undef THIS_FILE
+static char THIS_FILE[] = __FILE__;
+#endif
+
+/////////////////////////////////////////////////////////////////////////////
+// DlgAcsPhoneDoorRightCfg dialog
+
+
+DlgAcsPhoneDoorRightCfg::DlgAcsPhoneDoorRightCfg(CWnd* pParent /*=NULL*/)
+	: CDialog(DlgAcsPhoneDoorRightCfg::IDD, pParent)
+{
+	//{{AFX_DATA_INIT(DlgAcsPhoneDoorRightCfg)
+	
+	//}}AFX_DATA_INIT
+}
+
+
+void DlgAcsPhoneDoorRightCfg::DoDataExchange(CDataExchange* pDX)
+{
+	CDialog::DoDataExchange(pDX);
+	//{{AFX_DATA_MAP(DlgAcsPhoneDoorRightCfg)
+    DDX_Control(pDX, IDC_TREE_OPEN, m_treeOpen);
+    DDX_Control(pDX, IDC_TREE_CLOSE, m_treeClose);
+    DDX_Control(pDX, IDC_TREE_NORMAL_OPEN, m_treeNormalOpen);
+    DDX_Control(pDX, IDC_TREE_NORMAL_CLOSE, m_treeNormalClose);
+    DDX_Control(pDX, IDC_TREE_ARM, m_treeArm);
+    DDX_Control(pDX, IDC_TREE_DISARM, m_treeDisArm);
+    DDX_Control(pDX, IDC_COMBO_CHANNEL, m_comboChannel);
+	//}}AFX_DATA_MAP
+}
+
+
+BEGIN_MESSAGE_MAP(DlgAcsPhoneDoorRightCfg, CDialog)
+	//{{AFX_MSG_MAP(DlgAcsPhoneDoorRightCfg)
+    ON_BN_CLICKED(IDC_BUTTON_SET, OnBtnSet)
+    ON_BN_CLICKED(IDC_BUTTON_GET, OnBtnGet)
+    ON_NOTIFY(NM_CLICK, IDC_TREE_OPEN, OnClickTreeOpen)
+    ON_NOTIFY(NM_CLICK, IDC_TREE_CLOSE, OnClickTreeClose)
+    ON_NOTIFY(NM_CLICK, IDC_TREE_NORMAL_OPEN, OnClickTreeNormalOpen)
+    ON_NOTIFY(NM_CLICK, IDC_TREE_NORMAL_CLOSE, OnClickTreeNormalClose)
+    ON_NOTIFY(NM_CLICK, IDC_TREE_ARM, OnClickTreeArm)
+	ON_NOTIFY(NM_CLICK, IDC_TREE_DISARM, OnClickTreeDisArm)
+	//}}AFX_MSG_MAP
+END_MESSAGE_MAP()
+
+/////////////////////////////////////////////////////////////////////////////
+// DlgAcsPhoneDoorRightCfg message handlers
+
+BOOL DlgAcsPhoneDoorRightCfg::OnInitDialog() 
+{
+	CDialog::OnInitDialog();
+	
+	// TODO: Add extra initialization here
+    m_iDeviceIndex = g_pMainDlg->GetCurDeviceIndex();
+    m_lUserID = g_struDeviceInfo[m_iDeviceIndex].lLoginID;
+
+    CString csStr;
+    for (int i = 0; i < NET_SDK_MAX_ALLOWLIST_NUM_32; i++)
+    {
+        csStr.Format("%d",i+1);
+        m_comboChannel.InsertString(i, csStr);
+	}
+    
+    CreateTree();
+    return TRUE;  // return TRUE unless you set the focus to a control
+	              // EXCEPTION: OCX Property Pages should return FALSE
+}
+
+void DlgAcsPhoneDoorRightCfg::OnBtnSet() 
+{
+	// TODO: Add your control notification handler code here
+	UpdateData(TRUE);
+	GetTreeSel(); 
+    int iChannel = m_comboChannel.GetCurSel() + 1;
+    char szLan[1024];
+
+    if (!NET_DVR_SetDVRConfig(m_lUserID, NET_DVR_SET_PHONE_DOOR_RIGHT_CFG, iChannel, &m_struPhoneDoorRightCfg, sizeof(m_struPhoneDoorRightCfg)))
+    {
+        g_pMainDlg->AddLog(m_iDeviceIndex, OPERATION_FAIL_T, "NET_DVR_SET_PHONE_DOOR_RIGHT_CFG Failed");
+        g_StringLanType(szLan, "设置手机关联门权限参数失败", "Set phone door right cfg Failed");
+		MessageBox(szLan);
+    }
+    else
+    {
+        g_pMainDlg->AddLog(m_iDeviceIndex, OPERATION_SUCC_T, "NET_DVR_SET_PHONE_DOOR_RIGHT_CFG SUCC");
+    }
+}
+
+void DlgAcsPhoneDoorRightCfg::OnBtnGet() 
+{
+	// TODO: Add your control notification handler code here
+	int iChannel = m_comboChannel.GetCurSel() + 1;
+    DWORD dwReturned = 0;
+    char szLan[1024];
+    
+    if (!NET_DVR_GetDVRConfig(m_lUserID, NET_DVR_GET_PHONE_DOOR_RIGHT_CFG, iChannel, &m_struPhoneDoorRightCfg, sizeof(m_struPhoneDoorRightCfg), &dwReturned))
+    {
+        g_pMainDlg->AddLog(m_iDeviceIndex, OPERATION_FAIL_T, "NET_DVR_GET_PHONE_DOOR_RIGHT_CFG Failed");
+        g_StringLanType(szLan, "获取手机关联门权限参数失败", "Get phone door right cfg Failed");
+		MessageBox(szLan);
+    }
+    else
+    {
+        g_pMainDlg->AddLog(m_iDeviceIndex, OPERATION_SUCC_T, "NET_DVR_GET_PHONE_DOOR_RIGHT_CFG SUCC");
+        UpdateData(FALSE); 
+        CreateTree();
+    }
+}
+
+void DlgAcsPhoneDoorRightCfg::CreateTree()
+{
+    CString strTemp =_T("");
+    CString strChanTmp = _T("");
+    int i = 0;
+    m_treeOpen.DeleteAllItems();
+    m_treeClose.DeleteAllItems();
+    
+    HTREEITEM hChanItem = NULL;
+    HTREEITEM hFirstItem = NULL;
+       
+    for (i = 0; i < sizeof(m_struPhoneDoorRightCfg.byOpenRight); i++)
+    {
+        strTemp.Format("Door %d", i + 1);
+        hChanItem = m_treeOpen.InsertItem(strTemp, 0, 0, TVI_ROOT);
+        if (hFirstItem == NULL)
+        {
+            hFirstItem = hChanItem;
+        }
+
+        m_treeOpen.SetItemData(hChanItem, i);
+
+        if (m_struPhoneDoorRightCfg.byOpenRight[i])
+        {
+            m_treeOpen.SetCheck(hChanItem, TRUE);
+        }
+    }
+
+    m_treeOpen.SelectItem(hFirstItem);
+    m_treeOpen.Expand(m_treeOpen.GetRootItem(), TVE_EXPAND);
+
+    hChanItem = NULL;
+    hFirstItem = NULL;
+
+    for (i = 0; i < sizeof(m_struPhoneDoorRightCfg.byCloseRight); i++)
+    {
+        strTemp.Format("Door %d", i + 1);
+        hChanItem = m_treeClose.InsertItem(strTemp, 0, 0, TVI_ROOT);
+        if (hFirstItem == NULL)
+        {
+            hFirstItem = hChanItem;
+        }
+
+        m_treeClose.SetItemData(hChanItem, i);
+
+        if (m_struPhoneDoorRightCfg.byCloseRight[i])
+        {
+            m_treeClose.SetCheck(hChanItem, TRUE);
+        }
+    }
+
+    m_treeClose.SelectItem(hFirstItem);
+	m_treeClose.Expand(m_treeClose.GetRootItem(),TVE_EXPAND);
+
+    hChanItem = NULL;
+    hFirstItem = NULL;
+    m_treeNormalOpen.DeleteAllItems();    
+    for (i = 0; i < sizeof(m_struPhoneDoorRightCfg.byNormalOpenRight); i++)
+    {
+        strTemp.Format("Door %d", i + 1);
+        hChanItem = m_treeNormalOpen.InsertItem(strTemp, 0, 0, TVI_ROOT);
+        if (hFirstItem == NULL)
+        {
+            hFirstItem = hChanItem;
+        }
+        
+        m_treeNormalOpen.SetItemData(hChanItem, i);
+        
+        if (m_struPhoneDoorRightCfg.byNormalOpenRight[i])
+        {
+            m_treeNormalOpen.SetCheck(hChanItem, TRUE);
+        }
+    }
+    m_treeNormalOpen.SelectItem(hFirstItem);
+	m_treeNormalOpen.Expand(m_treeNormalOpen.GetRootItem(),TVE_EXPAND);
+
+
+    hChanItem = NULL;
+    hFirstItem = NULL;
+    m_treeNormalClose.DeleteAllItems();    
+    for (i = 0; i < sizeof(m_struPhoneDoorRightCfg.byNormalCloseRight); i++)
+    {
+        strTemp.Format("Door %d", i + 1);
+        hChanItem = m_treeNormalClose.InsertItem(strTemp, 0, 0, TVI_ROOT);
+        if (hFirstItem == NULL)
+        {
+            hFirstItem = hChanItem;
+        }
+        
+        m_treeNormalClose.SetItemData(hChanItem, i);
+        
+        if (m_struPhoneDoorRightCfg.byNormalCloseRight[i])
+        {
+            m_treeNormalClose.SetCheck(hChanItem, TRUE);
+        }
+    }
+    m_treeNormalClose.SelectItem(hFirstItem);
+	m_treeNormalClose.Expand(m_treeNormalClose.GetRootItem(),TVE_EXPAND);
+
+    hChanItem = NULL;
+    hFirstItem = NULL;
+    m_treeArm.DeleteAllItems();    
+    for (i = 0; i < sizeof(m_struPhoneDoorRightCfg.byArmRight); i++)
+    {
+        strTemp.Format("AlarmIn %d", i + 1);
+        hChanItem = m_treeArm.InsertItem(strTemp, 0, 0, TVI_ROOT);
+        if (hFirstItem == NULL)
+        {
+            hFirstItem = hChanItem;
+        }
+        
+        m_treeArm.SetItemData(hChanItem, i);
+        
+        if (m_struPhoneDoorRightCfg.byArmRight[i])
+        {
+            m_treeArm.SetCheck(hChanItem, TRUE);
+        }
+    }
+    m_treeArm.SelectItem(hFirstItem);
+	m_treeArm.Expand(m_treeArm.GetRootItem(),TVE_EXPAND);
+
+    hChanItem = NULL;
+    hFirstItem = NULL;
+    m_treeDisArm.DeleteAllItems();    
+    for (i = 0; i < sizeof(m_struPhoneDoorRightCfg.byDisarmRight); i++)
+    {
+        strTemp.Format("AlarmIn %d", i + 1);
+        hChanItem = m_treeDisArm.InsertItem(strTemp, 0, 0, TVI_ROOT);
+        if (hFirstItem == NULL)
+        {
+            hFirstItem = hChanItem;
+        }
+        
+        m_treeDisArm.SetItemData(hChanItem, i);
+        
+        if (m_struPhoneDoorRightCfg.byDisarmRight[i])
+        {
+            m_treeDisArm.SetCheck(hChanItem, TRUE);
+        }
+    }
+    m_treeDisArm.SelectItem(hFirstItem);
+	m_treeDisArm.Expand(m_treeDisArm.GetRootItem(),TVE_EXPAND);
+}
+
+void DlgAcsPhoneDoorRightCfg::GetTreeSel()
+{
+	UpdateData(TRUE); 
+	memset(&m_struPhoneDoorRightCfg, 0 , sizeof(m_struPhoneDoorRightCfg));
+	m_struPhoneDoorRightCfg.dwSize = sizeof(m_struPhoneDoorRightCfg);
+
+    int i = 0; 
+	HTREEITEM hTreeItem;
+
+	BOOL bCheck;
+	DWORD dwIndex;
+	DWORD dwCount = 0; 
+	CTreeCtrl *treeCtr = &m_treeOpen; 
+    dwCount = m_treeOpen.GetCount(); 
+	hTreeItem = m_treeOpen.GetRootItem();
+
+    for ( i=0; i<dwCount; i++)
+    {
+		bCheck = treeCtr->GetCheck(hTreeItem);
+		dwIndex = treeCtr->GetItemData(hTreeItem);
+		m_struPhoneDoorRightCfg.byOpenRight[dwIndex] = bCheck;
+		hTreeItem = treeCtr->GetNextSiblingItem(hTreeItem); 
+    }
+
+	treeCtr = &m_treeClose;
+	hTreeItem = m_treeClose.GetRootItem();
+	dwCount = m_treeClose.GetCount(); 
+    for ( i=0; i<dwCount; i++)
+    {
+		bCheck = treeCtr->GetCheck(hTreeItem);
+		dwIndex = treeCtr->GetItemData(hTreeItem);
+		m_struPhoneDoorRightCfg.byCloseRight[dwIndex] = bCheck;
+		hTreeItem = treeCtr->GetNextSiblingItem(hTreeItem); 
+    }
+
+	treeCtr = &m_treeNormalOpen;
+	hTreeItem = m_treeNormalOpen.GetRootItem();
+	dwCount = m_treeNormalOpen.GetCount(); 
+    for ( i=0; i<dwCount; i++)
+    {
+		bCheck = treeCtr->GetCheck(hTreeItem);
+		dwIndex = treeCtr->GetItemData(hTreeItem);
+		m_struPhoneDoorRightCfg.byNormalOpenRight[dwIndex] = bCheck;
+		hTreeItem = treeCtr->GetNextSiblingItem(hTreeItem); 
+    }
+
+	treeCtr = &m_treeNormalClose;
+	hTreeItem = m_treeNormalClose.GetRootItem();
+	dwCount = m_treeNormalClose.GetCount(); 
+    for ( i=0; i<dwCount; i++)
+    {
+		bCheck = treeCtr->GetCheck(hTreeItem);
+		dwIndex = treeCtr->GetItemData(hTreeItem);
+		m_struPhoneDoorRightCfg.byNormalCloseRight[dwIndex] = bCheck;
+		hTreeItem = treeCtr->GetNextSiblingItem(hTreeItem); 
+    }
+
+    treeCtr = &m_treeArm;
+    hTreeItem = m_treeArm.GetRootItem();
+    dwCount = m_treeArm.GetCount(); 
+    for ( i=0; i<dwCount; i++)
+    {
+        bCheck = treeCtr->GetCheck(hTreeItem);
+        dwIndex = treeCtr->GetItemData(hTreeItem);
+        m_struPhoneDoorRightCfg.byArmRight[dwIndex] = bCheck;
+        hTreeItem = treeCtr->GetNextSiblingItem(hTreeItem); 
+    }
+
+    treeCtr = &m_treeDisArm;
+    hTreeItem = m_treeDisArm.GetRootItem();
+    dwCount = m_treeDisArm.GetCount(); 
+    for ( i=0; i<dwCount; i++)
+    {
+        bCheck = treeCtr->GetCheck(hTreeItem);
+        dwIndex = treeCtr->GetItemData(hTreeItem);
+        m_struPhoneDoorRightCfg.byDisarmRight[dwIndex] = bCheck;
+        hTreeItem = treeCtr->GetNextSiblingItem(hTreeItem); 
+    }
+} 
+
+void DlgAcsPhoneDoorRightCfg::OnClickTreeOpen(NMHDR* pNMHDR, LRESULT* pResult) 
+{
+	// TODO: Add your control notification handler code here
+    UpdateData(TRUE);
+
+    CPoint pt(0,0);
+    CRect rc(0,0,0,0);
+    GetCursorPos(&pt);
+    m_treeOpen.ScreenToClient(&pt);
+    m_treeOpen.GetWindowRect(&rc);
+    m_treeOpen.ScreenToClient(&rc);
+    pt.x = pt.x - rc.left;
+    pt.y = pt.y - rc.top;
+    
+    UINT uFlag = 0;
+    HTREEITEM hSelect = m_treeOpen.HitTest(pt, &uFlag);
+    
+    if (NULL == hSelect) 
+    {
+        return;
+    }
+    m_treeOpen.SelectItem(hSelect);
+    DWORD dwIndex = m_treeOpen.GetItemData(hSelect);
+    BOOL bCheck = m_treeOpen.GetCheck(hSelect);
+    m_treeOpen.SetCheck(hSelect, !bCheck);
+    m_struPhoneDoorRightCfg.byOpenRight[dwIndex] = !bCheck;
+    //switch checkbox status on click
+    if (uFlag & LVHT_ONITEM ||uFlag & LVHT_TOLEFT || uFlag & LVHT_ONITEMLABEL)//LVHT_TOLEFT)
+    {
+        m_treeOpen.SetCheck(hSelect, !bCheck);
+        m_struPhoneDoorRightCfg.byOpenRight[dwIndex] = !bCheck;
+    }
+    else
+    {
+        m_treeOpen.SetCheck(hSelect, bCheck);
+        m_struPhoneDoorRightCfg.byOpenRight[dwIndex] = bCheck;
+	}
+    UpdateData(FALSE); 
+	*pResult = 0;
+}
+
+void DlgAcsPhoneDoorRightCfg::OnClickTreeClose(NMHDR* pNMHDR, LRESULT* pResult) 
+{
+	// TODO: Add your control notification handler code here
+    UpdateData(TRUE);
+    CPoint pt(0,0);
+    CRect rc(0,0,0,0);
+    GetCursorPos(&pt);
+    m_treeClose.ScreenToClient(&pt);
+    m_treeClose.GetWindowRect(&rc);
+    m_treeClose.ScreenToClient(&rc);
+    pt.x = pt.x - rc.left;
+    pt.y = pt.y - rc.top;
+    
+    UINT uFlag = 0;
+    HTREEITEM hSelect = m_treeClose.HitTest(pt, &uFlag);
+    
+    if (NULL == hSelect) 
+    {
+        return;
+    }
+    m_treeClose.SelectItem(hSelect);
+    DWORD dwIndex = m_treeClose.GetItemData(hSelect);
+    BOOL bCheck = m_treeClose.GetCheck(hSelect);
+    m_treeClose.SetCheck(hSelect, !bCheck);
+    m_struPhoneDoorRightCfg.byCloseRight[dwIndex] = !bCheck;
+    //switch checkbox status on click
+    if (uFlag & LVHT_ONITEM ||uFlag & LVHT_TOLEFT || uFlag & LVHT_ONITEMLABEL)
+    {
+        m_treeClose.SetCheck(hSelect, !bCheck);
+        m_struPhoneDoorRightCfg.byCloseRight[dwIndex] = !bCheck;
+    }
+    else
+    {
+        m_treeClose.SetCheck(hSelect, bCheck);
+        m_struPhoneDoorRightCfg.byCloseRight[dwIndex] = bCheck;
+	}
+    UpdateData(FALSE);
+	*pResult = 0;
+}
+
+void DlgAcsPhoneDoorRightCfg::OnClickTreeNormalOpen(NMHDR* pNMHDR, LRESULT* pResult) 
+{
+    // TODO: Add your control notification handler code here
+    UpdateData(TRUE);
+    CPoint pt(0,0);
+    CRect rc(0,0,0,0);
+    GetCursorPos(&pt);
+    m_treeNormalOpen.ScreenToClient(&pt);   
+    m_treeNormalOpen.GetWindowRect(&rc);
+    m_treeNormalOpen.ScreenToClient(&rc);
+    pt.x = pt.x - rc.left;
+    pt.y = pt.y - rc.top;
+    
+    UINT uFlag = 0;
+    HTREEITEM hSelect = m_treeNormalOpen.HitTest(pt, &uFlag);
+    
+    if (NULL == hSelect) 
+    {
+        return;
+    }
+    m_treeNormalOpen.SelectItem(hSelect);
+    DWORD dwIndex = m_treeNormalOpen.GetItemData(hSelect);
+    BOOL bCheck = m_treeNormalOpen.GetCheck(hSelect);
+    m_treeNormalOpen.SetCheck(hSelect, !bCheck);
+    m_struPhoneDoorRightCfg.byNormalOpenRight[dwIndex] = !bCheck;
+    //switch checkbox status on click
+    if (uFlag & LVHT_ONITEM ||uFlag & LVHT_TOLEFT || uFlag & LVHT_ONITEMLABEL)
+    {
+        m_treeNormalOpen.SetCheck(hSelect, !bCheck);
+        m_struPhoneDoorRightCfg.byNormalOpenRight[dwIndex] = !bCheck;
+    }
+    else
+    {
+        m_treeNormalOpen.SetCheck(hSelect, bCheck);
+        m_struPhoneDoorRightCfg.byNormalOpenRight[dwIndex] = bCheck;
+    }
+    UpdateData(FALSE);
+    *pResult = 0;
+}
+
+void DlgAcsPhoneDoorRightCfg::OnClickTreeNormalClose(NMHDR* pNMHDR, LRESULT* pResult) 
+{
+    // TODO: Add your control notification handler code here
+    UpdateData(TRUE);
+    CPoint pt(0,0);
+    CRect rc(0,0,0,0);
+    GetCursorPos(&pt);
+    m_treeNormalClose.ScreenToClient(&pt);   
+    m_treeNormalClose.GetWindowRect(&rc);
+    m_treeNormalClose.ScreenToClient(&rc);
+    pt.x = pt.x - rc.left;
+    pt.y = pt.y - rc.top;
+    
+    UINT uFlag = 0;
+    HTREEITEM hSelect = m_treeNormalClose.HitTest(pt, &uFlag);
+    
+    if (NULL == hSelect) 
+    {
+        return;
+    }
+    m_treeNormalClose.SelectItem(hSelect);
+    DWORD dwIndex = m_treeNormalClose.GetItemData(hSelect);
+    BOOL bCheck = m_treeNormalClose.GetCheck(hSelect);
+    m_treeNormalClose.SetCheck(hSelect, !bCheck);
+    m_struPhoneDoorRightCfg.byNormalCloseRight[dwIndex] = !bCheck;
+    //switch checkbox status on click
+    if (uFlag & LVHT_ONITEM ||uFlag & LVHT_TOLEFT || uFlag & LVHT_ONITEMLABEL)
+    {
+        m_treeNormalClose.SetCheck(hSelect, !bCheck);
+        m_struPhoneDoorRightCfg.byNormalCloseRight[dwIndex] = !bCheck;
+    }
+    else
+    {
+        m_treeNormalClose.SetCheck(hSelect, bCheck);
+        m_struPhoneDoorRightCfg.byNormalCloseRight[dwIndex] = bCheck;
+    }
+    UpdateData(FALSE);
+    *pResult = 0;
+}
+
+void DlgAcsPhoneDoorRightCfg::OnClickTreeArm(NMHDR* pNMHDR, LRESULT* pResult) 
+{
+	// TODO: Add your control notification handler code here
+	UpdateData(TRUE);
+    CPoint pt(0,0);
+    CRect rc(0,0,0,0);
+    GetCursorPos(&pt);
+    m_treeArm.ScreenToClient(&pt);   
+    m_treeArm.GetWindowRect(&rc);
+    m_treeArm.ScreenToClient(&rc);
+    pt.x = pt.x - rc.left;
+    pt.y = pt.y - rc.top;
+    
+    UINT uFlag = 0;
+    HTREEITEM hSelect = m_treeArm.HitTest(pt, &uFlag);
+    
+    if (NULL == hSelect) 
+    {
+        return;
+    }
+    m_treeArm.SelectItem(hSelect);
+    DWORD dwIndex = m_treeArm.GetItemData(hSelect);
+    BOOL bCheck = m_treeArm.GetCheck(hSelect);
+    m_treeArm.SetCheck(hSelect, !bCheck);
+    m_struPhoneDoorRightCfg.byArmRight[dwIndex] = !bCheck;
+    //switch checkbox status on click
+    if (uFlag & LVHT_ONITEM ||uFlag & LVHT_TOLEFT || uFlag & LVHT_ONITEMLABEL)
+    {
+		m_treeArm.SetCheck(hSelect, !bCheck);
+        m_struPhoneDoorRightCfg.byArmRight[dwIndex] = !bCheck;
+    }
+    else
+    {
+        m_treeArm.SetCheck(hSelect, bCheck);
+        m_struPhoneDoorRightCfg.byArmRight[dwIndex] = bCheck;
+	}
+    UpdateData(FALSE);
+	*pResult = 0;
+}
+
+void DlgAcsPhoneDoorRightCfg::OnClickTreeDisArm(NMHDR* pNMHDR, LRESULT* pResult) 
+{
+	// TODO: Add your control notification handler code here
+    UpdateData(TRUE);
+    CPoint pt(0,0);
+    CRect rc(0,0,0,0);
+    GetCursorPos(&pt);
+    m_treeDisArm.ScreenToClient(&pt);
+    m_treeDisArm.GetWindowRect(&rc);
+    m_treeDisArm.ScreenToClient(&rc);
+    pt.x = pt.x - rc.left;
+    pt.y = pt.y - rc.top;
+
+    UINT uFlag = 0;
+    HTREEITEM hSelect = m_treeDisArm.HitTest(pt, &uFlag);
+
+    if (NULL == hSelect) 
+    {
+        return;
+    }
+    m_treeDisArm.SelectItem(hSelect);
+    DWORD dwIndex = m_treeDisArm.GetItemData(hSelect);
+    BOOL bCheck = m_treeDisArm.GetCheck(hSelect);
+    m_treeDisArm.SetCheck(hSelect, !bCheck);
+    m_struPhoneDoorRightCfg.byDisarmRight[dwIndex] = !bCheck;
+
+    //switch checkbox status on click
+    if (uFlag & LVHT_ONITEM ||uFlag & LVHT_TOLEFT || uFlag & LVHT_ONITEMLABEL )
+    {
+        m_treeDisArm.SetCheck(hSelect, !bCheck);
+        m_struPhoneDoorRightCfg.byDisarmRight[dwIndex] = !bCheck;
+    }
+    else
+    {
+        m_treeDisArm.SetCheck(hSelect, bCheck);
+        m_struPhoneDoorRightCfg.byDisarmRight[dwIndex] = bCheck;
+    }	
+    UpdateData(FALSE);
+	*pResult = 0;
+}
+
+

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgAcsXmlDiffusion.h

@@ -0,0 +1,36 @@
+#pragma once
+
+
+// CDlgAcsXmlDiffusion 对话框
+
+class CDlgAcsXmlDiffusion : public CDialog
+{
+	DECLARE_DYNAMIC(CDlgAcsXmlDiffusion)
+
+public:
+	CDlgAcsXmlDiffusion(CWnd* pParent = NULL);   // 标准构造函数
+	virtual ~CDlgAcsXmlDiffusion();
+    BOOL OnInitDialog();
+    void GetCommandStrAndInputParam();
+
+// 对话框数据
+	enum { IDD = IDD_DLG_ACS_XML_DIFFUSION };
+
+protected:
+	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV 支持
+
+	DECLARE_MESSAGE_MAP()
+public:
+    int m_iDevIndex;
+    long m_lServerID;
+    CComboBox m_cmbOperateType;
+    CComboBox m_cmbCommand;
+    CString	m_csCommandStr;
+    CString	m_csInputParam;
+    CString	m_csOutputParam;
+    afx_msg void OnBnClickedBtnGet();
+    afx_msg void OnBnClickedBtnExit();
+    afx_msg void OnCbnSelchangeComboOperateType();
+    afx_msg void OnCbnSelchangeComboCommand();
+    BOOL m_bJsonFormat;
+};

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgAlarmCenterNetCfg.h

@@ -0,0 +1,64 @@
+#if !defined(AFX_DLGALARMCENTERNETCFG_H__896698C9_0E6B_4A5F_AC94_492A8C398951__INCLUDED_)
+#define AFX_DLGALARMCENTERNETCFG_H__896698C9_0E6B_4A5F_AC94_492A8C398951__INCLUDED_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif // _MSC_VER > 1000
+// DlgAlarmCenterNetCfg.h : header file
+//
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgAlarmCenterNetCfg dialog
+
+class CDlgAlarmCenterNetCfg : public CDialog
+{
+// Construction
+public:
+	CDlgAlarmCenterNetCfg(CWnd* pParent = NULL);   // standard constructor
+
+	int m_iDeviceIndex;
+	LONG m_lUserID;
+
+// Dialog Data
+	//{{AFX_DATA(CDlgAlarmCenterNetCfg)
+	enum { IDD = IDD_DLG_ALARM_CENTER_NETCFG };
+	CString	m_csAuxiliaryAddr;
+	int		m_iAuxiliaryPort;
+	CString	m_csHostAddr1;
+	short	m_wHostPort1;
+	CString	m_csHostAddr2;
+	short	m_wHostPort2;
+	CString	m_csHostAddr3;
+	short	m_wHostPort3;
+	CString	m_csHostAddr4;
+	short	m_wHostPort4;
+	CString	m_csHostAddr5;
+	short	m_wHostPort5;
+	CString	m_csHostAddr6;
+	short	m_wHostPort6;
+	//}}AFX_DATA
+
+
+// Overrides
+	// ClassWizard generated virtual function overrides
+	//{{AFX_VIRTUAL(CDlgAlarmCenterNetCfg)
+	protected:
+	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
+	//}}AFX_VIRTUAL
+
+// Implementation
+protected:
+
+	// Generated message map functions
+	//{{AFX_MSG(CDlgAlarmCenterNetCfg)
+	afx_msg void OnBtnGet();
+	afx_msg void OnBtnSet();
+	virtual BOOL OnInitDialog();
+	//}}AFX_MSG
+	DECLARE_MESSAGE_MAP()
+};
+
+//{{AFX_INSERT_LOCATION}}
+// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
+
+#endif // !defined(AFX_DLGALARMCENTERNETCFG_H__896698C9_0E6B_4A5F_AC94_492A8C398951__INCLUDED_)

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgAlarmExceptionHandle.h

@@ -0,0 +1,61 @@
+#if !defined(AFX_DLGALARMEXCEPTIONHANDLE_H__CBF9FED7_F89D_404E_AA2E_2D241A8CAF12__INCLUDED_)
+#define AFX_DLGALARMEXCEPTIONHANDLE_H__CBF9FED7_F89D_404E_AA2E_2D241A8CAF12__INCLUDED_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif // _MSC_VER > 1000
+// DlgAlarmExceptionHandle.h : header file
+//
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgAlarmExceptionHandle dialog
+
+class CDlgAlarmExceptionHandle : public CDialog
+{
+// Construction
+public:
+	CDlgAlarmExceptionHandle(CWnd* pParent = NULL);   // standard constructor
+
+// Dialog Data
+	//{{AFX_DATA(CDlgAlarmExceptionHandle)
+	enum { IDD = IDD_DLG_ALARM_EXCEPTION_HANDLE };
+	CTreeCtrl	m_treeAlarmOut;
+	BOOL	m_bChkMonitorAlarm;
+	BOOL	m_bChkAudioAlarm;
+	BOOL	m_bChkReportCenter;
+	BOOL	m_bChkInvokeAlarmOut;
+	BOOL	m_bChkInvokeJpegCapture;
+	BOOL	m_bChkPicFtp;
+	BOOL	m_bChkEmapAlarmOut;
+	//}}AFX_DATA
+
+
+// Overrides
+	// ClassWizard generated virtual function overrides
+	//{{AFX_VIRTUAL(CDlgAlarmExceptionHandle)
+	protected:
+	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
+	//}}AFX_VIRTUAL
+
+// Implementation
+protected:
+
+	// Generated message map functions
+	//{{AFX_MSG(CDlgAlarmExceptionHandle)
+	afx_msg void OnBtnSetAlarmExceptionHandle();
+	virtual BOOL OnInitDialog();
+	afx_msg void OnClickTreeAlarmOut(NMHDR* pNMHDR, LRESULT* pResult);
+	afx_msg void OnChkTriggerAlarmOutput();
+	//}}AFX_MSG
+	DECLARE_MESSAGE_MAP()
+public:
+	NET_DVR_HANDLEEXCEPTION_V30 *m_struHandleException;
+	BOOL m_bAlarmOut[MAX_ALARMOUT_V30];
+	DWORD m_dwDevIndex; 
+	BOOL m_bChkSmsAlarm;
+};
+
+//{{AFX_INSERT_LOCATION}}
+// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
+
+#endif // !defined(AFX_DLGALARMEXCEPTIONHANDLE_H__CBF9FED7_F89D_404E_AA2E_2D241A8CAF12__INCLUDED_)

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgAlarmHostExternalModule.cpp

@@ -0,0 +1,224 @@
+// DlgAlarmHostExternalModule.cpp : implementation file
+//
+
+#include "stdafx.h"
+#include "clientdemo.h"
+#include "DlgAlarmHostExternalModule.h"
+
+#ifdef _DEBUG
+#define new DEBUG_NEW
+#undef THIS_FILE
+static char THIS_FILE[] = __FILE__;
+#endif
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgAlarmHostExternalModule dialog
+
+
+CDlgAlarmHostExternalModule::CDlgAlarmHostExternalModule(CWnd* pParent /*=NULL*/)
+	: CDialog(CDlgAlarmHostExternalModule::IDD, pParent)
+, m_iDeviceIndex(-1)
+, m_lUserID(-1)
+, m_lHandle(-1)
+{
+	//{{AFX_DATA_INIT(CDlgAlarmHostExternalModule)
+		// NOTE: the ClassWizard will add member initialization here
+	//}}AFX_DATA_INIT
+}
+
+
+void CDlgAlarmHostExternalModule::DoDataExchange(CDataExchange* pDX)
+{
+	CDialog::DoDataExchange(pDX);
+	//{{AFX_DATA_MAP(CDlgAlarmHostExternalModule)
+	DDX_Control(pDX, IDC_PROGRESS1, m_progress);
+	//}}AFX_DATA_MAP
+}
+
+
+BEGIN_MESSAGE_MAP(CDlgAlarmHostExternalModule, CDialog)
+	//{{AFX_MSG_MAP(CDlgAlarmHostExternalModule)
+	ON_BN_CLICKED(IDC_BTN_AUTO_SEARCH, OnBtnAutoSearch)
+	ON_BN_CLICKED(IDC_BTN_REGISTER, OnBtnRegister)
+	ON_MESSAGE(WM_PROC_ALARMHOST_EXTERNAL_MODULE, OnGetProgress)
+	ON_BN_CLICKED(IDC_BTN_STOP, OnBtnStop)
+	//}}AFX_MSG_MAP
+END_MESSAGE_MAP()
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgAlarmHostExternalModule message handlers
+
+void CALLBACK g_ExternModuleCallback(DWORD dwDataType, void* lpBuffer, DWORD dwBufLen, void* pUserData)
+{
+	DWORD	dwStatus = 0;
+	DWORD	dwProgress = 0;
+	CDlgAlarmHostExternalModule *pThis = static_cast<CDlgAlarmHostExternalModule*>(pUserData);
+	HWND hWnd = pThis->GetSafeHwnd();
+	if (NULL == hWnd)
+	{
+		return;
+	}
+	
+	switch (dwDataType)
+	{
+	case NET_SDK_CALLBACK_TYPE_PROGRESS:
+		dwProgress = *((DWORD*)lpBuffer);
+		::PostMessage(hWnd, WM_PROC_ALARMHOST_EXTERNAL_MODULE, (DWORD)NET_SDK_CALLBACK_TYPE_PROGRESS, dwProgress);
+		break;
+	case NET_SDK_CALLBACK_TYPE_STATUS:
+		dwStatus = *(DWORD*)lpBuffer;
+		//dwProgress = *(((DWORD*)lpBuffer) + 1);
+		if (dwStatus==NET_SDK_CALLBACK_STATUS_SUCCESS)
+		{
+			::PostMessage(hWnd, WM_PROC_ALARMHOST_EXTERNAL_MODULE, (DWORD)NET_SDK_CALLBACK_TYPE_STATUS, (DWORD)NET_SDK_CALLBACK_STATUS_SUCCESS);
+		}
+		else
+		{
+			::PostMessage(hWnd, WM_PROC_ALARMHOST_EXTERNAL_MODULE, (DWORD)NET_SDK_CALLBACK_TYPE_STATUS, (DWORD)NET_SDK_CALLBACK_STATUS_FAILED);
+		}	
+		break;
+	default:
+		g_pMainDlg->AddLog(pThis->m_iDeviceIndex, OPERATION_FAIL_T, "Unknown Status");
+		break;
+	}
+}
+
+BOOL CDlgAlarmHostExternalModule::OnInitDialog() 
+{
+	CDialog::OnInitDialog();
+	// TODO: Add extra initialization here
+	m_iDeviceIndex = g_pMainDlg->GetCurDeviceIndex();
+	m_lUserID = g_struDeviceInfo[m_iDeviceIndex].lLoginID;
+	return TRUE;  // return TRUE unless you set the focus to a control
+	              // EXCEPTION: OCX Property Pages should return FALSE
+}
+
+void CDlgAlarmHostExternalModule::OnBtnAutoSearch() 
+{
+	// TODO: Add your control notification handler code here
+	UpdateData(TRUE);
+	char szLan[128] = {0};
+	if (m_lHandle>=0)
+	{
+		g_pMainDlg->AddLog(m_iDeviceIndex, OPERATION_FAIL_T, "It is searching, wait for a moment");
+	}
+	else
+	{
+		m_progress.SetPos(0);
+		g_StringLanType(szLan, "进度", "progress");
+		sprintf(szLan, "%s %%%d", szLan, 0);
+		SetDlgItemText(IDC_STATIC_PROGRESS, szLan);
+		m_lHandle = NET_DVR_StartRemoteConfig(m_lUserID, NET_DVR_SEARCH_ARMHOST_EXTERNAL_MODULE, NULL, 0, g_ExternModuleCallback, this);
+		if (m_lHandle>=0)
+		{
+			g_pMainDlg->AddLog(m_iDeviceIndex, OPERATION_SUCC_T, "Start Remote Config successfully");
+			GetDlgItem(IDC_BTN_AUTO_SEARCH)->EnableWindow(FALSE);
+			GetDlgItem(IDC_BTN_REGISTER)->EnableWindow(FALSE);
+		}
+		else
+		{
+			g_pMainDlg->AddLog(m_iDeviceIndex, OPERATION_FAIL_T, "Start Remote Config failed");
+			return;
+		}
+	}
+}
+
+void CDlgAlarmHostExternalModule::OnBtnRegister() 
+{
+	// TODO: Add your control notification handler code here
+	UpdateData(TRUE);
+	char szLan[128] = {0};
+	if (m_lHandle>=0)
+	{
+		g_pMainDlg->AddLog(m_iDeviceIndex, OPERATION_FAIL_T, "It is searching, wait for a moment");
+	}
+	else
+	{
+		m_progress.SetPos(0);
+		g_StringLanType(szLan, "进度", "progress");
+		sprintf(szLan, "%s %%%d", szLan, 0);
+		SetDlgItemText(IDC_STATIC_PROGRESS, szLan);
+		m_lHandle = NET_DVR_StartRemoteConfig(m_lUserID, NET_DVR_REGISTER_ALARMHOST_EXTERNAL_MODULE, NULL, 0, g_ExternModuleCallback, this);
+		if (m_lHandle>=0)
+		{
+			g_pMainDlg->AddLog(m_iDeviceIndex, OPERATION_SUCC_T, "Start Remote Config successfully");
+			GetDlgItem(IDC_BTN_AUTO_SEARCH)->EnableWindow(FALSE);
+			GetDlgItem(IDC_BTN_REGISTER)->EnableWindow(FALSE);
+		}
+		else
+		{
+			g_pMainDlg->AddLog(m_iDeviceIndex, OPERATION_FAIL_T, "Start Remote Config failed");
+			return;
+		}
+	}
+}
+
+LRESULT CDlgAlarmHostExternalModule::OnGetProgress(WPARAM wParam, LPARAM lParam)
+{
+	//CDlgMatrixDispRoute* pDispRoute = reinterpret_cast<CDlgMatrixDispRoute*>(wParam);
+	char szLan[128] = {0};
+	DWORD dwDataType = (DWORD)wParam;
+	DWORD dwProgress = 0;
+	DWORD dwStatus = 0;
+	
+	switch (dwDataType)
+	{
+	case NET_SDK_CALLBACK_TYPE_PROGRESS:
+		dwProgress = (DWORD)lParam;
+		g_StringLanType(szLan, "进度", "progress");
+		sprintf(szLan, "%s %%%d", szLan, dwProgress);
+		SetDlgItemText(IDC_STATIC_PROGRESS, szLan);
+		m_progress.SetPos(dwProgress);
+		break;
+	case NET_SDK_CALLBACK_TYPE_STATUS:
+		dwStatus = (DWORD)lParam;
+		if (NET_SDK_CALLBACK_STATUS_SUCCESS == dwStatus)
+		{
+			g_StringLanType(szLan, "搜索/注册成功", "search or register successful");
+			g_pMainDlg->AddLog(m_iDeviceIndex, OPERATION_SUCC_T, szLan);
+		}
+		else 
+		{
+			g_StringLanType(szLan, "搜索/注册失败", "search or register failed");
+			g_pMainDlg->AddLog(m_iDeviceIndex, OPERATION_FAIL_T, "operate failed");
+		}
+		if (!NET_DVR_StopRemoteConfig(m_lHandle))
+		{
+			g_pMainDlg->AddLog(m_iDeviceIndex, OPERATION_FAIL_T, "Stop Remote Config Failed");
+		}
+		else
+		{
+			g_pMainDlg->AddLog(m_iDeviceIndex, OPERATION_SUCC_T, "Stop Remote Config Successful");
+			GetDlgItem(IDC_BTN_AUTO_SEARCH)->EnableWindow(TRUE);
+			GetDlgItem(IDC_BTN_REGISTER)->EnableWindow(TRUE);
+			m_lHandle = -1;
+		}
+		break;
+	default:
+		g_pMainDlg->AddLog(m_iDeviceIndex, OPERATION_FAIL_T, "Unknown Status");
+		break;
+	}
+	return NULL;
+}
+
+void CDlgAlarmHostExternalModule::OnBtnStop() 
+{
+	// TODO: Add your control notification handler code here
+
+	char szLan[128] = {0};
+	if (!NET_DVR_StopRemoteConfig(m_lHandle))
+	{
+		g_pMainDlg->AddLog(m_iDeviceIndex, OPERATION_FAIL_T, "Stop Remote Config Failed");
+	}
+	else
+	{
+		g_pMainDlg->AddLog(m_iDeviceIndex, OPERATION_SUCC_T, "Stop Remote Config Successful");
+		GetDlgItem(IDC_BTN_AUTO_SEARCH)->EnableWindow(TRUE);
+		GetDlgItem(IDC_BTN_REGISTER)->EnableWindow(TRUE);
+		g_StringLanType(szLan, "进度", "progress");
+		sprintf(szLan, "%s %%%d", szLan, 0);
+		SetDlgItemText(IDC_STATIC_PROGRESS, szLan);
+		m_progress.SetPos(0);
+		m_lHandle = -1;
+	}
+}

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgAlarmhostModuleCfg.cpp

@@ -0,0 +1,153 @@
+// DlgAlarmhostModuleCfg.cpp : implementation file
+//
+
+#include "stdafx.h"
+#include "clientdemo.h"
+#include "DlgAlarmhostModuleCfg.h"
+
+#ifdef _DEBUG
+#define new DEBUG_NEW
+#undef THIS_FILE
+static char THIS_FILE[] = __FILE__;
+#endif
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgAlarmhostModuleCfg dialog
+
+
+CDlgAlarmhostModuleCfg::CDlgAlarmhostModuleCfg(CWnd* pParent /*=NULL*/)
+	: CDialog(CDlgAlarmhostModuleCfg::IDD, pParent)
+{
+	//{{AFX_DATA_INIT(CDlgAlarmhostModuleCfg)
+		// NOTE: the ClassWizard will add member initialization here
+	//}}AFX_DATA_INIT
+}
+
+
+void CDlgAlarmhostModuleCfg::DoDataExchange(CDataExchange* pDX)
+{
+	CDialog::DoDataExchange(pDX);
+	//{{AFX_DATA_MAP(CDlgAlarmhostModuleCfg)
+	DDX_Control(pDX, IDC_COMBO_ZONE_TYPE, m_cmZoneType);
+	DDX_Control(pDX, IDC_COMBO_TRIGGER_TYPE, m_cmTriggerType);
+	DDX_Control(pDX, IDC_COMBO_MODULE_TYPE, m_cmModuleType);
+	DDX_Control(pDX, IDC_COMBO_MODULE_ADDR, m_cmModuleAddress);
+	//}}AFX_DATA_MAP
+}
+
+
+BEGIN_MESSAGE_MAP(CDlgAlarmhostModuleCfg, CDialog)
+	//{{AFX_MSG_MAP(CDlgAlarmhostModuleCfg)
+	ON_BN_CLICKED(IDC_BTN_GET, OnBtnGet)
+	//}}AFX_MSG_MAP
+END_MESSAGE_MAP()
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgAlarmhostModuleCfg message handlers
+
+void CDlgAlarmhostModuleCfg::OnBtnGet() 
+{
+	// TODO: Add your control notification handler code here
+	memset(&m_struModuleCfg, 0, sizeof(m_struModuleCfg));
+	m_struModuleCfg.dwSize = sizeof(m_struModuleCfg);
+	DWORD dwReturn = 0;
+	int iModuleAddr = m_cmModuleAddress.GetCurSel();
+	int iZoneTypeCount = m_cmZoneType.GetCount();
+	int iTriggerTypeCount = m_cmTriggerType.GetCount();
+	if (!NET_DVR_GetDVRConfig(m_lUserID, NET_DVR_GET_ALARMHOST_MODULE_CFG, iModuleAddr, &m_struModuleCfg, sizeof(m_struModuleCfg), &dwReturn))
+	{
+		MessageBox("Get Module Config Failed");
+		g_pMainDlg->AddLog(m_iDeviceIndex, OPERATION_FAIL_T, "NET_DVR_GET_ALARMHOST_MODULE_CFG failed");
+		return;
+	}
+	else
+	{
+		g_pMainDlg->AddLog(m_iDeviceIndex, OPERATION_SUCC_T, "NET_DVR_GET_ALARMHOST_MODULE_CFG successful");
+	}
+
+	m_cmModuleType.SetCurSel(m_struModuleCfg.byModuleType - 1);
+	if (0xff == m_struModuleCfg.byZoneType)
+	{
+		m_cmZoneType.SetCurSel(iZoneTypeCount - 1);
+	}
+	else
+	{
+		m_cmZoneType.SetCurSel(m_struModuleCfg.byZoneType - 1);
+	}
+	if (0xff == m_struModuleCfg.byTriggerType)
+	{
+		m_cmTriggerType.SetCurSel(iTriggerTypeCount - 1);
+	}
+	else
+	{
+		m_cmTriggerType.SetCurSel(m_struModuleCfg.byTriggerType - 1);
+	}
+	UpdateData(FALSE);
+}
+
+BOOL CDlgAlarmhostModuleCfg::OnInitDialog() 
+{
+	CDialog::OnInitDialog();
+	
+	// TODO: Add extra initialization here
+	m_iDeviceIndex = g_pMainDlg->GetCurDeviceIndex();
+	m_lUserID = g_struDeviceInfo[m_iDeviceIndex].lLoginID;
+	int i = 0;
+	CString csStr;
+	m_cmModuleAddress.ResetContent();
+	for (i=0; i<256; i++)
+	{
+		csStr.Format("%d", i);
+		m_cmModuleAddress.AddString(csStr);
+	}
+	g_StringLanType(m_szLan, "防区", "Zone");
+	csStr.Format("%s", m_szLan);
+	m_cmModuleType.AddString(csStr);
+	g_StringLanType(m_szLan, "触发器", "Trigger");
+	csStr.Format("%s", m_szLan);
+	m_cmModuleType.AddString(csStr);
+	g_StringLanType(m_szLan, "防区触发器", "Trigger");
+	csStr.Format("%s", m_szLan);
+	m_cmModuleType.AddString(csStr);
+
+	g_StringLanType(m_szLan, "本地防区", "local zone");
+	csStr.Format("%s", m_szLan);
+	m_cmZoneType.AddString(csStr);
+	g_StringLanType(m_szLan, "单防区", "single zone");
+	csStr.Format("%s", m_szLan);
+	m_cmZoneType.AddString(csStr);
+	g_StringLanType(m_szLan, "双防区", "double zone");
+	csStr.Format("%s", m_szLan);
+	m_cmZoneType.AddString(csStr);
+	g_StringLanType(m_szLan, "8防区", "8 zone");
+	csStr.Format("%s", m_szLan);
+	m_cmZoneType.AddString(csStr);
+	g_StringLanType(m_szLan, "模拟量防区", "sensor zone");
+	csStr.Format("%s", m_szLan);
+	m_cmZoneType.AddString(csStr);
+	g_StringLanType(m_szLan, "单防区触发器", "sensor zone");
+	csStr.Format("%s", m_szLan);
+	m_cmZoneType.AddString(csStr);
+	g_StringLanType(m_szLan, "未知类型", "unknown");
+	csStr.Format("%s", m_szLan);
+	m_cmZoneType.AddString(csStr);
+
+	g_StringLanType(m_szLan, "本地触发器", "local zone");
+	csStr.Format("%s", m_szLan);
+	m_cmTriggerType.AddString(csStr);
+	g_StringLanType(m_szLan, "4路触发器", "single zone");
+	csStr.Format("%s", m_szLan);
+	m_cmTriggerType.AddString(csStr);
+	g_StringLanType(m_szLan, "8路触发器", "double zone");
+	csStr.Format("%s", m_szLan);
+	m_cmTriggerType.AddString(csStr);
+	g_StringLanType(m_szLan, "单防区触发器", "double zone");
+	csStr.Format("%s", m_szLan);
+	m_cmTriggerType.AddString(csStr);
+	g_StringLanType(m_szLan, "未知类型", "unknown");
+	csStr.Format("%s", m_szLan);
+	m_cmTriggerType.AddString(csStr);
+
+	return TRUE;  // return TRUE unless you set the focus to a control
+	              // EXCEPTION: OCX Property Pages should return FALSE
+}

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgAudioOutVolumeCfg.cpp

@@ -0,0 +1,216 @@
+// DlgAudioOutVolumeCfg.cpp : implementation file
+//
+
+#include "stdafx.h"
+#include "clientdemo.h"
+#include "DlgAudioOutVolumeCfg.h"
+
+#ifdef _DEBUG
+#define new DEBUG_NEW
+#undef THIS_FILE
+static char THIS_FILE[] = __FILE__;
+#endif
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgAudioOutVolumeCfg dialog
+
+
+CDlgAudioOutVolumeCfg::CDlgAudioOutVolumeCfg(CWnd* pParent /*=NULL*/)
+	: CDialog(CDlgAudioOutVolumeCfg::IDD, pParent)
+    , m_dwTalkVolume(0)
+{
+	//{{AFX_DATA_INIT(CDlgAudioOutVolumeCfg)
+	//}}AFX_DATA_INIT
+}
+
+
+void CDlgAudioOutVolumeCfg::DoDataExchange(CDataExchange* pDX)
+{
+    CDialog::DoDataExchange(pDX);
+    //{{AFX_DATA_MAP(CDlgAudioOutVolumeCfg)
+    //}}AFX_DATA_MAP
+    DDX_Text(pDX, IDC_EDIT_AUDIO_IN_VOLUME, m_iAudioInVolume);
+    DDX_Text(pDX, IDC_EDIT_AUDIO_IN_TALK_VOLUME, m_dwTalkVolume);
+    DDX_Control(pDX, IDC_COMBO_AUDIO_IN, m_comboAudioOutIndex);
+}
+
+
+BEGIN_MESSAGE_MAP(CDlgAudioOutVolumeCfg, CDialog)
+	//{{AFX_MSG_MAP(CDlgAudioOutVolumeCfg)
+	ON_BN_CLICKED(IDC_BTN_GET, OnBtnGet)
+	ON_BN_CLICKED(IDC_BTN_SET, OnBtnSet)
+	//}}AFX_MSG_MAP
+END_MESSAGE_MAP()
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgAudioOutVolumeCfg message handlers
+void CDlgAudioOutVolumeCfg::OnBtnGet() 
+{
+	// TODO: Add your control notification handler code here
+    UpdateData(TRUE);
+	
+	char szLan[128] = {0};
+	NET_DVR_VOLUME_CFG struVolumeCfg = {0};
+	memset(&struVolumeCfg, 0, sizeof(NET_DVR_VOLUME_CFG));
+
+    DWORD dwReturnedBytes = 0;
+
+    CString strID = _T("");
+    m_comboAudioOutIndex.GetLBText(m_comboAudioOutIndex.GetCurSel(), strID);
+
+    if (NET_DVR_GetDVRConfig(m_lUserID, NET_DVR_GET_AUDIOOUT_VOLUME_CFG, atoi(strID), &struVolumeCfg, sizeof(NET_DVR_VOLUME_CFG), &dwReturnedBytes))
+	{
+		g_pMainDlg->AddLog(m_dwDevIndex, OPERATION_SUCC_T, "NET_DVR_GET_AUDIOOUT_VOLUME_CFG");
+		g_StringLanType(szLan, "获取音频输出口音量调节参数成功!", "Success to get audio out volume parameter config");
+		//	AfxMessageBox(szLan);
+	}
+	else
+	{
+		g_pMainDlg->AddLog(m_dwDevIndex, OPERATION_FAIL_T, "NET_DVR_GET_AUDIOOUT_VOLUME_CFG");
+		g_StringLanType(szLan, "获取音频输出口音量调节参数失败!", "Fail to get audio out volume parameter config");
+		AfxMessageBox(szLan);
+		return;
+	}
+	
+    m_iAudioInVolume = struVolumeCfg.wVolume[0];
+    m_dwTalkVolume = struVolumeCfg.wTalkVolume;
+
+	UpdateData(FALSE);
+}
+
+void CDlgAudioOutVolumeCfg::OnBtnSet() 
+{
+	// TODO: Add your control notification handler code here
+	
+	UpdateData(TRUE);
+	
+	char szLan[128] = {0};
+	NET_DVR_VOLUME_CFG struVolumeCfg = {0};
+	memset(&struVolumeCfg, 0, sizeof(NET_DVR_VOLUME_CFG));
+	
+	struVolumeCfg.dwSize = sizeof(NET_DVR_VOLUME_CFG);
+	
+	struVolumeCfg.wVolume[0] = m_iAudioInVolume;
+    struVolumeCfg.wTalkVolume = (WORD)m_dwTalkVolume;
+
+    CString strID = _T("");
+    m_comboAudioOutIndex.GetLBText(m_comboAudioOutIndex.GetCurSel(), strID);
+
+    if (NET_DVR_SetDVRConfig(m_lUserID, NET_DVR_SET_AUDIOOUT_VOLUME_CFG, atoi(strID), &struVolumeCfg, sizeof(NET_DVR_VOLUME_CFG)))
+	{
+		g_pMainDlg->AddLog(m_dwDevIndex, OPERATION_SUCC_T, "NET_DVR_SET_AUDIOOUT_VOLUME_CFG");
+		g_StringLanType(szLan, "设置音频输出口音量调节参数成功!", "Success to set audio out volume parameter config");
+		//	AfxMessageBox(szLan);
+	}
+	else
+	{
+		g_pMainDlg->AddLog(m_dwDevIndex, OPERATION_FAIL_T, "NET_DVR_SET_AUDIOOUT_VOLUME_CFG");
+		g_StringLanType(szLan, "设置音频输出口音量调节参数失败!", "Fail to set audio out volume parameter config");
+		AfxMessageBox(szLan);
+		return;
+	}
+}
+
+BOOL CDlgAudioOutVolumeCfg::OnInitDialog() 
+{
+	CDialog::OnInitDialog();
+	
+	// TODO: Add extra initialization here
+
+    char szLan[128] = { 0 };
+    for (int i = 1; i <= 16; i++)
+    {
+        sprintf(szLan, "%d", i);
+        m_comboAudioOutIndex.AddString(szLan);
+    }
+
+    GetAudioCap();
+
+    m_comboAudioOutIndex.SetCurSel(0);
+
+	OnBtnGet();
+	
+	return TRUE;  // return TRUE unless you set the focus to a control
+	              // EXCEPTION: OCX Property Pages should return FALSE
+}
+
+bool CDlgAudioOutVolumeCfg::GetAudioCap()
+{
+    UpdateData(TRUE);
+    NET_DVR_XML_CONFIG_INPUT    struInput = { 0 };
+    NET_DVR_XML_CONFIG_OUTPUT   struOuput = { 0 };
+    struInput.dwSize = sizeof(struInput);
+    struOuput.dwSize = sizeof(struOuput);
+    char szUrl[256] = { 0 };
+    sprintf(szUrl, "GET /ISAPI/System/Audio/channels\r\n");
+    struInput.lpRequestUrl = szUrl;
+    struInput.dwRequestUrlLen = strlen(szUrl);
+    DWORD dwOutputLen = 1024 * 1024;
+    char *pOutBuf = new char[dwOutputLen];
+    memset(pOutBuf, 0, dwOutputLen);
+    struOuput.lpOutBuffer = pOutBuf;
+    struOuput.dwOutBufferSize = dwOutputLen;
+
+    if (!NET_DVR_STDXMLConfig(m_lUserID, &struInput, &struOuput))
+    {
+        g_pMainDlg->AddLog(m_dwDevIndex, OPERATION_FAIL_T, szUrl);
+        delete[]pOutBuf;
+        pOutBuf = NULL;
+        return false;
+    }
+    else
+    {
+        g_pMainDlg->AddLog(m_dwDevIndex, OPERATION_SUCC_T, szUrl);
+
+        m_comboAudioOutIndex.ResetContent();
+
+        CXmlBase xmlBase;
+        xmlBase.Parse(pOutBuf);
+        xmlBase.SetRoot();
+        if (xmlBase.FindElem("AudioChannelList") && xmlBase.IntoElem())
+        {
+            do
+            {
+                if (xmlBase.FindElem("AudioChannel") && xmlBase.IntoElem())
+                {
+                    if (xmlBase.FindElem("id"))
+                    {
+                        CString strID = xmlBase.GetData().c_str();
+
+                        if (xmlBase.FindElem("type") && xmlBase.GetData() == "audioOut")
+                        {
+                            m_comboAudioOutIndex.AddString(strID);
+                        }
+                    }
+
+                    xmlBase.OutOfElem();
+                }
+            } while (xmlBase.NextSibElem());
+
+            xmlBase.OutOfElem();
+        }
+
+    }
+
+    UpdateData(FALSE);
+
+    if (pOutBuf != NULL)
+    {
+        delete[]pOutBuf;
+        pOutBuf = NULL;
+    }
+
+    char szLan[128] = { 0 };
+    if (m_comboAudioOutIndex.GetCount() == 0)
+    {
+        for (int i = 1; i <= 16; i++)
+        {
+            sprintf(szLan, "%d", i);
+            m_comboAudioOutIndex.AddString(szLan);
+        }
+    }
+
+    return true;
+}
+
+

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgBvCalibParamCfg.h

@@ -0,0 +1,102 @@
+#if !defined(AFX_DLGBVCALIBPARAMCFG_H__59F187A7_D556_4FFA_9DD6_79FAC18140A8__INCLUDED_)
+#define AFX_DLGBVCALIBPARAMCFG_H__59F187A7_D556_4FFA_9DD6_79FAC18140A8__INCLUDED_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif // _MSC_VER > 1000
+// DlgBvCalibParamCfg.h : header file
+//
+// 双目图像矫正参数结构体
+typedef struct _BINOC_RECTIFY_PARAM_
+{
+    float cam_internal_mat[3][3];
+    float dist_coeffs[8];
+    float rotate_mat[3][3];
+    float project_mat[3][4];
+}BINOC_RECTIFY_PARAM;
+
+// 左右相机矫正参数
+typedef struct _BV_CALIB_PARAM_
+{
+    float               rot[3][3];
+    float               trans[3];
+    float               reproject_mat[4][4];
+    BINOC_RECTIFY_PARAM l_cam_param;
+    BINOC_RECTIFY_PARAM r_cam_param;
+}BV_CALIB_PARAM;
+/////////////////////////////////////////////////////////////////////////////
+// CDlgBvCalibParamCfg dialog
+
+class CDlgBvCalibParamCfg : public CDialog
+{
+// Construction
+public:
+	CDlgBvCalibParamCfg(CWnd* pParent = NULL);   // standard constructor
+
+// Dialog Data
+	//{{AFX_DATA(CDlgBvCalibParamCfg)
+	enum { IDD = IDD_DLG_BV_CALIB_PARAM_CFG };
+		// NOTE: the ClassWizard will add data members here
+	//}}AFX_DATA
+
+
+// Overrides
+	// ClassWizard generated virtual function overrides
+	//{{AFX_VIRTUAL(CDlgBvCalibParamCfg)
+	protected:
+	CComboBox	m_comLensType;
+	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
+	virtual BOOL OnInitDialog();
+	//}}AFX_VIRTUAL
+
+// Implementation
+protected:
+
+	// Generated message map functions
+	//{{AFX_MSG(CDlgBvCalibParamCfg)
+	virtual void OnOK();
+	//}}AFX_MSG
+	DECLARE_MESSAGE_MAP()
+public:
+	LONG    m_lLoginID;
+    int     m_iDevIndex;
+    LONG    m_lChannel;
+protected:
+	BOOL    GetBvCalibParam();
+    BOOL    SetBvCalibParam();
+
+	void    LoadWndContent();
+	void    SaveWndContent();
+private:
+	float   m_fReprojectMatrix[4][4];  
+
+	float   m_fLCamInternalMatrix[3][3]; 
+	float   m_fLDistCoeffs[8];           
+	float   m_fLRotateMatrix[3][3];      
+	float   m_fLProjectMatrix[3][4];     
+
+	float   m_fRCamInternalMatrix[3][3]; 
+	float   m_fRDistCoeffs[8];           
+	float   m_fRRotateMatrix[3][3];      
+	float   m_fRProjectMatrix[3][4];
+
+    float   m_fRotateMatrix[3][3];
+    float   m_fTransMatrix[3];
+	NET_DVR_BV_CORRECT_PARAM m_struBvCalibParam;
+
+public:
+    afx_msg void OnBnClickedButtonExport();
+
+    bool getBVCorrectParam(NET_DVR_BV_CORRECT_PARAM &bv_correct_param);
+    bool toolChangeDvrToBvCalib(NET_DVR_BV_CORRECT_PARAM dvr_calib_param, BV_CALIB_PARAM &bv_calib);
+    bool toolExportCalibParamToTxt(char *calib_rst_file_path, BV_CALIB_PARAM calib_param, float focalLenth);
+    CString BrowseFolderParam(HWND hWnd, LPCTSTR lpTitle);
+    afx_msg void OnBnClickedOk();
+    DWORD m_dwOriImgWidth;
+    DWORD m_dwOriImgHeight;
+};
+
+//{{AFX_INSERT_LOCATION}}
+// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
+
+#endif // !defined(AFX_DLGBVCALIBPARAMCFG_H__59F187A7_D556_4FFA_9DD6_79FAC18140A8__INCLUDED_)

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgCaptureFingerPrint.h

@@ -0,0 +1,32 @@
+#pragma once
+
+
+// CDlgCaptureFingerPrint 对话框
+
+class CDlgCaptureFingerPrint : public CDialog
+{
+	DECLARE_DYNAMIC(CDlgCaptureFingerPrint)
+
+public:
+	CDlgCaptureFingerPrint(CWnd* pParent = NULL);   // 标准构造函数
+	virtual ~CDlgCaptureFingerPrint();
+    BOOL OnInitDialog();
+
+// 对话框数据
+	enum { IDD = IDD_DLG_CAPTURE_FINGER_PRINT };
+
+protected:
+	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV 支持
+
+	DECLARE_MESSAGE_MAP()
+public:
+    int m_iDevIndex;
+    long m_lServerID;
+    afx_msg void OnBnClickedBtnGetFingerPrint();
+    afx_msg LRESULT OnMsgCaptureFingerPrintFinish(WPARAM wParam, LPARAM lParam);
+    LONG m_lRemoteHandle;
+    CComboBox m_cmbFingerPrintPicType;
+    int m_iFingerNo;
+    int m_iFingerPrintQuality;
+    int m_iFingerNoReturn;
+};

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgCenterPoint.h

@@ -0,0 +1,93 @@
+#if !defined(AFX_DLGCENTERPOINT_H__FDEDEF27_B8B1_4EAA_AF8D_BF7B9844F9D5__INCLUDED_)
+#define AFX_DLGCENTERPOINT_H__FDEDEF27_B8B1_4EAA_AF8D_BF7B9844F9D5__INCLUDED_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif // _MSC_VER > 1000
+#include "VcaCommonOperations.h"
+// DlgCenterPoint.h : header file
+//
+
+/////////////////////////////////////////////////////////////////////////////
+// DlgCenterPoint dialog
+
+class DlgCenterPoint : public CDialog,public CVcaCommonOperations
+{
+// Construction
+public:
+	DlgCenterPoint(CWnd* pParent = NULL);   // standard constructor
+    ~DlgCenterPoint();
+    enum
+    {
+        DRAW_TYPE_NONE      = 0,          //不画图
+        DRAW_TYPE_LANE_BOUNDARY_LINE = 1, //车道边界线
+        DRAW_TYPE_LANE_LINE   = 2,        //车道线
+        DRAW_TYPE_PLATE_RECOG_RGN   = 3   //牌识区别
+	};
+
+// Dialog Data
+	//{{AFX_DATA(DlgCenterPoint)
+	enum { IDD = IDD_DLG_CENTER_POINT };
+
+	//}}AFX_DATA
+
+
+// Overrides
+	// ClassWizard generated virtual function overrides
+	//{{AFX_VIRTUAL(DlgCenterPoint)
+	protected:
+	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
+    virtual BOOL OnInitDialog();
+	//}}AFX_VIRTUAL
+
+// Implementation
+protected:
+
+	// Generated message map functions
+	//{{AFX_MSG(DlgCenterPoint)
+    afx_msg void OnDestroy();
+    afx_msg void OnBtnDrawPlateRecogRgn();
+    afx_msg void OnBtnSave();
+    afx_msg void OnLButtonDown(UINT nFlags, CPoint point);
+    afx_msg void OnRButtonDown(UINT nFlags, CPoint point);
+    afx_msg void OnMouseMove(UINT nFlags, CPoint point);;
+    afx_msg void OnBtnEndDraw();
+	afx_msg void OnButtonGet();
+	//}}AFX_MSG
+	DECLARE_MESSAGE_MAP()
+public:
+    void DrawRgnFun(HDC hdc);
+protected:
+    void InitCtrlState();
+protected:
+    void LoadWndContent();
+    void SaveWndContent();
+    
+    void LoadViaLaneWndContent(int nLaneIndex);
+    void SaveViaLaneWndContent(int nLaneIndex);
+    BOOL SetITCTriggerCfg();
+    //   	long StartRealPlay();  // 开始预览 
+    //     BOOL StopRealPlay();  // 停止预览
+public:
+//     LONG m_lServerID;
+//     LONG m_lChannel;
+// 	int  m_iDevIndex;
+
+private:
+    int  m_iTriggerMode;
+    LONG m_lPlayHandle;
+    CRect m_rcPlayWnd;
+    NET_DVR_CENTER_POINT_CFG m_struCenterPointCfg;
+    int m_nCurDrawType;
+    int m_nCurLaneIndex;
+    int m_nDrawPointNum;
+    BOOL m_bFirstDrawLaneBoundary;
+    BOOL m_bFirstDrawLaneLine;
+    NET_DVR_CALIBRATION m_struCalibration;
+	char m_szStatusBuf[ISAPI_STATUS_LEN];
+};
+
+//{{AFX_INSERT_LOCATION}}
+// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
+
+#endif // !defined(AFX_DLGCENTERPOINT_H__FDEDEF27_B8B1_4EAA_AF8D_BF7B9844F9D5__INCLUDED_)

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgChannelInfo.cpp

@@ -0,0 +1,287 @@
+/**********************************************************
+FileName:    DlgChannelInfo.cpp
+Description: channel info    
+Date:        2008/05/17
+Note: 		 <global>struct, refer to GeneralDef.h, global variants and functions refer to ClientDemo.cpp 
+Modification History:      
+    <version> <time>         <desc>
+    <1.0    > <2008/05/17>       <created>
+***********************************************************/
+
+
+#include "stdafx.h"
+#include "ClientDemo.h"
+#include "DlgChannelInfo.h"
+#include ".\dlgchannelinfo.h"
+
+
+// CDlgChannelInfo dialog
+/*********************************************************
+  Function:	CDlgChannelInfo
+  Desc:		Constructor
+  Input:	
+  Output:	
+  Return:	
+**********************************************************/
+IMPLEMENT_DYNAMIC(CDlgChannelInfo, CDialog)
+CDlgChannelInfo::CDlgChannelInfo(CWnd* pParent /*=NULL*/)
+	: CDialog(CDlgChannelInfo::IDD, pParent)
+	, m_csChanName(_T(""))
+	, m_iChanNo(0)
+	, m_csLocalNodeName(_T(""))
+	, m_csDeviceIP(_T(""))
+	, m_bChanged(FALSE)
+	, m_pChanInfo(NULL)
+{
+}
+
+/*********************************************************
+  Function:	~CDlgChannelInfo
+  Desc:		destructor
+  Input:	
+  Output:	
+  Return:	
+**********************************************************/
+CDlgChannelInfo::~CDlgChannelInfo()
+{
+	if (m_pChanInfo != NULL)
+	{
+		m_pChanInfo = NULL;
+	}
+}
+
+/*********************************************************
+  Function:	DoDataExchange
+  Desc:		map between control and data
+  Input:	
+  Output:	
+  Return:	
+**********************************************************/
+void CDlgChannelInfo::DoDataExchange(CDataExchange* pDX)
+{
+    CDialog::DoDataExchange(pDX);
+    //{{AFX_DATA_MAP(CDlgChannelInfo)
+    DDX_Control(pDX, IDC_COMBO_PREVIEW_PROTOCOL_TYPE, m_cmPreviewProtocolType);
+    DDX_Control(pDX, IDC_COMBO_PASSBACK_RECORD, m_comboPassbackRecord);
+    DDX_Text(pDX, IDC_CHANNAME, m_csChanName);
+    DDX_Text(pDX, IDC_CHANNO, m_iChanNo);
+    DDX_Control(pDX, IDC_COMBO_PREVIEW_TYPE, m_cmPreviewMode);
+    DDX_Text(pDX, IDC_CHANINFO_DEV_NAME, m_csLocalNodeName);
+    DDX_Text(pDX, IDC_CHAN_DEVICE_IP, m_csDeviceIP);
+    DDX_Control(pDX, IDC_COMBO_PROTOCOL, m_comboProtocol);
+    DDX_Control(pDX, IDC_COMBO_TRANSPORT_TYPE, m_comboTransportType);
+    //}}AFX_DATA_MAP
+
+    DDX_Control(pDX, IDC_COMBO_VIDEO_CODING_TYPE, m_comVideoCodingType);
+}
+
+/*********************************************************
+  Function:	BEGIN_MESSAGE_MAP
+  Desc:		message map list
+  Input:	
+  Output:	
+  Return:	
+**********************************************************/
+BEGIN_MESSAGE_MAP(CDlgChannelInfo, CDialog)
+//{{AFX_MSG_MAP(CDlgChannelInfo)
+ON_BN_CLICKED(ID_OK, OnBnClickedOk)
+ON_BN_CLICKED(ID_CANCEL, OnBnClickedCancel)
+ON_UPDATE_COMMAND_UI(ID_MENU_CHANNEL_INFO, OnUpdateMenuChannelInfo)
+//}}AFX_MSG_MAP
+END_MESSAGE_MAP()
+
+
+
+// CDlgChannelInfo message handlers
+/*********************************************************
+  Function:	OnInitDialog
+  Desc:		initialize channel info dialog
+  Input:	
+  Output:	
+  Return:	
+**********************************************************/
+BOOL CDlgChannelInfo::OnInitDialog() 
+{
+	CDialog::OnInitDialog();
+	GetDlgItem(IDC_STATIC_PASSBACKRECORD)->ShowWindow(SW_HIDE);
+	GetDlgItem(IDC_COMBO_PASSBACK_RECORD)->ShowWindow(SW_HIDE);
+    AddStreamType();
+	if (m_pChanInfo == NULL)
+	{
+		return FALSE;
+	}
+
+	m_iChanNo = m_pChanInfo->iChannelNO;
+	m_csChanName.Format("%s",m_pChanInfo->chChanName);
+	m_csLocalNodeName.Format("%s",g_struDeviceInfo[m_pChanInfo->iDeviceIndex].chLocalNodeName);
+	m_csDeviceIP.Format("%s",g_struDeviceInfo[m_pChanInfo->iDeviceIndex].chDeviceIP);
+// 	m_comboProtocol.SetCurSel(m_pChanInfo->dwProtocol& 0x7fffffff);
+// //	m_comboProtocol.SetCurSel( ( (m_pChanInfo->dwProtocol& 0x7fffffff) >= 7) ? ((m_pChanInfo->dwProtocol& 0x7fffffff)-3) : (m_pChanInfo->dwProtocol& 0x7fffffff));
+// 	m_comboTransportType.SetCurSel((m_pChanInfo->dwProtocol>>31) & 0x01);
+
+
+    m_comboProtocol.SetCurSel(m_pChanInfo->dwLinkMode);
+    for (int i = 0; i < m_comboTransportType.GetCount(); i++)
+    {
+        if (m_comboTransportType.GetItemData(i) == m_pChanInfo->dwStreamType)
+        {
+            m_comboTransportType.SetCurSel(i);
+            break;
+        }
+    }
+    // m_comboTransportType.SetCurSel(g_struDeviceInfo[m_pChanInfo->iDeviceIndex].pStruChanInfo[m_pChanInfo->iChanIndex].dwStreamType);
+    //m_cmPreviewMode.SetCurSel(g_struDeviceInfo[m_pChanInfo->iDeviceIndex].pStruChanInfo[m_pChanInfo->iChanIndex].dwPreviewMode);
+    //m_cmPreviewProtocolType.SetCurSel(g_struDeviceInfo[m_pChanInfo->iDeviceIndex].pStruChanInfo[m_pChanInfo->iChanIndex].nPreviewProtocolType);
+    
+    m_comboProtocol.SetCurSel(m_pChanInfo->dwLinkMode);
+    //m_comboTransportType.SetCurSel(m_pChanInfo->dwStreamType);
+    m_cmPreviewMode.SetCurSel(m_pChanInfo->dwPreviewMode);
+    m_cmPreviewProtocolType.SetCurSel(m_pChanInfo->nPreviewProtocolType);
+    m_comVideoCodingType.SetCurSel(m_pChanInfo->nVideoCodingType);
+	if ((g_struDeviceInfo[m_pChanInfo->iDeviceIndex].bySupport2 & 0x4) == 0x4)
+	{
+		GetDlgItem(IDC_STATIC_PASSBACKRECORD)->ShowWindow(SW_SHOW);
+		GetDlgItem(IDC_COMBO_PASSBACK_RECORD)->ShowWindow(SW_SHOW);
+		m_comboPassbackRecord.SetCurSel(m_pChanInfo->bPassbackRecord);
+	}
+	UpdateData(FALSE);
+	
+	return TRUE;  // return TRUE unless you set the focus to a control
+	// EXCEPTION: OCX Property Pages should return FALSE
+}
+
+void CDlgChannelInfo::AddStreamType()
+{
+    char szLan[128] = { 0 };
+    int index = 0;
+
+    m_comboTransportType.ResetContent();
+    g_StringLanType(szLan, "主码流", "MainCode");
+    m_comboTransportType.AddString(szLan);
+    m_comboTransportType.SetItemData(index, 0);
+    index++;
+
+    g_StringLanType(szLan, "子码流", "SubCode");
+    m_comboTransportType.AddString(szLan);
+    m_comboTransportType.SetItemData(index, 1);
+    index++;
+
+    g_StringLanType(szLan, "码流3", "ThirdCode");
+    m_comboTransportType.AddString(szLan);
+    m_comboTransportType.SetItemData(index, 2);
+    index++;
+
+    g_StringLanType(szLan, "码流4/转码流", "TransCode");
+    m_comboTransportType.AddString(szLan);
+    m_comboTransportType.SetItemData(index, 3);
+    index++;
+
+    g_StringLanType(szLan, "码流5", "FifthCode");
+    m_comboTransportType.AddString(szLan);
+    m_comboTransportType.SetItemData(index, 4);
+    index++;
+
+    g_StringLanType(szLan, "码流6(自定义)", "SixthCode(Custom)");
+    m_comboTransportType.AddString(szLan);
+    m_comboTransportType.SetItemData(index, 5);
+    index++;
+
+    g_StringLanType(szLan, "码流7(自定义)", "SeventhCode(Custom)");
+    m_comboTransportType.AddString(szLan);
+    m_comboTransportType.SetItemData(index, 7);
+    index++;
+
+    g_StringLanType(szLan, "码流8(自定义)", "EighthCode(Custom)");
+    m_comboTransportType.AddString(szLan);
+    m_comboTransportType.SetItemData(index, 8);
+    index++;
+
+    g_StringLanType(szLan, "码流9(自定义)", "NinthCode(Custom)");
+    m_comboTransportType.AddString(szLan);
+    m_comboTransportType.SetItemData(index, 9);
+    index++;
+
+    g_StringLanType(szLan, "码流10(自定义)", "TenthCode(Custom)");
+    m_comboTransportType.AddString(szLan);
+    m_comboTransportType.SetItemData(index, 10);
+    index++;
+}
+
+/*********************************************************
+  Function:	OnBnClickedOk
+  Desc:		modify channel info
+  Input:	
+  Output:	
+  Return:	
+**********************************************************/
+void CDlgChannelInfo::OnBnClickedOk()
+{
+	UpdateData(TRUE);
+	for (int i = 0; i < g_struDeviceInfo[m_pChanInfo->iDeviceIndex].iDeviceChanNum; i++)
+	{
+		if (i == m_pChanInfo->iChanIndex)
+		{
+			continue;
+		}
+
+		if (0 == strcmp(g_struDeviceInfo[m_pChanInfo->iDeviceIndex].pStruChanInfo[i].chChanName,m_csChanName))
+		{
+			char szLan[1024] = {0};
+			g_StringLanType(szLan, "该通道名称已存在!", "this channel name is existed!");
+			AfxMessageBox(szLan);
+			return;
+		}
+	}
+
+	DWORD dwTemp = m_comboProtocol.GetCurSel();
+// 	if(dwTemp >= 4)
+// 	{
+// 		dwTemp += 3;
+// 	}
+
+	dwTemp |=(m_comboTransportType.GetCurSel()<< 31);
+
+	if (strcmp(m_pChanInfo->chChanName,m_csChanName) != 0 || m_pChanInfo->dwProtocol != dwTemp || m_pChanInfo->dwProtocol!=m_cmPreviewMode.GetCurSel())
+	{
+		m_bChanged = TRUE;
+	}
+
+	sprintf(m_pChanInfo->chChanName,"%s",m_csChanName.GetBuffer(0));
+	m_pChanInfo->dwProtocol = dwTemp;
+	m_pChanInfo->dwPreviewMode = m_cmPreviewMode.GetCurSel();
+	m_pChanInfo->nPreviewProtocolType = m_cmPreviewProtocolType.GetCurSel();
+    m_pChanInfo->nVideoCodingType = m_comVideoCodingType.GetCurSel();
+    m_pChanInfo->dwStreamType = m_comboTransportType.GetItemData(m_comboTransportType.GetCurSel());
+    m_pChanInfo->dwLinkMode = m_comboProtocol.GetCurSel();
+    m_pChanInfo->nPreviewProtocolType = m_pChanInfo->nPreviewProtocolType;
+    m_pChanInfo->dwPreviewMode = m_pChanInfo->dwPreviewMode;
+
+	if (m_comboPassbackRecord.GetCurSel() < 0)
+    {
+        m_pChanInfo->bPassbackRecord = FALSE;
+    }
+    else
+    {
+        m_pChanInfo->bPassbackRecord = m_comboPassbackRecord.GetCurSel();
+    }
+    m_pChanInfo->nPreviewProtocolType = m_cmPreviewProtocolType.GetCurSel();
+	OnOK();
+}
+
+/*********************************************************
+  Function:	OnBnClickedCancel
+  Desc:	    cancel channel info
+  Input:	
+  Output:	
+  Return:	
+**********************************************************/
+void CDlgChannelInfo::OnBnClickedCancel()
+{
+	OnCancel();
+}
+
+void CDlgChannelInfo::OnUpdateMenuChannelInfo(CCmdUI* pCmdUI) 
+{
+	// TODO: Add your command update UI handler code here
+	
+}

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgCloudUrlCfg.h

@@ -0,0 +1,55 @@
+#if !defined(AFX_DLGCLOUDURLCFG_H__A7629274_33D8_42D9_A208_D7FC9D9C501F__INCLUDED_)
+#define AFX_DLGCLOUDURLCFG_H__A7629274_33D8_42D9_A208_D7FC9D9C501F__INCLUDED_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif // _MSC_VER > 1000
+// DlgCloudUrlCfg.h : header file
+//
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgCloudUrlCfg dialog
+
+class CDlgCloudUrlCfg : public CDialog
+{
+// Construction
+public:
+	CDlgCloudUrlCfg(CWnd* pParent = NULL);   // standard constructor
+
+// Dialog Data
+	//{{AFX_DATA(CDlgCloudUrlCfg)
+	enum { IDD = IDD_DLG_CLOUD_URL_CFG };
+		// NOTE: the ClassWizard will add data members here
+	//}}AFX_DATA
+
+
+// Overrides
+	// ClassWizard generated virtual function overrides
+	//{{AFX_VIRTUAL(CDlgCloudUrlCfg)
+	protected:
+	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
+	//}}AFX_VIRTUAL
+
+// Implementation
+protected:
+
+	// Generated message map functions
+	//{{AFX_MSG(CDlgCloudUrlCfg)
+	afx_msg void OnBtnGetCloudUrl();
+    virtual BOOL OnInitDialog();
+	//}}AFX_MSG
+	DECLARE_MESSAGE_MAP()
+private:
+    CComboBox m_comboCloudType;
+    CString	m_csCloudUrl;
+    char m_szStatusBuf[ISAPI_STATUS_LEN];
+public:
+    int m_lUserID;
+    int m_lChanNo;
+    int m_iDevIndex;
+};
+
+//{{AFX_INSERT_LOCATION}}
+// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
+
+#endif // !defined(AFX_DLGCLOUDURLCFG_H__A7629274_33D8_42D9_A208_D7FC9D9C501F__INCLUDED_)

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgConferenceParam.h

@@ -0,0 +1,76 @@
+#include "afxwin.h"
+#if !defined(AFX_DLGCONFERENCEPARAM_H__E80A2FC3_760C_45CE_BB32_E0A987F5C628__INCLUDED_)
+#define AFX_DLGCONFERENCEPARAM_H__E80A2FC3_760C_45CE_BB32_E0A987F5C628__INCLUDED_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif // _MSC_VER > 1000
+// DlgConferenceParam.h : header file
+//
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgConferenceParam dialog
+
+class CDlgConferenceParam : public CDialog
+{
+// Construction
+public:
+	CDlgConferenceParam(CWnd* pParent = NULL);   // standard constructor
+
+// Dialog Data
+	//{{AFX_DATA(CDlgConferenceParam)
+	enum { IDD = IDD_DLG_MCU_PARAMTERS };
+	CComboBox	m_comboConferenceInput;
+	//}}AFX_DATA
+
+
+// Overrides
+	// ClassWizard generated virtual function overrides
+	//{{AFX_VIRTUAL(CDlgConferenceParam)
+	protected:
+	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
+	//}}AFX_VIRTUAL
+
+// Implementation
+protected:
+
+	// Generated message map functions
+	//{{AFX_MSG(CDlgConferenceParam)
+	virtual BOOL OnInitDialog();
+	afx_msg void OnButCall();
+	afx_msg void OnButConferenceRegion();
+	afx_msg void OnBtnSet();
+	afx_msg void OnBtnGet();
+	afx_msg void OnButTerminalConferenceStatus();
+
+	afx_msg void OnBtnAddConference();
+	afx_msg void OnBtnSearchConferenceStatus();
+	afx_msg void OnBtnGetConferenceStatus();
+	afx_msg void OnBtnGetConfDailyDistribution();
+	afx_msg void OnBtnGetConfCtrl();
+	afx_msg void OnBtnClearConfHistory();
+	afx_msg void OnBtnDelConference();
+	afx_msg void OnBtnTerminalCtrl();
+	afx_msg void OnBtnTermGroupList();
+	afx_msg void OnBtnTermGroupCfg();
+
+	afx_msg void OnBtnTermManCfg();
+
+	afx_msg void OnBtnGetAbility();
+	//}}AFX_MSG
+	DECLARE_MESSAGE_MAP()
+
+private:
+    int m_iDeviceIndex;
+    LONG m_lUserID;
+public:
+    afx_msg void OnBnClickedBtnGkConfig();
+    afx_msg void OnBnClickedBtnGkServer();
+    CComboBox m_comboStreamType;
+    afx_msg void OnCbnSelchangeComboConferenceInput();
+};
+
+//{{AFX_INSERT_LOCATION}}
+// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
+
+#endif // !defined(AFX_DLGCONFERENCEPARAM_H__E80A2FC3_760C_45CE_BB32_E0A987F5C628__INCLUDED_)

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgConfigAll.h

@@ -0,0 +1,45 @@
+#pragma once
+
+
+// CDlgConfigAll dialog
+
+class CDlgConfigAll : public CDialog
+{
+	DECLARE_DYNAMIC(CDlgConfigAll)
+
+public:
+	CDlgConfigAll(CWnd* pParent = NULL);   // standard constructor
+	virtual ~CDlgConfigAll();
+
+// Dialog Data
+
+
+public:
+	//{{AFX_DATA(CDlgConfigAll)
+	enum { IDD = IDD_DLG_CONFIG_ALL };
+	//}}AFX_DATA
+
+
+	//{{AFX_VIRTUAL(CDlgConfigAll)
+protected:
+	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
+	//}}AFX_VIRTUAL
+protected:
+	// Generated message map functions
+	//{{AFX_MSG(CDlgConfigAll)
+	afx_msg void OnBnClickedBtnRemoteConfig();
+	afx_msg void OnBnClickedBtnLocalConfig();
+	afx_msg void OnBnClickedBtnIPAccess();
+	afx_msg void OnBnClickedBtnBackPreview();
+	afx_msg void OnBnClickedBtnHDConfig();
+	afx_msg void OnBtnBatchConfig();
+	//}}AFX_MSG
+	DECLARE_MESSAGE_MAP()
+		
+public:
+	
+	int m_iDeviceIndex;
+	int m_iConfigType;
+	void ConfigWndUpdate();
+	
+};

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgDecoderAbility.h

@@ -0,0 +1,68 @@
+#if !defined(AFX_DLGDECODERABILITY_H__97B504C7_7B7A_4CC8_A5D7_E8DCBB1B33F6__INCLUDED_)
+#define AFX_DLGDECODERABILITY_H__97B504C7_7B7A_4CC8_A5D7_E8DCBB1B33F6__INCLUDED_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif // _MSC_VER > 1000
+// DlgDecoderAbility.h : header file
+//
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgDecoderAbility dialog
+
+class CDlgDecoderAbility : public CDialog
+{
+// Construction
+public:
+	void GetResolutionString(DWORD dwRes, char *lpResString);
+	void SetInfoToDlg(LPNET_DVR_MATRIX_ABILITY_V41 lpInter);
+	int m_iDeviceIndex;
+	CDlgDecoderAbility(CWnd* pParent = NULL);   // standard constructor
+	NET_DVR_MATRIX_ABILITY_V41 m_struMatrixAbility;
+// Dialog Data
+	//{{AFX_DATA(CDlgDecoderAbility)
+	enum { IDD = IDD_DLG_DECODER_ABILITY };
+	CComboBox	m_cmDispSeq;
+	CComboBox	m_cmWindowDispMode;
+	CComboBox	m_cmSupRes;
+	CComboBox	m_cmDispWindowChanType;
+	CComboBox	m_cmDispMode;
+	BYTE	m_byDecChanNums;
+	BYTE	m_byDispChanSeq;
+	BYTE	m_byDspNums;
+	BYTE	m_byScreenX;
+	BYTE	m_byScreenY;
+	BYTE	m_byStartScreenNums;
+	BYTE	m_byStartChan;
+	BYTE	m_bySupportScreenNums;
+	BYTE	m_byDispChanNums;
+	BYTE	m_byDispStartChan;
+	//}}AFX_DATA
+
+
+// Overrides
+	// ClassWizard generated virtual function overrides
+	//{{AFX_VIRTUAL(CDlgDecoderAbility)
+	protected:
+	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
+	//}}AFX_VIRTUAL
+
+// Implementation
+protected:
+
+	// Generated message map functions
+	//{{AFX_MSG(CDlgDecoderAbility)
+	virtual BOOL OnInitDialog();
+	afx_msg void OnBtnRfresh();
+	afx_msg void OnSelchangeComboDispmode();
+	afx_msg void OnSelchangeComboDispSeq();
+	afx_msg void OnSelchangeComboWindownum();
+	afx_msg void OnSelendokComboDispmode();
+	//}}AFX_MSG
+	DECLARE_MESSAGE_MAP()
+};
+
+//{{AFX_INSERT_LOCATION}}
+// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
+
+#endif // !defined(AFX_DLGDECODERABILITY_H__97B504C7_7B7A_4CC8_A5D7_E8DCBB1B33F6__INCLUDED_)

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgDiskQuota.cpp

@@ -0,0 +1,415 @@
+// DlgDiskQuota.cpp : implementation file
+//
+
+#include "stdafx.h"
+#include "clientdemo.h"
+#include "DlgDiskQuota.h"
+
+#ifdef _DEBUG
+#define new DEBUG_NEW
+#undef THIS_FILE
+static char THIS_FILE[] = __FILE__;
+#endif
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgDiskQuota dialog
+
+
+CDlgDiskQuota::CDlgDiskQuota(CWnd* pParent /*=NULL*/)
+	: CDialog(CDlgDiskQuota::IDD, pParent)
+    , m_dwPicPeriod(0)
+    , m_dwReocrdPeriod(0)
+    , m_iPubInfoCapacity(0)
+    , m_iPubInfoUsed(0)
+    , m_byPubInfoQuotaRatio(0)
+{
+	//{{AFX_DATA_INIT(CDlgDiskQuota)
+	m_iPicCapacity = 0;
+	m_iRecordCapacity = 0;
+	m_iPicUsed = 0;
+	m_iRecordUsed = 0;
+	m_byDrawPer = 0;
+	m_byPicPer = 0;
+	m_byRecordPer = 0;
+	m_byRecordQuotaRatio = 0;
+	m_byPicQuotaRatio = 0;
+	m_iAddInfoCapacity = 0;
+	m_byAddInfoQuotaRatio = 0;
+	m_iAddInfoUsed = 0;
+	m_bAllChann = FALSE;
+	//}}AFX_DATA_INIT
+    m_lServerID = -1;
+    m_lChannel = -1;
+    m_iDevIndex = -1;
+    m_lChannelNum = -1;
+    memset(&m_struDiskQuotaCfg, 0, sizeof(m_struDiskQuotaCfg));
+}
+
+
+void CDlgDiskQuota::DoDataExchange(CDataExchange* pDX)
+{
+    CDialog::DoDataExchange(pDX);
+    //{{AFX_DATA_MAP(CDlgDiskQuota)
+    DDX_Control(pDX, IDC_COMBO_ADDINFO_TYPE, m_comboAddInfoType);
+    DDX_Control(pDX, IDC_COMBO_RECORD_TYPE, m_comboRecordType);
+    DDX_Control(pDX, IDC_COMBO_PIC_TYPE, m_comboPicType);
+    DDX_Text(pDX, IDC_EDIT_PIC_CAPACITY, m_iPicCapacity);
+    DDX_Text(pDX, IDC_EDIT_RECORD_CAPACITY, m_iRecordCapacity);
+    DDX_Text(pDX, IDC_EDIT_USED_PIC, m_iPicUsed);
+    DDX_Text(pDX, IDC_EDIT_USED_RECORD, m_iRecordUsed);
+    DDX_Text(pDX, IDC_EDIT_DRAW_P, m_byDrawPer);
+    DDX_Text(pDX, IDC_EDIT_PICCTURE_P, m_byPicPer);
+    DDX_Text(pDX, IDC_EDIT_RECORD_P, m_byRecordPer);
+    DDX_Text(pDX, IDC_EDIT_RECORD_QUOTA_RATIO, m_byRecordQuotaRatio);
+    DDX_Text(pDX, IDC_EDIT_PIC_QUOTA_RATIO, m_byPicQuotaRatio);
+    DDX_Text(pDX, IDC_EDIT_ADDINFO_CAPACITY, m_iAddInfoCapacity);
+    DDX_Text(pDX, IDC_EDIT_ADDINFO_QUOTA_RATIO, m_byAddInfoQuotaRatio);
+    DDX_Text(pDX, IDC_EDIT_USED_ADDINFO, m_iAddInfoUsed);
+    DDX_Check(pDX, IDC_CHECK_ALL_CHANN, m_bAllChann);
+    //}}AFX_DATA_MAP
+    DDX_Text(pDX, IDC_EDIT_STORAGE_PERIOD_PIC, m_dwPicPeriod);
+    DDX_Text(pDX, IDC_EDIT_STORAGE_PERIOD_RECORD, m_dwReocrdPeriod);
+    DDX_Text(pDX, IDC_EDIT_PUBINFO_CAPACITY, m_iPubInfoCapacity);
+    DDX_Text(pDX, IDC_EDIT_USED_PUBINFO, m_iPubInfoUsed);
+    DDX_Text(pDX, IDC_EDIT_PUBINFO_QUOTA_RATIO, m_byPubInfoQuotaRatio);
+    DDX_Control(pDX, IDC_COMBO_PUBINFO_TYPE, m_comboPubInfoType);
+}
+
+
+BEGIN_MESSAGE_MAP(CDlgDiskQuota, CDialog)
+	//{{AFX_MSG_MAP(CDlgDiskQuota)
+	ON_BN_CLICKED(IDC_BTN_QUOTA_CFG, OnBtnQuotaCfg)
+	ON_BN_CLICKED(IDC_BUTTON_UPDATE, OnBtnQuotaUpgrade)
+	ON_BN_CLICKED(IDC_BUTTON_EXIT, OnBtnQuotaExit)
+	ON_BN_CLICKED(IDC_BTN_QUOTA_CFG2, OnBtnDrawFrameQuotaCfg)
+	ON_BN_CLICKED(IDC_BUTTON_UPDATE2, OnButtonDrawFrameUpdate)
+	ON_BN_CLICKED(IDC_BTN_DRAW_FRAME_QUOTA_CFG, OnBtnDrawFrameQuotaCfg)
+	ON_BN_CLICKED(IDC_BUTTON_DRAW_FRAME_UPDATE, OnButtonDrawFrameUpdate)
+	//}}AFX_MSG_MAP
+END_MESSAGE_MAP()
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgDiskQuota message handlers
+
+BOOL CDlgDiskQuota::OnInitDialog() 
+{
+	CDialog::OnInitDialog();
+    char szLan[128] = {0};
+	  
+    InitWnd();
+
+    if (!GetDiskQuotaCfg(m_lChannel, m_struDiskQuotaCfg))
+    {
+		g_StringLanType(szLan, "获取磁盘配额配置失败", "Fail to get disk quota configure");  
+        AfxMessageBox(szLan);
+    }
+
+	SetDiskQuotaCfgToWnd(m_struDiskQuotaCfg);
+
+	OnButtonDrawFrameUpdate();
+
+    UpdateData(FALSE);	
+    return TRUE;  // return TRUE unless you set the focus to a control
+	              // EXCEPTION: OCX Property Pages should return FALSE
+}
+
+
+void CDlgDiskQuota::InitWnd()
+{
+    char szLan[128] = {0};
+    int nIndex = 0;
+    m_comboPicType.ResetContent();
+	g_StringLanType(szLan, "按容量", " By Capacity");
+    m_comboPicType.InsertString(nIndex, szLan);
+    m_comboPicType.SetItemData(nIndex, 1);
+
+	nIndex++;
+	g_StringLanType(szLan, "按比例", " By proportion");
+    m_comboPicType.InsertString(nIndex, szLan);
+    m_comboPicType.SetItemData(nIndex, 2);
+
+	nIndex++;
+	g_StringLanType(szLan, "按时间", " By Time");
+    m_comboPicType.InsertString(nIndex, szLan);
+    m_comboPicType.SetItemData(nIndex, 3);
+	
+    nIndex= 0;
+    m_comboRecordType.ResetContent();
+	g_StringLanType(szLan, "按容量", " By Capacity");
+    m_comboRecordType.InsertString(nIndex, szLan);
+    m_comboRecordType.SetItemData(nIndex, 1);
+
+	nIndex++;
+	g_StringLanType(szLan, "按比例", " By proportion");
+    m_comboRecordType.InsertString(nIndex, szLan);
+    m_comboRecordType.SetItemData(nIndex, 2);
+
+    nIndex++;
+    g_StringLanType(szLan, "按时间", " By Time");
+    m_comboRecordType.InsertString(nIndex, szLan);
+    m_comboRecordType.SetItemData(nIndex, 3);
+
+    nIndex= 0;
+    m_comboAddInfoType.ResetContent();
+    g_StringLanType(szLan, "按容量", " By Capacity");
+    m_comboAddInfoType.InsertString(nIndex, szLan);
+    m_comboAddInfoType.SetItemData(nIndex, 1);
+    
+    nIndex++;
+    g_StringLanType(szLan, "按比例", " By proportion");
+    m_comboAddInfoType.InsertString(nIndex, szLan);
+    m_comboAddInfoType.SetItemData(nIndex, 2);
+
+    nIndex = 0;
+    m_comboPubInfoType.ResetContent();
+    g_StringLanType(szLan, "按容量", "By Capacity");
+    m_comboPubInfoType.InsertString(nIndex, szLan);
+    m_comboPubInfoType.SetItemData(nIndex, 1);
+
+    nIndex++;
+    g_StringLanType(szLan, "按比例", "By proportion");
+    m_comboPubInfoType.InsertString(nIndex, szLan);
+    m_comboPubInfoType.SetItemData(nIndex, 2);
+
+
+}
+
+BOOL CDlgDiskQuota::GetDiskQuotaCfg(LONG lChannel, NET_DVR_DISK_QUOTA_CFG_V60 &struDiskQuotaCfg)
+{
+    DWORD dwReturn = 0;
+
+    if (NET_DVR_GetDVRConfig(m_lServerID, NET_DVR_GET_DISK_QUOTA_CFG_V60, lChannel, &struDiskQuotaCfg, sizeof(struDiskQuotaCfg), &dwReturn))
+    //if (NET_DVR_GetDVRConfig(m_lServerID, NET_DVR_GET_DISK_QUOTA_CFG, lChannel, &struDiskQuotaCfg, sizeof(struDiskQuotaCfg), &dwReturn))
+    {
+        g_pMainDlg->AddLog(m_iDevIndex, OPERATION_SUCC_T, "NET_DVR_GET_DISK_QUOTA_CFG_V60");
+        return TRUE;
+    }
+    else
+    {
+        g_pMainDlg->AddLog(m_iDevIndex, OPERATION_FAIL_T, "NET_DVR_GET_DISK_QUOTA_CFG_V60");
+        return FALSE;
+    }
+    return TRUE;
+}
+
+BOOL CDlgDiskQuota::SetDiskQuotaCfg(LONG lChannel, NET_DVR_DISK_QUOTA_CFG_V60 &struDiskQuotaCfg)
+{
+
+    if (NET_DVR_SetDVRConfig(m_lServerID, NET_DVR_SET_DISK_QUOTA_CFG_V60, lChannel, &struDiskQuotaCfg, sizeof(struDiskQuotaCfg)))
+    //if (NET_DVR_SetDVRConfig(m_lServerID, NET_DVR_SET_DISK_QUOTA_CFG, lChannel, &struDiskQuotaCfg, sizeof(struDiskQuotaCfg)))
+    {
+        g_pMainDlg->AddLog(m_iDevIndex, OPERATION_SUCC_T, "NET_DVR_SET_DISK_QUOTA_CFG_V60");
+        return TRUE;
+    } 
+    else
+    {
+        g_pMainDlg->AddLog(m_iDevIndex, OPERATION_FAIL_T, "NET_DVR_SET_DISK_QUOTA_CFG_V60");
+        return FALSE;
+    }
+}
+
+void CDlgDiskQuota::GetDiskQuotaCfgFromWnd(NET_DVR_DISK_QUOTA_CFG_V60 &struDiskQuotaCfg)
+{
+    GetPicQuotaFromWnd(struDiskQuotaCfg.struPicQuota);
+    GetRecordQuotaFromWnd(struDiskQuotaCfg.struRecordQuota);
+    GetAddInfoQuotaFromWnd(struDiskQuotaCfg.struAddInfoQuota);
+    GetPubInfoQuotaFromWnd(struDiskQuotaCfg.struPubInfoFile);
+}
+
+void CDlgDiskQuota::GetPicQuotaFromWnd(NET_DVR_DISK_QUOTA_V60 &struPicQuota)
+{
+    struPicQuota.byQuotaType = m_comboPicType.GetItemData(m_comboPicType.GetCurSel());
+    struPicQuota.wStoragePeriod = m_dwPicPeriod;
+    struPicQuota.dwLCapacity = m_iPicCapacity;
+	struPicQuota.byQuotaRatio = m_byPicQuotaRatio;
+}
+void CDlgDiskQuota::GetRecordQuotaFromWnd(NET_DVR_DISK_QUOTA_V60 &struRecordQuota)
+{
+    struRecordQuota.byQuotaType = m_comboRecordType.GetItemData(m_comboRecordType.GetCurSel());
+    struRecordQuota.wStoragePeriod = m_dwReocrdPeriod;
+    struRecordQuota.dwLCapacity = m_iRecordCapacity;
+	struRecordQuota.byQuotaRatio = m_byRecordQuotaRatio;
+}
+void CDlgDiskQuota::GetAddInfoQuotaFromWnd(NET_DVR_DISK_QUOTA_V60 &struAddInfoQuota)
+{
+    struAddInfoQuota.byQuotaType = m_comboAddInfoType.GetItemData(m_comboAddInfoType.GetCurSel());
+    struAddInfoQuota.dwLCapacity = m_iAddInfoCapacity;
+    struAddInfoQuota.byQuotaRatio = m_byAddInfoQuotaRatio;
+}
+
+void CDlgDiskQuota::GetPubInfoQuotaFromWnd(NET_DVR_DISK_QUOTA_V60 &struPubInfoQuota)
+{
+    struPubInfoQuota.byQuotaType = m_comboPubInfoType.GetItemData(m_comboPubInfoType.GetCurSel());
+    struPubInfoQuota.dwLCapacity = m_iPubInfoCapacity;
+    struPubInfoQuota.byQuotaRatio = m_byPubInfoQuotaRatio;
+}
+
+void CDlgDiskQuota::SetDiskQuotaCfgToWnd(NET_DVR_DISK_QUOTA_CFG_V60 &struDiskQuotaCfg)
+{
+    SetPicQuotaToWnd(struDiskQuotaCfg.struPicQuota);
+    SetRecordQuotaToWnd(struDiskQuotaCfg.struRecordQuota);
+    SetAddInfoQuotaFromWnd(struDiskQuotaCfg.struAddInfoQuota);
+    SetPubInfoQuotaFromWnd(struDiskQuotaCfg.struPubInfoFile);
+}
+
+void CDlgDiskQuota::SetPicQuotaToWnd(NET_DVR_DISK_QUOTA_V60 &struPicQuota)
+{
+    int i = 0;
+    for (i = 0; i < m_comboPicType.GetCount(); i++)
+    {
+        if (struPicQuota.byQuotaType == m_comboPicType.GetItemData(i))
+        {
+            m_comboPicType.SetCurSel(i);
+			break;
+        }
+    }
+
+    m_iPicCapacity = struPicQuota.dwLCapacity;
+	m_iPicUsed = struPicQuota.dwLUsedSpace;
+	m_byPicQuotaRatio = struPicQuota.byQuotaRatio;
+    m_dwPicPeriod = struPicQuota.wStoragePeriod;
+}
+void CDlgDiskQuota::SetRecordQuotaToWnd(NET_DVR_DISK_QUOTA_V60 &struRecordQuota)
+{
+    int i = 0;
+    for (i = 0; i < m_comboRecordType.GetCount(); i++)
+    {
+        if (struRecordQuota.byQuotaType == m_comboRecordType.GetItemData(i))
+        {
+            m_comboRecordType.SetCurSel(i);
+			break;
+        }
+    }
+    
+    m_iRecordCapacity = struRecordQuota.dwLCapacity;
+	m_iRecordUsed = struRecordQuota.dwLUsedSpace;
+	m_byRecordQuotaRatio = struRecordQuota.byQuotaRatio;
+    m_dwReocrdPeriod = struRecordQuota.wStoragePeriod;
+}
+
+void CDlgDiskQuota::SetAddInfoQuotaFromWnd(NET_DVR_DISK_QUOTA_V60 &struAddInfoQuota)
+{
+    int i = 0;
+    for (i = 0; i < m_comboAddInfoType.GetCount(); i++)
+    {
+        if (struAddInfoQuota.byQuotaType == m_comboAddInfoType.GetItemData(i))
+        {
+            m_comboAddInfoType.SetCurSel(i);
+            break;
+        }
+    }
+    
+    m_iAddInfoCapacity = struAddInfoQuota.dwLCapacity;
+    m_iAddInfoUsed = struAddInfoQuota.dwLUsedSpace;
+    m_byAddInfoQuotaRatio = struAddInfoQuota.byQuotaRatio;
+}
+
+
+void CDlgDiskQuota::SetPubInfoQuotaFromWnd(NET_DVR_DISK_QUOTA_V60 &struPubInfoQuota)
+{
+    int i = 0;
+    for (i = 0; i < m_comboPubInfoType.GetCount(); ++i)
+    {
+        if (struPubInfoQuota.byQuotaType == m_comboPubInfoType.GetItemData(i))
+        {
+            m_comboPubInfoType.SetCurSel(i);
+            break;
+        }
+    }
+    m_iPubInfoCapacity = struPubInfoQuota.dwLCapacity;
+    m_iPubInfoUsed = struPubInfoQuota.dwLUsedSpace;
+    m_byPubInfoQuotaRatio = struPubInfoQuota.byQuotaRatio;
+
+}
+
+
+void CDlgDiskQuota::OnBtnQuotaCfg() 
+{
+    UpdateData(TRUE);
+
+    LONG lChannel = m_lChannel;
+    //if (m_bAllChann)
+    //{
+    //    lChannel = -1;
+    //}
+
+	char szLan[128] = {0};
+    GetDiskQuotaCfgFromWnd(m_struDiskQuotaCfg);
+	if (!SetDiskQuotaCfg(lChannel, m_struDiskQuotaCfg))
+	{
+		g_StringLanType(szLan, "配置磁盘配额失败", "Fail to set disk quota");    
+        AfxMessageBox(szLan);
+	}
+}
+
+void CDlgDiskQuota::OnBtnQuotaUpgrade()
+{   
+    UpdateData(TRUE);
+    LONG lChannel = m_lChannel;
+    if (m_bAllChann)
+    {
+        lChannel = 0xff;
+    }
+    
+	char szLan[128] = {0};
+	if (!GetDiskQuotaCfg(lChannel, m_struDiskQuotaCfg))
+    {
+		g_StringLanType(szLan, "获取磁盘配额配置失败", "Fail to get disk quota configure");  
+        AfxMessageBox(szLan);
+    }
+	
+	SetDiskQuotaCfgToWnd(m_struDiskQuotaCfg);
+    UpdateData(FALSE);	
+}
+
+void CDlgDiskQuota::OnBtnQuotaExit()
+{
+	CDialog::OnCancel();
+}
+
+void CDlgDiskQuota::OnBtnDrawFrameQuotaCfg() 
+{
+	UpdateData(TRUE);
+	char szLan[128] = {0};
+	
+	m_struDrawFrame.dwSize = sizeof(m_struDrawFrame);
+	m_struDrawFrame.byDrawFrameRecordQuota = m_byDrawPer;
+	m_struDrawFrame.byPicQuota = m_byPicPer;
+	m_struDrawFrame.byRecordQuota = m_byRecordPer;
+
+    if (NET_DVR_SetDVRConfig(m_lServerID, NET_DVR_SET_DRAWFRAME_DISK_QUOTA_CFG, m_lChannel, &m_struDrawFrame, sizeof(m_struDrawFrame)))
+    {
+        g_pMainDlg->AddLog(m_iDevIndex, OPERATION_SUCC_T, "NET_DVR_SET_DRAWFRAME_DISK_QUOTA_CFG");
+        return;
+    } 
+    else
+    {
+        g_pMainDlg->AddLog(m_iDevIndex, OPERATION_FAIL_T, "NET_DVR_SET_DRAWFRAME_DISK_QUOTA_CFG");
+		g_StringLanType(szLan, "设置磁盘配额配置失败", "Fail to setup disk quota configure");  
+        AfxMessageBox(szLan);
+        return;
+    }	
+}
+
+void CDlgDiskQuota::OnButtonDrawFrameUpdate() 
+{
+	char szLan[128] = {0};
+
+    DWORD dwReturn = 0;
+    if (NET_DVR_GetDVRConfig(m_lServerID, NET_DVR_GET_DRAWFRAME_DISK_QUOTA_CFG, m_lChannel, &m_struDrawFrame, sizeof(m_struDrawFrame), &dwReturn))
+    {
+		m_byDrawPer = m_struDrawFrame.byDrawFrameRecordQuota;
+		m_byPicPer = m_struDrawFrame.byPicQuota;
+		m_byRecordPer = m_struDrawFrame.byRecordQuota;		
+
+        g_pMainDlg->AddLog(m_iDevIndex, OPERATION_SUCC_T, "NET_DVR_GET_DRAWFRAME_DISK_QUOTA_CFG");
+        return;
+    }
+    else
+    {
+        g_pMainDlg->AddLog(m_iDevIndex, OPERATION_FAIL_T, "NET_DVR_GET_DRAWFRAME_DISK_QUOTA_CFG");
+		g_StringLanType(szLan, "获取抽帧通道磁盘配额配置失败", "Fail to get disk quota configure");  
+        AfxMessageBox(szLan);
+        return;
+    }
+}

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgFaceConsume.h

@@ -0,0 +1,24 @@
+#pragma once
+
+
+// CDlgFaceConsume 对话框
+
+class CDlgFaceConsume : public CDialogEx
+{
+	DECLARE_DYNAMIC(CDlgFaceConsume)
+
+public:
+	CDlgFaceConsume(CWnd* pParent = NULL);   // 标准构造函数
+	virtual ~CDlgFaceConsume();
+    LONG m_lUserID;
+    int m_iDeviceIndex;
+// 对话框数据
+	enum { IDD = IDD_DLG_FACE_CONSUME };
+
+protected:
+	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV 支持
+
+	DECLARE_MESSAGE_MAP()
+public:
+    afx_msg void OnBnClickedBtnConsumeSimulate();
+};

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgFirmWareversion.cpp

@@ -0,0 +1,67 @@
+// DlgFirmWareversion.cpp : 实现文件
+//
+
+#include "stdafx.h"
+#include "ClientDemo.h"
+#include "DlgFirmWareversion.h"
+#include "afxdialogex.h"
+
+
+// CDlgFirmWareversion 对话框
+
+IMPLEMENT_DYNAMIC(CDlgFirmWareversion, CDialogEx)
+
+CDlgFirmWareversion::CDlgFirmWareversion(CWnd* pParent /*=NULL*/)
+	: CDialogEx(CDlgFirmWareversion::IDD, pParent)
+    , m_FirmwareVersion(_T(""))
+{
+
+}
+
+CDlgFirmWareversion::~CDlgFirmWareversion()
+{
+}
+
+void CDlgFirmWareversion::DoDataExchange(CDataExchange* pDX)
+{
+    CDialogEx::DoDataExchange(pDX);
+    DDX_Text(pDX, IDC_EDIT_FIRMWARE_VERSION, m_FirmwareVersion);
+}
+
+
+BEGIN_MESSAGE_MAP(CDlgFirmWareversion, CDialogEx)
+    ON_BN_CLICKED(IDC_BTN_GET, &CDlgFirmWareversion::OnBnClickedBtnGet)
+END_MESSAGE_MAP()
+
+
+// CDlgFirmWareversion 消息处理程序
+
+
+
+
+
+void CDlgFirmWareversion::OnBnClickedBtnGet()
+{
+    NET_DVR_FIRMWARE_VERSION_IFNO struFirmwareVersion = { 0 };
+    NET_DVR_STD_CONFIG struCfg = { 0 };
+    struCfg.lpCondBuffer = &m_lChannel;
+    struCfg.dwCondSize = sizeof(m_lChannel);
+    struCfg.lpOutBuffer = &struFirmwareVersion;
+    struCfg.dwOutSize = sizeof(struFirmwareVersion);
+    memset(m_szStatusBuf, 0, ISAPI_STATUS_LEN);
+    struCfg.lpStatusBuffer = m_szStatusBuf;
+    struCfg.dwStatusSize = ISAPI_STATUS_LEN;
+
+    if (!NET_DVR_GetSTDConfig(m_lServerID, NET_DVR_GET_FIRMWARE_VERSION, &struCfg))
+    {
+        OutputDebugString(m_szStatusBuf);
+        g_pMainDlg->AddLog(m_iDevIndex, OPERATION_FAIL_T, "NET_DVR_GET_FIRMWARE_VERSION");
+    }
+    else
+    {
+        g_pMainDlg->AddLog(m_iDevIndex, OPERATION_SUCC_T, "NET_DVR_GET_FIRMWARE_VERSION");
+    }
+
+    m_FirmwareVersion.Format(_T("%s"), struFirmwareVersion.szFirmwareVersion);
+    UpdateData(FALSE);
+}

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgFisheyeTrackCfg.cpp

@@ -0,0 +1,700 @@
+// DlgFisheyeTrackCfg.cpp : implementation file
+//
+
+#include "stdafx.h"
+#include "clientdemo.h"
+#include "DlgFisheyeTrackCfg.h"
+#include "DlgVcaRemoteChannel.h"
+
+#ifdef _DEBUG
+#define new DEBUG_NEW
+#undef THIS_FILE
+static char THIS_FILE[] = __FILE__;
+#endif
+
+CDlgFisheyeTrackCfg *g_CDlgFisheyeTrackCfg = NULL;
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgFisheyeTrackCfg dialog
+void CALLBACK g_DrawFisheyeCalibPoint(LONG lRealHandle, HDC hDc, DWORD dwUser)
+{  
+    //CDlgFisheyeTrackCfg* pDlg = (CDlgFisheyeTrackCfg*)(dwUser);
+    if (g_CDlgFisheyeTrackCfg != NULL)
+    {
+        g_CDlgFisheyeTrackCfg->DrawFisheyeFun(hDc);
+    }
+}
+
+void CALLBACK g_DrawTrackDevFun(LONG lRealHandle, HDC hDc, DWORD dwUser)
+{
+    //CDlgFisheyeTrackCfg* pDlg = (CDlgFisheyeTrackCfg*)(dwUser);
+    //pDlg->DrawTrackDevFun(hDc);
+    if (g_CDlgFisheyeTrackCfg != NULL)
+    {
+        g_CDlgFisheyeTrackCfg->DrawTrackDevFun(hDc);
+    }
+}
+
+CDlgFisheyeTrackCfg::CDlgFisheyeTrackCfg(CWnd* pParent /*=NULL*/)
+	: CDialog(CDlgFisheyeTrackCfg::IDD, pParent)
+{
+	//{{AFX_DATA_INIT(CDlgFisheyeTrackCfg)
+	m_fFisheyePtX = 0.0f;
+	m_nTrackDevPosP = 0;
+	m_nTrackDevPosT = 0;
+	m_nTrackDevPosZ = 0;
+	m_nTrackDevHPosP = 0;
+	m_nTrackDevHPosT = 0;
+	m_nTrackDevHPosZ = 0;
+	//}}AFX_DATA_INIT
+	memset(&m_struTrackDevParam,0,sizeof(m_struTrackDevParam));
+	m_nCurCBIndex = 0;
+	m_bIsFisheyePlaying = FALSE;
+	m_lTrackDevRealhandle = -1;
+	m_lTrackDevUserID = -1;
+	m_nOperationType = OP_TYPE_NONE;
+	m_bDrawTrackPoint = FALSE;
+}
+
+
+void CDlgFisheyeTrackCfg::DoDataExchange(CDataExchange* pDX)
+{
+	CDialog::DoDataExchange(pDX);
+	//{{AFX_DATA_MAP(CDlgFisheyeTrackCfg)
+	DDX_Control(pDX, IDC_COMBO_CALIB_PT_NO, m_comboCalibPtNO);
+	DDX_Control(pDX, IDC_COMBO_TRANS_MODE, m_comboTransMode);
+	DDX_Text(pDX, IDC_EDIT_FISHEYE_PT_X, m_fFisheyePtX);
+	DDX_Text(pDX, IDC_EDIT_FISHEYE_PT_Y, m_fFisheyePtY);
+	DDX_Text(pDX, IDC_EDIT_TRACKDEV_POS_P, m_nTrackDevPosP);
+	DDX_Text(pDX, IDC_EDIT_TRACKDEV_POS_T, m_nTrackDevPosT);
+	DDX_Text(pDX, IDC_EDIT_TRACKDEV_POS_Z, m_nTrackDevPosZ);
+	DDX_Text(pDX, IDC_EDIT_TRACKDEV_HPOS_P, m_nTrackDevHPosP);
+	DDX_Text(pDX, IDC_EDIT_TRACKDEV_HPOS_T, m_nTrackDevHPosT);
+	DDX_Text(pDX, IDC_EDIT_TRACKDEV_HPOS_Z, m_nTrackDevHPosZ);
+	DDX_Check(pDX, IDC_CHECK_TRACKDEV_ENABLE,m_bTrackDevEnable);
+	DDX_Control(pDX,IDC_BTN_TILT_UP,        m_btnUp);
+	DDX_Control(pDX,IDC_BTN_TILT_DOWN,      m_btnDown);
+	DDX_Control(pDX,IDC_BTN_PAN_LEFT,       m_btnLeft);
+	DDX_Control(pDX,IDC_BTN_PAN_RIGHT,      m_btnRight);
+	DDX_Control(pDX,IDC_BTN_ZOOM_OUT,       m_btnZoomOut);
+	DDX_Control(pDX,IDC_BTN_ZOOM_IN,        m_btnZoomIn);
+	DDX_Control(pDX,IDC_BTN_FOCUS_NEAR,     m_btnFocusNear);
+	DDX_Control(pDX,IDC_BTN_FOCUS_FAR,      m_btnFocusFar);
+	DDX_Control(pDX,IDC_BTN_IRIS_CLOSE,     m_btnIrisClose);
+	DDX_Control(pDX,IDC_BTN_IRIS_OPEN,      m_btnIrisOpen);
+	//}}AFX_DATA_MAP
+}
+
+
+BEGIN_MESSAGE_MAP(CDlgFisheyeTrackCfg, CDialog)
+	//{{AFX_MSG_MAP(CDlgFisheyeTrackCfg)
+	ON_BN_CLICKED(IDC_BTN_FISHEYE_STARTREALPLAY, OnBtnFisheyeStartrealplay)
+	ON_BN_CLICKED(IDC_BTN_FISHEYE_STOPREALPLAY, OnBtnFisheyeStoprealplay)
+	ON_BN_CLICKED(IDC_BTN_SAVE, OnBtnSave)
+	ON_BN_CLICKED(IDC_BTN_TRACKDEV_CFG, OnBtnTrackdevCfg)
+	ON_BN_CLICKED(IDC_BTN_TRACKDEV_STARTREALPLAY, OnBtnTrackdevStartrealplay)
+	ON_BN_CLICKED(IDC_BTN_TRACKDEV_STOPREALPLAY, OnBtnTrackdevStoprealplay)
+	ON_CBN_SELCHANGE(IDC_COMBO_CALIB_PT_NO, OnSelchangeComboCalibPtNo)
+	ON_WM_DESTROY()
+	ON_WM_LBUTTONDOWN()
+	ON_WM_MOUSEMOVE()
+	ON_BN_CLICKED(IDC_BTN_CALIB_PT_NUM, OnBtnCalibPtNum)
+	ON_BN_CLICKED(IDC_BTN_GET_TRACKDEV_HORIZON_POS, OnBtnGetTrackdevHorizonPos)
+	ON_BN_CLICKED(IDC_BTN_GET_TRACKDEV_CALIB_POS, OnBtnGetTrackdevCalibPos)
+	ON_BN_CLICKED(IDC_RADIO_CALIB, OnRadioCalib)
+	ON_BN_CLICKED(IDC_RADIO_TRACK, OnRadioTrack)
+	//}}AFX_MSG_MAP
+END_MESSAGE_MAP()
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgFisheyeTrackCfg message handlers
+
+BOOL CDlgFisheyeTrackCfg::OnInitDialog()
+{
+	CDialog::OnInitDialog();
+
+    g_CDlgFisheyeTrackCfg = NULL;
+
+	InitCtrlState();
+    OnBtnFisheyeStartrealplay();
+
+	GetDlgItem(IDC_FISHEYE_PLAYWND)->GetWindowRect(&m_rcFisheyePlayWnd);
+	ScreenToClient(&m_rcFisheyePlayWnd);
+
+	GetDlgItem(IDC_TRACKDEV_PLAYWND)->GetWindowRect(&m_rcTrackDevPlayWnd);
+	ScreenToClient(&m_rcTrackDevPlayWnd);
+
+	if (!GetTrackDevParam())
+	{
+		char szErr[100] = "\0";
+		char szCn[50] = "\0";
+		char szEn[50] ="\0";
+		sprintf(szCn,"获取跟随设备参数失败，错误代码 %d",NET_DVR_GetLastError());
+		sprintf(szCn,"Get track device param failed,error code %d",NET_DVR_GetLastError());
+		g_StringLanType(szErr,szCn,szEn);
+		AfxMessageBox(szErr);
+	}
+
+	LoadWndContent();
+	OnRadioCalib();
+
+	return TRUE;
+}
+
+void CDlgFisheyeTrackCfg::OnLButtonDown(UINT nFlags, CPoint point)
+{
+	CDialog::OnLButtonDown(nFlags,point);
+	if (m_rcFisheyePlayWnd.PtInRect(point))
+	{   
+		int nXOffset = point.x - m_rcFisheyePlayWnd.left;
+		int nYOffset = point.y - m_rcFisheyePlayWnd.top;
+		
+		float fX = float((nXOffset * 1.000)) / m_rcFisheyePlayWnd.Width();
+		float fY = float((nYOffset * 1.000)) / m_rcFisheyePlayWnd.Height();
+
+		if (m_nOperationType == OP_TYPE_CALIB)
+		{
+			int nCalibPtNum = GetDlgItemInt(IDC_EDIT_CALIB_PT_NUM);
+			if (nCalibPtNum < 2 || nCalibPtNum > MAX_CALIB_PT)
+			{
+				return;
+				
+			}
+			int nXOffset = point.x - m_rcFisheyePlayWnd.left;
+			int nYOffset = point.y - m_rcFisheyePlayWnd.top;
+			
+			m_fFisheyePtX = fX;
+			m_fFisheyePtY = fY;
+			
+			UpdateData(FALSE);
+			
+		    SaveCalibPointFromWnd(m_nCurCBIndex);
+		}
+		else if (m_nOperationType == OP_TYPE_TRACK)
+		{   
+            NET_DVR_PTZ_MANUALTRACE struPTZManualTrace = {0};
+            struPTZManualTrace.dwSize = sizeof(struPTZManualTrace);
+			struPTZManualTrace.struPoint.fX = fX;
+			struPTZManualTrace.struPoint.fY = fY;
+            struPTZManualTrace.dwChannel = m_lChannel;
+			if (!NET_DVR_RemoteControl(m_lServerID,NET_DVR_CONTROL_PTZ_MANUALTRACE,&struPTZManualTrace,sizeof(struPTZManualTrace)))
+			{
+				CString strErr = "";
+				strErr.Format(_T("Track failed,error ID = %d"),NET_DVR_GetLastError());
+				AfxMessageBox(strErr);
+			}
+		}
+	}
+}
+
+void CDlgFisheyeTrackCfg::OnMouseMove(UINT nFlags, CPoint point)
+{
+	CDialog::OnMouseMove(nFlags,point);
+	if (m_rcFisheyePlayWnd.PtInRect(point))
+	{
+		if (m_nOperationType != OP_TYPE_TRACK)
+		{
+			return;
+		}
+		m_ptTrack = point;
+		m_bDrawTrackPoint = TRUE;
+	}
+	else
+	{
+		m_bDrawTrackPoint = FALSE;
+	}
+}
+
+
+void CDlgFisheyeTrackCfg::OnDestroy()
+{
+	StopRealPlay();
+	LogoutTrackDev();
+	CDialog::OnDestroy();
+}
+
+void CDlgFisheyeTrackCfg::OnBtnFisheyeStartrealplay() 
+{
+	if (!m_bIsFisheyePlaying)
+	{
+		m_bIsFisheyePlaying = StartRealPlay(GetDlgItem(IDC_FISHEYE_PLAYWND)->GetSafeHwnd(),g_DrawFisheyeCalibPoint,this);
+	}
+}
+
+void CDlgFisheyeTrackCfg::OnBtnFisheyeStoprealplay() 
+{   
+	if (m_bIsFisheyePlaying)
+	{
+		StopRealPlay();
+		m_bIsFisheyePlaying = FALSE;
+		GetDlgItem(IDC_FISHEYE_PLAYWND)->Invalidate();
+	}
+}
+
+
+void CDlgFisheyeTrackCfg::OnBtnSave() 
+{   
+	SaveWndContent();
+
+	char szErr[100] = "\0";
+	char szCn[50] = "\0";
+	char szEn[50] ="\0";
+	if (!SetTrackDevParam())
+	{
+	
+		sprintf(szCn,"设置跟随设备参数失败，错误代码 %d",NET_DVR_GetLastError());
+		sprintf(szCn,"Set track device param failed,error code %d",NET_DVR_GetLastError());
+		g_StringLanType(szErr,szCn,szEn);
+		AfxMessageBox(szErr);
+	}
+	else
+	{
+		g_StringLanType(szErr,"保存跟随设备参数成功","Set track device param successfully");
+		AfxMessageBox(szErr);
+	}
+}
+
+
+void CDlgFisheyeTrackCfg::OnBtnTrackdevCfg() 
+{   
+	const NET_DVR_CHANNEL& struChannel = m_struTrackDevParam.struTrackDevChan;
+	CDlgVcaRemoteChannel dlg;
+	dlg.SetRemoteChannelParam(struChannel.byAddress,struChannel.wDVRPort,struChannel.sUserName,struChannel.sPassword,struChannel.dwChannel);
+	if (dlg.DoModal() == IDOK)
+	{   
+		CString strAddress = "";
+		CString strUserName = "";
+		CString strPwd = "";
+		DWORD   dwChannel = 0;
+		DWORD   wPort = 0;
+		dlg.GetRemoteChannelParam(strAddress,wPort,strUserName,strPwd,dwChannel);
+		strncpy((char*)m_struTrackDevParam.struTrackDevChan.byAddress,strAddress.GetBuffer(strAddress.GetLength()),MAX_DOMAIN_NAME);
+		strncpy((char*)m_struTrackDevParam.struTrackDevChan.sUserName,strUserName.GetBuffer(strUserName.GetLength()),NAME_LEN);
+		strncpy((char*)m_struTrackDevParam.struTrackDevChan.sPassword,strPwd.GetBuffer(strPwd.GetLength()),PASSWD_LEN);
+		m_struTrackDevParam.struTrackDevChan.wDVRPort = wPort;
+		m_struTrackDevParam.struTrackDevChan.dwChannel = dwChannel;
+
+		LogoutTrackDev();
+		LoginTrackDev();
+		StartTrackDevRealPlay();
+	}
+}
+
+void CDlgFisheyeTrackCfg::OnBtnTrackdevStartrealplay() 
+{   
+	LoginTrackDev();
+	if (m_lTrackDevRealhandle < 0)
+	{
+		StartTrackDevRealPlay();
+	}
+	
+}
+
+void CDlgFisheyeTrackCfg::OnBtnTrackdevStoprealplay() 
+{
+	StopTrackDevRealPlay();
+}
+
+
+void CDlgFisheyeTrackCfg::OnSelchangeComboCalibPtNo() 
+{
+	int nCurSel = m_comboCalibPtNO.GetCurSel();
+	if (nCurSel != CB_ERR)
+	{   
+		UpdateData(TRUE);
+		SaveCalibPointFromWnd(m_nCurCBIndex);
+		m_nCurCBIndex = nCurSel;
+		LoadCalibPointToWnd(nCurSel);
+		UpdateData(FALSE);
+	}
+}
+
+void CDlgFisheyeTrackCfg::InitCtrlState()
+{   
+	m_btnUp.m_dwPtzCommand        =  TILT_UP;
+	m_btnDown.m_dwPtzCommand      =  TILT_DOWN;
+	m_btnLeft.m_dwPtzCommand      =  PAN_LEFT;
+	m_btnRight.m_dwPtzCommand     =  PAN_RIGHT;
+	m_btnZoomIn.m_dwPtzCommand    =  ZOOM_IN;
+	m_btnZoomOut.m_dwPtzCommand   =  ZOOM_OUT;
+	m_btnFocusNear.m_dwPtzCommand =  FOCUS_NEAR;
+	m_btnFocusFar.m_dwPtzCommand  =  FOCUS_FAR;
+	m_btnIrisOpen.m_dwPtzCommand  =  IRIS_OPEN;
+	m_btnIrisClose.m_dwPtzCommand =  IRIS_CLOSE;
+
+	m_comboTransMode.ResetContent();
+	m_comboTransMode.InsertString(0,_T("Net SDK"));
+	m_comboTransMode.SetItemData(0,TRANS_MODE_NETSDK);
+	m_comboTransMode.InsertString(1,_T("RS485"));
+	m_comboTransMode.SetItemData(1,TRANS_MODE_RS485);
+	m_comboTransMode.SetCurSel(0);
+}
+
+BOOL CDlgFisheyeTrackCfg::GetTrackDevParam()
+{
+	DWORD dwReturn = 0;
+	BOOL bResult = FALSE;
+	
+	if (!NET_DVR_GetDVRConfig(m_lServerID,NET_DVR_GET_TRACK_DEV_PARAM,m_lChannel,&m_struTrackDevParam,sizeof(m_struTrackDevParam),&dwReturn))
+	{
+		g_pMainDlg->AddLog(m_lServerID, OPERATION_FAIL_T, "NET_DVR_GET_TRACK_DEV_PARAM");
+		bResult = FALSE;
+	}
+	else
+	{
+		g_pMainDlg->AddLog(m_lServerID, OPERATION_SUCC_T, "NET_DVR_GET_TRACK_DEV_PARAM");
+		bResult = TRUE;
+	}
+
+	return TRUE;
+}
+
+BOOL CDlgFisheyeTrackCfg::SetTrackDevParam()
+{   
+	BOOL bResult = FALSE;
+	if (!NET_DVR_SetDVRConfig(m_lServerID,NET_DVR_SET_TRACK_DEV_PARAM,m_lChannel,&m_struTrackDevParam,sizeof(m_struTrackDevParam)))
+	{
+		g_pMainDlg->AddLog(m_lServerID, OPERATION_FAIL_T, "NET_DVR_SET_TRACK_DEV_PARAM");
+		bResult = FALSE;
+	}
+	else
+	{
+		g_pMainDlg->AddLog(m_lServerID, OPERATION_SUCC_T, "NET_DVR_SET_TRACK_DEV_PARAM");
+		bResult = TRUE;
+	}
+
+	return bResult;
+}
+
+void CDlgFisheyeTrackCfg::LoadWndContent()
+{   
+	SetDlgItemInt(IDC_EDIT_CALIB_PT_NUM,m_struTrackDevParam.struCalParam.byPointNum);
+	m_comboCalibPtNO.ResetContent();
+	CString strItem = "";
+	int i = 0;
+	for (i = 0; i < m_struTrackDevParam.struCalParam.byPointNum && i < MAX_CALIB_PT; i++)
+	{
+		strItem.Format("%d",i + 1);
+		m_comboCalibPtNO.InsertString(i,strItem);
+		m_comboCalibPtNO.SetItemData(i,i + 1);
+	}
+	m_comboCalibPtNO.SetCurSel(0);
+
+	const NET_DVR_TRACK_CALIBRATION_PARAM_V41& struTrackCalib = m_struTrackDevParam.struCalParam;
+	m_nTrackDevHPosP  = HexToDec(struTrackCalib.struHorizonPtzPos.wPanPos);
+	m_nTrackDevHPosT  = HexToDec(struTrackCalib.struHorizonPtzPos.wTiltPos);
+	m_nTrackDevHPosZ  = HexToDec(struTrackCalib.struHorizonPtzPos.wZoomPos);
+
+	int nCurSelCBIndex = m_comboCalibPtNO.GetCurSel();
+	LoadCalibPointToWnd(nCurSelCBIndex);
+
+	m_bTrackDevEnable = m_struTrackDevParam.byEnable;
+
+	for (i = 0; i < m_comboTransMode.GetCount(); i++)
+	{
+		if (m_comboTransMode.GetItemData(i) == m_struTrackDevParam.byTransMode)
+		{
+			m_comboTransMode.SetCurSel(i);
+			break;
+		}
+	}
+
+	UpdateData(FALSE);
+}
+
+void CDlgFisheyeTrackCfg::SaveWndContent()
+{   
+	UpdateData(TRUE);
+
+	NET_DVR_TRACK_CALIBRATION_PARAM_V41& struTrackCalib = m_struTrackDevParam.struCalParam;
+	struTrackCalib.struHorizonPtzPos.wPanPos  = DecToHex(m_nTrackDevHPosP);
+	struTrackCalib.struHorizonPtzPos.wTiltPos = DecToHex(m_nTrackDevHPosT);
+	struTrackCalib.struHorizonPtzPos.wZoomPos = DecToHex(m_nTrackDevHPosZ);
+
+    int nCurSelCBIndex = m_comboCalibPtNO.GetCurSel();
+	SaveCalibPointFromWnd(nCurSelCBIndex);
+
+	m_struTrackDevParam.byEnable = m_bTrackDevEnable;
+	m_struTrackDevParam.byTransMode = m_comboTransMode.GetItemData(m_comboTransMode.GetCurSel());
+}
+
+
+void CDlgFisheyeTrackCfg::LoadCalibPointToWnd(int nIndex)
+{
+	const NET_DVR_TRACK_CALIBRATION_PARAM_V41& struTrackCalib = m_struTrackDevParam.struCalParam;
+	m_fFisheyePtX = struTrackCalib.struCBPoint[nIndex].struPoint.fX;
+	m_fFisheyePtY = struTrackCalib.struCBPoint[nIndex].struPoint.fY;
+	
+	m_nTrackDevPosP = HexToDec(struTrackCalib.struCBPoint[nIndex].struPtzPos.wPanPos);
+	m_nTrackDevPosT = HexToDec(struTrackCalib.struCBPoint[nIndex].struPtzPos.wTiltPos);
+	m_nTrackDevPosZ = HexToDec(struTrackCalib.struCBPoint[nIndex].struPtzPos.wZoomPos);
+     
+	NET_DVR_PTZPOS struPtzPos = struTrackCalib.struCBPoint[nIndex].struPtzPos;
+    
+	if (m_lTrackDevUserID != -1)
+	{   
+		struPtzPos.wAction = 1;
+		NET_DVR_SetDVRConfig(m_lTrackDevUserID,NET_DVR_SET_PTZPOS,m_lChannel,&struPtzPos,sizeof(NET_DVR_PTZPOS));
+	}
+}
+
+
+void CDlgFisheyeTrackCfg::SaveCalibPointFromWnd(int nIndex)
+{   
+	UpdateData(TRUE);
+
+	NET_DVR_TRACK_CALIBRATION_PARAM_V41& struTrackCalib = m_struTrackDevParam.struCalParam;
+	struTrackCalib.struCBPoint[nIndex].struPoint.fX = m_fFisheyePtX;
+	struTrackCalib.struCBPoint[nIndex].struPoint.fY = m_fFisheyePtY;
+	
+	struTrackCalib.struCBPoint[nIndex].struPtzPos.wPanPos  = DecToHex(m_nTrackDevPosP);
+	struTrackCalib.struCBPoint[nIndex].struPtzPos.wTiltPos = DecToHex(m_nTrackDevPosT);
+	struTrackCalib.struCBPoint[nIndex].struPtzPos.wZoomPos = DecToHex(m_nTrackDevPosZ);
+}
+
+
+void CDlgFisheyeTrackCfg::LoginTrackDev()
+{   
+	CWaitCursor wait;
+	if (m_lTrackDevUserID < 0)
+	{   
+		NET_DVR_DEVICEINFO_V30 struDevInfo = {0};
+		const NET_DVR_CHANNEL& struChannel = m_struTrackDevParam.struTrackDevChan;
+		m_lTrackDevUserID = NET_DVR_Login_V30((char*)struChannel.byAddress,struChannel.wDVRPort,(char*)struChannel.sUserName,
+			(char*)struChannel.sPassword,&struDevInfo);
+
+		if (m_lTrackDevUserID < 0)
+		{
+			g_pMainDlg->AddLog(-1, OPERATION_FAIL_T, "NET_DVR_Login_V30");
+			AfxMessageBox("Login track device failed");
+		}
+	}
+}
+
+void CDlgFisheyeTrackCfg::LogoutTrackDev()
+{
+	if (m_lTrackDevUserID >= 0)
+	{
+		StopTrackDevRealPlay();
+		if (!NET_DVR_Logout_V30(m_lTrackDevUserID))
+		{
+			g_pMainDlg->AddLog(-1, OPERATION_FAIL_T, "NET_DVR_Logout_V30");
+		}
+		m_lTrackDevUserID = -1;
+	}
+}
+
+void CDlgFisheyeTrackCfg::StartTrackDevRealPlay()
+{
+	NET_DVR_CLIENTINFO struPlay;
+	struPlay.hPlayWnd 	= GetDlgItem(IDC_TRACKDEV_PLAYWND)->GetSafeHwnd();
+	struPlay.lChannel 	= m_struTrackDevParam.struTrackDevChan.dwChannel; 
+	struPlay.lLinkMode 	= 0;
+	struPlay.sMultiCastIP = "";	
+	m_lTrackDevRealhandle = NET_DVR_RealPlay_V30(m_lTrackDevUserID, &struPlay, NULL,NULL, TRUE); 
+	BOOL bRet = FALSE;
+	if (m_lTrackDevRealhandle < 0)
+	{
+		g_pMainDlg->AddLog(-1, OPERATION_FAIL_T, "NET_DVR_RealPlay_V30");
+	}
+	else
+	{
+		g_pMainDlg->AddLog(-1, OPERATION_SUCC_T, "NET_DVR_RealPlay_V30");
+		NET_DVR_RigisterDrawFun(m_lTrackDevRealhandle, g_DrawTrackDevFun, 0);//DC Draw callback
+	}
+
+	CScenePTZButton::m_lPlayHandle = m_lTrackDevRealhandle;
+}
+
+void CDlgFisheyeTrackCfg::StopTrackDevRealPlay()
+{   
+	if (m_lTrackDevRealhandle >= 0)
+	{
+		if (!NET_DVR_StopRealPlay(m_lTrackDevRealhandle))
+		{
+			g_pMainDlg->AddLog(-1, OPERATION_FAIL_T, "NET_DVR_StopRealPlay");
+		}
+		m_lTrackDevRealhandle = -1;
+		GetDlgItem(IDC_TRACKDEV_PLAYWND)->Invalidate();
+	}
+}
+
+
+void CDlgFisheyeTrackCfg::DrawTrackDevFun(HDC hdc)
+{
+	CPen pen;
+	pen.CreatePen(PS_SOLID,1,RGB(0,255,0));
+	SelectObject(hdc,pen);
+
+	int nHCenter = m_rcTrackDevPlayWnd.Width() / 2;
+	int nVCenter = m_rcTrackDevPlayWnd.Height() / 2;
+
+	CPoint pt1(nHCenter - 15,nVCenter);
+	CPoint pt2(nHCenter + 15,nVCenter);
+	CPoint pt3(nHCenter,nVCenter - 15);
+	CPoint pt4(nHCenter,nVCenter + 15);
+
+	MoveToEx(hdc,pt1.x,pt1.y,NULL);
+	LineTo(hdc,pt2.x,pt2.y);
+
+	MoveToEx(hdc,pt3.x,pt3.y,NULL);
+	LineTo(hdc,pt4.x,pt4.y);
+}
+
+
+void CDlgFisheyeTrackCfg::DrawFisheyeFun(HDC hdc)
+{
+	const NET_DVR_TRACK_CALIBRATION_PARAM_V41& struTrackCalib = m_struTrackDevParam.struCalParam;
+
+	SetBkMode(hdc,TRANSPARENT);
+
+    for (int i = 0; i < struTrackCalib.byPointNum; i++)
+	{   
+		if (i == m_nCurCBIndex)
+		{
+			SetTextColor(hdc,RGB(255,0,0));
+		}
+		else
+		{
+			SetTextColor(hdc,RGB(0,255,0));
+		}
+		int nLeft = struTrackCalib.struCBPoint[i].struPoint.fX * m_rcFisheyePlayWnd.Width();
+		int nTop = struTrackCalib.struCBPoint[i].struPoint.fY * m_rcFisheyePlayWnd.Height();
+		int nRight = nLeft + 30;
+	    int nBottom = nTop + 20;
+		CRect rcText(nLeft,nTop,nRight,nBottom);
+		char szText[10] = "\0";
+		sprintf(szText,"+[%d]",i +1);
+		DrawText(hdc,szText,strlen(szText),rcText,DT_VCENTER | DT_LEFT);
+	}
+
+	if (m_nOperationType == OP_TYPE_TRACK && m_bDrawTrackPoint)
+	{   
+		CPoint pt;
+		GetCursorPos(&pt);
+		GetDlgItem(IDC_FISHEYE_PLAYWND)->ScreenToClient(&pt);
+		using namespace Gdiplus;
+		Graphics graphics(hdc);
+		SolidBrush  brush(Color(100, 255, 0, 0));
+		Rect rcEllipse(pt.x - 12, pt.y - 12, 24, 24);
+		graphics.FillEllipse(&brush,rcEllipse);
+
+	}
+}
+
+void CDlgFisheyeTrackCfg::OnBtnCalibPtNum() 
+{   
+	int nCalibPtNum = 0;
+	nCalibPtNum = GetDlgItemInt(IDC_EDIT_CALIB_PT_NUM);
+
+	if (nCalibPtNum < 2 || nCalibPtNum > MAX_CALIB_PT)
+	{
+		AfxMessageBox("Incorrect range,[2,6] is reasonable");
+		return;
+	}
+
+	m_struTrackDevParam.struCalParam.byPointNum = nCalibPtNum;
+
+	m_comboCalibPtNO.ResetContent();
+	CString strItem = "";
+	for (int i = 0; i < nCalibPtNum; i++)
+	{
+		strItem.Format("%d",i + 1);
+		m_comboCalibPtNO.InsertString(i,strItem);
+		m_comboCalibPtNO.SetItemData(i,i + 1);
+	}
+	m_comboCalibPtNO.SetCurSel(0);
+}
+
+void CDlgFisheyeTrackCfg::OnBtnGetTrackdevHorizonPos() 
+{   
+	LoginTrackDev();
+	if (m_lTrackDevUserID < 0)
+	{
+		return;
+	}
+	NET_DVR_PTZPOS struPtzPos = {0};
+	DWORD  dwReturn  = 0;
+	BOOL bRst  = NET_DVR_GetDVRConfig(m_lTrackDevUserID,NET_DVR_GET_PTZPOS,1,&struPtzPos,sizeof(struPtzPos),&dwReturn);
+	
+	if (!bRst)
+	{   
+		g_pMainDlg->AddLog(m_iDevIndex, OPERATION_FAIL_T, "NET_DVR_GET_PTZPOS Chan[%d]", m_struTrackDevParam.struTrackDevChan.dwChannel);
+		char szLan[32] = {0};
+		g_StringLanType(szLan, "获取PTZ坐标失败", "Get PTZ pos failed!");
+		AfxMessageBox(szLan);
+	}
+	else
+	{
+		m_nTrackDevHPosP  = HexToDec(struPtzPos.wPanPos);
+		m_nTrackDevHPosT  = HexToDec(struPtzPos.wTiltPos);
+		m_nTrackDevHPosZ  = HexToDec(struPtzPos.wZoomPos);
+	    UpdateData(FALSE);
+	}
+}
+
+void CDlgFisheyeTrackCfg::OnBtnGetTrackdevCalibPos() 
+{
+    LoginTrackDev();
+	if (m_lTrackDevUserID < 0)
+	{
+		return;
+	}
+
+	NET_DVR_PTZPOS struPtzPos = {0};
+	DWORD  dwReturn  = 0;
+	BOOL bRst  = NET_DVR_GetDVRConfig(m_lTrackDevUserID,NET_DVR_GET_PTZPOS,1,&struPtzPos,sizeof(struPtzPos),&dwReturn);
+	
+	if (!bRst)
+	{   
+		g_pMainDlg->AddLog(m_iDevIndex, OPERATION_FAIL_T, "NET_DVR_GET_PTZPOS Chan[%d]", m_struTrackDevParam.struTrackDevChan.dwChannel);
+		char szLan[32] = {0};
+		g_StringLanType(szLan, "获取PTZ坐标失败", "Get PTZ pos failed!");
+		AfxMessageBox(szLan);
+	}
+	else
+	{
+		m_nTrackDevPosP  = HexToDec(struPtzPos.wPanPos);
+		m_nTrackDevPosT  = HexToDec(struPtzPos.wTiltPos);
+		m_nTrackDevPosZ  = HexToDec(struPtzPos.wZoomPos);
+		UpdateData(FALSE);
+	}
+}
+
+void CDlgFisheyeTrackCfg::OnRadioCalib() 
+{
+	m_nOperationType = OP_TYPE_CALIB;
+	CheckDlgButton(IDC_RADIO_CALIB,BST_CHECKED);
+	CheckDlgButton(IDC_RADIO_TRACK,BST_UNCHECKED);
+	EnableCalib(TRUE);
+}
+
+void CDlgFisheyeTrackCfg::OnRadioTrack() 
+{
+	m_nOperationType = OP_TYPE_TRACK;
+	CheckDlgButton(IDC_RADIO_CALIB,BST_UNCHECKED);
+	CheckDlgButton(IDC_RADIO_TRACK,BST_CHECKED);
+	EnableCalib(FALSE);
+}
+
+
+void CDlgFisheyeTrackCfg::EnableCalib(BOOL bEnable)
+{
+	GetDlgItem(IDC_BTN_GET_TRACKDEV_HORIZON_POS)->EnableWindow(bEnable);
+	GetDlgItem(IDC_BTN_GET_TRACKDEV_CALIB_POS)->EnableWindow(bEnable);
+	GetDlgItem(IDC_BTN_CALIB_PT_NUM)->EnableWindow(bEnable);
+	GetDlgItem(IDC_COMBO_CALIB_PT_NO)->EnableWindow(bEnable);
+	GetDlgItem(IDC_BTN_TILT_UP)->EnableWindow(bEnable);
+	GetDlgItem(IDC_BTN_TILT_DOWN)->EnableWindow(bEnable);
+	GetDlgItem(IDC_BTN_PAN_LEFT)->EnableWindow(bEnable);
+	GetDlgItem(IDC_BTN_PAN_RIGHT)->EnableWindow(bEnable);
+
+
+	GetDlgItem(IDC_BTN_ZOOM_OUT)->EnableWindow(bEnable);
+	GetDlgItem(IDC_BTN_ZOOM_IN)->EnableWindow(bEnable);
+	GetDlgItem(IDC_BTN_FOCUS_NEAR)->EnableWindow(bEnable);
+	GetDlgItem(IDC_BTN_FOCUS_FAR)->EnableWindow(bEnable);
+	GetDlgItem(IDC_BTN_IRIS_CLOSE)->EnableWindow(bEnable);
+	GetDlgItem(IDC_BTN_IRIS_OPEN)->EnableWindow(bEnable);
+	GetDlgItem(IDC_BTN_SAVE)->EnableWindow(bEnable);
+}

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgGetDigitalChannelStatus.cpp

@@ -0,0 +1,232 @@
+// DlgGetDigitalChannelStatus.cpp : implementation file
+//
+
+#include "stdafx.h"
+#include "clientdemo.h"
+#include "DlgGetDigitalChannelStatus.h"
+
+#ifdef _DEBUG
+#define new DEBUG_NEW
+#undef THIS_FILE
+static char THIS_FILE[] = __FILE__;
+#endif
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgGetDigitalChannelStatus dialog
+
+
+CDlgGetDigitalChannelStatus::CDlgGetDigitalChannelStatus(CWnd* pParent /*=NULL*/)
+	: CDialog(CDlgGetDigitalChannelStatus::IDD, pParent)
+{
+	//{{AFX_DATA_INIT(CDlgGetDigitalChannelStatus)
+	m_strDChannelStatus = _T("");
+	//}}AFX_DATA_INIT
+}
+
+
+void CDlgGetDigitalChannelStatus::DoDataExchange(CDataExchange* pDX)
+{
+	CDialog::DoDataExchange(pDX);
+	//{{AFX_DATA_MAP(CDlgGetDigitalChannelStatus)
+	DDX_Text(pDX, IDC_EDIT_CHANNEL_STATUS, m_strDChannelStatus);
+	//}}AFX_DATA_MAP
+}
+
+
+BEGIN_MESSAGE_MAP(CDlgGetDigitalChannelStatus, CDialog)
+	//{{AFX_MSG_MAP(CDlgGetDigitalChannelStatus)
+	ON_BN_CLICKED(IDC_BUTTON_GET, OnButtonGet)
+	//}}AFX_MSG_MAP
+END_MESSAGE_MAP()
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgGetDigitalChannelStatus message handlers
+
+void CDlgGetDigitalChannelStatus::OnButtonGet() 
+{
+	// TODO: Add your control notification handler code here
+	m_strDChannelStatus = "";
+
+	NET_DVR_DIGITAL_CHANNEL_STATE struDChannelState = {0};
+	DWORD dwReturnValue = 0; 
+	if (!NET_DVR_GetDVRConfig(m_lUserID, NET_DVR_GET_DIGITAL_CHANNEL_STATE, 0, &struDChannelState, sizeof(struDChannelState), &dwReturnValue))
+	{
+		char szLan[256] = {0};
+		g_StringLanType(szLan, "»ñȡʧ°Ü!", "Fail to Get !");
+		g_pMainDlg->AddLog(m_dwDevIndex, OPERATION_FAIL_T, "NET_DVR_GET_DIGITAL_CHANNEL_STATE");
+        AfxMessageBox(szLan);
+		return;
+	}
+	else
+	{
+		g_pMainDlg->AddLog(m_dwDevIndex, OPERATION_SUCC_T, "NET_DVR_GET_DIGITAL_CHANNEL_STATE");
+	}
+	
+    NET_DVR_DIGITAL_CHANNEL_SECURITY_STATUS struSecurityStatus = {0};
+    if (!NET_DVR_GetDVRConfig(m_lUserID, NET_DVR_GET_DIGITAL_CHAN_SECURITY_STATUS, 0, &struSecurityStatus, sizeof(struSecurityStatus), &dwReturnValue))
+    {
+        g_pMainDlg->AddLog(m_dwDevIndex, OPERATION_FAIL_T, "NET_DVR_GET_DIGITAL_CHAN_SECURITY_STATUS");
+    }
+    else
+    {
+        g_pMainDlg->AddLog(m_dwDevIndex, OPERATION_SUCC_T, "NET_DVR_GET_DIGITAL_CHAN_SECURITY_STATUS");
+    }
+
+	CString strTemp;
+    int i = 0;
+	for (i=0; i<64; i++)
+	{
+		switch (struDChannelState.byDigitalChanState[i])
+        {
+        case NET_SDK_DC_STATUS_CONNECTED:
+            strTemp.Format("DigitalChanState[%d] is Connected\r\n",  i);
+            break;
+        case NET_SDK_DC_STATUS_CONNECTING:
+            strTemp.Format("DigitalChanState[%d] is Connecting\r\n",  i);
+            break;
+        case NET_SDK_DC_STATUS_BAND_WIDTH_EXCEED:
+            strTemp.Format("DigitalChanState[%d] is Band Width Exceed\r\n",  i );
+            break;
+        case NET_SDK_DC_STATUS_DOMAIN_ERROR:
+            strTemp.Format("DigitalChanState[%d] is Domain Error\r\n",  i);
+            break;
+        case NET_SDK_DC_STATUS_CHANNEL_ERROR:
+            strTemp.Format("DigitalChanState[%d] is Channel Error\r\n",  i);
+            break;
+        case NET_SDK_DC_STATUS_ACCOUNT_ERROR:
+            strTemp.Format("DigitalChanState[%d] is Account Error\r\n",  i);
+            break;
+        case NET_SDK_DC_STATUS_STREAM_TYPE_NOT_SUPPORT:
+            strTemp.Format("DigitalChanState[%d] is not support Stream Type \r\n",  i);
+            break;
+        case NET_SDK_DC_STATUS_CONFLICT_WITH_DVR:
+            strTemp.Format("DigitalChanState[%d] is Conflict With Dvr\r\n",  i);
+            break;
+			
+        case NET_SDK_DC_STATUS_CONFLICT_WITH_IPC:
+            strTemp.Format("DigitalChanState[%d] is Conflict with IPC\r\n",  i);
+            break;
+        case NET_SDK_DC_STATUS_NETWORK_UNREACHBALE:
+            strTemp.Format("DigitalChanState[%d] is NetWork Unreachbale\r\n",  i);
+            break;
+        case NET_SDK_DC_STATUS_IPC_NOT_EXIST:
+            strTemp.Format("DigitalChanState[%d] is IPC not Exit\r\n",  i);
+            break;
+            
+        case NET_SDK_DC_STATUS_IPC_EXCEPTION:
+            strTemp.Format("DigitalChanState[%d] is IPC Exception\r\n",  i);
+            break;
+        case NET_SDK_DC_STATUS_RESOLUTION_NOT_SUPPORT:
+            strTemp.Format("DigitalChanState[%d] is Not Support Resolution \r\n",  i);
+            break;
+        case NET_SDK_DC_STATUS_OTHER_ERROR:
+            strTemp.Format("DigitalChanState[%d] is Other Error \r\n",  i);
+            break;
+        case NET_SDK_DC_STATUS_IPC_LAN_ERR :
+            strTemp.Format("DigitalChanState[%d] is language mismatch\r\n", i);
+            break;
+        case NET_SDK_DC_STATUS_USER_LOCKED:
+            strTemp.Format("DigitalChanState[%d] is user locked\r\n", i);
+            break;
+        case NET_SDK_DC_STATUS_NOT_ACTIVATED:
+            strTemp.Format("DigitalChanState[%d] is not activated\r\n",  i);
+            break;
+        case NET_SDK_DC_STATUS_USER_NOT_EXIST:
+            strTemp.Format("DigitalChanState[%d] is user not exist\r\n", i);
+            break;
+        case NET_SDK_DC_STATUS_IPC_UNREGISTERED:
+            strTemp.Format("DigitalChanState[%d] is ipc unregistered\r\n", i);
+            break;
+        case NET_SDK_DC_STATUS_POE_PORT_DETECTING:
+            strTemp.Format("DigitalChanState[%d] is poe port detecting\r\n", i);
+            break;
+        default:
+            strTemp.Format("DigitalChanState[%d] is UnKnown Error \r\n",  i);
+            break;
+        }
+        m_strDChannelStatus += strTemp;
+        strTemp.Format("DigitalChanState[%d] security status is[%d]\r\n", i, struSecurityStatus.byDigitalChanPasswordStatus[i]);
+        m_strDChannelStatus += strTemp;
+    }
+	
+	for (i = 0; i < MAX_CHANNUM_V30*3; i++)
+	{
+		switch (struDChannelState.byDigitalChanStateEx[i])
+        {
+        case NET_SDK_DC_STATUS_CONNECTING:
+            strTemp.Format("DigitalChanState[%d] is Connected\r\n",  i+64);
+            break;
+        case NET_SDK_DC_STATUS_BAND_WIDTH_EXCEED:
+            strTemp.Format("DigitalChanState[%d] is Band Width Exceed\r\n",  i+64);
+            break;
+        case NET_SDK_DC_STATUS_DOMAIN_ERROR:
+            strTemp.Format("DigitalChanState[%d] is Domain Error\r\n",  i+64);
+            break;
+        case NET_SDK_DC_STATUS_CHANNEL_ERROR:
+            strTemp.Format("DigitalChanState[%d] is Channel Error\r\n",  i+64);
+            break;
+        case NET_SDK_DC_STATUS_ACCOUNT_ERROR:
+            strTemp.Format("DigitalChanState[%d] is Account Error\r\n",  i+64);
+            break;
+        case NET_SDK_DC_STATUS_STREAM_TYPE_NOT_SUPPORT:
+            strTemp.Format("DigitalChanState[%d] is not support Stream Type \r\n",  i+64);
+            break;
+        case NET_SDK_DC_STATUS_CONFLICT_WITH_DVR:
+            strTemp.Format("DigitalChanState[%d] is Conflict With Dvr\r\n",  i+64);
+            break;
+			
+        case NET_SDK_DC_STATUS_CONFLICT_WITH_IPC:
+            strTemp.Format("DigitalChanState[%d] is Conflict with IPC\r\n",  i+64);
+            break;
+        case NET_SDK_DC_STATUS_NETWORK_UNREACHBALE:
+            strTemp.Format("DigitalChanState[%d] is NetWork Unreachbale\r\n",  i+64);
+            break;
+        case NET_SDK_DC_STATUS_IPC_NOT_EXIST:
+            strTemp.Format("DigitalChanState[%d] is IPC not Exit\r\n",  i+64);
+            break;
+            
+        case NET_SDK_DC_STATUS_IPC_EXCEPTION:
+            strTemp.Format("DigitalChanState[%d] is IPC Exception\r\n",  i+64);
+            break;
+        case NET_SDK_DC_STATUS_RESOLUTION_NOT_SUPPORT:
+            strTemp.Format("DigitalChanState[%d] is Not Support Resolution \r\n", i+64);
+            break;
+        case NET_SDK_DC_STATUS_OTHER_ERROR:
+            strTemp.Format("DigitalChanState[%d] is Other Error \r\n",  i+64);
+            break;
+        case NET_SDK_DC_STATUS_IPC_LAN_ERR :
+            strTemp.Format("DigitalChanState[%d] is language mismatch\r\n", i+64);
+            break;
+        case NET_SDK_DC_STATUS_USER_LOCKED:
+            strTemp.Format("DigitalChanState[%d] is user locked\r\n", i+64);
+            break;
+        case NET_SDK_DC_STATUS_NOT_ACTIVATED:
+            strTemp.Format("DigitalChanState[%d] is not activated\r\n",  i+64);
+            break;
+        case NET_SDK_DC_STATUS_USER_NOT_EXIST:
+            strTemp.Format("DigitalChanState[%d] is user not exist\r\n", i+64);
+            break;
+        case NET_SDK_DC_STATUS_IPC_UNREGISTERED:
+            strTemp.Format("DigitalChanState[%d] is ipc unregistered\r\n", i+64);
+            break;
+        default:
+            strTemp.Format("DigitalChanState[%d] is UnKnown Error \r\n",  i+64);
+            break;
+        }
+        m_strDChannelStatus += strTemp;
+        strTemp.Format("DigitalChanState[%d] security status is[%d]\r\n", i+64, struSecurityStatus.byDigitalChanPasswordStatus[i+64]);
+        m_strDChannelStatus += strTemp;
+	}
+	
+	UpdateData(FALSE);
+}
+
+BOOL CDlgGetDigitalChannelStatus::OnInitDialog() 
+{
+	CDialog::OnInitDialog();
+	
+	// TODO: Add extra initialization here
+	
+	return TRUE;  // return TRUE unless you set the focus to a control
+	              // EXCEPTION: OCX Property Pages should return FALSE
+}

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgGroupCfg.cpp

@@ -0,0 +1,148 @@
+// DlgGroupCfg.cpp : implementation file
+//
+
+#include "stdafx.h"
+#include "clientdemo.h"
+#include "DlgGroupCfg.h"
+
+#ifdef _DEBUG
+#define new DEBUG_NEW
+#undef THIS_FILE
+static char THIS_FILE[] = __FILE__;
+#endif
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgGroupCfg dialog
+
+
+CDlgGroupCfg::CDlgGroupCfg(CWnd* pParent /*=NULL*/)
+	: CDialog(CDlgGroupCfg::IDD, pParent)
+{
+	//{{AFX_DATA_INIT(CDlgGroupCfg)
+	m_bEnable = FALSE;
+	m_bValidEnable = FALSE;
+	m_csGroupName = _T("");
+	m_startDate = COleDateTime::GetCurrentTime();
+	m_startTime = COleDateTime::GetCurrentTime();
+	m_stopDate = COleDateTime::GetCurrentTime();
+	m_stopTime = COleDateTime::GetCurrentTime();
+	m_dwGroupNo = 1;
+	//}}AFX_DATA_INIT
+
+    m_lUserID = -1;
+	m_lChannel = -1;
+	m_iDevIndex = -1;
+
+	memset(&m_struGroupCfg, 0, sizeof(m_struGroupCfg));
+}
+
+
+void CDlgGroupCfg::DoDataExchange(CDataExchange* pDX)
+{
+	CDialog::DoDataExchange(pDX);
+	//{{AFX_DATA_MAP(CDlgGroupCfg)
+	DDX_Check(pDX, IDC_CHECK_ENABLE, m_bEnable);
+	DDX_Check(pDX, IDC_CHECK_VALID_ENABLE, m_bValidEnable);
+	DDX_Text(pDX, IDC_EDIT_GROUP_NAME, m_csGroupName);
+	DDX_DateTimeCtrl(pDX, IDC_START_DATE, m_startDate);
+	DDX_DateTimeCtrl(pDX, IDC_START_TIME, m_startTime);
+	DDX_DateTimeCtrl(pDX, IDC_STOP_DATE, m_stopDate);
+	DDX_DateTimeCtrl(pDX, IDC_STOP_TIME, m_stopTime);
+	DDX_Text(pDX, IDC_EDIT_GROUP_GROUPNO, m_dwGroupNo);
+    DDX_Control(pDX, IDC_CMB_TIME_TYPE, m_cmbTimeType);
+	//}}AFX_DATA_MAP
+}
+
+
+BEGIN_MESSAGE_MAP(CDlgGroupCfg, CDialog)
+	//{{AFX_MSG_MAP(CDlgGroupCfg)
+	ON_BN_CLICKED(IDC_BTN_GET_GROUP_CFG, OnBtnGetGroupCfg)
+	ON_BN_CLICKED(IDC_BTN_SET_GROUP_CFG, OnBtnSetGroupCfg)
+	//}}AFX_MSG_MAP
+END_MESSAGE_MAP()
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgGroupCfg message handlers
+
+BOOL CDlgGroupCfg::OnInitDialog() 
+{
+	CDialog::OnInitDialog();
+	
+	// TODO: Add extra initialization here
+	OnBtnGetGroupCfg() ;
+	return TRUE;  // return TRUE unless you set the focus to a control
+	              // EXCEPTION: OCX Property Pages should return FALSE
+}
+
+void CDlgGroupCfg::OnBtnGetGroupCfg() 
+{
+	// TODO: Add your control notification handler code here
+    UpdateData(TRUE); 
+	DWORD dwReturn = 0;
+	
+ 	memset(&m_struGroupCfg, 0, sizeof(m_struGroupCfg));
+    if (NET_DVR_GetDVRConfig(m_lUserID, NET_DVR_GET_GROUP_CFG, m_dwGroupNo, &m_struGroupCfg, sizeof(m_struGroupCfg), &dwReturn))
+    {
+        g_pMainDlg->AddLog(m_iDevIndex, OPERATION_SUCC_T, "NET_DVR_GET_GROUP_CFG");
+    }
+    else
+    {
+        g_pMainDlg->AddLog(m_iDevIndex, OPERATION_FAIL_T, "NET_DVR_GET_GROUP_CFG");
+        return;
+    }
+
+	m_bEnable = m_struGroupCfg.byEnable;
+	m_csGroupName.Format(_T("%s"), m_struGroupCfg.byGroupName);
+	m_bValidEnable = m_struGroupCfg.struValidPeriodCfg.byEnable;
+    if (m_struGroupCfg.struValidPeriodCfg.struBeginTime.wYear != 0)
+    {
+        m_startDate.SetDate(m_struGroupCfg.struValidPeriodCfg.struBeginTime.wYear, m_struGroupCfg.struValidPeriodCfg.struBeginTime.byMonth, m_struGroupCfg.struValidPeriodCfg.struBeginTime.byDay);
+    }
+	m_startTime.SetTime(m_struGroupCfg.struValidPeriodCfg.struBeginTime.byHour, m_struGroupCfg.struValidPeriodCfg.struBeginTime.byMinute, m_struGroupCfg.struValidPeriodCfg.struBeginTime.bySecond);
+    if (m_struGroupCfg.struValidPeriodCfg.struEndTime.wYear != 0)
+    {
+        m_stopDate.SetDate(m_struGroupCfg.struValidPeriodCfg.struEndTime.wYear, m_struGroupCfg.struValidPeriodCfg.struEndTime.byMonth, m_struGroupCfg.struValidPeriodCfg.struEndTime.byDay);
+    }
+	m_stopTime.SetTime(m_struGroupCfg.struValidPeriodCfg.struEndTime.byHour, m_struGroupCfg.struValidPeriodCfg.struEndTime.byMinute, m_struGroupCfg.struValidPeriodCfg.struEndTime.bySecond);
+    m_cmbTimeType.SetCurSel(m_struGroupCfg.struValidPeriodCfg.byTimeType);
+	UpdateData(FALSE);
+}
+
+void CDlgGroupCfg::OnBtnSetGroupCfg() 
+{
+	// TODO: Add your control notification handler code here
+	UpdateData(TRUE);
+	
+	memset(&m_struGroupCfg, 0, sizeof(m_struGroupCfg));
+	m_struGroupCfg.dwSize = sizeof(m_struGroupCfg);
+	m_struGroupCfg.byEnable = m_bEnable;
+	memcpy(m_struGroupCfg.byGroupName, m_csGroupName, m_csGroupName.GetLength());
+
+	m_struGroupCfg.struValidPeriodCfg.byEnable = m_bValidEnable;
+	m_struGroupCfg.struValidPeriodCfg.struBeginTime.wYear = m_startDate.GetYear();
+	m_struGroupCfg.struValidPeriodCfg.struBeginTime.byMonth = m_startDate.GetMonth();
+	m_struGroupCfg.struValidPeriodCfg.struBeginTime.byDay = m_startDate.GetDay();
+	m_struGroupCfg.struValidPeriodCfg.struBeginTime.byHour = m_startTime.GetHour();
+	m_struGroupCfg.struValidPeriodCfg.struBeginTime.byMinute = m_startTime.GetMinute();
+	m_struGroupCfg.struValidPeriodCfg.struBeginTime.bySecond = m_startTime.GetSecond();
+	
+	m_struGroupCfg.struValidPeriodCfg.struEndTime.wYear = m_stopDate.GetYear();
+	m_struGroupCfg.struValidPeriodCfg.struEndTime.byMonth = m_stopDate.GetMonth();
+	m_struGroupCfg.struValidPeriodCfg.struEndTime.byDay = m_stopDate.GetDay();
+	m_struGroupCfg.struValidPeriodCfg.struEndTime.byHour = m_stopTime.GetHour();
+	m_struGroupCfg.struValidPeriodCfg.struEndTime.byMinute = m_stopTime.GetMinute();
+	m_struGroupCfg.struValidPeriodCfg.struEndTime.bySecond = m_stopTime.GetSecond();
+
+    m_struGroupCfg.struValidPeriodCfg.byTimeType = m_cmbTimeType.GetCurSel();
+
+	if (NET_DVR_SetDVRConfig(m_lUserID, NET_DVR_SET_GROUP_CFG, m_dwGroupNo, &m_struGroupCfg, sizeof(m_struGroupCfg)))
+    {
+        g_pMainDlg->AddLog(m_iDevIndex, OPERATION_SUCC_T, "NET_DVR_SET_GROUP_CFG");
+    }
+    else
+    {
+        g_pMainDlg->AddLog(m_iDevIndex, OPERATION_FAIL_T, "NET_DVR_SET_GROUP_CFG");
+        return;
+    }
+
+}

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgIOOutCfg.cpp

@@ -0,0 +1,294 @@
+// DlgIOOutCfg.cpp : implementation file
+//
+
+#include "stdafx.h"
+#include "clientdemo.h"
+#include "DlgIOOutCfg.h"
+
+#ifdef _DEBUG
+#define new DEBUG_NEW
+#undef THIS_FILE
+static char THIS_FILE[] = __FILE__;
+#endif
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgIOOutCfg dialog
+
+
+CDlgIOOutCfg::CDlgIOOutCfg(CWnd* pParent /*=NULL*/)
+	: CDialog(CDlgIOOutCfg::IDD, pParent)
+{
+	//{{AFX_DATA_INIT(CDlgIOOutCfg)
+	m_bChkFlashLightEnable = FALSE;
+	m_byEndHour = 0;
+	m_byDutyRatio = 0;
+	m_byEndMin = 0;
+	m_byFreqMulti = 0;
+	m_byStartHour = 0;
+	m_byStartMin = 0;
+	//}}AFX_DATA_INIT
+
+	memset(&m_struIOOutCfgCond, 0, sizeof(NET_DVR_IOOUT_COND));
+	memset(&m_struIOOutCfg, 0 , sizeof(NET_DVR_IOOUT_CFG));
+
+}
+
+void CDlgIOOutCfg::DoDataExchange(CDataExchange* pDX)
+{
+	CDialog::DoDataExchange(pDX);
+	//{{AFX_DATA_MAP(CDlgIOOutCfg)
+	DDX_Control(pDX, IDC_COMBO_DEFAULTSTATE, m_cbDefaultState);
+	DDX_Control(pDX, IDC_COMBO_WORKSTATE, m_cbWorkState);
+	DDX_Control(pDX, IDC_COMBO_WORKMODE, m_cbWorkMode);
+	DDX_Control(pDX, IDC_COMBO_SYNC_OUTPUTNO, m_cbSyncOutputNo);
+	DDX_Check(pDX, IDC_CHECK_ENABLE_FLASHLIGHT, m_bChkFlashLightEnable);
+	DDX_Text(pDX, IDC_EDIT_ENDHOUR, m_byEndHour);
+	DDX_Text(pDX, IDC_EDIT_DUTYRATIO, m_byDutyRatio);
+	DDX_Text(pDX, IDC_EDIT_ENDMIN, m_byEndMin);
+	DDX_Text(pDX, IDC_EDIT_FREQMULTI, m_byFreqMulti);
+	DDX_Text(pDX, IDC_EDIT_STARTHOUR, m_byStartHour);
+	DDX_Text(pDX, IDC_EDIT_STARTMIN, m_byStartMin);
+	//}}AFX_DATA_MAP
+}
+
+
+BEGIN_MESSAGE_MAP(CDlgIOOutCfg, CDialog)
+	//{{AFX_MSG_MAP(CDlgIOOutCfg)
+	ON_BN_CLICKED(IDC_BUTTON_GET, OnButtonGet)
+	ON_BN_CLICKED(IDC_CHECK_ENABLE_FLASHLIGHT, OnCheckEnableFlashlight)
+	ON_CBN_SELCHANGE(IDC_COMBO_WORKMODE, OnSelchangeComboWorkmode)
+	ON_BN_CLICKED(IDC_BUTTON_SET, OnButtonSet)
+	ON_CBN_SELCHANGE(IDC_COMBO_SYNC_OUTPUTNO, OnSelchangeComboSyncOutputno)
+	//}}AFX_MSG_MAP
+END_MESSAGE_MAP()
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgIOOutCfg message handlers
+
+void CDlgIOOutCfg::OnButtonGet() 
+{
+	// TODO: Add your control notification handler code here
+	
+	//获取前清空
+	memset(&m_struIOOutCfg,0,sizeof(NET_DVR_IOOUT_CFG));
+	m_struIOOutCfgCond.bySyncOutputNo = m_cbSyncOutputNo.GetCurSel();
+
+	m_struIOOutCfgCond.dwSize = sizeof(NET_DVR_IOOUT_COND);
+	m_struIOOutCfg.dwSize = sizeof(NET_DVR_IOOUT_CFG);
+ 
+	CString strErr;
+  	BOOL bRet = NET_DVR_GetDeviceConfig(m_lUserID, NET_DVR_GET_IOOUT_CFG, 1, &m_struIOOutCfgCond, \
+		sizeof(NET_DVR_IOOUT_COND),&m_iStatus, &m_struIOOutCfg,	sizeof(NET_DVR_IOOUT_CFG));
+	if (bRet)
+	{
+		if (m_iStatus == 0) 
+		{
+			UpdateCtrlData(); //更新并显示第i索引的数据
+		 	g_pMainDlg->AddLog(m_iDeviceIndex, OPERATION_SUCC_T, "NET_DVR_GET_IOOUT_CFG Suss!");
+		}
+		else
+		{
+			g_pMainDlg->AddLog(m_iDeviceIndex, OPERATION_FAIL_T, "NET_DVR_GET_IOOUT_CFG Failed!");
+		}
+	}
+	else
+	{
+		strErr.Format("NET_DVR_GET_IOOUT_CFG failed! err Code[%d]", NET_DVR_GetLastError());
+		MessageBox(strErr);
+		return;
+	}	
+	UpdateData(FALSE);
+}
+
+BOOL CDlgIOOutCfg::OnInitDialog() 
+{
+	CDialog::OnInitDialog();
+	
+	// TODO: Add extra initialization here
+	m_cbSyncOutputNo.SetCurSel(0);
+	EnableWindows(TRUE);
+	EnableTimeCtrl(m_bChkFlashLightEnable);
+	return TRUE;  // return TRUE unless you set the focus to a control
+	              // EXCEPTION: OCX Property Pages should return FALSE
+}
+
+void CDlgIOOutCfg::UpdateCtrlData()
+{
+	m_cbWorkMode.SetCurSel(m_struIOOutCfg.byWorkMode);
+	if (m_struIOOutCfg.byWorkMode == 1) //如果是频闪模式
+	{
+		EnableWindows(TRUE); //控件窗口使能
+		m_cbWorkState.SetCurSel(m_struIOOutCfg.uWorkModeInfo.struStrobeLamp.byWorkState);
+		m_cbDefaultState.SetCurSel(m_struIOOutCfg.uWorkModeInfo.struStrobeLamp.byDefaultState);
+		m_byFreqMulti = m_struIOOutCfg.uWorkModeInfo.struStrobeLamp.byFreqMulti;
+		m_byDutyRatio = m_struIOOutCfg.uWorkModeInfo.struStrobeLamp.byDutyRatio;
+		m_bChkFlashLightEnable = m_struIOOutCfg.uWorkModeInfo.struStrobeLamp.byFlashLightEnable;
+			
+		if (m_bChkFlashLightEnable)
+		{
+			EnableTimeCtrl(TRUE); //使能时间控制
+			m_byStartHour = m_struIOOutCfg.uWorkModeInfo.struStrobeLamp.struFlashLightTime.byStartHour;
+			m_byStartMin = m_struIOOutCfg.uWorkModeInfo.struStrobeLamp.struFlashLightTime.byStartMin;
+			m_byEndHour = m_struIOOutCfg.uWorkModeInfo.struStrobeLamp.struFlashLightTime.byStopHour;
+			m_byEndMin = m_struIOOutCfg.uWorkModeInfo.struStrobeLamp.struFlashLightTime.byStopMin;
+		}
+		else
+			EnableTimeCtrl(FALSE);
+	}
+	else
+	{
+		EnableWindows(FALSE); //当前界面显示参数无效
+		EnableTimeCtrl(FALSE);
+	}
+	UpdateData(FALSE);
+}
+
+void CDlgIOOutCfg::EnableWindows(BOOL bEnable)
+{
+	GetDlgItem(IDC_STATIC_DEFAULTSTATE)->EnableWindow(bEnable);
+	GetDlgItem(IDC_COMBO_DEFAULTSTATE)->EnableWindow(bEnable);
+	GetDlgItem(IDC_STATIC_WORKSTATE)->EnableWindow(bEnable);
+	GetDlgItem(IDC_COMBO_WORKSTATE)->EnableWindow(bEnable);
+	GetDlgItem(IDC_STATIC_FREQMULTI)->EnableWindow(bEnable);
+	GetDlgItem(IDC_EDIT_FREQMULTI)->EnableWindow(bEnable);
+	GetDlgItem(IDC_STATIC_DUTYRATIO)->EnableWindow(bEnable);
+	GetDlgItem(IDC_EDIT_DUTYRATIO)->EnableWindow(bEnable);
+	GetDlgItem(IDC_STATIC_PERCENT)->EnableWindow(bEnable);
+	GetDlgItem(IDC_CHECK_ENABLE_FLASHLIGHT)->EnableWindow(bEnable);
+// 	GetDlgItem(IDC_STATIC_STARTTIME)->EnableWindow(bEnable);
+// 	GetDlgItem(IDC_EDIT_STARTHOUR)->EnableWindow(bEnable);
+// 	GetDlgItem(IDC_STATIC_STARTHOUR)->EnableWindow(bEnable);
+// 	GetDlgItem(IDC_EDIT_STARTMIN)->EnableWindow(bEnable);
+// 	GetDlgItem(IDC_STATIC_STARTMIN)->EnableWindow(bEnable);
+// 	GetDlgItem(IDC_STATIC_ENDTIME)->EnableWindow(bEnable);
+// 	GetDlgItem(IDC_EDIT_ENDHOUR)->EnableWindow(bEnable);
+// 	GetDlgItem(IDC_STATIC_ENDHOUR)->EnableWindow(bEnable);
+// 	GetDlgItem(IDC_EDIT_ENDMIN)->EnableWindow(bEnable);
+// 	GetDlgItem(IDC_STATIC_ENDMIN)->EnableWindow(bEnable);
+
+	UpdateData(TRUE);//控件有效的前提下才去判断时间控件是否有效
+	if (bEnable)
+	{
+		EnableTimeCtrl(m_bChkFlashLightEnable);
+	}
+	else
+	{
+		EnableTimeCtrl(FALSE);
+	}
+}
+
+void CDlgIOOutCfg::EnableTimeCtrl(BOOL bEnable)
+{
+	GetDlgItem(IDC_STATIC_STARTTIME)->EnableWindow(bEnable);
+	GetDlgItem(IDC_EDIT_STARTHOUR)->EnableWindow(bEnable);
+	GetDlgItem(IDC_STATIC_STARTHOUR)->EnableWindow(bEnable);
+	GetDlgItem(IDC_EDIT_STARTMIN)->EnableWindow(bEnable);
+	GetDlgItem(IDC_STATIC_STARTMIN)->EnableWindow(bEnable);
+	GetDlgItem(IDC_STATIC_ENDTIME)->EnableWindow(bEnable);
+	GetDlgItem(IDC_EDIT_ENDHOUR)->EnableWindow(bEnable);
+	GetDlgItem(IDC_STATIC_ENDHOUR)->EnableWindow(bEnable);
+	GetDlgItem(IDC_EDIT_ENDMIN)->EnableWindow(bEnable);
+	GetDlgItem(IDC_STATIC_ENDMIN)->EnableWindow(bEnable);
+}
+
+void CDlgIOOutCfg::OnCheckEnableFlashlight() 
+{
+	// TODO: Add your control notification handler code here
+	UpdateData(TRUE);
+	EnableTimeCtrl(m_bChkFlashLightEnable);
+}
+
+void CDlgIOOutCfg::OnSelchangeComboWorkmode() 
+{
+	// TODO: Add your control notification handler code here
+	if (m_cbWorkMode.GetCurSel() == 0)
+	{
+		EnableWindows(FALSE);
+	}
+	else
+		EnableWindows(TRUE);
+}
+
+void CDlgIOOutCfg::OnButtonSet() 
+{
+	// TODO: Add your control notification handler code here
+	
+	SaveData();
+	char szLan[128]={0};
+	if (m_cbWorkMode.GetCurSel() == -1)	 	
+	{
+		g_StringLanType(szLan,"请选择要配置的工作模式!","please select the work mode to be set!");
+		MessageBox(szLan);
+		return;
+	}
+
+	m_struIOOutCfgCond.dwSize = sizeof(NET_DVR_IOOUT_COND);
+	m_struIOOutCfg.dwSize = sizeof(NET_DVR_IOOUT_CFG);
+
+	CString strErr;
+	BOOL bRet = NET_DVR_SetDeviceConfig(m_lUserID,NET_DVR_SET_IOOUT_CFG,1,&m_struIOOutCfgCond,sizeof(NET_DVR_IOOUT_COND),\
+							&m_iStatus,&m_struIOOutCfg,sizeof(NET_DVR_IOOUT_CFG));
+	if (bRet)
+	{
+		if (m_iStatus== 0) 
+		{
+ 			g_pMainDlg->AddLog(m_iDeviceIndex, OPERATION_SUCC_T, " NET_DVR_SET_IOOUT_CFG Suss!");
+		}
+		else
+		{
+			g_pMainDlg->AddLog(m_iDeviceIndex, OPERATION_FAIL_T, "NET_DVR_SET_IOOUT_CFG Failed!");
+		}
+	}
+	else
+	{
+		strErr.Format("NET_DVR_SET_IOOUT_CFG failed! err Code[%d]", NET_DVR_GetLastError());
+		MessageBox(strErr);
+	}
+}
+
+void CDlgIOOutCfg::SaveData()
+{
+	UpdateData(TRUE);
+	char szLan[128]={0};
+	m_struIOOutCfgCond.bySyncOutputNo = m_cbSyncOutputNo.GetCurSel();
+	
+	m_struIOOutCfg.byWorkMode = m_cbWorkMode.GetCurSel();
+	if (m_cbWorkMode.GetCurSel() == 0) //若是报警输出模式，不进行参数配置
+	{
+		EnableWindows(FALSE);
+		memset(&m_struIOOutCfg,0,sizeof(NET_DVR_IOOUT_CFG)); //全部清0
+		m_struIOOutCfg.dwSize = sizeof(NET_DVR_IOOUT_CFG); //只给dwsize赋值
+		return;
+	}
+	
+	if(m_cbWorkState.GetCurSel() == -1 || m_cbDefaultState.GetCurSel() == -1)
+	{
+		g_StringLanType(szLan,"生效状态或默认状态无效!","Work state or Default state is invalid!");
+		MessageBox(szLan);
+		return;
+	}
+	
+	m_struIOOutCfg.uWorkModeInfo.struStrobeLamp.byDefaultState = m_cbDefaultState.GetCurSel();
+	m_struIOOutCfg.uWorkModeInfo.struStrobeLamp.byWorkState = m_cbWorkState.GetCurSel();
+	m_struIOOutCfg.uWorkModeInfo.struStrobeLamp.byFreqMulti = m_byFreqMulti;
+	m_struIOOutCfg.uWorkModeInfo.struStrobeLamp.byDutyRatio = m_byDutyRatio;
+	m_struIOOutCfg.uWorkModeInfo.struStrobeLamp.byFlashLightEnable = m_bChkFlashLightEnable;
+	
+	if (m_bChkFlashLightEnable == 0)
+	{
+		memset(&m_struIOOutCfg.uWorkModeInfo.struStrobeLamp.struFlashLightTime,0,sizeof(NET_DVR_SCHEDTIME)); //将时间赋值为全0
+	}
+	else
+	{
+		m_struIOOutCfg.uWorkModeInfo.struStrobeLamp.struFlashLightTime.byStartHour = m_byStartHour;
+		m_struIOOutCfg.uWorkModeInfo.struStrobeLamp.struFlashLightTime.byStartMin = m_byStartMin;
+		m_struIOOutCfg.uWorkModeInfo.struStrobeLamp.struFlashLightTime.byStopHour = m_byEndHour;
+		m_struIOOutCfg.uWorkModeInfo.struStrobeLamp.struFlashLightTime.byStopMin = m_byEndMin;
+	}
+}
+
+void CDlgIOOutCfg::OnSelchangeComboSyncOutputno() 
+{
+	// TODO: Add your control notification handler code here
+	OnButtonGet();
+}

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgITCIOinCfg.h

@@ -0,0 +1,148 @@
+#if !defined(AFX_DLGITCIOINCFG_H__434E8B9F_B761_43D5_BCE5_1D8A8EDE7D8D__INCLUDED_)
+#define AFX_DLGITCIOINCFG_H__434E8B9F_B761_43D5_BCE5_1D8A8EDE7D8D__INCLUDED_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif // _MSC_VER > 1000
+// DlgITCIOinCfg.h : header file
+//
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgITCIOinCfg dialog
+
+class CDlgITCIOinCfg : public CDialog
+{
+// Construction
+public:
+	CDlgITCIOinCfg(CWnd* pParent = NULL);   // standard constructor
+	~CDlgITCIOinCfg();
+// Dialog Data
+	//{{AFX_DATA(CDlgITCIOinCfg)
+	enum { IDD = IDD_DLG_ITC_IOIN_CFG };
+	CComboBox	m_comOperateTypeVeh;
+	CComboBox	m_comDelCond;
+	CComboBox	m_comTriggerMode;
+	CComboBox   m_comCtrlMode;
+	CComboBox	m_comPlateTypeTemp;
+	CComboBox	m_comPlateColorTemp;
+	CComboBox	m_comListTypeTemp;
+	CComboBox	m_comListTypeVeh;
+	CListCtrl	m_lstVehicle;
+	CComboBox	m_comLampLaneNo;
+	CComboBox	m_comLampCtrl;
+	CComboBox	m_comPlateType;
+	CComboBox	m_comPlateColor;
+	CComboBox	m_comOperateType;
+	CComboBox	m_comLaneNo;
+	CComboBox	m_comGateCtrl;
+	CComboBox	m_comVehicleControl;
+	CComboBox	m_comRelayNum;
+	CComboBox	m_comRelayInfo;
+	CComboBox	m_comLane;
+	CComboBox	m_comIOInNum;
+	CComboBox	m_comGateType;
+	CComboBox	m_comGateSingleIO;
+	CComboBox	m_comDelListType;
+	BOOL	m_bAlarmHost;
+	BOOL	m_bArm;
+	BOOL	m_bCard;
+	BOOL	m_bEnable;
+	BOOL	m_bEpolice;
+	BOOL	m_bHVT;
+	BOOL	m_bNoMatching;
+	BOOL	m_bNoPlateColor;
+	BOOL	m_bPlateColor;
+	BOOL	m_bRelay;
+	BOOL	m_bRS485;
+	BOOL	m_bSingleIO;
+	CString	m_csCardNum;
+	CString	m_csPlateNum;
+	CString	m_csCardNumVeh;
+	CString	m_csPlateNumVeh;
+	CString	m_csCardNoTemp;
+	CString	m_csLicenseTemp;
+	DWORD	m_dwDataIndexTemp;
+	COleDateTime	m_startDate;
+	COleDateTime	m_startTime;
+	COleDateTime	m_stopDate;
+	COleDateTime	m_stopTime;
+	DWORD	m_startMilliSec;
+	DWORD	m_stopMilliSec;
+	BOOL	m_bCheckStartTime;
+	BOOL	m_bCheckStopTime;
+	//}}AFX_DATA
+
+
+// Overrides
+	// ClassWizard generated virtual function overrides
+	//{{AFX_VIRTUAL(CDlgITCIOinCfg)
+	protected:
+	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
+	//}}AFX_VIRTUAL
+
+// Implementation
+protected:
+
+	// Generated message map functions
+	//{{AFX_MSG(CDlgITCIOinCfg)
+	afx_msg void OnBtnGetEntrance();
+	afx_msg void OnBtnSetEntrance();
+	virtual BOOL OnInitDialog();
+	afx_msg void OnSelchangeComboLane();
+	afx_msg void OnSelchangeComboRelayNum();
+	afx_msg void OnSelchangeComboVehicleControl();
+	afx_msg void OnSelchangeComboIoinNo();
+	afx_msg void OnBtnGateCtrl();
+	afx_msg void OnBtnDel();
+	afx_msg void OnBtnLampCtrl();
+	afx_msg void OnBtnVehicleControl();
+//	afx_msg void OnClickListVehicle(NMHDR* pNMHDR, LRESULT* pResult);
+	afx_msg void OnBtnSyncVehicleControl();
+	afx_msg void OnBtnSendVehData();
+	afx_msg void OnBtnStopVehData();
+	afx_msg void OnBtnCreateLink();
+	afx_msg void OnSelchangeComboDelCond();
+	afx_msg void OnSelchangeComboOperateType();
+	afx_msg void OnBtnSaveEntrance();
+	afx_msg void OnCheckStartTime();
+	afx_msg void OnCheckStopTime();
+	afx_msg void OnSelchangeComboOperateTypeVeh();
+	afx_msg void OnDblclkListVehicle(NMHDR* pNMHDR, LRESULT* pResult);
+	afx_msg void OnBtnTest();
+	//}}AFX_MSG
+	DECLARE_MESSAGE_MAP()
+
+public:
+	void CurCfgUpdate();
+	static DWORD WINAPI GetVehInfoThread(LPVOID lpVehInfo);
+	void AddVehInfotoDlg(int iItem, LPNET_DVR_VEHICLE_CONTROL_LIST_INFO lpInter);
+	void AnalysisTime(CString strTime);
+	void ListTest();
+	LONG m_lServerID;
+	BYTE m_byIOInNum;
+	BYTE m_byRelayNum;
+	LONG m_lHandle;
+	BOOL	m_bGetNext;
+	HANDLE	m_hGetInfoThread;
+	int		m_iStruCount;
+	int		m_iItem;
+	LONG    m_lSyncVehHandle;
+	BOOL m_bCheckSet;
+
+	NET_DVR_BARRIERGATE_COND m_struGateCond;
+	NET_DVR_ENTRANCE_CFG m_struEntrance;
+	NET_DVR_BARRIERGATE_CFG m_struGateCFG;
+	NET_DVR_VEHICLE_CONTROL_DELINFO m_struDelVehicleInfo;
+	NET_DVR_GATELAMP_INFO m_struLampCtrl;
+	NET_DVR_VEHICLE_CONTROL_COND m_struVehCond;
+	LPNET_DVR_VEHICLE_CONTROL_LIST_INFO m_pStruVehInfo;
+	NET_DVR_VEHICLE_CONTROL_LIST_INFO m_struVehInfo;
+	NET_DVR_TIME_V30 m_struTime;
+    BOOL m_ParkingDetectEnabled;
+    int m_ParkingDetectJudgeTime;
+};
+
+//{{AFX_INSERT_LOCATION}}
+// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
+
+#endif // !defined(AFX_DLGITCIOINCFG_H__BE93276C_208E_4C82_91C7_2975281DDE23__INCLUDED_)

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgITSConfig.cpp

@@ -0,0 +1,143 @@
+// DlgITSConfig.cpp : implementation file
+//
+
+#include "stdafx.h"
+#include "clientdemo.h"
+#include "DlgITSConfig.h"
+#include "DlgITSUpload.h"
+#include "DlgITSBaseInfo.h"
+#include "DlgITSImageMergeCfg.h"
+#include "DlgITSIpcCfg.h"
+#include "DlgITSOverlapCfg.h"
+#include "DlgITSWorkState.h"
+#include "DlgITSRoadInfo.h"
+#include "DlgITCAblity.h"
+
+#ifdef _DEBUG
+#define new DEBUG_NEW
+#undef THIS_FILE
+static char THIS_FILE[] = __FILE__;
+#endif
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgITSConfig dialog
+
+
+CDlgITSConfig::CDlgITSConfig(CWnd* pParent /*=NULL*/)
+	: CDialog(CDlgITSConfig::IDD, pParent)
+{
+	//{{AFX_DATA_INIT(CDlgITSConfig)
+		// NOTE: the ClassWizard will add member initialization here
+	//}}AFX_DATA_INIT
+}
+
+
+void CDlgITSConfig::DoDataExchange(CDataExchange* pDX)
+{
+	CDialog::DoDataExchange(pDX);
+	//{{AFX_DATA_MAP(CDlgITSConfig)
+		// NOTE: the ClassWizard will add DDX and DDV calls here
+	//}}AFX_DATA_MAP
+}
+
+
+BEGIN_MESSAGE_MAP(CDlgITSConfig, CDialog)
+	//{{AFX_MSG_MAP(CDlgITSConfig)
+	ON_BN_CLICKED(IDC_BTN_DATA_UPLOAD_CFG, OnBtnDataUploadCfg)
+	ON_BN_CLICKED(IDC_BTN_GET_ITS_BASEINFO, OnBtnGetItsBaseinfo)
+	ON_BN_CLICKED(IDC_BTN_ITS_IMGMERGE, OnBtnItsImgmerge)
+	ON_BN_CLICKED(IDC_BTN_REUPLOAD_CFG, OnBtnReuploadCfg)
+	ON_BN_CLICKED(IDC_BTN_ITS_IPC_CFG, OnBtnItsIpcCfg)
+	ON_BN_CLICKED(IDC_BTN_ITS_OVERLAP_CFG, OnBtnItsOverlapCfg)
+	ON_BN_CLICKED(IDC_BTN_ROAD_INFO_GET, OnBtnRoadInfoGet)
+	ON_BN_CLICKED(IDC_BTN_DEVICE, OnBtnDevice)
+	ON_BN_CLICKED(IDC_BTN_GETITC_ABLITY, OnBtnGetitcAblity)
+	//}}AFX_MSG_MAP
+END_MESSAGE_MAP()
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgITSConfig message handlers
+
+void CDlgITSConfig::OnBtnDataUploadCfg() 
+{
+	// TODO: Add your control notification handler code here
+	CDlgITSUpload dlg;
+	dlg.m_lServerID = m_lServerID;			
+	dlg.m_iDevIndex = m_iDevIndex;			
+	dlg.m_lChannel = m_lChannel;
+	dlg.DoModal();	
+}
+
+void CDlgITSConfig::OnBtnGetItsBaseinfo() 
+{
+	// TODO: Add your control notification handler code here
+	CDlgITSBaseInfo dlg;
+	dlg.m_lServerID = m_lServerID;			
+	dlg.m_iDevIndex = m_iDevIndex;			
+	dlg.m_lChannel = m_lChannel;
+	dlg.DoModal();
+}
+
+void CDlgITSConfig::OnBtnItsImgmerge() 
+{
+	// TODO: Add your control notification handler code here
+	CDlgITSImageMergeCfg dlg;
+	dlg.m_lServerID = m_lServerID;			
+	dlg.m_iDevIndex = m_iDevIndex;			
+	dlg.m_lChannel = m_lChannel;
+	dlg.DoModal();
+}
+
+void CDlgITSConfig::OnBtnReuploadCfg() 
+{
+	// TODO: Add your control notification handler code here
+	
+}
+
+void CDlgITSConfig::OnBtnItsIpcCfg() 
+{
+	// TODO: Add your control notification handler code here
+	CDlgITSIpcCfg dlg;
+	dlg.m_lServerID = m_lServerID;			
+	dlg.m_iDevIndex = m_iDevIndex;			
+	dlg.m_lChannel = m_lChannel;
+	dlg.DoModal();
+}
+
+void CDlgITSConfig::OnBtnItsOverlapCfg() 
+{
+	// TODO: Add your control notification handler code here
+	CDlgITSOverlapCfg dlg;
+	dlg.m_lServerID = m_lServerID;			
+	dlg.m_iDevIndex = m_iDevIndex;			
+	dlg.m_lChannel = m_lChannel;
+	dlg.DoModal();
+}
+
+void CDlgITSConfig::OnBtnRoadInfoGet() 
+{
+	// TODO: Add your control notification handler code here
+	CDlgITSRoadInfo dlg;
+	dlg.m_lServerID = m_lServerID;			
+	dlg.m_iDevIndex = m_iDevIndex;			
+//	dlg.m_lChannel = m_lChannel;
+	dlg.DoModal();
+}
+
+void CDlgITSConfig::OnBtnDevice() 
+{
+	// TODO: Add your control notification handler code here
+	CDlgITSWorkState dlg;
+	dlg.m_lLoginID = m_lServerID;			
+	dlg.m_iDeviceIndex = m_iDevIndex;			
+	dlg.DoModal();
+}
+
+void CDlgITSConfig::OnBtnGetitcAblity() 
+{
+	// TODO: Add your control notification handler code here
+	CDlgITCAblity dlg;
+	dlg.m_lServerID = m_lServerID;			
+	dlg.m_iDeviceIndex = m_iDevIndex;			
+	dlg.DoModal();
+}

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgITSWorkState.h

@@ -0,0 +1,93 @@
+#if !defined(AFX_DLGITSWORKSTATE_H__2DE9C5CB_8154_45C7_B61C_FB1CC0F21E9B__INCLUDED_)
+#define AFX_DLGITSWORKSTATE_H__2DE9C5CB_8154_45C7_B61C_FB1CC0F21E9B__INCLUDED_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif // _MSC_VER > 1000
+// DlgITSWorkState.h : header file
+//
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgITSWorkState dialog
+
+class CDlgITSWorkState : public CDialog
+{
+// Construction
+public:
+	CDlgITSWorkState(CWnd* pParent = NULL);   // standard constructor
+
+// Dialog Data
+	//{{AFX_DATA(CDlgITSWorkState)
+	enum { IDD = IDD_DLG_ITS_WORKSTATE };
+	CComboBox	m_comboDevChan;
+	CListCtrl	m_listAlarmOutState;
+	CListCtrl	m_listAlarmInState;
+	CComboBox	m_comboLocalDisplay;
+	CComboBox	m_comboHostIndex;
+	CListCtrl	m_listDiskState;
+	CListCtrl	m_listChanState;
+	CString	m_csHostIP;
+	DWORD	m_dwCpuUsage;
+	DWORD	m_dwDataTotal;
+	DWORD	m_dwDevTemp;
+	CString	m_csDeviceName;
+	DWORD	m_dwEndDay;
+	DWORD	m_dwEndHour;
+	DWORD	m_dwEndMilliSec;
+	DWORD	m_dwEndMinute;
+	DWORD	m_dwEndMonth;
+	DWORD	m_dwEndSec;
+	DWORD	m_dwEndYear;
+	DWORD	m_dwMemoryUsage;
+	DWORD	m_dwNeedSendData;
+	DWORD	m_dwRunTime;
+	DWORD	m_dwStartDay;
+	DWORD	m_dwStartHour;
+	DWORD	m_dwStartMilliSec;
+	DWORD	m_dwStartMinute;
+	DWORD	m_dwStartMonth;
+	DWORD	m_dwStartSec;
+	DWORD	m_dwStartYear;
+	CString	m_csDeviceState;
+	//}}AFX_DATA
+
+
+// Overrides
+	// ClassWizard generated virtual function overrides
+	//{{AFX_VIRTUAL(CDlgITSWorkState)
+	protected:
+	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
+	virtual BOOL OnInitDialog();
+	//}}AFX_VIRTUAL
+
+// Implementation
+protected:
+
+	// Generated message map functions
+	//{{AFX_MSG(CDlgITSWorkState)
+	afx_msg void OnBtnGet();
+	afx_msg void OnSelchangeComboHost();
+	//}}AFX_MSG
+	DECLARE_MESSAGE_MAP()
+
+public:
+	int m_iDeviceIndex;
+	CString m_csRecState;
+	CString m_csSignalState;
+	CString m_csHardWareState;
+	CString m_csLinkCount;
+	CString m_csBitrate;
+	CString m_csDiskVolume;
+	CString m_csDiskFreeSpace;
+	CString m_csDiskState;
+	BOOL CheckInitParam(void);
+	LONG m_lLoginID;
+	int m_iHostSel;
+
+	NET_ITS_WORKSTATE m_struWorkState;
+};
+
+//{{AFX_INSERT_LOCATION}}
+// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
+
+#endif // !defined(AFX_DLGITSWORKSTATE_H__2DE9C5CB_8154_45C7_B61C_FB1CC0F21E9B__INCLUDED_)

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgInfoDiffusionClock.cpp

@@ -0,0 +1,199 @@
+// DlgInfoDiffusionClock.cpp : implementation file
+//
+
+#include "stdafx.h"
+#include "clientdemo.h"
+#include "DlgInfoDiffusionClock.h"
+
+#ifdef _DEBUG
+#define new DEBUG_NEW
+#undef THIS_FILE
+static char THIS_FILE[] = __FILE__;
+#endif
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgInfoDiffusionClock dialog
+
+
+CDlgInfoDiffusionClock::CDlgInfoDiffusionClock(CWnd* pParent /*=NULL*/)
+	: CDialog(CDlgInfoDiffusionClock::IDD, pParent)
+{
+	//{{AFX_DATA_INIT(CDlgInfoDiffusionClock)
+	m_bIconEnable = FALSE;
+	m_bHmsEnable = FALSE;
+	m_bWeekEnable = FALSE;
+	m_bYmdEnable = FALSE;
+	m_dwBackPic = 0;
+	m_dwClockH = 0;
+	m_dwIconH = 0;
+	m_szIconType = _T("");
+	m_dwIconW = 0;
+	m_dwIconX = 0;
+	m_dwIconY = 0;
+	m_dwClockW = 0;
+	m_dwHmsBackB = 0;
+	m_dwHmsBackG = 0;
+	m_dwHmsBackR = 0;
+	m_dwHmsFontB = 0;
+	m_dwHmsFontG = 0;
+	m_dwHmsFontR = 0;
+	m_dwWeekBackB = 0;
+	m_dwWeekBackG = 0;
+	m_dwWeekBackR = 0;
+	m_dwWeekFontB = 0;
+	m_dwWeekFontG = 0;
+	m_dwWeekFontR = 0;
+	m_dwWeekFontSize = 0;
+	m_dwWeekH = 0;
+	m_dwWeekW = 0;
+	m_dwWeekX = 0;
+	m_dwWeekY = 0;
+	m_dwYmdFontB = 0;
+	m_dwYmdBackB = 0;
+	m_dwYmdBackG = 0;
+	m_dwYmdBackR = 0;
+	m_dwYmdFontSize = 0;
+	m_dwYmdFontG = 0;
+	m_dwYmdH = 0;
+	m_dwYmdW = 0;
+	m_dwYmdX = 0;
+	m_dwYmdY = 0;
+	m_dwYmsFontSize = 0;
+	m_dwYmsH = 0;
+	m_dwYmsW = 0;
+	m_dwYmsX = 0;
+	m_dwYmsY = 0;
+	m_dwYmdFontR = 0;
+	//}}AFX_DATA_INIT
+
+	m_iDeviceIndex = g_pMainDlg->GetCurDeviceIndex();
+	m_lUserID = g_struDeviceInfo[m_iDeviceIndex].lLoginID;
+}
+
+
+void CDlgInfoDiffusionClock::DoDataExchange(CDataExchange* pDX)
+{
+	CDialog::DoDataExchange(pDX);
+	//{{AFX_DATA_MAP(CDlgInfoDiffusionClock)
+	DDX_Check(pDX, IDC_CHECK_COLCK_ICON, m_bIconEnable);
+	DDX_Check(pDX, IDC_CHECK_HMS, m_bHmsEnable);
+	DDX_Check(pDX, IDC_CHECK_WEEK, m_bWeekEnable);
+	DDX_Check(pDX, IDC_CHECK_YMD, m_bYmdEnable);
+	DDX_Text(pDX, IDC_EDIT_CLOCK_BACK_PIC, m_dwBackPic);
+	DDX_Text(pDX, IDC_EDIT_CLOCK_HEIGHT, m_dwClockH);
+	DDX_Text(pDX, IDC_EDIT_CLOCK_ICON_HEIGHT, m_dwIconH);
+	DDX_Text(pDX, IDC_EDIT_CLOCK_ICON_TYPE, m_szIconType);
+	DDX_Text(pDX, IDC_EDIT_CLOCK_ICON_WIDTH, m_dwIconW);
+	DDX_Text(pDX, IDC_EDIT_CLOCK_ICON_X, m_dwIconX);
+	DDX_Text(pDX, IDC_EDIT_CLOCK_ICON_Y, m_dwIconY);
+	DDX_Text(pDX, IDC_EDIT_CLOCKWIDTH, m_dwClockW);
+	DDX_Text(pDX, IDC_EDIT_HMS_BACK_B, m_dwHmsBackB);
+	DDX_Text(pDX, IDC_EDIT_HMS_BACK_G, m_dwHmsBackG);
+	DDX_Text(pDX, IDC_EDIT_HMS_BACK_R, m_dwHmsBackR);
+	DDX_Text(pDX, IDC_EDIT_HMS_FONT_B, m_dwHmsFontB);
+	DDX_Text(pDX, IDC_EDIT_HMS_FONT_G, m_dwHmsFontG);
+	DDX_Text(pDX, IDC_EDIT_HMS_FONT_R, m_dwHmsFontR);
+	DDX_Text(pDX, IDC_EDIT_WEEK_BACK_B, m_dwWeekBackB);
+	DDX_Text(pDX, IDC_EDIT_WEEK_BACK_G, m_dwWeekBackG);
+	DDX_Text(pDX, IDC_EDIT_WEEK_BACK_R, m_dwWeekBackR);
+	DDX_Text(pDX, IDC_EDIT_WEEK_FONT_B, m_dwWeekFontB);
+	DDX_Text(pDX, IDC_EDIT_WEEK_FONT_G, m_dwWeekFontG);
+	DDX_Text(pDX, IDC_EDIT_WEEK_FONT_R, m_dwWeekFontR);
+	DDX_Text(pDX, IDC_EDIT_WEEK_FONT_SIZE, m_dwWeekFontSize);
+	DDX_Text(pDX, IDC_EDIT_WEEK_HEIGHT, m_dwWeekH);
+	DDX_Text(pDX, IDC_EDIT_WEEK_WIDTH, m_dwWeekW);
+	DDX_Text(pDX, IDC_EDIT_WEEK_X, m_dwWeekX);
+	DDX_Text(pDX, IDC_EDIT_WEEK_Y, m_dwWeekY);
+	DDX_Text(pDX, IDC_EDIT_YMD_B, m_dwYmdFontB);
+	DDX_Text(pDX, IDC_EDIT_YMD_BACK_B, m_dwYmdBackB);
+	DDX_Text(pDX, IDC_EDIT_YMD_BACK_G, m_dwYmdBackG);
+	DDX_Text(pDX, IDC_EDIT_YMD_BACK_R, m_dwYmdBackR);
+	DDX_Text(pDX, IDC_EDIT_YMD_FONT_SIZE, m_dwYmdFontSize);
+	DDX_Text(pDX, IDC_EDIT_YMD_G, m_dwYmdFontG);
+	DDX_Text(pDX, IDC_EDIT_YMD_HEIGHT, m_dwYmdH);
+	DDX_Text(pDX, IDC_EDIT_YMD_WIDTH, m_dwYmdW);
+	DDX_Text(pDX, IDC_EDIT_YMD_X, m_dwYmdX);
+	DDX_Text(pDX, IDC_EDIT_YMD_Y, m_dwYmdY);
+	DDX_Text(pDX, IDC_EDIT_YMS_FONT_SIZE, m_dwYmsFontSize);
+	DDX_Text(pDX, IDC_EDIT_YMS_HEIGHT, m_dwYmsH);
+	DDX_Text(pDX, IDC_EDIT_YMS_WIDTH, m_dwYmsW);
+	DDX_Text(pDX, IDC_EDIT_YMS_X, m_dwYmsX);
+	DDX_Text(pDX, IDC_EDIT_YMS_Y, m_dwYmsY);
+	DDX_Text(pDX, IDC_EDIT1_YMD_R, m_dwYmdFontR);
+	//}}AFX_DATA_MAP
+}
+
+
+BEGIN_MESSAGE_MAP(CDlgInfoDiffusionClock, CDialog)
+	//{{AFX_MSG_MAP(CDlgInfoDiffusionClock)
+	ON_BN_CLICKED(IDC_BTN_OK, OnBtnOk)
+	ON_BN_CLICKED(IDC_BTN_CANCEL, OnBtnCancel)
+	//}}AFX_MSG_MAP
+END_MESSAGE_MAP()
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgInfoDiffusionClock message handlers
+
+
+void CDlgInfoDiffusionClock::OnBtnOk() 
+{
+	// TODO: Add your control notification handler code here
+	UpdateData(TRUE);
+	m_struMaterial->struStaticMaterial.struLock.dwTotalHeight = m_dwClockH;
+	m_struMaterial->struStaticMaterial.struLock.dwTotalWidth = m_dwClockW;
+	m_struMaterial->struStaticMaterial.struLock.dwBackPicId = m_dwBackPic;
+	m_struMaterial->struStaticMaterial.struLock.byIconEnable = m_bIconEnable;
+	m_struMaterial->struStaticMaterial.struLock.dwIconX = m_dwIconX;
+	m_struMaterial->struStaticMaterial.struLock.dwIconY = m_dwIconY;
+	m_struMaterial->struStaticMaterial.struLock.dwIconH = m_dwIconH;
+	m_struMaterial->struStaticMaterial.struLock.dwIconW = m_dwIconW;
+	memcpy(m_struMaterial->struStaticMaterial.struLock.szIconType,m_szIconType,sizeof(m_szIconType));
+
+	m_struMaterial->struStaticMaterial.struLock.struYmd.byEnable = m_bYmdEnable;
+	m_struMaterial->struStaticMaterial.struLock.struYmd.dwFontSize = m_dwYmdFontSize;
+	m_struMaterial->struStaticMaterial.struLock.struYmd.struFontColor.dwRed = m_dwYmdFontR;
+	m_struMaterial->struStaticMaterial.struLock.struYmd.struFontColor.dwGreen = m_dwYmdFontG;
+	m_struMaterial->struStaticMaterial.struLock.struYmd.struFontColor.dwBlue = m_dwYmdFontB;
+	m_struMaterial->struStaticMaterial.struLock.struYmd.struBackColor.dwRed = m_dwYmdBackR;
+	m_struMaterial->struStaticMaterial.struLock.struYmd.struBackColor.dwGreen = m_dwYmdBackG;
+	m_struMaterial->struStaticMaterial.struLock.struYmd.struBackColor.dwBlue = m_dwYmdBackB;
+	m_struMaterial->struStaticMaterial.struLock.struYmd.dwPositionX = m_dwYmdX;
+	m_struMaterial->struStaticMaterial.struLock.struYmd.dwPositionY = m_dwYmdY;
+	m_struMaterial->struStaticMaterial.struLock.struYmd.dwHeight = m_dwYmdH;
+	m_struMaterial->struStaticMaterial.struLock.struYmd.dwWidth = m_dwYmdW;
+
+	m_struMaterial->struStaticMaterial.struLock.struHms.byEnable = m_bHmsEnable;
+	m_struMaterial->struStaticMaterial.struLock.struHms.dwFontSize = m_dwYmsFontSize;
+	m_struMaterial->struStaticMaterial.struLock.struHms.struFontColor.dwRed = m_dwHmsFontR;
+	m_struMaterial->struStaticMaterial.struLock.struHms.struFontColor.dwGreen = m_dwHmsFontG;
+	m_struMaterial->struStaticMaterial.struLock.struHms.struFontColor.dwBlue = m_dwHmsFontB;
+	m_struMaterial->struStaticMaterial.struLock.struHms.struBackColor.dwRed = m_dwHmsBackR;
+	m_struMaterial->struStaticMaterial.struLock.struHms.struBackColor.dwGreen = m_dwHmsBackG;
+	m_struMaterial->struStaticMaterial.struLock.struHms.struBackColor.dwBlue = m_dwHmsBackB;
+	m_struMaterial->struStaticMaterial.struLock.struHms.dwPositionX = m_dwYmsX;
+	m_struMaterial->struStaticMaterial.struLock.struHms.dwPositionY = m_dwYmsY;
+	m_struMaterial->struStaticMaterial.struLock.struHms.dwHeight = m_dwYmsH;
+	m_struMaterial->struStaticMaterial.struLock.struHms.dwWidth = m_dwYmsW;
+
+	m_struMaterial->struStaticMaterial.struLock.struWeek.byEnable = m_bWeekEnable;
+	m_struMaterial->struStaticMaterial.struLock.struWeek.dwFontSize = m_dwWeekFontSize;
+	m_struMaterial->struStaticMaterial.struLock.struWeek.struFontColor.dwRed = m_dwWeekFontR;
+	m_struMaterial->struStaticMaterial.struLock.struWeek.struFontColor.dwGreen = m_dwWeekFontG;
+	m_struMaterial->struStaticMaterial.struLock.struWeek.struFontColor.dwBlue = m_dwWeekFontB;
+	m_struMaterial->struStaticMaterial.struLock.struWeek.struBackColor.dwRed = m_dwWeekBackR;
+	m_struMaterial->struStaticMaterial.struLock.struWeek.struBackColor.dwGreen = m_dwWeekBackG;
+	m_struMaterial->struStaticMaterial.struLock.struWeek.struBackColor.dwBlue = m_dwWeekBackB;
+	m_struMaterial->struStaticMaterial.struLock.struWeek.dwPositionX = m_dwWeekX;
+	m_struMaterial->struStaticMaterial.struLock.struWeek.dwPositionY = m_dwWeekY;
+	m_struMaterial->struStaticMaterial.struLock.struWeek.dwHeight = m_dwWeekH;
+	m_struMaterial->struStaticMaterial.struLock.struWeek.dwWidth = m_dwWeekW;
+
+	CDialog::OnOK();
+
+}
+
+void CDlgInfoDiffusionClock::OnBtnCancel() 
+{
+	// TODO: Add your control notification handler code here
+	CDialog::OnCancel();
+}

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgInfoDiffusionClockWeather.cpp

@@ -0,0 +1,378 @@
+// DlgInfoDiffusionClockWeather.cpp : implementation file
+//
+
+#include "stdafx.h"
+#include "clientdemo.h"
+#include "DlgInfoDiffusionClockWeather.h"
+
+#ifdef _DEBUG
+#define new DEBUG_NEW
+#undef THIS_FILE
+static char THIS_FILE[] = __FILE__;
+#endif
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgInfoDiffusionClockWeather dialog
+
+
+CDlgInfoDiffusionClockWeather::CDlgInfoDiffusionClockWeather(CWnd* pParent /*=NULL*/)
+	: CDialog(CDlgInfoDiffusionClockWeather::IDD, pParent)
+{
+	//{{AFX_DATA_INIT(CDlgInfoDiffusionClockWeather)
+	m_byAir = FALSE;
+	m_byCity = FALSE;
+	m_byContent = FALSE;
+	m_byHum = FALSE;
+	m_byTemp = FALSE;
+	m_byUpdate = FALSE;
+	m_byDate = FALSE;
+	m_byIcon = FALSE;
+	m_byWind = FALSE;
+	m_dwAirBackB = 0;
+	m_dwAirBackG = 0;
+	m_dwAirBackR = 0;
+	m_dwAirFontB = 0;
+	m_dwAirFontG = 0;
+	m_dwAirFontR = 0;
+	m_dwAirFontSize = 0;
+	m_dwAirH = 0;
+	m_dwAirW = 0;
+	m_dwAirX = 0;
+	m_dwAirY = 0;
+	m_dwCityBackB = 0;
+	m_dwCityBackG = 0;
+	m_dwCityBackR = 0;
+	m_dwCityFontB = 0;
+	m_dwCityFontG = 0;
+	m_dwCityFontR = 0;
+	m_dwCityFontSize = 0;
+	m_dwCityH = 0;
+	m_dwCityW = 0;
+	m_dwCityX = 0;
+	m_dwCityY = 0;
+	m_dwContentBackB = 0;
+	m_dwContentBackG = 0;
+	m_dwContentBackR = 0;
+	m_dwContentFontB = 0;
+	m_dwContentFontG = 0;
+	m_dwContentFontR = 0;
+	m_dwContentFontSize = 0;
+	m_dwContentH = 0;
+	m_dwContentW = 0;
+	m_dwContentY = 0;
+	m_dwContentX = 0;
+	m_dwDateBackB = 0;
+	m_dwDateBackG = 0;
+	m_dwDateBackR = 0;
+	m_dwDateFontB = 0;
+	m_dwDateFontG = 0;
+	m_dwDateFontR = 0;
+	m_dwDateFontSize = 0;
+	m_dwDateH = 0;
+	m_dwDateW = 0;
+	m_dwDateX = 0;
+	m_dwDateY = 0;
+	m_dwHumBackB = 0;
+	m_dwHumBackG = 0;
+	m_dwHumBackR = 0;
+	m_dwHumFontB = 0;
+	m_dwHumFontG = 0;
+	m_dwHumFontR = 0;
+	m_dwHumFontSize = 0;
+	m_dwHumH = 0;
+	m_dwHumX = 0;
+	m_dwHumY = 0;
+	m_dwTempBackB = 0;
+	m_dwTempBackG = 0;
+	m_dwTempBackR = 0;
+	m_dwTempFontB = 0;
+	m_dwTempFontG = 0;
+	m_dwTempFontR = 0;
+	m_dwTempFontSize = 0;
+	m_dwTempH = 0;
+	m_dwTempW = 0;
+	m_dwTempX = 0;
+	m_dwTempY = 0;
+	m_dwUpdateBackB = 0;
+	m_dwUpdateBackG = 0;
+	m_dwUpdateBackR = 0;
+	m_dwUpdateFontB = 0;
+	m_dwUpdateFontG = 0;
+	m_dwUpdateFontR = 0;
+	m_dwUpdateFontSize = 0;
+	m_dwUpdateH = 0;
+	m_dwUpdateW = 0;
+	m_dwUpdateX = 0;
+	m_dwUpdateY = 0;
+	m_dwWeateBackPic = 0;
+	m_dwWeaIconW = 0;
+	m_dwWeaH = 0;
+	m_dwWeaIconH = 0;
+	m_dwWeaIconX = 0;
+	m_dwWeaIconY = 0;
+	m_dwWeaW = 0;
+	m_dwWindFontB = 0;
+	m_dwWindFontG = 0;
+	m_dwWindFontR = 0;
+	m_dwWindBackB = 0;
+	m_dwWindBackG = 0;
+	m_dwWindBackR = 0;
+	m_dwWindFontSize = 0;
+	m_dwWindX = 0;
+	m_dwWindY = 0;
+	m_dwWindH = 0;
+	m_dwHumW = 0;
+	m_dwWindW = 0;
+	//}}AFX_DATA_INIT
+}
+
+
+void CDlgInfoDiffusionClockWeather::DoDataExchange(CDataExchange* pDX)
+{
+	CDialog::DoDataExchange(pDX);
+	//{{AFX_DATA_MAP(CDlgInfoDiffusionClockWeather)
+	DDX_Check(pDX, IDC_CHECK_AIR, m_byAir);
+	DDX_Check(pDX, IDC_CHECK_CITY, m_byCity);
+	DDX_Check(pDX, IDC_CHECK_CONTENT, m_byContent);
+	DDX_Check(pDX, IDC_CHECK_HUM, m_byHum);
+	DDX_Check(pDX, IDC_CHECK_TEMP, m_byTemp);
+	DDX_Check(pDX, IDC_CHECK_UPDATE, m_byUpdate);
+	DDX_Check(pDX, IDC_CHECK_WEATHER_DATE, m_byDate);
+	DDX_Check(pDX, IDC_CHECK_WEATHER_ICON, m_byIcon);
+	DDX_Check(pDX, IDC_CHECK_WIND, m_byWind);
+	DDX_Text(pDX, IDC_EDIT_AIR_BACK_B, m_dwAirBackB);
+	DDX_Text(pDX, IDC_EDIT_AIR_BACK_G, m_dwAirBackG);
+	DDX_Text(pDX, IDC_EDIT_AIR_BACK_R, m_dwAirBackR);
+	DDX_Text(pDX, IDC_EDIT_AIR_FONT_B, m_dwAirFontB);
+	DDX_Text(pDX, IDC_EDIT_AIR_FONT_G, m_dwAirFontG);
+	DDX_Text(pDX, IDC_EDIT_AIR_FONT_R, m_dwAirFontR);
+	DDX_Text(pDX, IDC_EDIT_AIR_FONT_SIZE, m_dwAirFontSize);
+	DDX_Text(pDX, IDC_EDIT_AIR_HEIGHT, m_dwAirH);
+	DDX_Text(pDX, IDC_EDIT_AIR_WIDTH, m_dwAirW);
+	DDX_Text(pDX, IDC_EDIT_AIR_X, m_dwAirX);
+	DDX_Text(pDX, IDC_EDIT_AIR_Y, m_dwAirY);
+	DDX_Text(pDX, IDC_EDIT_CITY_BACK_B, m_dwCityBackB);
+	DDX_Text(pDX, IDC_EDIT_CITY_BACK_G, m_dwCityBackG);
+	DDX_Text(pDX, IDC_EDIT_CITY_BACK_R, m_dwCityBackR);
+	DDX_Text(pDX, IDC_EDIT_CITY_FONT_B, m_dwCityFontB);
+	DDX_Text(pDX, IDC_EDIT_CITY_FONT_G, m_dwCityFontG);
+	DDX_Text(pDX, IDC_EDIT_CITY_FONT_R, m_dwCityFontR);
+	DDX_Text(pDX, IDC_EDIT_CITY_FONT_SIZE, m_dwCityFontSize);
+	DDX_Text(pDX, IDC_EDIT_CITY_HEIGHT, m_dwCityH);
+	DDX_Text(pDX, IDC_EDIT_CITY_WIDTH, m_dwCityW);
+	DDX_Text(pDX, IDC_EDIT_CITY_X, m_dwCityX);
+	DDX_Text(pDX, IDC_EDIT_CITY_Y, m_dwCityY);
+	DDX_Text(pDX, IDC_EDIT_CONTENT_BACK_B, m_dwContentBackB);
+	DDX_Text(pDX, IDC_EDIT_CONTENT_BACK_G, m_dwContentBackG);
+	DDX_Text(pDX, IDC_EDIT_CONTENT_BACK_R, m_dwContentBackR);
+	DDX_Text(pDX, IDC_EDIT_CONTENT_FONT_B, m_dwContentFontB);
+	DDX_Text(pDX, IDC_EDIT_CONTENT_FONT_G, m_dwContentFontG);
+	DDX_Text(pDX, IDC_EDIT_CONTENT_FONT_R, m_dwContentFontR);
+	DDX_Text(pDX, IDC_EDIT_CONTENT_FONT_SIZE, m_dwContentFontSize);
+	DDX_Text(pDX, IDC_EDIT_CONTENT_HEIGHT, m_dwContentH);
+	DDX_Text(pDX, IDC_EDIT_CONTENT_WIDTH, m_dwContentW);
+	DDX_Text(pDX, IDC_EDIT_CONTENT_Y, m_dwContentY);
+	DDX_Text(pDX, IDC_EDIT_CONTENT_X, m_dwContentX);
+	DDX_Text(pDX, IDC_EDIT_DATE_BACK_B, m_dwDateBackB);
+	DDX_Text(pDX, IDC_EDIT_DATE_BACK_G, m_dwDateBackG);
+	DDX_Text(pDX, IDC_EDIT_DATE_BACK_R, m_dwDateBackR);
+	DDX_Text(pDX, IDC_EDIT_DATE_FONT_B, m_dwDateFontB);
+	DDX_Text(pDX, IDC_EDIT_DATE_FONT_G, m_dwDateFontG);
+	DDX_Text(pDX, IDC_EDIT_DATE_FONT_R, m_dwDateFontR);
+	DDX_Text(pDX, IDC_EDIT_DATE_FONT_SIZE, m_dwDateFontSize);
+	DDX_Text(pDX, IDC_EDIT_DATE_HIGHT, m_dwDateH);
+	DDX_Text(pDX, IDC_EDIT_DATE_WIDTH, m_dwDateW);
+	DDX_Text(pDX, IDC_EDIT_DATE_X, m_dwDateX);
+	DDX_Text(pDX, IDC_EDIT_DATE_Y, m_dwDateY);
+	DDX_Text(pDX, IDC_EDIT_HUM_BACK_B, m_dwHumBackB);
+	DDX_Text(pDX, IDC_EDIT_HUM_BACK_G, m_dwHumBackG);
+	DDX_Text(pDX, IDC_EDIT_HUM_BACK_R, m_dwHumBackR);
+	DDX_Text(pDX, IDC_EDIT_HUM_FONT_B, m_dwHumFontB);
+	DDX_Text(pDX, IDC_EDIT_HUM_FONT_G, m_dwHumFontG);
+	DDX_Text(pDX, IDC_EDIT_HUM_FONT_R, m_dwHumFontR);
+	DDX_Text(pDX, IDC_EDIT_HUM_FONT_SIZE, m_dwHumFontSize);
+	DDX_Text(pDX, IDC_EDIT_HUM_HEIGHT, m_dwHumH);
+	DDX_Text(pDX, IDC_EDIT_HUM_X, m_dwHumX);
+	DDX_Text(pDX, IDC_EDIT_HUM_Y, m_dwHumY);
+	DDX_Text(pDX, IDC_EDIT_TEMP_BACK_B, m_dwTempBackB);
+	DDX_Text(pDX, IDC_EDIT_TEMP_BACK_G, m_dwTempBackG);
+	DDX_Text(pDX, IDC_EDIT_TEMP_BACK_R, m_dwTempBackR);
+	DDX_Text(pDX, IDC_EDIT_TEMP_FONT_B, m_dwTempFontB);
+	DDX_Text(pDX, IDC_EDIT_TEMP_FONT_G, m_dwTempFontG);
+	DDX_Text(pDX, IDC_EDIT_TEMP_FONT_R, m_dwTempFontR);
+	DDX_Text(pDX, IDC_EDIT_TEMP_FONT_SIZE, m_dwTempFontSize);
+	DDX_Text(pDX, IDC_EDIT_TEMP_HEIGHT, m_dwTempH);
+	DDX_Text(pDX, IDC_EDIT_TEMP_WIDTH, m_dwTempW);
+	DDX_Text(pDX, IDC_EDIT_TEMP_X, m_dwTempX);
+	DDX_Text(pDX, IDC_EDIT_TEMP_Y, m_dwTempY);
+	DDX_Text(pDX, IDC_EDIT_UPDATE_BACK_B, m_dwUpdateBackB);
+	DDX_Text(pDX, IDC_EDIT_UPDATE_BACK_G, m_dwUpdateBackG);
+	DDX_Text(pDX, IDC_EDIT_UPDATE_BACK_R, m_dwUpdateBackR);
+	DDX_Text(pDX, IDC_EDIT_UPDATE_FONT_B, m_dwUpdateFontB);
+	DDX_Text(pDX, IDC_EDIT_UPDATE_FONT_G, m_dwUpdateFontG);
+	DDX_Text(pDX, IDC_EDIT_UPDATE_FONT_R, m_dwUpdateFontR);
+	DDX_Text(pDX, IDC_EDIT_UPDATE_FONT_SIZE, m_dwUpdateFontSize);
+	DDX_Text(pDX, IDC_EDIT_UPDATE_HEIGHT, m_dwUpdateH);
+	DDX_Text(pDX, IDC_EDIT_UPDATE_WIDTH, m_dwUpdateW);
+	DDX_Text(pDX, IDC_EDIT_UPDATE_X, m_dwUpdateX);
+	DDX_Text(pDX, IDC_EDIT_UPDATE_Y, m_dwUpdateY);
+	DDX_Text(pDX, IDC_EDIT_WEATHER_BACK_PIC, m_dwWeateBackPic);
+	DDX_Text(pDX, IDC_EDIT_WEATHER_ICON_WIDTH, m_dwWeaIconW);
+	DDX_Text(pDX, IDC_EDIT_WEATHER_HEIGHT, m_dwWeaH);
+	DDX_Text(pDX, IDC_EDIT_WEATHER_ICON_HEIGHT, m_dwWeaIconH);
+	DDX_Text(pDX, IDC_EDIT_WEATHER_ICON_X, m_dwWeaIconX);
+	DDX_Text(pDX, IDC_EDIT_WEATHER_ICON_Y, m_dwWeaIconY);
+	DDX_Text(pDX, IDC_EDIT_WEATHER_WIDTH, m_dwWeaW);
+	DDX_Text(pDX, IDC_EDIT_WIDN_FONT_B, m_dwWindFontB);
+	DDX_Text(pDX, IDC_EDIT_WIDN_FONT_G, m_dwWindFontG);
+	DDX_Text(pDX, IDC_EDIT_WIDN_FONT_R, m_dwWindFontR);
+	DDX_Text(pDX, IDC_EDIT_WIND_BACK_B, m_dwWindBackB);
+	DDX_Text(pDX, IDC_EDIT_WIND_BACK_G, m_dwWindBackG);
+	DDX_Text(pDX, IDC_EDIT_WIND_BACK_R, m_dwWindBackR);
+	DDX_Text(pDX, IDC_EDIT_WIND_FONT_SIZE, m_dwWindFontSize);
+	DDX_Text(pDX, IDC_EDIT_WIND_X, m_dwWindX);
+	DDX_Text(pDX, IDC_EDIT_WIND_Y, m_dwWindY);
+	DDX_Text(pDX, IDC_EDIT_WIND_HEIGHT, m_dwWindH);
+	DDX_Text(pDX, IDC_EDIT_HUM_WIDTH, m_dwHumW);
+	DDX_Text(pDX, IDC_EDIT_WIND_WIDTH, m_dwWindW);
+	//}}AFX_DATA_MAP
+}
+
+
+BEGIN_MESSAGE_MAP(CDlgInfoDiffusionClockWeather, CDialog)
+	//{{AFX_MSG_MAP(CDlgInfoDiffusionClockWeather)
+	ON_BN_CLICKED(IDC_BTN_OK, OnBtnOk)
+	ON_BN_CLICKED(IDC_BTN_CANCEL, OnBtnCancel)
+	//}}AFX_MSG_MAP
+END_MESSAGE_MAP()
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgInfoDiffusionClockWeather message handlers
+
+
+void CDlgInfoDiffusionClockWeather::OnBtnOk() 
+{
+	// TODO: Add your control notification handler code here
+	UpdateData(TRUE);
+	m_struMaterial->struStaticMaterial.struWeather.dwTotalHeight = m_dwWeaH;
+	m_struMaterial->struStaticMaterial.struWeather.dwTotalWidth = m_dwWeaW;
+	m_struMaterial->struStaticMaterial.struWeather.dwBackPicId = m_dwWeateBackPic;
+	m_struMaterial->struStaticMaterial.struWeather.byIconEnable = m_byIcon;
+	m_struMaterial->struStaticMaterial.struWeather.dwIconX = m_dwWeaIconX;
+	m_struMaterial->struStaticMaterial.struWeather.dwIconY = m_dwWeaIconY;
+	m_struMaterial->struStaticMaterial.struWeather.dwIconH = m_dwWeaIconH;
+	m_struMaterial->struStaticMaterial.struWeather.dwIconW = m_dwWeaIconW;
+	
+	m_struMaterial->struStaticMaterial.struWeather.struDate.byEnable = m_byDate;
+	m_struMaterial->struStaticMaterial.struWeather.struDate.dwFontSize = m_dwDateFontSize;
+	m_struMaterial->struStaticMaterial.struWeather.struDate.struFontColor.dwRed = m_dwDateFontR;
+	m_struMaterial->struStaticMaterial.struWeather.struDate.struFontColor.dwGreen = m_dwDateFontG;
+	m_struMaterial->struStaticMaterial.struWeather.struDate.struFontColor.dwBlue = m_dwDateFontB;
+	m_struMaterial->struStaticMaterial.struWeather.struDate.struBackColor.dwRed = m_dwDateBackR;
+	m_struMaterial->struStaticMaterial.struWeather.struDate.struBackColor.dwGreen = m_dwDateBackG;
+	m_struMaterial->struStaticMaterial.struWeather.struDate.struBackColor.dwBlue = m_dwDateBackB;
+	m_struMaterial->struStaticMaterial.struWeather.struDate.dwPositionX = m_dwDateX;
+	m_struMaterial->struStaticMaterial.struWeather.struDate.dwPositionY = m_dwDateY;
+	m_struMaterial->struStaticMaterial.struWeather.struDate.dwHeight = m_dwDateH;
+	m_struMaterial->struStaticMaterial.struWeather.struDate.dwWidth = m_dwDateW;
+
+	m_struMaterial->struStaticMaterial.struWeather.struTemp.byEnable = m_byTemp;
+	m_struMaterial->struStaticMaterial.struWeather.struTemp.dwFontSize = m_dwTempFontSize;
+	m_struMaterial->struStaticMaterial.struWeather.struTemp.struFontColor.dwRed = m_dwTempFontR;
+	m_struMaterial->struStaticMaterial.struWeather.struTemp.struFontColor.dwGreen = m_dwTempFontG;
+	m_struMaterial->struStaticMaterial.struWeather.struTemp.struFontColor.dwBlue = m_dwTempFontB;
+	m_struMaterial->struStaticMaterial.struWeather.struTemp.struBackColor.dwRed = m_dwTempBackR;
+	m_struMaterial->struStaticMaterial.struWeather.struTemp.struBackColor.dwGreen = m_dwTempBackG;
+	m_struMaterial->struStaticMaterial.struWeather.struTemp.struBackColor.dwBlue = m_dwTempBackB;
+	m_struMaterial->struStaticMaterial.struWeather.struTemp.dwPositionX = m_dwTempX;
+	m_struMaterial->struStaticMaterial.struWeather.struTemp.dwPositionY = m_dwTempY;
+	m_struMaterial->struStaticMaterial.struWeather.struTemp.dwHeight = m_dwTempH;
+	m_struMaterial->struStaticMaterial.struWeather.struTemp.dwWidth = m_dwTempW;
+
+	m_struMaterial->struStaticMaterial.struWeather.struContent.byEnable = m_byContent;
+	m_struMaterial->struStaticMaterial.struWeather.struContent.dwFontSize = m_dwContentFontSize;
+	m_struMaterial->struStaticMaterial.struWeather.struContent.struFontColor.dwRed = m_dwContentFontR;
+	m_struMaterial->struStaticMaterial.struWeather.struContent.struFontColor.dwGreen = m_dwContentFontG;
+	m_struMaterial->struStaticMaterial.struWeather.struContent.struFontColor.dwBlue = m_dwContentFontB;
+	m_struMaterial->struStaticMaterial.struWeather.struContent.struBackColor.dwRed = m_dwContentBackR;
+	m_struMaterial->struStaticMaterial.struWeather.struContent.struBackColor.dwGreen = m_dwContentBackG;
+	m_struMaterial->struStaticMaterial.struWeather.struContent.struBackColor.dwBlue = m_dwContentBackB;
+	m_struMaterial->struStaticMaterial.struWeather.struContent.dwPositionX = m_dwContentX;
+	m_struMaterial->struStaticMaterial.struWeather.struContent.dwPositionY = m_dwContentY;
+	m_struMaterial->struStaticMaterial.struWeather.struContent.dwHeight = m_dwContentH;
+	m_struMaterial->struStaticMaterial.struWeather.struContent.dwWidth = m_dwContentW;
+
+	m_struMaterial->struStaticMaterial.struWeather.struCity.byEnable = m_byCity;
+	m_struMaterial->struStaticMaterial.struWeather.struCity.dwFontSize = m_dwCityFontSize;
+	m_struMaterial->struStaticMaterial.struWeather.struCity.struFontColor.dwRed = m_dwCityFontR;
+	m_struMaterial->struStaticMaterial.struWeather.struCity.struFontColor.dwGreen = m_dwCityFontG;
+	m_struMaterial->struStaticMaterial.struWeather.struCity.struFontColor.dwBlue = m_dwCityFontB;
+	m_struMaterial->struStaticMaterial.struWeather.struCity.struBackColor.dwRed = m_dwCityBackR;
+	m_struMaterial->struStaticMaterial.struWeather.struCity.struBackColor.dwGreen = m_dwCityBackG;
+	m_struMaterial->struStaticMaterial.struWeather.struCity.struBackColor.dwBlue = m_dwCityBackB;
+	m_struMaterial->struStaticMaterial.struWeather.struCity.dwPositionX = m_dwCityX;
+	m_struMaterial->struStaticMaterial.struWeather.struCity.dwPositionY = m_dwCityY;
+	m_struMaterial->struStaticMaterial.struWeather.struCity.dwHeight = m_dwCityH;
+	m_struMaterial->struStaticMaterial.struWeather.struCity.dwWidth = m_dwCityW;
+
+	m_struMaterial->struStaticMaterial.struWeather.struHum.byEnable = m_byHum;
+	m_struMaterial->struStaticMaterial.struWeather.struHum.dwFontSize = m_dwHumFontSize;
+	m_struMaterial->struStaticMaterial.struWeather.struHum.struFontColor.dwRed = m_dwHumFontR;
+	m_struMaterial->struStaticMaterial.struWeather.struHum.struFontColor.dwGreen = m_dwHumFontG;
+	m_struMaterial->struStaticMaterial.struWeather.struHum.struFontColor.dwBlue = m_dwHumFontB;
+	m_struMaterial->struStaticMaterial.struWeather.struHum.struBackColor.dwRed = m_dwHumBackR;
+	m_struMaterial->struStaticMaterial.struWeather.struHum.struBackColor.dwGreen = m_dwHumBackG;
+	m_struMaterial->struStaticMaterial.struWeather.struHum.struBackColor.dwBlue = m_dwHumBackB;
+	m_struMaterial->struStaticMaterial.struWeather.struHum.dwPositionX = m_dwHumX;
+	m_struMaterial->struStaticMaterial.struWeather.struHum.dwPositionY = m_dwHumY;
+	m_struMaterial->struStaticMaterial.struWeather.struHum.dwHeight = m_dwHumH;
+	m_struMaterial->struStaticMaterial.struWeather.struHum.dwWidth = m_dwHumW;
+
+	m_struMaterial->struStaticMaterial.struWeather.struAir.byEnable = m_byAir;
+	m_struMaterial->struStaticMaterial.struWeather.struAir.dwFontSize = m_dwAirFontSize;
+	m_struMaterial->struStaticMaterial.struWeather.struAir.struFontColor.dwRed = m_dwAirFontR;
+	m_struMaterial->struStaticMaterial.struWeather.struAir.struFontColor.dwGreen = m_dwAirFontG;
+	m_struMaterial->struStaticMaterial.struWeather.struAir.struFontColor.dwBlue = m_dwAirFontB;
+	m_struMaterial->struStaticMaterial.struWeather.struAir.struBackColor.dwRed = m_dwAirBackR;
+	m_struMaterial->struStaticMaterial.struWeather.struAir.struBackColor.dwGreen = m_dwAirBackG;
+	m_struMaterial->struStaticMaterial.struWeather.struAir.struBackColor.dwBlue = m_dwAirBackB;
+	m_struMaterial->struStaticMaterial.struWeather.struAir.dwPositionX = m_dwAirX;
+	m_struMaterial->struStaticMaterial.struWeather.struAir.dwPositionY = m_dwAirY;
+	m_struMaterial->struStaticMaterial.struWeather.struAir.dwHeight = m_dwAirH;
+	m_struMaterial->struStaticMaterial.struWeather.struAir.dwWidth = m_dwAirW;
+
+	m_struMaterial->struStaticMaterial.struWeather.struUpdate.byEnable = m_byUpdate;
+	m_struMaterial->struStaticMaterial.struWeather.struUpdate.dwFontSize = m_dwUpdateFontSize;
+	m_struMaterial->struStaticMaterial.struWeather.struUpdate.struFontColor.dwRed = m_dwUpdateFontR;
+	m_struMaterial->struStaticMaterial.struWeather.struUpdate.struFontColor.dwGreen = m_dwUpdateFontG;
+	m_struMaterial->struStaticMaterial.struWeather.struUpdate.struFontColor.dwBlue = m_dwUpdateFontB;
+	m_struMaterial->struStaticMaterial.struWeather.struUpdate.struBackColor.dwRed = m_dwUpdateBackR;
+	m_struMaterial->struStaticMaterial.struWeather.struUpdate.struBackColor.dwGreen = m_dwUpdateBackG;
+	m_struMaterial->struStaticMaterial.struWeather.struUpdate.struBackColor.dwBlue = m_dwUpdateBackB;
+	m_struMaterial->struStaticMaterial.struWeather.struUpdate.dwPositionX = m_dwUpdateX;
+	m_struMaterial->struStaticMaterial.struWeather.struUpdate.dwPositionY = m_dwUpdateY;
+	m_struMaterial->struStaticMaterial.struWeather.struUpdate.dwHeight = m_dwUpdateH;
+	m_struMaterial->struStaticMaterial.struWeather.struUpdate.dwWidth = m_dwUpdateW;
+
+	m_struMaterial->struStaticMaterial.struWeather.struWind.byEnable = m_byWind;
+	m_struMaterial->struStaticMaterial.struWeather.struWind.dwFontSize = m_dwWindFontSize;
+	m_struMaterial->struStaticMaterial.struWeather.struWind.struFontColor.dwRed = m_dwWindFontR;
+	m_struMaterial->struStaticMaterial.struWeather.struWind.struFontColor.dwGreen = m_dwWindFontG;
+	m_struMaterial->struStaticMaterial.struWeather.struWind.struFontColor.dwBlue = m_dwWindFontB;
+	m_struMaterial->struStaticMaterial.struWeather.struWind.struBackColor.dwRed = m_dwWindBackR;
+	m_struMaterial->struStaticMaterial.struWeather.struWind.struBackColor.dwGreen = m_dwWindBackG;
+	m_struMaterial->struStaticMaterial.struWeather.struWind.struBackColor.dwBlue = m_dwWindBackB;
+	m_struMaterial->struStaticMaterial.struWeather.struWind.dwPositionX = m_dwWindX;
+	m_struMaterial->struStaticMaterial.struWeather.struWind.dwPositionY = m_dwWindY;
+	m_struMaterial->struStaticMaterial.struWeather.struWind.dwHeight = m_dwWindH;
+	m_struMaterial->struStaticMaterial.struWeather.struWind.dwWidth = m_dwWindW;
+
+	CDialog::OnOK();
+	
+}
+
+void CDlgInfoDiffusionClockWeather::OnBtnCancel() 
+{
+	// TODO: Add your control notification handler code here
+	CDialog::OnCancel();
+}

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgInfoDiffusionClockWeather.h

@@ -0,0 +1,154 @@
+#if !defined(AFX_DLGINFODIFFUSIONCLOCKWEATHER_H__DDFCF73E_E6C7_4ED5_8C71_4A286C525A98__INCLUDED_)
+#define AFX_DLGINFODIFFUSIONCLOCKWEATHER_H__DDFCF73E_E6C7_4ED5_8C71_4A286C525A98__INCLUDED_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif // _MSC_VER > 1000
+// DlgInfoDiffusionClockWeather.h : header file
+//
+#include "InfoDiffusionParamsConvert.h"
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgInfoDiffusionClockWeather dialog
+
+class CDlgInfoDiffusionClockWeather : public CDialog
+{
+// Construction
+public:
+	CDlgInfoDiffusionClockWeather(CWnd* pParent = NULL);   // standard constructor
+
+// Dialog Data
+	//{{AFX_DATA(CDlgInfoDiffusionClockWeather)
+	enum { IDD = IDD_DLG_WEATHER };
+	BOOL	m_byAir;
+	BOOL	m_byCity;
+	BOOL	m_byContent;
+	BOOL	m_byHum;
+	BOOL	m_byTemp;
+	BOOL	m_byUpdate;
+	BOOL	m_byDate;
+	BOOL	m_byIcon;
+	BOOL	m_byWind;
+	DWORD	m_dwAirBackB;
+	DWORD	m_dwAirBackG;
+	DWORD	m_dwAirBackR;
+	DWORD	m_dwAirFontB;
+	DWORD	m_dwAirFontG;
+	DWORD	m_dwAirFontR;
+	DWORD	m_dwAirFontSize;
+	DWORD	m_dwAirH;
+	DWORD	m_dwAirW;
+	DWORD	m_dwAirX;
+	DWORD	m_dwAirY;
+	DWORD	m_dwCityBackB;
+	DWORD	m_dwCityBackG;
+	DWORD	m_dwCityBackR;
+	DWORD	m_dwCityFontB;
+	DWORD	m_dwCityFontG;
+	DWORD	m_dwCityFontR;
+	DWORD	m_dwCityFontSize;
+	DWORD	m_dwCityH;
+	DWORD	m_dwCityW;
+	DWORD	m_dwCityX;
+	DWORD	m_dwCityY;
+	DWORD	m_dwContentBackB;
+	DWORD	m_dwContentBackG;
+	DWORD	m_dwContentBackR;
+	DWORD	m_dwContentFontB;
+	DWORD	m_dwContentFontG;
+	DWORD	m_dwContentFontR;
+	DWORD	m_dwContentFontSize;
+	DWORD	m_dwContentH;
+	DWORD	m_dwContentW;
+	DWORD	m_dwContentY;
+	DWORD	m_dwContentX;
+	DWORD	m_dwDateBackB;
+	DWORD	m_dwDateBackG;
+	DWORD	m_dwDateBackR;
+	DWORD	m_dwDateFontB;
+	DWORD	m_dwDateFontG;
+	DWORD	m_dwDateFontR;
+	DWORD	m_dwDateFontSize;
+	DWORD	m_dwDateH;
+	DWORD	m_dwDateW;
+	DWORD	m_dwDateX;
+	DWORD	m_dwDateY;
+	DWORD	m_dwHumBackB;
+	DWORD	m_dwHumBackG;
+	DWORD	m_dwHumBackR;
+	DWORD	m_dwHumFontB;
+	DWORD	m_dwHumFontG;
+	DWORD	m_dwHumFontR;
+	DWORD	m_dwHumFontSize;
+	DWORD	m_dwHumH;
+	DWORD	m_dwHumX;
+	DWORD	m_dwHumY;
+	DWORD	m_dwTempBackB;
+	DWORD	m_dwTempBackG;
+	DWORD	m_dwTempBackR;
+	DWORD	m_dwTempFontB;
+	DWORD	m_dwTempFontG;
+	DWORD	m_dwTempFontR;
+	DWORD	m_dwTempFontSize;
+	DWORD	m_dwTempH;
+	DWORD	m_dwTempW;
+	DWORD	m_dwTempX;
+	DWORD	m_dwTempY;
+	DWORD	m_dwUpdateBackB;
+	DWORD	m_dwUpdateBackG;
+	DWORD	m_dwUpdateBackR;
+	DWORD	m_dwUpdateFontB;
+	DWORD	m_dwUpdateFontG;
+	DWORD	m_dwUpdateFontR;
+	DWORD	m_dwUpdateFontSize;
+	DWORD	m_dwUpdateH;
+	DWORD	m_dwUpdateW;
+	DWORD	m_dwUpdateX;
+	DWORD	m_dwUpdateY;
+	DWORD	m_dwWeateBackPic;
+	DWORD	m_dwWeaIconW;
+	DWORD	m_dwWeaH;
+	DWORD	m_dwWeaIconH;
+	DWORD	m_dwWeaIconX;
+	DWORD	m_dwWeaIconY;
+	DWORD	m_dwWeaW;
+	DWORD	m_dwWindFontB;
+	DWORD	m_dwWindFontG;
+	DWORD	m_dwWindFontR;
+	DWORD	m_dwWindBackB;
+	DWORD	m_dwWindBackG;
+	DWORD	m_dwWindBackR;
+	DWORD	m_dwWindFontSize;
+	DWORD	m_dwWindX;
+	DWORD	m_dwWindY;
+	DWORD	m_dwWindH;
+	DWORD	m_dwHumW;
+	DWORD	m_dwWindW;
+	//}}AFX_DATA
+
+
+// Overrides
+	// ClassWizard generated virtual function overrides
+	//{{AFX_VIRTUAL(CDlgInfoDiffusionClockWeather)
+	protected:
+	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
+	//}}AFX_VIRTUAL
+
+// Implementation
+protected:
+
+	// Generated message map functions
+	//{{AFX_MSG(CDlgInfoDiffusionClockWeather)
+	afx_msg void OnBtnOk();
+	afx_msg void OnBtnCancel();
+	//}}AFX_MSG
+	DECLARE_MESSAGE_MAP()
+
+public:
+	LPNET_DVR_MATERIAL m_struMaterial;
+};
+
+//{{AFX_INSERT_LOCATION}}
+// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
+
+#endif // !defined(AFX_DLGINFODIFFUSIONCLOCKWEATHER_H__DDFCF73E_E6C7_4ED5_8C71_4A286C525A98__INCLUDED_)

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgInteractiveFileInfoCfg.h

@@ -0,0 +1,73 @@
+#include "afxwin.h"
+#if !defined(AFX_DLGINTERACTIVEFILEINFOCFG_H__9BDA9787_5822_4915_A64C_0B016CC14A38__INCLUDED_)
+#define AFX_DLGINTERACTIVEFILEINFOCFG_H__9BDA9787_5822_4915_A64C_0B016CC14A38__INCLUDED_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif // _MSC_VER > 1000
+// DlgInteractiveFileInfoCfg.h : header file
+//
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgInteractiveFileInfoCfg dialog
+
+class CDlgInteractiveFileInfoCfg : public CDialog
+{
+// Construction
+public:
+	CDlgInteractiveFileInfoCfg(CWnd* pParent = NULL);   // standard constructor
+
+// Dialog Data
+	//{{AFX_DATA(CDlgInteractiveFileInfoCfg)
+	enum { IDD = IDD_DLG_INTERACTIVE_FILEINFO };
+	CComboBox	m_comVideoFormat;
+	CComboBox	m_comPicFormat;
+	CListCtrl	m_listFileInfoCfg;
+	CString	m_csFileName;
+	int		m_nFileType;
+	DWORD	m_dwFileIndex;
+	long	m_dwFileSize;
+	DWORD	m_dwPPTPage;
+	//}}AFX_DATA
+
+
+// Overrides
+	// ClassWizard generated virtual function overrides
+	//{{AFX_VIRTUAL(CDlgInteractiveFileInfoCfg)
+	protected:
+	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
+	//}}AFX_VIRTUAL
+
+// Implementation
+protected:
+
+	// Generated message map functions
+	//{{AFX_MSG(CDlgInteractiveFileInfoCfg)
+	virtual BOOL OnInitDialog();
+	afx_msg void OnBtnSet();
+	afx_msg void OnBtnGet();
+	afx_msg void OnRadPic();
+	afx_msg void OnRadVideo();
+	afx_msg void OnBtnGetFileinfo();
+	afx_msg void OnClickListFileinfo(NMHDR* pNMHDR, LRESULT* pResult);
+	afx_msg void OnRadioAll();
+	afx_msg void OnBtnClear();
+	//}}AFX_MSG
+	DECLARE_MESSAGE_MAP()
+
+public:
+	LONG	m_lServerID;
+	int     m_iDevIndex;
+	LONG    m_lChannel;
+	NET_DVR_SCREEN_FILE_INFO m_struScreenFileInfo;
+	int     m_nCurSelFile;
+    CComboBox m_cmbDocFormat;
+    CString m_sOtherFileFormat;
+    afx_msg void OnBnClickedRadDoc();
+    afx_msg void OnBnClickedRadOther();
+};
+
+//{{AFX_INSERT_LOCATION}}
+// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
+
+#endif // !defined(AFX_DLGINTERACTIVEFILEINFOCFG_H__9BDA9787_5822_4915_A64C_0B016CC14A38__INCLUDED_)

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgIscsiCfg.h

@@ -0,0 +1,55 @@
+#if !defined(AFX_DLGISCSICFG_H__2FE95E6F_6273_4929_A58C_1231544CB73C__INCLUDED_)
+#define AFX_DLGISCSICFG_H__2FE95E6F_6273_4929_A58C_1231544CB73C__INCLUDED_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif // _MSC_VER > 1000
+// DlgIscsiCfg.h : header file
+//
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgIscsiCfg dialog
+
+class CDlgIscsiCfg : public CDialog
+{
+// Construction
+public:
+	CDlgIscsiCfg(CWnd* pParent = NULL);   // standard constructor
+
+// Dialog Data
+	//{{AFX_DATA(CDlgIscsiCfg)
+	enum { IDD = IDD_DLG_ISCSI_CFG };
+	BOOL	m_bEnable;
+	CString	m_csNvtIndexCode;
+	int		m_iPort;
+	CString	m_csIpAddr;
+	//}}AFX_DATA
+
+
+// Overrides
+	// ClassWizard generated virtual function overrides
+	//{{AFX_VIRTUAL(CDlgIscsiCfg)
+	protected:
+	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
+	//}}AFX_VIRTUAL
+
+// Implementation
+protected:
+
+	// Generated message map functions
+	//{{AFX_MSG(CDlgIscsiCfg)
+	virtual BOOL OnInitDialog();
+	virtual void OnOK();
+	afx_msg void OnChangeEditVrmPort();
+	//}}AFX_MSG
+	DECLARE_MESSAGE_MAP()
+public:
+    long m_lServerID;
+    long m_iDevIndex;
+    NET_DVR_ISCSI_CFG m_struIscsiCfg;
+};
+
+//{{AFX_INSERT_LOCATION}}
+// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
+
+#endif // !defined(AFX_DLGISCSICFG_H__2FE95E6F_6273_4929_A58C_1231544CB73C__INCLUDED_)

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgLocalRecordSchedule.h

@@ -0,0 +1,78 @@
+#pragma once
+#include "afxwin.h"
+
+
+// CDlgLocalRecordSchedule dialog
+
+class CDlgLocalRecordSchedule : public CDialog
+{
+	DECLARE_DYNAMIC(CDlgLocalRecordSchedule)
+
+public:
+	CDlgLocalRecordSchedule(CWnd* pParent = NULL);   // standard constructor
+	virtual ~CDlgLocalRecordSchedule();
+
+// Dialog Data
+
+
+public:
+	//{{AFX_DATA(CDlgLocalRecordSchedule)
+	enum { IDD = IDD_DLG_LOCAL_RECORD_SCHEDULE };
+	CComboBox m_comboScheduleWeekday;
+	CComboBox m_comboCopyWeekday;
+	int m_iHour11;
+	int m_iMin11;
+	int m_iHour12;
+	int m_iMin12;
+	int m_iHour21;
+	int m_iMin21;
+	int m_iHour22;
+	int m_iMin22;
+	int m_iHour31;
+	int m_iMin31;
+	int m_iHour32;
+	int m_iMin32;
+	int m_iHour41;
+	int m_iMin41;
+	int m_iHour42;
+	int m_iMin42;
+	int m_iHour51;
+	int m_iMin51;
+	int m_iHour52;
+	int m_iMin52;
+	int m_iHour61;
+	int m_iMin61;
+	int m_iHour62;
+	int m_iMin62;
+	int m_iHour71;
+	int m_iMin71;
+	int m_iHour72;
+	int m_iMin72;
+	int m_iHour81;
+	int m_iMin81;
+	int m_iHour82;
+	int m_iMin82;
+	//}}AFX_DATA
+
+
+
+	//{{AFX_VIRTUAL(CDlgLocalRecordSchedule)
+protected:
+	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
+	//}}AFX_VIRTUAL
+protected:
+	// Generated message map functions
+	//{{AFX_MSG(CDlgLocalRecordSchedule)
+	virtual BOOL OnInitDialog();
+	afx_msg void OnBnClickedLocalRecOk();
+	afx_msg void OnBnClickedLocalRecExit();
+	afx_msg void OnBnClickedBtnRecCopy();
+	afx_msg void OnCbnSelchangeComboWeekday();
+	//}}AFX_MSG
+	
+	DECLARE_MESSAGE_MAP()
+		
+public:
+	
+	
+};

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgMergeDev.cpp

@@ -0,0 +1,129 @@
+// DlgMergeDev.cpp : implementation file
+//
+
+#include "stdafx.h"
+#include "clientdemo.h"
+#include "DlgMergeDev.h"
+#include "DlgWallCfgUniform.h"
+#include "DlgWallWinVideoWall.h"
+#include "DlgSenceControlUniform.h"
+#include "DlgMergeDevPic.h"
+#include "DlgMergeDecOsd.h"
+#include "DlgMergeDevResource.h"
+
+#ifdef _DEBUG
+#define new DEBUG_NEW
+#undef THIS_FILE
+static char THIS_FILE[] = __FILE__;
+#endif
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgMergeDev dialog
+
+
+CDlgMergeDev::CDlgMergeDev(CWnd* pParent /*=NULL*/)
+	: CDialog(CDlgMergeDev::IDD, pParent)
+{
+	//{{AFX_DATA_INIT(CDlgMergeDev)
+		// NOTE: the ClassWizard will add member initialization here
+	//}}AFX_DATA_INIT
+}
+
+
+void CDlgMergeDev::DoDataExchange(CDataExchange* pDX)
+{
+	CDialog::DoDataExchange(pDX);
+	//{{AFX_DATA_MAP(CDlgMergeDev)
+		// NOTE: the ClassWizard will add DDX and DDV calls here
+	//}}AFX_DATA_MAP
+}
+
+
+BEGIN_MESSAGE_MAP(CDlgMergeDev, CDialog)
+	//{{AFX_MSG_MAP(CDlgMergeDev)
+	ON_BN_CLICKED(IDC_BTN_OUTPUT_CFG, OnBtnOutputCfg)
+	ON_BN_CLICKED(IDC_BTN_WIN_CFG, OnBtnWinCfg)
+	ON_BN_CLICKED(IDC_BTN_OUTPUT_PIC, OnBtnOutputPic)
+	ON_BN_CLICKED(IDC_BTN_OUTPUT_OSD, OnBtnOutputOsd)
+	ON_BN_CLICKED(IDC_BTN_CHAN_RESOURCE, OnBtnChanResource)
+	ON_BN_CLICKED(IDC_BTN_SCENE, OnBtnScene)
+	ON_BN_CLICKED(IDC_BTN_EXIT, OnBtnExit)
+	//}}AFX_MSG_MAP
+END_MESSAGE_MAP()
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgMergeDev message handlers
+
+BOOL CDlgMergeDev::OnInitDialog() 
+{
+	CDialog::OnInitDialog();
+	
+	// TODO: Add extra initialization here
+	m_iDeviceIndex = g_pMainDlg->GetCurDeviceIndex();
+
+	return TRUE;  // return TRUE unless you set the focus to a control
+	              // EXCEPTION: OCX Property Pages should return FALSE
+}
+
+
+void CDlgMergeDev::OnBtnOutputCfg() 
+{
+	// TODO: Add your control notification handler code here
+    CDlgWallCfg_Uniform dlg;
+    dlg.m_lUserID = m_lUserID;
+    dlg.m_iDeviceIndex = m_iDeviceIndex;
+    dlg.DoModal();	
+}
+
+void CDlgMergeDev::OnBtnWinCfg() 
+{
+	// TODO: Add your control notification handler code here
+	CDlgWallWinVideoWall dlg;
+    dlg.m_lUserID = m_lUserID;
+    dlg.m_iDeviceIndex = m_iDeviceIndex;
+    dlg.DoModal();
+}
+
+void CDlgMergeDev::OnBtnOutputPic() 
+{
+	// TODO: Add your control notification handler code here
+
+    CDlgMergeDevPic dlg;
+    dlg.m_lUserID = m_lUserID;
+    dlg.m_iDeviceIndex = m_iDeviceIndex;
+    dlg.DoModal();
+
+}
+
+void CDlgMergeDev::OnBtnOutputOsd() 
+{
+	// TODO: Add your control notification handler code here
+	CDlgMergeDecOsd dlg;
+    dlg.m_lUserID = m_lUserID;
+    dlg.m_iDeviceIndex = m_iDeviceIndex;
+    dlg.DoModal();
+}
+
+void CDlgMergeDev::OnBtnChanResource() 
+{
+	// TODO: Add your control notification handler code here
+    CDlgMergeDevResource dlg;
+    dlg.m_lUserID = m_lUserID;
+    dlg.m_iDeviceIndex = m_iDeviceIndex;
+    dlg.DoModal();	
+}
+
+void CDlgMergeDev::OnBtnScene() 
+{
+	// TODO: Add your control notification handler code here
+    CDlgSenceControlUniform dlg;
+    dlg.m_lUserID = m_lUserID;
+    dlg.m_iDeviceIndex = m_iDeviceIndex;
+    dlg.DoModal();	
+}
+
+void CDlgMergeDev::OnBtnExit() 
+{
+	// TODO: Add your control notification handler code here
+	OnCancel();
+}

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgMultiCardCfg.h

@@ -0,0 +1,69 @@
+#if !defined(AFX_DLGMULTICARDCFG_H__666FF054_9F66_45E4_B270_B4BAD279B595__INCLUDED_)
+#define AFX_DLGMULTICARDCFG_H__666FF054_9F66_45E4_B270_B4BAD279B595__INCLUDED_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif // _MSC_VER > 1000
+// DlgMultiCardCfg.h : header file
+//
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgMultiCardCfg dialog
+
+class CDlgMultiCardCfg : public CDialog
+{
+// Construction
+public:
+	CDlgMultiCardCfg(CWnd* pParent = NULL);   // standard constructor
+
+// Dialog Data
+	//{{AFX_DATA(CDlgMultiCardCfg)
+	enum { IDD = IDD_DLG_MULTI_CARD };
+	CComboBox	m_comMultiCardIndex;
+	CComboBox	m_comGroupIndex;
+	BOOL	m_bCombinationEnable;
+	BOOL	m_bEnable;
+	BOOL	m_bMultiCardEnable;
+	BOOL	m_bOffLineVerify;
+	DWORD	m_dwGroupNo;
+	BYTE	m_byMemberNum;
+	BYTE	m_bySequenceNo;
+	BYTE	m_bySwipeIntervalTimeout;
+	DWORD	m_dwTemplateNo;
+	DWORD	m_dwDoorNo;
+	//}}AFX_DATA
+
+
+// Overrides
+	// ClassWizard generated virtual function overrides
+	//{{AFX_VIRTUAL(CDlgMultiCardCfg)
+	protected:
+	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
+	//}}AFX_VIRTUAL
+
+// Implementation
+protected:
+
+	// Generated message map functions
+	//{{AFX_MSG(CDlgMultiCardCfg)
+	virtual BOOL OnInitDialog();
+	afx_msg void OnBtnGetMultiCard();
+	afx_msg void OnBtnSetMultiCard();
+	afx_msg void OnSelchangeComboCombinationIndex();
+	afx_msg void OnSelchangeComboGroupIndex();
+	afx_msg void OnBtnSaveMultiCard();
+	afx_msg void OnSelchangeComboMultiCardIndex();
+	//}}AFX_MSG
+	DECLARE_MESSAGE_MAP()
+public:
+	LONG m_lUserID;
+	LONG m_lChannel;
+	int m_iDevIndex;
+
+	NET_DVR_MULTI_CARD_CFG_V50 m_struMultiCardCfg;
+};
+
+//{{AFX_INSERT_LOCATION}}
+// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
+
+#endif // !defined(AFX_DLGMULTICARDCFG_H__666FF054_9F66_45E4_B270_B4BAD279B595__INCLUDED_)

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgPTZPreset.cpp

@@ -0,0 +1,448 @@
+/**********************************************************
+FileName:    DlgPTZPreset.cpp
+Description: PTZ preset     
+Date:        2008/06/28
+Note: 		 <global>struct, refer to GeneralDef.h, global variants and functions refer to ClientDemo.cpp  
+Modification History:      
+    <version> <time>         <desc>
+    <1.0    > <2008/06/28>       <created>
+***********************************************************/
+
+#include "stdafx.h"
+#include "ClientDemo.h"
+#include "DlgPTZPreset.h"
+#include ".\dlgptzpreset.h"
+
+extern BOOL PTZPresetAll(LONG lRealHandle, int iDevIndex, int iChanIndex, DWORD dwPTZCommand, DWORD dwPresetIndex, char *szCmdString);
+// CDlgPTZPreset dialog
+/*********************************************************
+  Function:	CDlgPTZPreset
+  Desc:		constructor
+  Input:	
+  Output:	
+  Return:	
+**********************************************************/
+IMPLEMENT_DYNAMIC(CDlgPTZPreset, CDialog)
+CDlgPTZPreset::CDlgPTZPreset(CWnd* pParent /*=NULL*/)
+	: CDialog(CDlgPTZPreset::IDD, pParent)
+	, m_bAuto(FALSE)
+    , m_wSensitivity(0)
+{
+	m_iDevIndex = -1;
+	m_lLoginID = -1;
+	m_lChanNum = -1;
+}
+
+/*********************************************************
+  Function:	~CDlgPTZPreset
+  Desc:		destructor
+  Input:	
+  Output:	
+  Return:	
+**********************************************************/
+CDlgPTZPreset::~CDlgPTZPreset()
+{
+}
+
+/*********************************************************
+Function:	DoDataExchange
+Desc:		the map between control and variable
+Input:	
+Output:	
+Return:	
+**********************************************************/
+void CDlgPTZPreset::DoDataExchange(CDataExchange* pDX)
+{
+    CDialog::DoDataExchange(pDX);
+    //{{AFX_DATA_MAP(CDlgPTZPreset)
+    DDX_Control(pDX, IDC_COMBO_WIPER_MODE, m_comboWiperMode);
+    DDX_Control(pDX, IDC_COMBO_PRESET_SETUP, m_comboPreset);
+    DDX_Text(pDX, IDC_EDIT_TIME_INTERVAL, m_byWorkTimeInterval);
+    DDX_Text(pDX, IDC_EDIT_CONTINUE_TIME, m_dwContinueWorkTime);
+    //}}AFX_DATA_MAP
+
+    DDX_Text(pDX, IDC_EDIT_SENSITIVITY_RAIN, m_wSensitivity);
+}
+
+/*********************************************************
+Function:	BEGIN_MESSAGE_MAP
+Desc:		the map between control and function
+Input:	
+Output:	
+Return:	
+**********************************************************/
+BEGIN_MESSAGE_MAP(CDlgPTZPreset, CDialog)
+	//{{AFX_MSG_MAP(CDlgPTZPreset)	
+	ON_BN_CLICKED(IDC_BTN_PRESET_ADD, OnBnClickedBtnPresetAdd)
+	ON_BN_CLICKED(IDC_BTN_PRESET_DEL, OnBnClickedBtnPresetDel)
+	ON_BN_CLICKED(IDC_BTN_EXIT, OnBtnExit)
+	ON_BN_CLICKED(IDC_BTN_PTZ_TRAN, OnBtnPtzTran)
+	ON_BN_CLICKED(IDC_BTN_DO, OnBtnDo)
+	ON_BN_CLICKED(IDC_BTN_PTZ_LIGHT, OnBtnPtzLight)
+	ON_BN_CLICKED(IDC_BTN_WIPER, OnBtnWiper)
+	ON_BN_CLICKED(IDC_BTN_GET_WIPER, OnBtnGetWiper)
+	ON_BN_CLICKED(IDC_BTN_SET_WIPER, OnBtnSetWiper)
+	ON_CBN_SELCHANGE(IDC_COMBO_WIPER_MODE, OnSelchangeComboWiperMode)
+	ON_BN_CLICKED(IDC_BTN_LINEAR_SCAN, OnBtnLinearScan)
+	ON_BN_CLICKED(IDC_BTN_CLE_ALL_SEQ, OnBtnCleAllSeq)
+	ON_BN_CLICKED(IDC_BTN_CLE_ALL_CRUISE, OnBtnCleAllCruise)
+	ON_BN_CLICKED(IDC_BTN_ALL_CLE_PREST, OnBtnAllClePrest)
+	//}}AFX_MSG_MAP
+
+END_MESSAGE_MAP()
+
+
+// CDlgPTZPreset message handlers
+/*********************************************************
+Function:	OnInitDialog
+Desc:		Initialize the dialog
+Input:	
+Output:	
+Return:	
+**********************************************************/
+BOOL CDlgPTZPreset::OnInitDialog()
+{
+	CDialog::OnInitDialog();
+
+	int i=0;
+	char szNum[8] = {0};
+	for (i=0; i<301/*MAX_PRESET_V30+2*/; i++)//0 and 257 just for test
+	{
+		sprintf(szNum, "%d", i);
+		m_comboPreset.AddString(szNum);
+	}
+	m_comboPreset.SetCurSel(1);
+
+	int iChanIndex = g_pMainDlg->GetCurChanIndex();
+    if (iChanIndex < 0)
+    {
+        iChanIndex = 0;
+    }
+	
+	m_iDevIndex=g_pMainDlg->GetCurDeviceIndex();
+	if (m_iDevIndex >= 0)
+	{
+		m_lLoginID = g_struDeviceInfo[m_iDevIndex].lLoginID;
+		//	m_lChanNum = g_struDeviceInfo[m_iDevIndex].struChanInfo[m_iDevIndex].iChannelNO;
+		m_lChanNum = iChanIndex + g_struDeviceInfo[m_iDevIndex].iStartChan;
+	}
+    AddResolution();
+	
+	memset(&m_struWiperInfo, 0, sizeof(m_struWiperInfo));
+	m_comboWiperMode.SetCurSel(0);
+	GetDlgItem(IDC_STATIC_TIME_INTERVAL)->ShowWindow(SW_HIDE);
+	GetDlgItem(IDC_EDIT_TIME_INTERVAL)->ShowWindow(SW_HIDE);
+	GetDlgItem(IDC_STATIC_TIME_INTERVAL_UNIT)->ShowWindow(SW_HIDE);
+	GetDlgItem(IDC_STATIC_CONTINUE_TIME)->ShowWindow(SW_HIDE);
+	GetDlgItem(IDC_EDIT_CONTINUE_TIME)->ShowWindow(SW_HIDE);
+	GetDlgItem(IDC_STATIC_CONTINUE_TIME_UNIT)->ShowWindow(SW_HIDE);
+    GetDlgItem(IDC_STATIC_SENSITIVITY)->ShowWindow(SW_HIDE);
+    GetDlgItem(IDC_EDIT_SENSITIVITY_RAIN)->ShowWindow(SW_HIDE);
+	UpdateData(FALSE);
+	return TRUE;  // return TRUE unless you set the focus to a control
+	// EXCEPTION: OCX Property Pages should return FALSE
+}
+
+/*********************************************************
+  Function:	OnBnClickedBtnPresetAdd
+  Desc:		add presets
+  Input:	
+  Output:	
+  Return:	
+**********************************************************/
+void CDlgPTZPreset::OnBnClickedBtnPresetAdd()
+{
+	UpdateData(TRUE);
+	int iWndIndex = g_pMainDlg->m_iCurWndIndex;
+	int iPreset = m_comboPreset.GetCurSel();
+	int iDevIndex=g_pMainDlg->GetCurDeviceIndex();
+	int iChanIndex = g_pMainDlg->GetCurChanIndex();
+	PTZPresetAll(g_dlgOutput[iWndIndex].m_lPlayHandle, iDevIndex, iChanIndex, SET_PRESET, iPreset, "SET_PRESET");
+}
+
+/*********************************************************
+  Function:	OnBnClickedBtnPresetDel
+  Desc:		delete presets
+  Input:	
+  Output:	
+  Return:	
+**********************************************************/
+void CDlgPTZPreset::OnBnClickedBtnPresetDel()
+{
+	UpdateData(TRUE);
+	int iWndIndex = g_pMainDlg->m_iCurWndIndex;
+	int iPreset = m_comboPreset.GetCurSel();
+	int iDevIndex=g_pMainDlg->GetCurDeviceIndex();
+	int iChanIndex = g_pMainDlg->GetCurChanIndex();
+	PTZPresetAll(g_dlgOutput[iWndIndex].m_lPlayHandle, iDevIndex, iChanIndex, CLE_PRESET, iPreset, "CLE_PRESET");
+}
+
+/*********************************************************
+  Function:	OnBtnExit
+  Desc:		exit the dialog
+  Input:	none
+  Output:	none
+  Return:	none
+**********************************************************/
+void CDlgPTZPreset::OnBtnExit() 
+{
+	// TODO: Add your control notification handler code here
+	CDialog::OnCancel();
+}
+
+void CDlgPTZPreset::OnBtnPtzTran() 
+{
+	// TODO: Add your control notification handler code here
+	char  sCodeBuf[128] = {0};
+    sCodeBuf[0] = (char)0xa0;
+
+    sCodeBuf[1] = (char)0x00;
+
+    sCodeBuf[2] = (char)0x00;
+
+    sCodeBuf[3] = (char)0x07;
+
+    sCodeBuf[4] = (char)0x00;
+
+    sCodeBuf[5] = (char)0x63;
+
+    sCodeBuf[6] = (char)0xaf;
+
+    sCodeBuf[7] = (char)0x6b;
+	if (g_dlgOutput[g_pMainDlg->m_iCurWndIndex].m_lPlayHandle >= 0)
+	{
+		if (!NET_DVR_TransPTZ_EX(g_dlgOutput[g_pMainDlg->m_iCurWndIndex].m_lPlayHandle, sCodeBuf, 8))
+		{
+			g_dlgOutput[g_pMainDlg->m_iCurWndIndex].AddLog(OPERATION_FAIL_T, "NET_DVR_TransPTZ_EX");
+		}
+	}
+
+}
+
+extern BOOL PTZControlAll(LONG lRealHandle, int iDevIndex, int iChanIndex, DWORD dwPTZCommand,DWORD dwStop, char *szCmdString);
+void CDlgPTZPreset::OnBtnDo() 
+{
+	// TODO: Add your control notification handler code here
+	UpdateData(TRUE);
+	int iDevIndex=g_pMainDlg->GetCurDeviceIndex();
+	int iChanIndex = g_pMainDlg->GetCurChanIndex();
+
+	PTZControlAll(g_dlgOutput[g_pMainDlg->m_iCurWndIndex].m_lPlayHandle, iDevIndex, iChanIndex, PAN_AUTO, 0, "PAN_AUTO");
+}
+
+void CDlgPTZPreset::OnBtnPtzLight() 
+{
+	// TODO: Add your control notification handler code here
+	UpdateData(TRUE);
+	int iDevIndex=g_pMainDlg->GetCurDeviceIndex();
+	int iChanIndex = g_pMainDlg->GetCurChanIndex();
+
+	for (int i = 0; i<100; i++)
+	{
+		if (i%2 == 0)
+		{
+			PTZControlAll(g_dlgOutput[g_pMainDlg->m_iCurWndIndex].m_lPlayHandle, iDevIndex, iChanIndex, LIGHT_PWRON, 0, "LIGHT_PWRON");	
+		}
+		else
+		{
+			PTZControlAll(g_dlgOutput[g_pMainDlg->m_iCurWndIndex].m_lPlayHandle, iDevIndex+1, iChanIndex, LIGHT_PWRON, 0, "LIGHT_PWRON");	
+		}
+		
+	}
+}
+
+void CDlgPTZPreset::OnBtnWiper() 
+{
+	// TODO: Add your control notification handler code here
+	UpdateData(TRUE);
+	int iDevIndex=g_pMainDlg->GetCurDeviceIndex();
+	int iChanIndex = g_pMainDlg->GetCurChanIndex();
+
+	PTZControlAll(g_dlgOutput[g_pMainDlg->m_iCurWndIndex].m_lPlayHandle, iDevIndex, iChanIndex, WIPER_PWRON, 0, "WIPER_PWRON");	
+	Sleep(2000);
+	PTZControlAll(g_dlgOutput[g_pMainDlg->m_iCurWndIndex].m_lPlayHandle, iDevIndex, iChanIndex, WIPER_PWRON, 1, "WIPER_PWRON");
+	
+}
+
+void CDlgPTZPreset::OnBtnSetWiper() 
+{
+	// TODO: Add your control notification handler code here
+	UpdateData(TRUE);
+	memset(&m_struWiperInfo, 0, sizeof(m_struWiperInfo));
+	m_struWiperInfo.dwSize = sizeof(m_struWiperInfo);
+	m_struWiperInfo.byWiperWorkMode = m_comboWiperMode.GetCurSel();
+	if(1 == m_comboWiperMode.GetCurSel())
+	{
+		m_struWiperInfo.ustruWiperModeParam.struWiperContinueWorkParam.byWorkTimeInterval = m_byWorkTimeInterval;
+		m_struWiperInfo.ustruWiperModeParam.struWiperContinueWorkParam.dwContinueWorkTime = m_dwContinueWorkTime;
+	}
+    else if (2 == m_comboWiperMode.GetCurSel())
+    {
+        m_struWiperInfo.wSensitivity = m_wSensitivity;
+    }
+
+	if (!NET_DVR_SetDVRConfig(m_lLoginID, NET_DVR_SET_WIPERINFO_CFG, m_lChanNum, &m_struWiperInfo, sizeof(m_struWiperInfo)))
+    {
+        g_pMainDlg->AddLog(m_iDevIndex, OPERATION_FAIL_T, "NET_DVR_SET_WIPERINFO_CFG");
+    }
+	else
+	{
+		g_pMainDlg->AddLog(m_iDevIndex, OPERATION_SUCC_T, "NET_DVR_SET_WIPERINFO_CFG");
+	}
+	UpdateData(FALSE);
+}
+
+void CDlgPTZPreset::OnBtnGetWiper() 
+{
+	// TODO: Add your control notification handler code here
+	UpdateData(TRUE);
+	DWORD dwReturn = 0;
+	memset(&m_struWiperInfo, 0, sizeof(m_struWiperInfo));
+	
+	if (!NET_DVR_GetDVRConfig(m_lLoginID, NET_DVR_GET_WIPERINFO_CFG, m_lChanNum, &m_struWiperInfo, sizeof(m_struWiperInfo), &dwReturn))
+    {
+        g_pMainDlg->AddLog(m_iDevIndex, OPERATION_FAIL_T, "NET_DVR_GET_WIPERINFO_CFG");
+    }
+	else
+	{
+		g_pMainDlg->AddLog(m_iDevIndex, OPERATION_SUCC_T, "NET_DVR_GET_WIPERINFO_CFG");
+	}
+	
+    SetResolutionCurSel(m_struWiperInfo.byWiperWorkMode);
+	OnSelchangeComboWiperMode();
+	UpdateData(FALSE);
+}
+
+void CDlgPTZPreset::OnSelchangeComboWiperMode() 
+{
+	// TODO: Add your control notification handler code here
+	UpdateData(TRUE);
+    if (0 == m_comboWiperMode.GetItemData(m_comboWiperMode.GetCurSel()))
+	{
+		GetDlgItem(IDC_STATIC_TIME_INTERVAL)->ShowWindow(SW_HIDE);
+		GetDlgItem(IDC_EDIT_TIME_INTERVAL)->ShowWindow(SW_HIDE);
+		GetDlgItem(IDC_STATIC_TIME_INTERVAL_UNIT)->ShowWindow(SW_HIDE);
+		GetDlgItem(IDC_STATIC_CONTINUE_TIME)->ShowWindow(SW_HIDE);
+		GetDlgItem(IDC_EDIT_CONTINUE_TIME)->ShowWindow(SW_HIDE);
+		GetDlgItem(IDC_STATIC_CONTINUE_TIME_UNIT)->ShowWindow(SW_HIDE);
+        GetDlgItem(IDC_STATIC_SENSITIVITY)->ShowWindow(SW_HIDE);
+        GetDlgItem(IDC_EDIT_SENSITIVITY_RAIN)->ShowWindow(SW_HIDE);
+	}
+    else if (1 == m_comboWiperMode.GetItemData(m_comboWiperMode.GetCurSel()))
+	{
+		GetDlgItem(IDC_STATIC_TIME_INTERVAL)->ShowWindow(SW_SHOW);
+		GetDlgItem(IDC_EDIT_TIME_INTERVAL)->ShowWindow(SW_SHOW);
+		GetDlgItem(IDC_STATIC_TIME_INTERVAL_UNIT)->ShowWindow(SW_SHOW);
+		GetDlgItem(IDC_STATIC_CONTINUE_TIME)->ShowWindow(SW_SHOW);
+		GetDlgItem(IDC_EDIT_CONTINUE_TIME)->ShowWindow(SW_SHOW);
+		GetDlgItem(IDC_STATIC_CONTINUE_TIME_UNIT)->ShowWindow(SW_SHOW);
+        GetDlgItem(IDC_STATIC_SENSITIVITY)->ShowWindow(SW_HIDE);
+        GetDlgItem(IDC_EDIT_SENSITIVITY_RAIN)->ShowWindow(SW_HIDE);
+		
+		m_byWorkTimeInterval = m_struWiperInfo.ustruWiperModeParam.struWiperContinueWorkParam.byWorkTimeInterval;
+		m_dwContinueWorkTime = m_struWiperInfo.ustruWiperModeParam.struWiperContinueWorkParam.dwContinueWorkTime;
+	}
+    else if (2 == m_comboWiperMode.GetItemData(m_comboWiperMode.GetCurSel()))
+    {
+        GetDlgItem(IDC_STATIC_TIME_INTERVAL)->ShowWindow(SW_HIDE);
+        GetDlgItem(IDC_EDIT_TIME_INTERVAL)->ShowWindow(SW_HIDE);
+        GetDlgItem(IDC_STATIC_TIME_INTERVAL_UNIT)->ShowWindow(SW_HIDE);
+        GetDlgItem(IDC_STATIC_CONTINUE_TIME)->ShowWindow(SW_HIDE);
+        GetDlgItem(IDC_EDIT_CONTINUE_TIME)->ShowWindow(SW_HIDE);
+        GetDlgItem(IDC_STATIC_CONTINUE_TIME_UNIT)->ShowWindow(SW_HIDE);
+        GetDlgItem(IDC_STATIC_SENSITIVITY)->ShowWindow(SW_SHOW);
+        GetDlgItem(IDC_EDIT_SENSITIVITY_RAIN)->ShowWindow(SW_SHOW);
+
+        m_wSensitivity = m_struWiperInfo.wSensitivity;
+    }
+	UpdateData(FALSE);
+}
+
+void CDlgPTZPreset::OnBtnLinearScan() 
+{
+	// TODO: Add your control notification handler code here
+
+	UpdateData(TRUE);
+	int iDevIndex=g_pMainDlg->GetCurDeviceIndex();
+	int iChanIndex = g_pMainDlg->GetCurChanIndex();
+
+	if (iChanIndex >= 0 && iDevIndex >= 0)
+	{
+		PTZControlAll(g_dlgOutput[g_pMainDlg->m_iCurWndIndex].m_lPlayHandle, iDevIndex, iChanIndex, LINEAR_SCAN, 0, "LINEAR_SCAN");	
+	}
+
+}
+
+
+void CDlgPTZPreset::OnBtnCleAllSeq() 
+{
+	// TODO: Add your control notification handler code here
+	UpdateData(TRUE);
+	int iWndIndex = g_pMainDlg->m_iCurWndIndex;
+	int iDevIndex=g_pMainDlg->GetCurDeviceIndex();
+	int iChanIndex = g_pMainDlg->GetCurChanIndex();
+	if (iChanIndex >= 0 && iDevIndex >= 0)
+	{
+		PTZPresetAll(g_dlgOutput[iWndIndex].m_lPlayHandle, iDevIndex, iChanIndex, CLE_ALL_SEQ, 0, "CLE_ALL_SEQ");
+	}
+}
+
+void CDlgPTZPreset::OnBtnCleAllCruise() 
+{
+	// TODO: Add your control notification handler code here
+	UpdateData(TRUE);
+	int iWndIndex = g_pMainDlg->m_iCurWndIndex;
+	int iDevIndex=g_pMainDlg->GetCurDeviceIndex();
+	int iChanIndex = g_pMainDlg->GetCurChanIndex();
+	if (iChanIndex >= 0 && iDevIndex >= 0)
+	{
+		PTZPresetAll(g_dlgOutput[iWndIndex].m_lPlayHandle, iDevIndex, iChanIndex, CLE_ALL_CRUISE, 0, "CLE_ALL_CRUISE");
+	}
+}
+
+void CDlgPTZPreset::OnBtnAllClePrest() 
+{
+	// TODO: Add your control notification handler code here
+	UpdateData(TRUE);
+	int iWndIndex = g_pMainDlg->m_iCurWndIndex;
+	int iDevIndex=g_pMainDlg->GetCurDeviceIndex();
+	int iChanIndex = g_pMainDlg->GetCurChanIndex();
+	if (iChanIndex >= 0 && iDevIndex >= 0)
+	{
+		PTZPresetAll(g_dlgOutput[iWndIndex].m_lPlayHandle, iDevIndex, iChanIndex, CLE_ALL_PRESET, 0, "CLE_ALL_PRESET");
+	}
+}
+
+void CDlgPTZPreset::AddResolution()
+{
+    char szLan[128] = { 0 };
+    m_comboWiperMode.ResetContent();
+    int index = 0;
+
+    g_StringLanType(szLan, "单次模式", "Single");
+    m_comboWiperMode.InsertString(index, szLan);
+    m_comboWiperMode.SetItemData(index, 0);
+    index++;
+
+    g_StringLanType(szLan, "持续模式", "Continue");
+    m_comboWiperMode.InsertString(index, szLan);
+    m_comboWiperMode.SetItemData(index, 1);
+    index++;
+
+    g_StringLanType(szLan, "自动模式", "Auto");
+    m_comboWiperMode.InsertString(index, szLan);
+    m_comboWiperMode.SetItemData(index, 2);
+    index++;
+}
+
+void CDlgPTZPreset::SetResolutionCurSel(DWORD dwData)
+{
+    for (int i = 0; i < m_comboWiperMode.GetCount(); i++)
+    {
+        if (m_comboWiperMode.GetItemData(i) == dwData)
+        {
+            m_comboWiperMode.SetCurSel(i);
+            return;
+        }
+    }
+}

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgPassiveTransCode.h

@@ -0,0 +1,131 @@
+#if !defined(AFX_DLGPASSIVETRANSCODE_H__BB2689F9_70F8_41FD_97E8_0D4057476193__INCLUDED_)
+#define AFX_DLGPASSIVETRANSCODE_H__BB2689F9_70F8_41FD_97E8_0D4057476193__INCLUDED_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif // _MSC_VER > 1000
+// DlgPassiveTransCode.h : header file
+//
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgPassiveTransCode dialog
+
+#include "DlgPassiveWin.h"
+#define MAX_PASSIVE_TRANS_NUM   128
+
+class CDlgPassiveTransCode : public CDialog
+{
+// Construction
+public:
+	CDlgPassiveTransCode(CWnd* pParent = NULL);   // standard constructor
+
+// Dialog Data
+	//{{AFX_DATA(CDlgPassiveTransCode)
+	enum { IDD = IDD_DLG_PASSIVE_TRANS_CODE };
+	CComboBox	m_comboSrcStreamType;
+	CComboBox	m_comboCallBackType;
+	CComboBox	m_comboStream;
+	CComboBox	m_comboProtocol;
+	CComboBox	m_comboGetStreamMode;
+	CComboBox	m_comboDevChan;
+	CComboBox	m_comboStreamType;	
+	CComboBox	m_comboVideoBitrate;
+	CComboBox	m_comboVEncType;
+	CComboBox	m_comboResolution;
+	CComboBox	m_comboPicQuality;
+	CComboBox	m_comboFrameRate;
+	CComboBox	m_comboFormatType;
+	CComboBox	m_comboEncComplexity;
+	CComboBox	m_comboCmpType;
+	CComboBox	m_comboBPFrame;
+	CComboBox	m_comboBitrateType;
+	CComboBox	m_comboAEncType;
+	DWORD	m_dwChannel;
+	DWORD	m_dwIInterval;
+	CString	m_csStreamId;
+	DWORD	m_dwBitrate;
+	BOOL	m_bChannel;
+	CString	m_csDevIP;
+	DWORD	m_dwPort;
+	CString	m_csPassword;
+	CString	m_csUserName;
+	CString	m_csFilePath;
+	DWORD	m_dwStreamSize;
+	BOOL	m_bCycleRead;
+	BOOL	m_bSaveFile;
+	BOOL	m_bSavePreFile;
+	//}}AFX_DATA
+
+
+// Overrides
+	// ClassWizard generated virtual function overrides
+	//{{AFX_VIRTUAL(CDlgPassiveTransCode)
+	protected:
+	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
+	//}}AFX_VIRTUAL
+
+// Implementation
+protected:
+
+	// Generated message map functions
+	//{{AFX_MSG(CDlgPassiveTransCode)
+	virtual BOOL OnInitDialog();
+	afx_msg void OnBtnStartPassiveTrans();
+	afx_msg void OnSelchangeComboCmpType();
+	afx_msg void OnChkChannel();
+	afx_msg void OnBtnSendData();
+	afx_msg void OnBtnStopPassiveTrans();
+	afx_msg void OnBtnExit();
+	afx_msg void OnBtnDisp();
+	afx_msg void OnBtnBrowse();
+	afx_msg void OnDestroy();
+	afx_msg void OnCancelMode();
+	//}}AFX_MSG
+	DECLARE_MESSAGE_MAP()
+
+public:
+	LONG m_lUserID;
+	int m_iDeviceIndex;
+	int m_iSelCmpType;
+	LONG m_lPassiveTransHandle/*[MAX_PASSIVE_TRANS_NUM]*/;
+	LONG m_lDevUserID/*[MAX_PASSIVE_TRANS_NUM]*/;
+	LONG m_lRealPlayHandle/*[MAX_PASSIVE_TRANS_NUM]*/;
+	char m_pHead[100];    
+    char m_pFileData[100]; //±£´æÎļþµÄÍ·40×Ö½Ú
+	HANDLE m_hSendEvent;
+	HANDLE m_hHeadGetEvent;
+	HANDLE m_hExitFileThread;
+	NET_DVR_STREAM_INFO m_struStreamInfo;
+	NET_DVR_PASSIVETRANSINFO m_struPassiveTransInfo;
+	NET_DVR_COMPRESSIONCFG_V30 m_struCmpCfgV30;
+	NET_DVR_COMPRESSIONCFG_ABILITY m_struCompressionCfgAblity;
+	char m_pSdpInfo[2 * 1024];
+	CDlgPassiveWin m_dlgDisp;
+	HANDLE m_hFile;
+	HANDLE m_hFilePre;
+
+	HANDLE m_hSrcFile;
+	HANDLE m_hFileThread;
+	BOOL m_bNeedSendAgain;
+	BOOL m_bGbStream;
+	DWORD m_dwStreamType;
+
+	void InsertMainResolution();
+	void InsertSubResolution();
+	void InsertFrame();
+	void InsertBitrateType();
+	void InsertBitrate();
+	void InsertStreamType();
+	void InsertPicQuality();
+	void InsertBpFrame();
+	void InsertVideoEnc();
+	void InsertAudioEnc();
+	void InsertVEncComplexity();
+	void InsertFormatType();
+
+};
+
+//{{AFX_INSERT_LOCATION}}
+// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
+
+#endif // !defined(AFX_DLGPASSIVETRANSCODE_H__BB2689F9_70F8_41FD_97E8_0D4057476193__INCLUDED_)

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgPdcResult.h

@@ -0,0 +1,88 @@
+#include "afxwin.h"
+#if !defined(AFX_DLGPDCRESULT_H__DF8FC47D_0B2E_41E2_8E88_7CB1EC8195CC__INCLUDED_)
+#define AFX_DLGPDCRESULT_H__DF8FC47D_0B2E_41E2_8E88_7CB1EC8195CC__INCLUDED_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif // _MSC_VER > 1000
+// DlgPdcResult.h : header file
+//
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgPdcResult dialog
+
+class CDlgPdcResult : public CDialog
+{
+// Construction
+public:
+	CDlgPdcResult(CWnd* pParent = NULL);   // standard constructor
+	~CDlgPdcResult();
+
+// Dialog Data
+	//{{AFX_DATA(CDlgPdcResult)
+	enum { IDD = IDD_DLG_PDC_RESULT };
+	CComboBox	m_cmbChannel;
+	CComboBox	m_comReportType;
+	CListCtrl	m_lstPdcResult;
+	COleDateTime	m_startDate;
+	COleDateTime	m_startTime;
+	COleDateTime	m_stopDate;
+	COleDateTime	m_stopTime;
+	DWORD	m_dwTerminalNo;
+	BOOL	m_bEnableProgram;
+	DWORD	m_dwScheduleNo;
+	//}}AFX_DATA
+
+
+// Overrides
+	// ClassWizard generated virtual function overrides
+	//{{AFX_VIRTUAL(CDlgPdcResult)
+	protected:
+	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
+	//}}AFX_VIRTUAL
+
+// Implementation
+protected:
+
+	// Generated message map functions
+	//{{AFX_MSG(CDlgPdcResult)
+	virtual BOOL OnInitDialog();
+	afx_msg void OnBtnGetPdcResult();
+	afx_msg void OnBtnCleanPdcResult();
+	//}}AFX_MSG
+	DECLARE_MESSAGE_MAP()
+
+public:
+	long  m_lServerID; // Óû§ID
+    int   m_iDevIndex; // É豸Ë÷Òý
+	long  m_lChannel;
+
+	int	 m_iStruCount;
+	BOOL m_bGetNext;
+	LONG m_lHandle;
+	HANDLE m_hGetInfoThread;
+	NET_DVR_PDC_QUERY_COND m_struPdcResultCond;
+    //	LPNET_DVR_PDC_RESULT m_pStruPdcResult;
+    NET_DVR_PDC_RESULT m_struPdcResult;
+
+	static DWORD WINAPI GetPdcResultThread(LPVOID lpPdcResult);
+	void AddPdcResultLst(LPNET_DVR_PDC_RESULT lpInter);
+    void UpdateChanStatus();
+    BOOL m_bTriggerPeopleCountingData;
+    BOOL m_bMultiChannelSearch;
+    CListCtrl m_listChan;
+    BOOL m_byChildChecked;
+    CComboBox m_comMinTimeInterva;
+    CComboBox m_comstatisticType;
+    BOOL m_bGroup;
+    BOOL m_bFaceExpression;
+    BOOL m_bGender;
+    BOOL m_bGlasses;
+    BOOL m_bMask;
+    afx_msg void OnNMDblclkListPdcResult(NMHDR *pNMHDR, LRESULT *pResult);
+};
+
+//{{AFX_INSERT_LOCATION}}
+// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
+
+#endif // !defined(AFX_DLGPDCRESULT_H__DF8FC47D_0B2E_41E2_8E88_7CB1EC8195CC__INCLUDED_)

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgPersonnelStatis.h

@@ -0,0 +1,72 @@
+#if !defined(AFX_DLGPERSONNELSTATIS_H__9644D285_65B4_469A_ACC6_9C185F966606__INCLUDED_)
+#define AFX_DLGPERSONNELSTATIS_H__9644D285_65B4_469A_ACC6_9C185F966606__INCLUDED_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif // _MSC_VER > 1000
+// DlgPersonnelStatis.h : header file
+//
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgPersonnelStatis dialog
+
+class CDlgPersonnelStatis : public CDialog
+{
+// Construction
+public:
+	CDlgPersonnelStatis(CWnd* pParent = NULL);   // standard constructor
+
+// Dialog Data
+	//{{AFX_DATA(CDlgPersonnelStatis)
+	enum { IDD = IDD_DLG_PERSONNEL_STATIS };
+	CComboBox	m_comPerortType;
+	CListCtrl	m_lPerStatistics;
+	COleDateTime	m_startDate;
+	COleDateTime	m_startTime;
+	BOOL	m_bUserful;
+	BOOL	m_bPersonNumUseful;
+	BOOL	m_bSexUseful;
+	DWORD	m_dwTerminalNo;
+	BOOL	m_bEnableProgram;
+	DWORD	m_dwScheduleNo;
+	//}}AFX_DATA
+
+
+// Overrides
+	// ClassWizard generated virtual function overrides
+	//{{AFX_VIRTUAL(CDlgPersonnelStatis)
+	protected:
+	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
+	//}}AFX_VIRTUAL
+
+// Implementation
+protected:
+
+	// Generated message map functions
+	//{{AFX_MSG(CDlgPersonnelStatis)
+	virtual BOOL OnInitDialog();
+	afx_msg void OnBtnGetPersonnelStatisitcs();
+	afx_msg void OnBtnCleanHeatmapInfo();
+	//}}AFX_MSG
+	DECLARE_MESSAGE_MAP()
+
+public:
+	NET_DVR_FACECAPTURE_STATISTICS_COND m_struStatisticsCond;
+	NET_DVR_FACECAPTURE_STATISTICS_RESULT m_struStatisticsResult;
+	NET_DVR_SEXGROUP_PARAM m_struSexgroupParam;
+	LONG  m_lChannel;
+	LONG m_lHandle;
+	long  m_lServerID; // Óû§ID
+    int   m_iDevIndex; // É豸Ë÷Òý
+	BOOL m_bGetNext;
+
+	HANDLE m_hGetInfoThread;
+
+	static DWORD WINAPI GetPersonnelStatisticsThread(LPVOID lpPersonnelStatistics);
+	void AddPersonnelStatisticsLst(LPNET_DVR_FACECAPTURE_STATISTICS_RESULT lpInter);
+};
+
+//{{AFX_INSERT_LOCATION}}
+// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
+
+#endif // !defined(AFX_DLGPERSONNELSTATIS_H__9644D285_65B4_469A_ACC6_9C185F966606__INCLUDED_)

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgPictureUpload.h

@@ -0,0 +1,75 @@
+#include "afxwin.h"
+#if !defined(AFX_DLGPICTUREUPLOAD_H__710DA2CA_3633_40FF_A3D0_02DBDEBA1314__INCLUDED_)
+#define AFX_DLGPICTUREUPLOAD_H__710DA2CA_3633_40FF_A3D0_02DBDEBA1314__INCLUDED_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif // _MSC_VER > 1000
+// DlgPictureUpload.h : header file
+//
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgPictureUpload dialog
+
+class CDlgPictureUpload : public CDialog
+{
+// Construction
+public:
+	CDlgPictureUpload(CWnd* pParent = NULL);   // standard constructor
+    ~CDlgPictureUpload();
+// Dialog Data
+	//{{AFX_DATA(CDlgPictureUpload)
+	enum { IDD = IDD_DLG_PICTURE_UPLOAD };
+	CComboBox	m_comPicType;
+	CString	m_csFilePath;
+	CString	m_csPicUrl;
+	BOOL	m_bPicStruct;
+	COleDateTime	m_date;
+	COleDateTime	m_time;
+	//}}AFX_DATA
+
+
+// Overrides
+	// ClassWizard generated virtual function overrides
+	//{{AFX_VIRTUAL(CDlgPictureUpload)
+	protected:
+	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
+	//}}AFX_VIRTUAL
+
+// Implementation
+protected:
+
+	// Generated message map functions
+	//{{AFX_MSG(CDlgPictureUpload)
+	virtual BOOL OnInitDialog();
+	afx_msg void OnBtnFilePath();
+	afx_msg void OnBtnPicUpload();
+	afx_msg void OnCheckPicStruct();
+	afx_msg void OnBtnPicDownload();
+	//}}AFX_MSG
+	DECLARE_MESSAGE_MAP()
+public:
+    LONG m_lServerID;
+    LONG m_lChannel;
+    LONG m_lDeviceIndex;
+
+    LONG m_lUploadHandle;
+    BOOL m_bUpLoading;
+	HANDLE	m_hUpLoadThread;
+    DWORD m_dwThreadId;
+
+    char* m_pPicInfo;
+    NET_DVR_UPLOAD_PICTURE_INFO m_struPicInfo;
+    static DWORD WINAPI GetUpLoadFileThread(LPVOID pParam);
+  //  void ShowPicUrl(CString strUrl);
+    CString m_csIp;
+    DWORD m_dwPort;
+    afx_msg void OnBnClickedBtnPicDownloadv50();
+    CComboBox m_pictureUserType;
+    DWORD m_pictureId;
+};
+
+//{{AFX_INSERT_LOCATION}}
+// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
+
+#endif // !defined(AFX_DLGPICTUREUPLOAD_H__710DA2CA_3633_40FF_A3D0_02DBDEBA1314__INCLUDED_)

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgPlayBack.h

@@ -0,0 +1,68 @@
+#pragma once
+#include "afxcmn.h"
+#include "DlgPlayLocalFile.h"
+#include "DlgPlayRemoteFile.h"
+#include "DlgPlayRemoteTime.h"
+#include "DlgPlayEvent.h"
+#include "DlgPlayMotion.h"
+#include "DlgPlayLockFile.h"//2011-8-23
+#include "DlgPlayDvrRecord.h"//2011-8-25
+
+#include "JPEGPicDownload.h"
+#include "DlgRecordLabel.h"
+#include "DlgSmartSearchPicture.h"
+#include "DlgPlayRemoteFileMedical.h"
+// CDlgPlayBack dialog
+
+class CDlgPlayBack : public CDialog
+{
+	DECLARE_DYNAMIC(CDlgPlayBack)
+
+public:
+	CDlgPlayBack(CWnd* pParent = NULL);   // standard constructor
+	virtual ~CDlgPlayBack();
+
+// Dialog Data
+
+
+public:
+	//{{AFX_DATA(CDlgPlayBack)
+	enum { IDD = IDD_DLG_PLAY_BACK };
+	CTabCtrl m_tabPlayBack;
+	//}}AFX_DATA
+	
+	
+	//{{AFX_VIRTUAL(CDlgPlayBack)
+protected:
+	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
+	//}}AFX_VIRTUAL
+protected:
+	// Generated message map functions
+	//{{AFX_MSG(CDlgPlayBack)
+	virtual BOOL OnInitDialog();
+	afx_msg void OnTcnSelchangeTabPlayBack(NMHDR *pNMHDR, LRESULT *pResult);
+	//}}AFX_MSG
+	
+	DECLARE_MESSAGE_MAP()
+		
+public:
+	CDlgPlayEvent	m_dlgPlayEvent;//2009-07-30
+	
+	CDlgPlayRemoteTime	m_dlgPlayRemoteTime;
+	CDlgPlayRemoteFile m_dlgPlayRemoteFile;
+	CDlgPlayLocalFile m_dlgPlayLocalFile;
+    CDlgPlayMotion      m_dlgPlayMotion;
+
+	CJPEGPicDownload  m_dlgJpegPicDownload;
+    CDlgRecordLabel     m_dlgRecordLabel;
+	CDlgPlayLockFile m_dlgPlayLockFile;//2011-8-23
+	CDlgPlayDvrRecord m_dlgPlayDvrRecord;//2011-8-25
+	CDlgSmartSearchPicture m_dlgSmartSearchPic;
+
+	int m_iPlayBackType;//playback type
+	
+	void PlayBackWinUpdate();
+	void FinishAll();
+	void HideAll();
+    
+};

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgPlayDvrRecord.h

@@ -0,0 +1,66 @@
+#if !defined(AFX_DLGPLAYDVRRECORD_H__08E3EDF0_4B04_4DC0_BABD_278E1A6D4951__INCLUDED_)
+#define AFX_DLGPLAYDVRRECORD_H__08E3EDF0_4B04_4DC0_BABD_278E1A6D4951__INCLUDED_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif // _MSC_VER > 1000
+// DlgPlayDvrRecord.h : header file
+//
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgPlayDvrRecord dialog
+
+class CDlgPlayDvrRecord : public CDialog
+{
+// Construction
+public:
+	CDlgPlayDvrRecord(CWnd* pParent = NULL);   // standard constructor
+    virtual ~CDlgPlayDvrRecord();
+// Dialog Data
+	//{{AFX_DATA(CDlgPlayDvrRecord)
+	enum { IDD = IDD_DLG_PLAY_DVR_RECORD };
+	CComboBox	m_cmRecordChannel;
+	CComboBox	m_comboRecordType;
+	//}}AFX_DATA
+
+
+// Overrides
+	// ClassWizard generated virtual function overrides
+	//{{AFX_VIRTUAL(CDlgPlayDvrRecord)
+	protected:
+	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
+	//}}AFX_VIRTUAL
+
+// Implementation
+protected:
+
+	// Generated message map functions
+	//{{AFX_MSG(CDlgPlayDvrRecord)
+	virtual BOOL OnInitDialog();
+	afx_msg void OnBtnStartRecord();
+	afx_msg void OnBtnStopRecord();
+	//}}AFX_MSG
+	DECLARE_MESSAGE_MAP()
+
+public:
+	HWND m_hPareTabWnd;
+	HWND m_hPareDlgWnd;
+	int  m_iDeviceIndex;	
+	int  m_iChanIndex;	
+	int  m_iChanCount;
+	LONG m_lChannel;
+	LONG m_lRecordType;
+	LONG m_lStartChan;
+	LONG m_lLoginID;
+	
+
+    void SetParentWnd(HWND *hhWnd, int iParentNum);
+	BOOL CheckInitParam();
+	void InitComboBox();
+
+};
+
+//{{AFX_INSERT_LOCATION}}
+// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
+
+#endif // !defined(AFX_DLGPLAYDVRRECORD_H__08E3EDF0_4B04_4DC0_BABD_278E1A6D4951__INCLUDED_)

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgPlayMotion.cpp

@@ -0,0 +1,1759 @@
+// DlgPlayMotion.cpp : implementation file
+//
+
+#include "stdafx.h"
+#include "clientdemo.h"
+#include "DlgPlayMotion.h"
+#include "DlgIPCSimpIntellCfg.h"
+#include "resource.h"
+
+#ifdef _DEBUG
+#define new DEBUG_NEW
+#undef THIS_FILE
+static char THIS_FILE[] = __FILE__;
+#endif
+int g_dwPrecision = 16;
+CDlgPlayMotion *g_PlayMotion = NULL;
+/////////////////////////////////////////////////////////////////////////////
+// CDlgPlayMotion dialog
+void CALLBACK DrawSearchMotionArea(LONG lRealHandle, HDC hDc, DWORD dwUser)
+{
+    CDlgPlayMotion *lp = (CDlgPlayMotion *)g_PlayMotion;
+
+    switch(lp->m_dwSearchType)
+    {
+    case 0:
+//         {
+//             CRect rect;
+//             int i = 0,j = 0;
+//             CPoint point;
+//             for (i = 0;i<18;i++)
+//             {
+//                 for (j = 0;j<22;j++)
+//                 {
+//                     if (g_PlayMotion->m_struSmartSearch.uSmartSearchCond.byMotionScope[i][j] == 1)
+//                     {
+//                         point.x = j*g_dwPrecision;
+//                         point.y = i*g_dwPrecision;
+//                         rect.left = point.x;
+		//                         rect.top = point.y;
+		//                         rect.right = point.x + g_dwPrecision;
+		//                         rect.bottom = point.y + g_dwPrecision;
+		//                         ::DrawEdge(hDc, &rect, BDR_SUNKENOUTER, BF_RECT);
+		//                     }
+		//                 }
+		//             }
+		//         }
+		//         break;
+    case 1:
+    case 2:
+        lp->F_DrawFun(lRealHandle, hDc, dwUser);
+        break;
+    default:
+        break;
+        
+    }
+
+	SetBkMode(hDc,TRANSPARENT);
+}
+
+
+DWORD  GetMotionInfoThread(LPVOID pParam)
+{
+    CDlgPlayMotion *pPlayMotion = (CDlgPlayMotion*)pParam;
+
+   
+    NET_DVR_SMART_SEARCH_RET struSmartSearchRet = {0};
+    long nStatus = -1; 
+    char szLan[128] = {0};
+    
+    pPlayMotion->m_listMotionTime.DeleteAllItems();
+    int nItemIndex = 0;
+    while (1)
+    {
+        nStatus = NET_DVR_SearchNextInfo(pPlayMotion->m_lSearchHandle, &struSmartSearchRet);
+        CString str = "";
+    
+        if (-1 == nStatus)
+        {
+            g_StringLanType(szLan, "查找失败", "Fail to search");
+            str = szLan;
+			g_PlayMotion->GetDlgItem(IDC_STATIC_MOTION_SEARCH_STATE)->SetWindowText(str);
+            break;
+        }
+        else if (NET_DVR_FILE_SUCCESS == nStatus)
+        {
+            char chStartTime[128] = {0};
+            char chStopTime[128] = {0};
+            sprintf(chStartTime, "%04d%02d%02d%02d%02d%02d",struSmartSearchRet.struStartTime.dwYear, 
+                struSmartSearchRet.struStartTime.dwMonth, struSmartSearchRet.struStartTime.dwDay,
+                struSmartSearchRet.struStartTime.dwHour, struSmartSearchRet.struStartTime.dwMinute, 
+                struSmartSearchRet.struStartTime.dwSecond);
+            sprintf(chStopTime, "%04d%02d%02d%02d%02d%02d", struSmartSearchRet.struEndTime.dwYear, struSmartSearchRet.struEndTime.dwMonth, 
+                struSmartSearchRet.struEndTime.dwDay, struSmartSearchRet.struEndTime.dwHour, struSmartSearchRet.struEndTime.dwMinute, 
+                struSmartSearchRet.struEndTime.dwSecond);
+            
+            char chCount[256]= {0};
+            sprintf(chCount, "%d", nItemIndex+1);
+            pPlayMotion->m_listMotionTime.InsertItem(nItemIndex, chCount, 0);
+            pPlayMotion->m_listMotionTime.SetItemText(nItemIndex, 1,chStartTime);
+            pPlayMotion->m_listMotionTime.SetItemText(nItemIndex, 2, chStopTime );
+            TRACE("StartTime:Y[%d]M[%d]D[%d]H[%d]M[%d]S[%d]  EndTime:Y[%d]M[%d]D[%d]H[%d]M[%d]S[%d]\n",
+                struSmartSearchRet.struStartTime.dwYear, struSmartSearchRet.struStartTime.dwMonth, struSmartSearchRet.struStartTime.dwDay,
+                struSmartSearchRet.struStartTime.dwHour, struSmartSearchRet.struStartTime.dwMinute, struSmartSearchRet.struStartTime.dwSecond,
+                struSmartSearchRet.struEndTime.dwYear, struSmartSearchRet.struEndTime.dwMonth, struSmartSearchRet.struEndTime.dwDay,
+                struSmartSearchRet.struEndTime.dwHour, struSmartSearchRet.struEndTime.dwMinute, struSmartSearchRet.struEndTime.dwSecond
+                );
+            g_StringLanType(szLan, "获取到文件信息", "Access to file information");
+            str = szLan;
+            nItemIndex++;
+        }
+        else if (NET_DVR_ISFINDING == nStatus)
+        {
+            g_StringLanType(szLan, "正在查找", "searching");
+            str = szLan;
+        }
+        else if (NET_DVR_NOMOREFILE == nStatus)
+        {
+            g_StringLanType(szLan, "查找时没有更多文件", "search end");
+            str = szLan;
+			g_PlayMotion->GetDlgItem(IDC_STATIC_MOTION_SEARCH_STATE)->SetWindowText(str);
+            AfxMessageBox(szLan);
+            break;
+        }
+        else if (NET_DVR_FILE_EXCEPTION == nStatus)
+        {
+            g_StringLanType(szLan, "查找文件时异常", "search exception");
+            str = szLan;
+			g_PlayMotion->GetDlgItem(IDC_STATIC_MOTION_SEARCH_STATE)->SetWindowText(str);
+            break;
+        }
+        else if (NET_DVR_FILE_NOFIND == nStatus)
+        {
+            g_StringLanType(szLan, "没有查找到文件", "search nothing");
+            str = szLan;
+            AfxMessageBox(szLan);
+			g_PlayMotion->GetDlgItem(IDC_STATIC_MOTION_SEARCH_STATE)->SetWindowText(str);
+            break;
+        }
+        else
+        {
+            g_StringLanType(szLan, "查找错误", "search error");
+            str = szLan;
+			g_PlayMotion->GetDlgItem(IDC_STATIC_MOTION_SEARCH_STATE)->SetWindowText(str);
+            break;
+        }
+        g_PlayMotion->GetDlgItem(IDC_STATIC_MOTION_SEARCH_STATE)->SetWindowText(str);
+        
+    }
+    
+    if (!NET_DVR_StopSearch(pPlayMotion->m_lSearchHandle))
+    {
+
+    }
+    return 1;
+}
+
+CDlgPlayMotion::CDlgPlayMotion(CWnd* pParent /*=NULL*/)
+	: CDialog(CDlgPlayMotion::IDD, pParent)
+	, m_csStreamID(_T(""))
+{
+	//{{AFX_DATA_INIT(CDlgPlayMotion)
+	m_ctDateStart = 0;
+	m_ctDateStop = 0;
+	m_ctTimeStart = 0;
+	m_ctTimeStop = 0;
+	m_iTime = 0;
+	m_dwIntrusionDuration = 0;
+	m_dwIntrusionRate = 0;
+	m_dwIntrusionSensitivity = 0;
+	m_dwTravesePlaneSensitivity = 0;
+	m_dwTraversePlanePreTime = 0;
+	m_dwTraversePlaneDelayTime = 0;
+	m_dwIntrusionPreTime = 0;
+	m_dwIntrusionDelayTime = 0;
+	m_fPanPos = 0.0f;
+	m_fTitlePos = 0.0f;
+	m_fZoomPos = 0.0f;
+	//}}AFX_DATA_INIT
+    m_hFindThread = NULL;
+    m_lServerID = -1;
+    m_lChannel = -1;
+    m_iDevIndex = -1;
+    memset(&m_struSmartSearchV40, 0, sizeof(m_struSmartSearchV40));
+    m_lSearchHandle = -1;
+    m_lRealPlayHandle = -1;
+    m_lPlayBackHandle = -1;
+    m_iDrawingIndex = -1;
+    memset(m_bMouseMove, 0, sizeof(m_bMouseMove));
+    memset(m_struRect, 0, sizeof(m_struRect));
+    memset(m_bDrawed, 0, sizeof(m_bDrawed));
+    memset(&m_struStartTime, 0, sizeof(m_struStartTime)) ;
+    memset(&m_struStopTime, 0, sizeof(m_struStopTime));
+    m_iItemSel = -1;
+	m_dwSearchType = 0;
+    m_iFieldNo = 0 ;
+	m_iLineNo = 0;
+    
+    
+}
+
+
+void CDlgPlayMotion::DoDataExchange(CDataExchange* pDX)
+{
+	CDialog::DoDataExchange(pDX);
+	//{{AFX_DATA_MAP(CDlgPlayMotion)
+	DDX_Control(pDX, IDC_COMBO_SEX, m_cmbSex);
+	DDX_Control(pDX, IDC_COMBO_ADVANCE, m_cmbAdvance);
+	DDX_Control(pDX, IDC_COMBO_EYEGLASS, m_cmbEyeGlass);
+	DDX_Control(pDX, IDC_COMBO_COLOR_RATE, m_cmbColorRate);
+	DDX_Control(pDX, IDC_COMBO_COLOR_R, m_cmbColorR);
+	DDX_Control(pDX, IDC_COMBO_COLOR_G, m_cmbColorG);
+	DDX_Control(pDX, IDC_COMBO_COLOR_B, m_cmbColorB);
+	DDX_Control(pDX, IDC_COMBO_RES, m_cmbRes);
+	DDX_Control(pDX, IDC_COMBO_INTRUSION_CUR_AREA, m_cmbIntrusionCurArea);
+	DDX_Control(pDX, IDC_COMBO_CUR_AREA, m_cmbCurArea);
+	DDX_Control(pDX, IDC_COMBO_TRAVERSE_PLANE_DIRECTION, m_cmbTraversePlaneDirction);
+	DDX_Control(pDX, IDC_COMBO_SEARCH_TYPE, m_cmbSearchType);
+	DDX_Control(pDX, IDC_LIST_MOTION_TIME, m_listMotionTime);
+	DDX_Control(pDX, IDC_COMBO_SEARCH_SENSE, m_comboSearchSense);
+	DDX_DateTimeCtrl(pDX, IDC_COMBO_REMOTE_DATE_START, m_ctDateStart);
+	DDX_DateTimeCtrl(pDX, IDC_COMBO_REMOTE_DATE_STOP, m_ctDateStop);
+	DDX_DateTimeCtrl(pDX, IDC_COMBO_REMOTE_TIME_START, m_ctTimeStart);
+	DDX_DateTimeCtrl(pDX, IDC_COMBO_REMOTE_TIME_STOP, m_ctTimeStop);
+	DDX_Text(pDX, IDC_EDIT_TIME, m_iTime);
+	DDX_Text(pDX, IDC_EDIT_INTRUSION_DURATION, m_dwIntrusionDuration);
+	DDX_Text(pDX, IDC_EDIT_INTRUSION_RATE, m_dwIntrusionRate);
+	DDX_Text(pDX, IDC_EDIT_INTRUSION_SENSITIVITY, m_dwIntrusionSensitivity);
+	DDX_Text(pDX, IDC_EDIT_TRAVERSE_PLANE_SENSITIVITY, m_dwTravesePlaneSensitivity);
+	DDX_Text(pDX, IDC_EDIT_TRAVERSE_PLANE_PRE_TIME, m_dwTraversePlanePreTime);
+	DDX_Text(pDX, IDC_EDIT_TRAVERSE_PLANE_DELAY_TIME, m_dwTraversePlaneDelayTime);
+	DDX_Text(pDX, IDC_EDIT_INTRUSION_PRE_TIME, m_dwIntrusionPreTime);
+	DDX_Text(pDX, IDC_EDIT_INTRUSION_DELAY_TIME, m_dwIntrusionDelayTime);
+	DDX_Text(pDX, IDC_EDIT_PAN_POS, m_fPanPos);
+	DDX_Text(pDX, IDC_EDIT_TITLE_POS, m_fTitlePos);
+	DDX_Text(pDX, IDC_EDIT_ZOOM_POS, m_fZoomPos);
+	DDX_Text(pDX, IDC_EDIT_STREAM_ID2, m_csStreamID);
+	DDX_Control(pDX, IDC_CMB_RELATED_CHANNEL, m_cmbRelatedChan);
+	//}}AFX_DATA_MAP
+}
+
+
+BEGIN_MESSAGE_MAP(CDlgPlayMotion, CDialog)
+	//{{AFX_MSG_MAP(CDlgPlayMotion)
+	ON_BN_CLICKED(IDC_BTN_MOTION_SEARCH, OnBtnMotionSearch)
+	ON_BN_CLICKED(IDC_BTN_PREVIEW, OnBtnPreview)
+	ON_NOTIFY(NM_CLICK, IDC_LIST_MOTION_TIME, OnClickListMotionTime)
+	ON_NOTIFY(NM_DBLCLK, IDC_LIST_MOTION_TIME, OnDblclkListMotionTime)
+	ON_WM_TIMER()
+	ON_CBN_SELCHANGE(IDC_COMBO_SEARCH_TYPE, OnSelchangeComboSearchType)
+	ON_BN_CLICKED(IDC_BTN_CLEARPIC, OnBtnClearpic)
+	ON_BN_CLICKED(IDC_BTN_GET_PTZ, OnBtnGetPtz)
+	//}}AFX_MSG_MAP
+END_MESSAGE_MAP()
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgPlayMotion message handlers
+
+void CDlgPlayMotion::OnBtnMotionSearch() 
+{
+    UpdateData(TRUE);
+   	char szLan[128] = {0};
+ 
+	m_struSmartSearchV40.dwSize = sizeof(m_struSmartSearchV40);
+
+    m_struSmartSearchV40.struStartTime.wYear = (WORD)m_ctDateStart.GetYear();
+    m_struSmartSearchV40.struStartTime.byMonth = (BYTE)m_ctDateStart.GetMonth();
+    m_struSmartSearchV40.struStartTime.byDay = (BYTE)m_ctDateStart.GetDay();
+    m_struSmartSearchV40.struStartTime.byHour = (BYTE)m_ctTimeStart.GetHour();
+    m_struSmartSearchV40.struStartTime.byMinute = (BYTE)m_ctTimeStart.GetMinute();
+    m_struSmartSearchV40.struStartTime.bySecond = (BYTE)m_ctTimeStart.GetSecond();
+    m_struSmartSearchV40.struEndTime.wYear = (WORD)m_ctDateStop.GetYear();
+    m_struSmartSearchV40.struEndTime.byMonth = (BYTE)m_ctDateStop.GetMonth();
+    m_struSmartSearchV40.struEndTime.byDay = (BYTE)m_ctDateStop.GetDay();
+    m_struSmartSearchV40.struEndTime.byHour = (BYTE)m_ctTimeStop.GetHour();
+    m_struSmartSearchV40.struEndTime.byMinute = (BYTE)m_ctTimeStop.GetMinute();
+    m_struSmartSearchV40.struEndTime.bySecond = (BYTE)m_ctTimeStop.GetSecond();
+    m_struSmartSearchV40.byISO8601 = g_bISO8601;
+    m_struSmartSearchV40.cStartTimeDifferenceH = g_iHourDiffWithUTC;
+    m_struSmartSearchV40.cStartTimeDifferenceM = g_iMinDiffWithUTC;
+    m_struSmartSearchV40.cStopTimeDifferenceH = g_iHourDiffWithUTC;
+    m_struSmartSearchV40.cStopTimeDifferenceM = g_iMinDiffWithUTC;
+
+    //m_struSmartSearch.byChan = (BYTE)m_lChannel;
+
+	m_struSmartSearchV40.struIDInfo.dwChannel = m_cmbRelatedChan.GetItemData(m_cmbRelatedChan.GetCurSel());
+	m_struSmartSearchV40.struIDInfo.dwSize = sizeof(NET_DVR_STREAM_INFO);
+	strncpy((char*)m_struSmartSearchV40.struIDInfo.byID, m_csStreamID, STREAM_ID_LEN);
+	   
+    DWORD dwCurSearchType = m_cmbSearchType.GetCurSel();
+	
+    m_struSmartSearchV40.bySearchCondType = m_cmbSearchType.GetCurSel();
+    DWORD dwTemp = 0;
+ 
+    switch(dwCurSearchType)
+    {
+    case 0:
+        break;
+    case 1:
+        dwTemp = m_cmbCurArea.GetCurSel();
+        //m_struSmartSearch.uSmartSearchCond.struTraversPlaneCond.struVcaTraversePlane[dwTemp].dwCrossDirection = m_cmbTraversePlaneDirction.GetCurSel();
+        m_struSmartSearchV40.uSmartSearchCond.struTraversPlaneCond.struVcaTraversePlane[dwTemp].bySensitivity = (BYTE)m_dwTravesePlaneSensitivity;
+        m_struSmartSearchV40.uSmartSearchCond.struTraversPlaneCond.struVcaTraversePlane[dwTemp].dwCrossDirection = (VCA_CROSS_DIRECTION)m_cmbTraversePlaneDirction.GetCurSel();
+        m_struSmartSearchV40.uSmartSearchCond.struTraversPlaneCond.dwPreTime  = m_dwTraversePlanePreTime;
+        m_struSmartSearchV40.uSmartSearchCond.struTraversPlaneCond.dwDelayTime = m_dwTraversePlaneDelayTime;
+        m_struSmartSearchV40.uSmartSearchCond.struTraversPlaneCond.struPTZPosInfo.dwPanPos = m_fPanPos*10;
+        m_struSmartSearchV40.uSmartSearchCond.struTraversPlaneCond.struPTZPosInfo.dwTiltPos = m_fTitlePos*10;
+        m_struSmartSearchV40.uSmartSearchCond.struTraversPlaneCond.struPTZPosInfo.dwZoomPos = m_fZoomPos*10;
+        m_struSmartSearchV40.uSmartSearchCond.struTraversPlaneCond.byAdvanceType = m_cmbAdvance.GetCurSel();
+        if (m_cmbAdvance.GetCurSel() == 1)
+        {
+            m_struSmartSearchV40.uSmartSearchCond.struTraversPlaneCond.uAdvanceCond.struHumanFeature.byGroup = m_cmbRes.GetItemData(m_cmbRes.GetCurSel());
+            m_struSmartSearchV40.uSmartSearchCond.struTraversPlaneCond.uAdvanceCond.struHumanFeature.byEyeGlass = m_cmbEyeGlass.GetItemData(m_cmbEyeGlass.GetCurSel());
+            m_struSmartSearchV40.uSmartSearchCond.struTraversPlaneCond.uAdvanceCond.struHumanFeature.bySex = m_cmbSex.GetItemData(m_cmbSex.GetCurSel());
+        }
+        else if (m_cmbAdvance.GetCurSel() == 2)
+        {
+            m_struSmartSearchV40.uSmartSearchCond.struTraversPlaneCond.uAdvanceCond.struObjectFeature.byColorRatel = m_cmbColorRate.GetCurSel();
+            m_struSmartSearchV40.uSmartSearchCond.struTraversPlaneCond.uAdvanceCond.struObjectFeature.byRed  = m_cmbColorR.GetCurSel();
+            m_struSmartSearchV40.uSmartSearchCond.struTraversPlaneCond.uAdvanceCond.struObjectFeature.byGreen = m_cmbColorG.GetCurSel();
+            m_struSmartSearchV40.uSmartSearchCond.struTraversPlaneCond.uAdvanceCond.struObjectFeature.byBlue = m_cmbColorB.GetCurSel();
+        }
+        break;
+    case 2:
+        dwTemp = m_cmbIntrusionCurArea.GetCurSel();
+        m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.struVcaIntrusion[dwTemp].byRate = (BYTE)m_dwIntrusionRate;
+        m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.struVcaIntrusion[dwTemp].wDuration = m_dwIntrusionDuration;
+        m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.struVcaIntrusion[dwTemp].bySensitivity = m_dwIntrusionSensitivity;
+        m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.dwPreTime = m_dwIntrusionPreTime;
+        m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.dwDelayTime = m_dwIntrusionDelayTime;
+        m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.struPTZPosInfo.dwPanPos = m_fPanPos*10;
+        m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.struPTZPosInfo.dwTiltPos = m_fTitlePos*10;
+        m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.struPTZPosInfo.dwZoomPos = m_fZoomPos*10;
+        m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.byAdvanceType = m_cmbAdvance.GetCurSel();
+        if (m_cmbAdvance.GetCurSel() == 1)
+        {
+            m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.uAdvanceCond.struHumanFeature.byGroup = m_cmbRes.GetItemData(m_cmbRes.GetCurSel());
+            m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.uAdvanceCond.struHumanFeature.byEyeGlass = m_cmbEyeGlass.GetItemData(m_cmbEyeGlass.GetCurSel());
+            m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.uAdvanceCond.struHumanFeature.bySex = m_cmbSex.GetItemData(m_cmbSex.GetCurSel());
+        }
+        else if (m_cmbAdvance.GetCurSel() == 2)
+        {
+            m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.uAdvanceCond.struObjectFeature.byColorRatel = m_cmbColorRate.GetCurSel();
+            m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.uAdvanceCond.struObjectFeature.byRed  = m_cmbColorR.GetCurSel();
+            m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.uAdvanceCond.struObjectFeature.byGreen = m_cmbColorG.GetCurSel();
+            m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.uAdvanceCond.struObjectFeature.byBlue = m_cmbColorB.GetCurSel();
+        }
+        break;
+    case 3:
+        memcpy(&m_struSmartSearchV40.uSmartSearchCond.struFaceSnapCond.struFacePolygon, &m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.struVcaIntrusion[m_iFieldNo].struRegion, sizeof(NET_VCA_POLYGON));
+
+        m_struSmartSearchV40.uSmartSearchCond.struFaceSnapCond.dwPreTime  = m_dwTraversePlanePreTime;
+        m_struSmartSearchV40.uSmartSearchCond.struFaceSnapCond.dwDelayTime = m_dwTraversePlaneDelayTime;
+        break;
+    }
+    m_struSmartSearchV40.bySensitivity = m_comboSearchSense.GetCurSel()+1;
+    m_lSearchHandle =  NET_DVR_SmartSearch_V40(m_lServerID, &m_struSmartSearchV40);
+    
+    if (-1 == m_lSearchHandle)
+    {
+        int i = NET_DVR_GetLastError();
+        g_pMainDlg->AddLog(m_iDevIndex, OPERATION_FAIL_T, "NET_DVR_SmartSearch");
+        g_StringLanType(szLan, "获取文件列表失败!", "Fail to get file list");
+        return;
+    }
+    
+    if (m_hFindThread == NULL)
+    {
+        m_hFindThread = CreateThread(NULL,0,LPTHREAD_START_ROUTINE(GetMotionInfoThread),this,0,NULL);
+    }
+    
+    if (m_hFindThread != NULL)
+    {
+        CloseHandle(m_hFindThread);
+        m_hFindThread = NULL;
+    }
+}
+
+BOOL CDlgPlayMotion::OnInitDialog() 
+{
+	CDialog::OnInitDialog();
+
+	int i = -1; 
+    for (i =0 ; i < MOTION_NUM; i++)
+    {
+        m_bMouseMove[i] = FALSE;
+        m_bDrawed[i] = FALSE;
+    }
+
+    CRect rc(0, 0, 0, 0);
+    GetParent()->GetClientRect(&rc);
+    ((CTabCtrl*)GetParent())->AdjustRect(FALSE, &rc);
+    MoveWindow(&rc);
+
+    CRect rcMotion(0, 0, 0, 0);
+    GetDlgItem(IDC_PIC_MOTION_DETECT)->GetWindowRect(&rcMotion);
+    ScreenToClient(&rcMotion);
+    rcMotion.right = rcMotion.left - 5 + 16*22;
+    rcMotion.bottom = rcMotion.top - 12 + 16*18;
+    GetDlgItem(IDC_PIC_MOTION_DETECT)->MoveWindow(rcMotion);
+
+    CTime timeCur = CTime::GetCurrentTime();
+    CTime timeStart(timeCur.GetYear(),timeCur.GetMonth(),timeCur.GetDay(),0,0,0);
+    CTime timeStop(timeCur.GetYear(),timeCur.GetMonth(),timeCur.GetDay(),23,59,59);
+    m_ctDateStart = timeStart;
+    m_ctTimeStart = timeStart;
+    m_ctDateStop = timeStop;
+    m_ctTimeStop = timeStop;
+
+    m_comboSearchSense.SetCurSel(1); 
+
+    int nIndex = 0;
+    m_listMotionTime.SetExtendedStyle(m_listMotionTime.GetExtendedStyle() | LVS_EX_FULLROWSELECT);
+    char szLan[128] = {0};
+    g_StringLanType(szLan, "序号","Index");
+    m_listMotionTime.InsertColumn(nIndex, szLan,LVCFMT_LEFT, 50, -1);
+    nIndex++;
+    g_StringLanType(szLan, "开始时间", "Start time");
+    m_listMotionTime.InsertColumn(nIndex, szLan, LVCFMT_LEFT, 120, -1);
+    nIndex++;
+    g_StringLanType(szLan, "结束时间", "Stop Time");
+    m_listMotionTime.InsertColumn(nIndex, szLan, LVCFMT_LEFT, 120, -1);
+    nIndex++;
+
+	int iChanIndex = g_pMainDlg->GetCurChanIndex();
+    
+	if (iChanIndex > -1)
+    {
+        m_lChannel = g_struDeviceInfo[m_iDevIndex].pStruChanInfo[iChanIndex].iChannelNO;
+    }
+	GetDlgItem(IDC_PIC_MOTION_DETECT)->GetWindowRect(&m_rcWnd);
+
+	if (iChanIndex > -1)
+	{
+		m_cmbRelatedChan.ResetContent();
+		for (i = 0; i < g_struDeviceInfo[m_iDevIndex].iDeviceChanNum; i++)
+		{
+			m_cmbRelatedChan.AddString(g_struDeviceInfo[m_iDevIndex].pStruChanInfo[iChanIndex].chChanName);
+			m_cmbRelatedChan.SetItemData(i, g_struDeviceInfo[m_iDevIndex].pStruChanInfo[iChanIndex].iChannelNO);
+		}
+	}
+
+    UpdateData(FALSE);
+	return TRUE;  // return TRUE unless you set the focus to a control
+	              // EXCEPTION: OCX Property Pages should return FALSE
+}
+
+long CDlgPlayMotion::StartPlay()
+{
+
+    NET_DVR_PREVIEWINFO struPlayInfo = { 0 };
+    
+    struPlayInfo.lChannel = m_lChannel;
+    //			struPlayInfo.sMultiCastIP = g_struDeviceInfo[iDeviceIndex].chDeviceMultiIP;
+    struPlayInfo.dwLinkMode = 0;
+    struPlayInfo.dwStreamType = 0;
+    struPlayInfo.hPlayWnd = GetDlgItem(IDC_PIC_MOTION_DETECT)->GetSafeHwnd();
+    strncpy((char*)struPlayInfo.byStreamID, m_csStreamID, STREAM_ID_LEN);
+
+    m_lRealPlayHandle = NET_DVR_RealPlay_V40(m_lServerID, &struPlayInfo, NULL, NULL);
+
+    if (-1 == m_lRealPlayHandle)
+    {
+        AfxMessageBox("Fail to preview");
+		g_pMainDlg->AddLog(m_iDevIndex, OPERATION_FAIL_T, "NET_DVR_RealPlay_V40");
+    }
+    else
+    {
+        g_pMainDlg->AddLog(m_iDevIndex, OPERATION_SUCC_T, "NET_DVR_RealPlay_V40");
+    }
+     return m_lRealPlayHandle;
+}
+
+BOOL CDlgPlayMotion::StopPlay()
+{
+    BOOL bRet = TRUE;
+    if (m_lRealPlayHandle >= 0)
+    {
+        bRet = NET_DVR_StopRealPlay(m_lRealPlayHandle);
+        m_lRealPlayHandle = -1;
+
+    }   
+    return bRet;
+}
+
+void CDlgPlayMotion::PostNcDestroy() 
+{
+	// TODO: Add your specialized code here and/or call the base class
+	StopPlay();
+	CDialog::PostNcDestroy();
+}
+
+BOOL CDlgPlayMotion::PreTranslateMessage(MSG* pMsg) 
+{
+    /*CPoint pt(0,0);
+    CRect  rcWnd(0,0,0,0);
+    GetDlgItem(IDC_PIC_MOTION_DETECT)->GetWindowRect(&rcWnd);
+
+	GetCursorPos(&pt);
+
+    switch (pMsg->message)
+    {
+    case WM_LBUTTONDOWN:
+        if (PtInRect(&rcWnd, pt) && (GetAsyncKeyState(VK_LCONTROL)<0 || GetAsyncKeyState(VK_RCONTROL)<0))
+        {
+            for (int nMotionIndex = 0; nMotionIndex < MOTION_NUM; nMotionIndex++)
+            {
+                if (m_bDrawed[nMotionIndex] == FALSE)
+                {
+                    //Get the Drawing Rect Index
+                    m_iDrawingIndex = nMotionIndex;  
+                    m_struRect[m_iDrawingIndex].fX = (float)(pt.x-rcWnd.left)/(float)rcWnd.Width();
+                    m_struRect[m_iDrawingIndex].fY = (float)(pt.y-rcWnd.top)/(float)rcWnd.Height();
+                    m_bMouseMove[m_iDrawingIndex] = TRUE;
+                    TRACE("m_struRect.fX =%f m_struRect.fY =%f\n", m_struRect[m_iDrawingIndex].fX,m_struRect[m_iDrawingIndex].fY);
+                    break;
+                }
+            }
+        }
+        break;
+    case WM_LBUTTONUP:
+        if (PtInRect(&rcWnd, pt) && (GetAsyncKeyState(VK_LCONTROL)<0 || GetAsyncKeyState(VK_RCONTROL)<0))
+        {
+            m_bMouseMove[m_iDrawingIndex] = FALSE;
+            m_bDrawed[m_iDrawingIndex] = TRUE;
+            break;
+        }
+        break;
+    case WM_MOUSEMOVE:
+        if (PtInRect(&rcWnd, pt)  && m_bMouseMove[m_iDrawingIndex] && (GetAsyncKeyState(VK_LCONTROL)<0 || GetAsyncKeyState(VK_RCONTROL)<0))
+        {   
+            m_struRect[m_iDrawingIndex].fWidth = (float)(pt.x-rcWnd.left)/(float)rcWnd.Width() -  m_struRect[m_iDrawingIndex].fX;
+            m_struRect[m_iDrawingIndex].fHeight = (float)(pt.y-rcWnd.top)/(float)rcWnd.Height() -  m_struRect[m_iDrawingIndex].fY;
+            
+            
+            TRACE("WM_MOUSEMOVE  MotionIndex[%d] fWidth[%f] fHeight[%f]\n", m_iDrawingIndex, m_struRect[m_iDrawingIndex].fWidth, m_struRect[m_iDrawingIndex].fHeight);
+            
+            for(int i = int(m_struRect[m_iDrawingIndex].fX * 22); i <= int((m_struRect[m_iDrawingIndex].fX +m_struRect[m_iDrawingIndex].fWidth)*22); i++)
+            {
+                for (int j = int(m_struRect[m_iDrawingIndex].fY*18); j <= int((m_struRect[m_iDrawingIndex].fY + m_struRect[m_iDrawingIndex].fHeight)*18); j++)
+                {
+                    m_struSmartSearch.byMotionScope[j][i] = 1;
+                }
+            }
+            break;
+        }
+        break;
+    case WM_RBUTTONDOWN:
+        if (PtInRect(&rcWnd, pt) && (GetAsyncKeyState(VK_LCONTROL)<0 || GetAsyncKeyState(VK_RCONTROL)<0))
+        {
+            memset(&m_struRect, 0, sizeof(m_struRect));
+            memset(m_struSmartSearch.byMotionScope, 0, sizeof(m_struSmartSearch.byMotionScope));
+            for (int i = 0; i < MOTION_NUM; i++)
+            {
+                m_bDrawed[i] = FALSE;
+                m_bMouseMove[i] = FALSE;
+            }
+        }
+    }
+	return CDialog::PreTranslateMessage(pMsg);*/
+	CPoint pt(0, 0);
+    GetDlgItem(IDC_PIC_MOTION_DETECT)->GetWindowRect(&m_rcWnd);
+    GetCursorPos(&pt);
+    ScreenToClient(&m_rcWnd);
+    ScreenToClient(&pt);
+    
+    // 	if (m_bChkDrawPlate)
+    // 	{
+    // 		PreDrawPolygonMsg(pMsg, pt);
+    // 	}
+    if (m_cmbSearchType.GetCurSel() == 0)
+    {
+        PreDrawMotionMsg(pMsg,pt);
+    }
+    if (m_cmbSearchType.GetCurSel() == 1)
+    {
+        PreDrawLineMsg(pMsg, pt);
+    }
+    else if(m_cmbSearchType.GetCurSel() == 2 || m_cmbSearchType.GetCurSel() == 3)
+    {
+        PreDrawPolygonMsg(pMsg, pt);
+    }
+    
+    
+	return CDialog::PreTranslateMessage(pMsg);
+}
+
+void CDlgPlayMotion::SetParentWnd(HWND *hhWnd, int iParentNum)
+{
+
+}
+
+BOOL CDlgPlayMotion::CheckInitParam()
+{
+    g_PlayMotion = this;
+
+    m_iDevIndex = g_pMainDlg->GetCurDeviceIndex();
+    if (m_iDevIndex >= 0)
+    {
+        m_lServerID = g_struDeviceInfo[m_iDevIndex].lLoginID;
+        int iChanIndex = g_pMainDlg->GetCurChanIndex();
+        if (iChanIndex == -1)
+        {
+            iChanIndex = 1;
+        }
+        m_lChannel = g_struDeviceInfo[m_iDevIndex].pStruChanInfo[iChanIndex].iChannelNO;
+    }    
+
+	ShowSetInfo(0);
+    m_cmbAdvance.ResetContent();
+    char szLan[128]= {0};
+    g_StringLanType(szLan,"不带","No With");
+    m_cmbAdvance.AddString(szLan);
+    g_StringLanType(szLan,"人体属性","Human Feature");
+    m_cmbAdvance.AddString(szLan);
+    g_StringLanType(szLan,"物体颜色","Object Color");
+    m_cmbAdvance.AddString(szLan);
+    m_cmbAdvance.SetCurSel(0);
+    AddObjectIFeatureInfo();
+    AddHumanFeatureInfo();
+
+    m_cmbSearchType.SetCurSel(0);
+    m_cmbCurArea.SetCurSel(0);
+    m_cmbIntrusionCurArea.SetCurSel(0);
+    m_cmbTraversePlaneDirction.SetCurSel(0);
+    
+	if (m_iDevIndex >= 0)
+	{
+		m_cmbRelatedChan.ResetContent();
+		int i = -1;
+		for (i = 0; i < g_struDeviceInfo[m_iDevIndex].iDeviceChanNum; i++)
+		{
+			m_cmbRelatedChan.AddString(g_struDeviceInfo[m_iDevIndex].pStruChanInfo[i].chChanName);
+			m_cmbRelatedChan.SetItemData(i, g_struDeviceInfo[m_iDevIndex].pStruChanInfo[i].iChannelNO);
+		}
+		m_cmbRelatedChan.SetCurSel(0);
+	}
+	
+	UpdateData(FALSE);
+
+    return TRUE;
+}
+
+void CDlgPlayMotion::OnBtnPreview() 
+{
+    if (m_lRealPlayHandle >= 0)
+    {
+		NET_DVR_RigisterDrawFun(m_lRealPlayHandle, NULL, (DWORD)this);
+        StopPlay();
+        Invalidate();
+    }
+    else
+    {
+		m_dwSearchType = m_cmbSearchType.GetCurSel();
+        StartPlay();
+        if (m_lRealPlayHandle >= 0)
+        {
+            NET_DVR_RigisterDrawFun(m_lRealPlayHandle, DrawSearchMotionArea, (DWORD)this);
+        }
+    }
+}
+
+
+void CDlgPlayMotion::OnClickListMotionTime(NMHDR* pNMHDR, LRESULT* pResult) 
+{
+	// TODO: Add your control notification handler code here
+    POSITION  iPos = m_listMotionTime.GetFirstSelectedItemPosition();
+    if (iPos == NULL)
+    {
+        return;
+    }
+    char szTime[32] = {0};
+    char szTmp[8] = {0};
+    int iOffset = 0;
+    m_iItemSel = m_listMotionTime.GetNextSelectedItem(iPos);
+    sprintf(szTime, "%s", m_listMotionTime.GetItemText(m_iItemSel, 1));
+    memcpy(szTmp, szTime, 4);
+    m_struStartTime.dwYear = atoi(szTmp);
+    
+    iOffset+=4;
+    memset(szTmp, 0, 8);
+    memcpy(szTmp, szTime+iOffset, 2);	
+    m_struStartTime.dwMonth = atoi(szTmp);
+    
+    iOffset+=2;memset(szTmp, 0, 8);
+    memcpy(szTmp, szTime+iOffset, 2);
+    m_struStartTime.dwDay = atoi(szTmp);
+    
+    iOffset+=2;memset(szTmp, 0, 8);
+    memcpy(szTmp, szTime+iOffset, 2);
+    m_struStartTime.dwHour = atoi(szTmp);
+    
+    iOffset+=2;memset(szTmp, 0, 8);
+    memcpy(szTmp, szTime+iOffset, 2);
+    m_struStartTime.dwMinute = atoi(szTmp);
+    
+    iOffset+=2;memset(szTmp, 0, 8);
+    memcpy(szTmp, szTime+iOffset, 2);
+    m_struStartTime.dwSecond = atoi(szTmp);
+    
+    memset(szTime, 0, 32);
+    sprintf(szTime, "%s", m_listMotionTime.GetItemText(m_iItemSel, 2));//stop time
+    iOffset=0;memset(szTmp, 0, 8);
+    memcpy(szTmp, szTime+iOffset, 4);
+    m_struStopTime.dwYear = atoi(szTmp);
+    
+    iOffset+=4;memset(szTmp, 0, 8);
+    memcpy(szTmp, szTime+iOffset, 2);
+    m_struStopTime.dwMonth = atoi(szTmp);
+    
+    iOffset+=2;memset(szTmp, 0, 8);
+    memcpy(szTmp, szTime+iOffset, 2);
+    m_struStopTime.dwDay = atoi(szTmp);
+    
+    iOffset+=2;memset(szTmp, 0, 8);
+    memcpy(szTmp, szTime+iOffset, 2);
+    m_struStopTime.dwHour = atoi(szTmp);
+    
+    iOffset+=2;memset(szTmp, 0, 8);
+    memcpy(szTmp, szTime+iOffset, 2);
+    m_struStopTime.dwMinute = atoi(szTmp);
+    
+    iOffset+=2;memset(szTmp, 0, 8);
+    memcpy(szTmp, szTime+iOffset, 2);
+    m_struStopTime.dwSecond = atoi(szTmp);
+	UpdateData(FALSE);
+	*pResult = 0;
+}
+
+void CDlgPlayMotion::OnDblclkListMotionTime(NMHDR* pNMHDR, LRESULT* pResult) 
+{
+	BtnRemoteFileStop();
+    BtnRemotFilePlay();
+
+	*pResult = 0;
+}
+
+void CDlgPlayMotion::BtnRemoteFileStop()
+{
+
+}
+
+void CDlgPlayMotion::BtnRemotFilePlay()
+{
+    StopPlay();
+    if (m_lPlayBackHandle == -1)
+    {
+        PlayBack();
+    }
+}
+
+extern BOOL ConvertTime(time_t *lpInBuf, LPNET_DVR_TIME pOutBuf, BOOL bInToOut);
+
+void CDlgPlayMotion::PlayBack()
+ {
+    UpdateData(TRUE);
+    
+    int m_nVerifyret = -1;
+    CString csFileName;
+    int iFileSelPos = 0;
+    HWND hPlayWnd=GetDlgItem(IDC_PIC_MOTION_DETECT)->GetSafeHwnd();
+    POSITION  posItem = m_listMotionTime.GetFirstSelectedItemPosition();
+    NET_DVR_TIME struStartTime,struStopTime;
+    char szLan[128] = {0};
+    
+    //	remoteplay_info.srcfilename=m_szFileName;
+    if (m_lPlayBackHandle >= 0)
+    {
+        if (NET_DVR_StopPlayBack(m_lPlayBackHandle))
+        {
+            g_pMainDlg->AddLog(m_iDevIndex, OPERATION_SUCC_T, "NET_DVR_StopPlayBack");
+        }
+        m_lPlayBackHandle = -1;
+        Sleep(400);
+    }
+    if (m_lPlayBackHandle == -1)
+    {
+        time_t tmp;
+        m_iTime = 5;
+        ConvertTime(&tmp, &m_struStartTime, FALSE);
+        tmp -= m_iTime;
+        ConvertTime(&tmp, &m_struStartTime, TRUE);
+        ConvertTime(&tmp, &m_struStopTime, FALSE);
+        tmp += m_iTime;
+        ConvertTime(&tmp, &m_struStopTime, TRUE);
+        memcpy(&struStartTime, &m_struStartTime, sizeof(NET_DVR_TIME));
+        memcpy(&struStopTime, &m_struStopTime, sizeof(NET_DVR_TIME));	
+        
+        
+        m_lPlayBackHandle = NET_DVR_PlayBackByTime(m_lServerID, m_lChannel, &struStartTime, &struStopTime, hPlayWnd);//NULL
+        
+        if (m_lPlayBackHandle== -1)
+        {
+            g_pMainDlg->AddLog(m_iDevIndex, OPERATION_FAIL_T, "NET_DVR_PlayBackByTime ChanNum[%d]", m_lChannel);
+            g_StringLanType(szLan, "远程回放失败", "Fail to play back remote");
+            AfxMessageBox(szLan);
+            return;
+        }
+        NET_DVR_GetPlayBackPlayerIndex(m_lPlayBackHandle);
+
+        NET_DVR_PlayBackControl(m_lPlayBackHandle, NET_DVR_PLAYSTART, 0, NULL);
+
+#if 1
+
+        if (NET_DVR_PlayBackControl(m_lPlayBackHandle, NET_DVR_PLAYSTARTAUDIO, 0, NULL))
+        {
+//            m_bSound=TRUE;
+            NET_DVR_PlayBackControl(m_lPlayBackHandle, NET_DVR_PLAYAUDIOVOLUME, (0xffff)/2, NULL);
+  //          m_sliderVolume.SetPos(50);
+//            ((CButton *)GetDlgItem(IDC_BTN_EVENT_FILE_SOUND))->SetIcon(m_hSoundStartIcon);
+        }
+        else
+        {
+//             m_bSound=FALSE;
+//             ((CButton *)GetDlgItem(IDC_BTN_EVENT_FILE_SOUND))->SetIcon(m_hSoundStopIcon);
+        }
+#endif
+        //SetPlayState();
+        SetTimer(PLAYBYTIME_TIMER, 3000, NULL);
+    }
+    else
+    {
+//         if (m_bPause)
+//         {
+//             if (NET_DVR_PlayBackControl(m_lPlayBackHandle, NET_DVR_PLAYRESTART, 0, NULL))
+//             {
+//                 g_pMainDlg->AddLog(m_iDevIndex, OPERATION_FAIL_T, "NET_DVR_PLAYRESTART");
+//                 m_bPause=FALSE;
+//                 SetPlayState();
+//             }
+//         }
+//         else
+//         {
+//             if (NET_DVR_PlayBackControl(m_lPlayBackHandle, NET_DVR_PLAYPAUSE, 0, NULL))
+//             {
+//                 g_pMainDlg->AddLog(m_iDevIndex, OPERATION_FAIL_T, "NET_DVR_PLAYPAUSE");
+//                 m_bPause=TRUE;
+//                 CButton *pButton;	
+//                 pButton = (CButton *)GetDlgItem(IDC_BTN_EVENT_FILE_PLAY);
+//                 pButton->SetIcon(m_hPlayEnableIcon);
+//                 pButton->EnableWindow(TRUE);
+//             }
+//         }
+    }
+}
+
+
+#if (_MSC_VER >= 1500)	//vs2008
+void CDlgPlayMotion::OnTimer(UINT_PTR nIDEvent)
+#else
+void CDlgPlayMotion::OnTimer(UINT nIDEvent)
+#endif
+{
+	// TODO: Add your message handler code here and/or call default
+    DWORD nPos;
+    char szLan[128] = {0};
+    //	NET_DVR_TIME struOsdTime;
+    if (nIDEvent == PLAYBYTIME_TIMER)
+    {
+        if (m_lPlayBackHandle >= 0)
+        {
+            if (NET_DVR_PlayBackControl(m_lPlayBackHandle, NET_DVR_PLAYGETPOS, 0, &nPos))
+            {
+                g_pMainDlg->AddLog(m_iDevIndex, OPERATION_SUCC_T, "NET_DVR_PLAYGETPOS pos[%d]", nPos);
+            }
+            else
+            {
+                g_pMainDlg->AddLog(m_iDevIndex, OPERATION_FAIL_T, "NET_DVR_PLAYGETPOS");
+            }
+            
+            if (nPos > 100)
+            {
+                StopPlayBack();
+                g_StringLanType(szLan, "由于网络原因或DVR忙,回放异常终止!", " Due to network reasons or DVR is busy, playback abnormal termination");
+                AfxMessageBox(szLan);
+            }
+            if (nPos == 100)
+            {				
+                StopPlayBack();
+                g_StringLanType(szLan, "按时间回放结束", "playback by time over");
+                AfxMessageBox(szLan);
+            }		
+        }
+        
+    }
+
+	CDialog::OnTimer(nIDEvent);
+}
+
+void CDlgPlayMotion::StopPlayBack()
+{
+    if (m_lPlayBackHandle >= 0)
+    {
+        if (!NET_DVR_StopPlayBack(m_lPlayBackHandle))
+        {
+            g_pMainDlg->AddLog(m_iDevIndex, OPERATION_FAIL_T, "NET_DVR_StopPlayBack");
+        }
+        else
+        {
+            g_pMainDlg->AddLog(m_iDevIndex, OPERATION_SUCC_T, "NET_DVR_StopPlayBack");
+        
+        }
+        m_lPlayBackHandle = -1;
+        //KillTimer(REMOTE_PLAY_STATE_TIMER);
+        UpdateData(FALSE);
+        Invalidate(TRUE);
+    }
+//     m_bPause = FALSE;
+//     m_bSetFrame = FALSE;
+//     
+// 	SetStopState();
+}
+
+void CDlgPlayMotion::OnSelchangeComboSearchType() 
+{
+	// TODO: Add your control notification handler code here
+	UpdateData(TRUE);
+
+    int iCurSelect = m_cmbSearchType.GetCurSel();
+    if (iCurSelect  < 0)
+    {
+        iCurSelect = 0;
+    }
+         memset(m_bDrawed,0, sizeof(m_bDrawed));
+    ShowSetInfo(iCurSelect);
+    if (iCurSelect != 0)
+    {
+        CleanMotionPic();
+        m_dwPosNum = 0;
+    }
+    //OnBtnClearpic();
+}
+
+void CDlgPlayMotion::ShowSetInfo(DWORD dwSearchType)
+{   
+    //show Detectin
+     switch(dwSearchType)
+     {
+     case 0:
+         GetDlgItem(IDC_STATIC_SENSITIVITY)->ShowWindow(SW_SHOW);
+         GetDlgItem(IDC_COMBO_SEARCH_SENSE)->ShowWindow(SW_SHOW);
+
+         GetDlgItem(IDC_STATIC_TRAVERSE_PLANE)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_STATIC_TRAVERSE_PLANE_CUR_AREA)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_COMBO_CUR_AREA)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_STATIC_TRAVERSE_PLANE_SENSITIVITY)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_EDIT_TRAVERSE_PLANE_SENSITIVITY)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_STATIC_TRAVERSE_PLANE_DIRECTION)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_COMBO_TRAVERSE_PLANE_DIRECTION)->ShowWindow(SW_HIDE);
+		 GetDlgItem(IDC_STATIC_TRAVERSE_PLANE_PRE_TIME)->ShowWindow(SW_HIDE);
+		 GetDlgItem(IDC_EDIT_TRAVERSE_PLANE_PRE_TIME)->ShowWindow(SW_HIDE);
+		 GetDlgItem(IDC_STATIC_TRAVERSE_PLANE_PRE_TIME_SECONDS)->ShowWindow(SW_HIDE);
+		 GetDlgItem(IDC_STATIC_TRAVERSE_PLANE_DELAY_TIME)->ShowWindow(SW_HIDE);
+		 GetDlgItem(IDC_EDIT_TRAVERSE_PLANE_DELAY_TIME)->ShowWindow(SW_HIDE);
+		 GetDlgItem(IDC_STATIC_TRAVERSE_PLANE_DELAY_TIME_SECONDS)->ShowWindow(SW_HIDE);
+
+
+         GetDlgItem(IDC_STATIC_INTRUSION_CONF)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_STATIC_INTRUSION_DURATION)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_EDIT_INTRUSION_DURATION)->ShowWindow(SW_HIDE);
+		 GetDlgItem(IDC_EDIT_INTRUSION_PRE_TIME)->ShowWindow(SW_HIDE);
+		 GetDlgItem(IDC_STATIC_INTRUSION_PRE_TIME)->ShowWindow(SW_HIDE);
+		 GetDlgItem(IDC_STATIC_INTRUSION_DELAY_TIME)->ShowWindow(SW_HIDE);
+		 GetDlgItem(IDC_STATIC_INTRUSION_PRE_TIME_SECONDS)->ShowWindow(SW_HIDE);
+		 GetDlgItem(IDC_EDIT_INTRUSION_DELAY_TIME)->ShowWindow(SW_HIDE);
+		 GetDlgItem(IDC_STATIC_INTRUSION_DELAY_TIME_SECONDS)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_STATIC_INTRUSION_SENSITIVITY)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_EDIT_INTRUSION_SENSITIVITY)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_STATIC_INTRUSION_RATE)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_EDIT_INTRUSION_RATE)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_STATIC_INTRUSION_CUR_AREA)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_COMBO_INTRUSION_CUR_AREA)->ShowWindow(SW_HIDE);
+
+         GetDlgItem(IDC_BTN_CLEARPIC)->ShowWindow(SW_HIDE);
+         
+         GetDlgItem(IDC_BTN_GET_PTZ)->ShowWindow(SW_HIDE);
+         
+         GetDlgItem(IDC_EDIT_PAN_POS)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_EDIT_TITLE_POS)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_EDIT_ZOOM_POS)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_STATIC_P)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_STATIC_T)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_STATIC_Z)->ShowWindow(SW_HIDE);
+         break;
+     case 1: //Travese Plane
+         GetDlgItem(IDC_STATIC_SENSITIVITY)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_COMBO_SEARCH_SENSE)->ShowWindow(SW_HIDE);
+         
+         GetDlgItem(IDC_STATIC_TRAVERSE_PLANE)->ShowWindow(SW_SHOW);
+         GetDlgItem(IDC_STATIC_TRAVERSE_PLANE_CUR_AREA)->ShowWindow(SW_SHOW);
+         GetDlgItem(IDC_COMBO_CUR_AREA)->ShowWindow(SW_SHOW);
+         GetDlgItem(IDC_STATIC_TRAVERSE_PLANE_SENSITIVITY)->ShowWindow(SW_SHOW);
+         GetDlgItem(IDC_EDIT_TRAVERSE_PLANE_SENSITIVITY)->ShowWindow(SW_SHOW);
+         GetDlgItem(IDC_STATIC_TRAVERSE_PLANE_DIRECTION)->ShowWindow(SW_SHOW);
+         GetDlgItem(IDC_COMBO_TRAVERSE_PLANE_DIRECTION)->ShowWindow(SW_SHOW);
+		 GetDlgItem(IDC_STATIC_TRAVERSE_PLANE_PRE_TIME)->ShowWindow(SW_SHOW);
+		 GetDlgItem(IDC_EDIT_TRAVERSE_PLANE_PRE_TIME)->ShowWindow(SW_SHOW);
+		 GetDlgItem(IDC_STATIC_TRAVERSE_PLANE_PRE_TIME_SECONDS)->ShowWindow(SW_SHOW);
+		 GetDlgItem(IDC_STATIC_TRAVERSE_PLANE_DELAY_TIME)->ShowWindow(SW_SHOW);
+		 GetDlgItem(IDC_EDIT_TRAVERSE_PLANE_DELAY_TIME)->ShowWindow(SW_SHOW);
+		 GetDlgItem(IDC_STATIC_TRAVERSE_PLANE_DELAY_TIME_SECONDS)->ShowWindow(SW_SHOW);
+         
+         
+         GetDlgItem(IDC_STATIC_INTRUSION_CONF)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_STATIC_INTRUSION_DURATION)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_EDIT_INTRUSION_DURATION)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_STATIC_INTRUSION_SENSITIVITY)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_EDIT_INTRUSION_SENSITIVITY)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_STATIC_INTRUSION_RATE)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_EDIT_INTRUSION_RATE)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_STATIC_INTRUSION_CUR_AREA)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_COMBO_INTRUSION_CUR_AREA)->ShowWindow(SW_HIDE);
+		 GetDlgItem(IDC_EDIT_INTRUSION_PRE_TIME)->ShowWindow(SW_HIDE);
+		 GetDlgItem(IDC_STATIC_INTRUSION_PRE_TIME)->ShowWindow(SW_HIDE);
+		 GetDlgItem(IDC_STATIC_INTRUSION_DELAY_TIME)->ShowWindow(SW_HIDE);
+		 GetDlgItem(IDC_STATIC_INTRUSION_PRE_TIME_SECONDS)->ShowWindow(SW_HIDE);
+		 GetDlgItem(IDC_EDIT_INTRUSION_DELAY_TIME)->ShowWindow(SW_HIDE);
+		 GetDlgItem(IDC_STATIC_INTRUSION_DELAY_TIME_SECONDS)->ShowWindow(SW_HIDE);
+
+         GetDlgItem(IDC_BTN_CLEARPIC)->ShowWindow(SW_SHOW);
+
+         GetDlgItem(IDC_BTN_GET_PTZ)->ShowWindow(SW_SHOW);
+         
+         GetDlgItem(IDC_EDIT_PAN_POS)->ShowWindow(SW_SHOW);
+         GetDlgItem(IDC_EDIT_TITLE_POS)->ShowWindow(SW_SHOW);
+         GetDlgItem(IDC_EDIT_ZOOM_POS)->ShowWindow(SW_SHOW);
+         GetDlgItem(IDC_STATIC_P)->ShowWindow(SW_SHOW);
+         GetDlgItem(IDC_STATIC_T)->ShowWindow(SW_SHOW);
+         GetDlgItem(IDC_STATIC_Z)->ShowWindow(SW_SHOW);
+         break;
+     case 2:    //Intrusion
+         GetDlgItem(IDC_STATIC_SENSITIVITY)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_COMBO_SEARCH_SENSE)->ShowWindow(SW_HIDE);
+         
+         GetDlgItem(IDC_STATIC_TRAVERSE_PLANE)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_STATIC_TRAVERSE_PLANE_CUR_AREA)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_COMBO_CUR_AREA)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_STATIC_TRAVERSE_PLANE_SENSITIVITY)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_EDIT_TRAVERSE_PLANE_SENSITIVITY)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_STATIC_TRAVERSE_PLANE_DIRECTION)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_COMBO_TRAVERSE_PLANE_DIRECTION)->ShowWindow(SW_HIDE);
+		 GetDlgItem(IDC_STATIC_TRAVERSE_PLANE_PRE_TIME)->ShowWindow(SW_HIDE);
+		 GetDlgItem(IDC_EDIT_TRAVERSE_PLANE_PRE_TIME)->ShowWindow(SW_HIDE);
+		 GetDlgItem(IDC_STATIC_TRAVERSE_PLANE_PRE_TIME_SECONDS)->ShowWindow(SW_HIDE);
+		 GetDlgItem(IDC_STATIC_TRAVERSE_PLANE_DELAY_TIME)->ShowWindow(SW_HIDE);
+		 GetDlgItem(IDC_EDIT_TRAVERSE_PLANE_DELAY_TIME)->ShowWindow(SW_HIDE);
+		 GetDlgItem(IDC_STATIC_TRAVERSE_PLANE_DELAY_TIME_SECONDS)->ShowWindow(SW_HIDE);
+		 
+         GetDlgItem(IDC_STATIC_INTRUSION_CONF)->ShowWindow(SW_SHOW);
+         GetDlgItem(IDC_STATIC_INTRUSION_DURATION)->ShowWindow(SW_SHOW);
+         GetDlgItem(IDC_EDIT_INTRUSION_DURATION)->ShowWindow(SW_SHOW);
+         GetDlgItem(IDC_STATIC_INTRUSION_SENSITIVITY)->ShowWindow(SW_SHOW);
+         GetDlgItem(IDC_EDIT_INTRUSION_SENSITIVITY)->ShowWindow(SW_SHOW);
+         GetDlgItem(IDC_STATIC_INTRUSION_RATE)->ShowWindow(SW_SHOW);
+         GetDlgItem(IDC_EDIT_INTRUSION_RATE)->ShowWindow(SW_SHOW);
+         GetDlgItem(IDC_STATIC_INTRUSION_CUR_AREA)->ShowWindow(SW_SHOW);
+         GetDlgItem(IDC_COMBO_INTRUSION_CUR_AREA)->ShowWindow(SW_SHOW);
+		 GetDlgItem(IDC_EDIT_INTRUSION_PRE_TIME)->ShowWindow(SW_SHOW);
+		 GetDlgItem(IDC_STATIC_INTRUSION_PRE_TIME)->ShowWindow(SW_SHOW);
+		 GetDlgItem(IDC_STATIC_INTRUSION_DELAY_TIME)->ShowWindow(SW_SHOW);
+		 GetDlgItem(IDC_STATIC_INTRUSION_PRE_TIME_SECONDS)->ShowWindow(SW_SHOW);
+		 GetDlgItem(IDC_EDIT_INTRUSION_DELAY_TIME)->ShowWindow(SW_SHOW);
+		 GetDlgItem(IDC_STATIC_INTRUSION_DELAY_TIME_SECONDS)->ShowWindow(SW_SHOW);
+
+         GetDlgItem(IDC_BTN_CLEARPIC)->ShowWindow(SW_SHOW);
+         GetDlgItem(IDC_BTN_GET_PTZ)->ShowWindow(SW_SHOW);
+         
+         GetDlgItem(IDC_EDIT_PAN_POS)->ShowWindow(SW_SHOW);
+         GetDlgItem(IDC_EDIT_TITLE_POS)->ShowWindow(SW_SHOW);
+         GetDlgItem(IDC_EDIT_ZOOM_POS)->ShowWindow(SW_SHOW);
+         GetDlgItem(IDC_STATIC_P)->ShowWindow(SW_SHOW);
+         GetDlgItem(IDC_STATIC_T)->ShowWindow(SW_SHOW);
+         GetDlgItem(IDC_STATIC_Z)->ShowWindow(SW_SHOW);
+         break;
+     case 3:
+         GetDlgItem(IDC_STATIC_TRAVERSE_PLANE_PRE_TIME)->ShowWindow(SW_SHOW);
+         GetDlgItem(IDC_EDIT_TRAVERSE_PLANE_PRE_TIME)->ShowWindow(SW_SHOW);
+
+         GetDlgItem(IDC_STATIC_TRAVERSE_PLANE_DELAY_TIME)->ShowWindow(SW_SHOW);
+		 GetDlgItem(IDC_EDIT_TRAVERSE_PLANE_DELAY_TIME)->ShowWindow(SW_SHOW);
+         GetDlgItem(IDC_STATIC_SENSITIVITY)->ShowWindow(SW_SHOW);
+         GetDlgItem(IDC_COMBO_SEARCH_SENSE)->ShowWindow(SW_SHOW);
+         
+         GetDlgItem(IDC_STATIC_TRAVERSE_PLANE)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_STATIC_TRAVERSE_PLANE_CUR_AREA)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_COMBO_CUR_AREA)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_STATIC_TRAVERSE_PLANE_SENSITIVITY)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_EDIT_TRAVERSE_PLANE_SENSITIVITY)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_STATIC_TRAVERSE_PLANE_DIRECTION)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_COMBO_TRAVERSE_PLANE_DIRECTION)->ShowWindow(SW_HIDE);
+         
+         
+         GetDlgItem(IDC_STATIC_INTRUSION_CONF)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_STATIC_INTRUSION_DURATION)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_EDIT_INTRUSION_DURATION)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_STATIC_INTRUSION_SENSITIVITY)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_EDIT_INTRUSION_SENSITIVITY)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_STATIC_INTRUSION_RATE)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_EDIT_INTRUSION_RATE)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_STATIC_INTRUSION_CUR_AREA)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_COMBO_INTRUSION_CUR_AREA)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_EDIT_INTRUSION_PRE_TIME)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_STATIC_INTRUSION_PRE_TIME)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_STATIC_INTRUSION_DELAY_TIME)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_STATIC_INTRUSION_PRE_TIME_SECONDS)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_EDIT_INTRUSION_DELAY_TIME)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_STATIC_INTRUSION_DELAY_TIME_SECONDS)->ShowWindow(SW_HIDE);
+         
+         GetDlgItem(IDC_BTN_CLEARPIC)->ShowWindow(SW_HIDE);
+         
+         GetDlgItem(IDC_BTN_GET_PTZ)->ShowWindow(SW_SHOW);
+         
+         GetDlgItem(IDC_EDIT_PAN_POS)->ShowWindow(SW_SHOW);
+         GetDlgItem(IDC_EDIT_TITLE_POS)->ShowWindow(SW_SHOW);
+         GetDlgItem(IDC_EDIT_ZOOM_POS)->ShowWindow(SW_SHOW);
+         GetDlgItem(IDC_STATIC_P)->ShowWindow(SW_SHOW);
+         GetDlgItem(IDC_STATIC_T)->ShowWindow(SW_SHOW);
+         GetDlgItem(IDC_STATIC_Z)->ShowWindow(SW_SHOW);
+         break;
+     default:
+         GetDlgItem(IDC_STATIC_SENSITIVITY)->ShowWindow(SW_SHOW);
+         GetDlgItem(IDC_COMBO_SEARCH_SENSE)->ShowWindow(SW_SHOW);
+         
+         GetDlgItem(IDC_STATIC_TRAVERSE_PLANE)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_STATIC_TRAVERSE_PLANE_CUR_AREA)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_COMBO_CUR_AREA)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_STATIC_TRAVERSE_PLANE_SENSITIVITY)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_EDIT_TRAVERSE_PLANE_SENSITIVITY)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_STATIC_TRAVERSE_PLANE_DIRECTION)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_COMBO_TRAVERSE_PLANE_DIRECTION)->ShowWindow(SW_HIDE);
+         
+         
+         GetDlgItem(IDC_STATIC_INTRUSION_CONF)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_STATIC_INTRUSION_DURATION)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_EDIT_INTRUSION_DURATION)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_STATIC_INTRUSION_SENSITIVITY)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_EDIT_INTRUSION_SENSITIVITY)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_STATIC_INTRUSION_RATE)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_EDIT_INTRUSION_RATE)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_STATIC_INTRUSION_CUR_AREA)->ShowWindow(SW_HIDE);
+         GetDlgItem(IDC_COMBO_INTRUSION_CUR_AREA)->ShowWindow(SW_HIDE);
+		 GetDlgItem(IDC_EDIT_INTRUSION_PRE_TIME)->ShowWindow(SW_HIDE);
+		 GetDlgItem(IDC_STATIC_INTRUSION_PRE_TIME)->ShowWindow(SW_HIDE);
+		 GetDlgItem(IDC_STATIC_INTRUSION_DELAY_TIME)->ShowWindow(SW_HIDE);
+		 GetDlgItem(IDC_STATIC_INTRUSION_PRE_TIME_SECONDS)->ShowWindow(SW_HIDE);
+		 GetDlgItem(IDC_EDIT_INTRUSION_DELAY_TIME)->ShowWindow(SW_HIDE);
+		 GetDlgItem(IDC_STATIC_INTRUSION_DELAY_TIME_SECONDS)->ShowWindow(SW_HIDE);
+
+         GetDlgItem(IDC_BTN_CLEARPIC)->ShowWindow(SW_HIDE);
+
+         GetDlgItem(IDC_BTN_GET_PTZ)->ShowWindow(SW_SHOW);
+         
+         GetDlgItem(IDC_EDIT_PAN_POS)->ShowWindow(SW_SHOW);
+         GetDlgItem(IDC_EDIT_TITLE_POS)->ShowWindow(SW_SHOW);
+         GetDlgItem(IDC_EDIT_ZOOM_POS)->ShowWindow(SW_SHOW);
+         GetDlgItem(IDC_STATIC_P)->ShowWindow(SW_SHOW);
+         GetDlgItem(IDC_STATIC_T)->ShowWindow(SW_SHOW);
+         GetDlgItem(IDC_STATIC_Z)->ShowWindow(SW_SHOW);
+         break;
+     }
+     UpdateData(FALSE);
+}
+
+void CDlgPlayMotion::OnBtnClearpic() 
+{
+    // TODO: Add your control notification handler code here
+//     if (m_cmbSearchType.GetCurSel() == 0)
+//     {
+//         memset(&(m_struSmartSearch.uSmartSearchCond.byMotionScope), 0, sizeof(BYTE)*64*96);
+//     }
+    if (m_cmbSearchType.GetCurSel() == 1)
+    {
+        memset(&(m_struSmartSearchV40.uSmartSearchCond.struTraversPlaneCond.struVcaTraversePlane[m_cmbTraversePlaneDirction.GetCurSel()]), 0, sizeof(NET_VCA_TRAVERSE_PLANE));
+    }
+    else if (m_cmbSearchType.GetCurSel() == 2 || m_cmbSearchType.GetCurSel() == 3)
+    {
+        memset(&m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.struVcaIntrusion , 0, sizeof(NET_VCA_INTRUSION) * MAX_INTRUSIONREGION_NUM);
+        m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.struVcaIntrusion[m_iFieldNo].struRegion.dwPointNum = 0;
+        m_dwPosNum = 0;
+       // OnBtnPreview();
+       // OnInitDialog();
+        //OnBtnPreview();
+
+    }
+}
+
+void CDlgPlayMotion::CleanMotionPic()
+{
+    memset(&(m_struSmartSearchV40.uSmartSearchCond.byMotionScope), 0, sizeof(BYTE)*64*96);
+}
+
+void CDlgPlayMotion::F_DrawFun( long lPlayHandle, HDC hDc, DWORD dwUser)
+{
+    if (m_cmbSearchType.GetCurSel() == 0)
+    {
+        F_DrawMotion(hDc);
+    }
+    if (m_cmbSearchType.GetCurSel() == 1)
+    {
+        F_DrawLine(hDc);
+    }
+    else if (m_cmbSearchType.GetCurSel() == 2 || m_cmbSearchType.GetCurSel() == 3)
+    {
+        F_DrawPolygon(hDc);
+    }
+}
+
+void CDlgPlayMotion::F_DrawMotion(HDC hDc )
+{
+    CRect rect;
+    int i = 0,j = 0;
+    CPoint point;
+    for (i = 0;i<18;i++)
+    {
+        for (j = 0;j<22;j++)
+        {
+            if (m_struSmartSearchV40.uSmartSearchCond.byMotionScope[i][j] == 1)
+            {
+                point.x = j*g_dwPrecision;
+                point.y = i*g_dwPrecision;
+                rect.left = point.x;
+                rect.top = point.y;
+                rect.right = point.x + g_dwPrecision;
+                rect.bottom = point.y + g_dwPrecision;
+                ::DrawEdge(hDc, &rect, BDR_SUNKENOUTER, BF_RECT);
+            }
+        }
+    }
+}
+
+void CDlgPlayMotion::F_DrawLine( HDC hDc )
+{
+    int iDirect = -1;
+    m_iLineNo = m_cmbCurArea.GetCurSel(); 
+    int i = m_struSmartSearchV40.uSmartSearchCond.struTraversPlaneCond.struVcaTraversePlane[m_iLineNo].struPlaneBottom.struStart.fX;
+    int x1 = (int)(m_struSmartSearchV40.uSmartSearchCond.struTraversPlaneCond.struVcaTraversePlane[m_iLineNo].struPlaneBottom.struStart.fX*m_rcWnd.Width());
+    int y1 = (int)(m_struSmartSearchV40.uSmartSearchCond.struTraversPlaneCond.struVcaTraversePlane[m_iLineNo].struPlaneBottom.struStart.fY*m_rcWnd.Height());
+    int x2 = (int)(m_struSmartSearchV40.uSmartSearchCond.struTraversPlaneCond.struVcaTraversePlane[m_iLineNo].struPlaneBottom.struEnd.fX*m_rcWnd.Width());
+    int y2 = (int)(m_struSmartSearchV40.uSmartSearchCond.struTraversPlaneCond.struVcaTraversePlane[m_iLineNo].struPlaneBottom.struEnd.fY*m_rcWnd.Height());
+    
+    COLORREF color = RGB(0,255,0); 
+    SetTextColor(hDc,color);
+    
+    using namespace Gdiplus;
+    Graphics graphics(hDc);
+    Color DrawColor;
+    DrawColor.SetValue(DrawColor.MakeARGB(50,GetRValue(color) ,GetGValue(color),GetBValue(color)));
+    
+    Pen pen(color, 4);
+    pen.SetStartCap(LineCapFlat);
+    pen.SetEndCap(LineCapFlat);
+    
+    CPen DrawPen;
+    DrawPen.CreatePen(PS_SOLID, 2, color);
+    
+ 
+    
+    HGDIOBJ pOldPen = SelectObject(hDc, DrawPen);
+    MoveToEx(hDc, x1, y1, NULL);
+    LineTo(hDc, x2, y2);
+    
+    //Draw arrow
+    //    F_DrawArrowhead(hDc, lpDrawTaversePlane);
+    //Draw label
+    
+    SelectObject(hDc, pOldPen);
+    DeleteObject(DrawPen);
+}
+
+void CDlgPlayMotion::F_DrawPolygon( HDC hDc)
+{
+    using namespace Gdiplus;
+    Graphics graphics(hDc);
+    SolidBrush  brush(Color(50, 0, 0, 0));
+    COLORREF color = RGB(0,255,0); 
+    brush.SetColor(Color(50, GetRValue(color), GetGValue(color), GetBValue(color)));
+    
+    POINT point[ITC_MAX_POLYGON_POINT_NUM] = {0};
+    
+    CPen DrawPen;
+    unsigned int i;
+    
+    DrawPen.CreatePen(PS_SOLID, 2, color);
+    SetTextColor(hDc,color);
+    SetBkMode(hDc, TRANSPARENT);
+
+    m_iFieldNo = m_cmbIntrusionCurArea.GetCurSel(); 
+    HGDIOBJ pOldPen = SelectObject(hDc, DrawPen);
+    MoveToEx(hDc, (int)(m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.struVcaIntrusion[m_iFieldNo].struRegion.struPos[0].fX*m_rcWnd.Width()), \
+        (int)(m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.struVcaIntrusion[m_iFieldNo].struRegion.struPos[0].fY*m_rcWnd.Height()), NULL);
+    
+    for(i=1; i< m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.struVcaIntrusion[m_iFieldNo].struRegion.dwPointNum && i < VCA_MAX_POLYGON_POINT_NUM + 1; i++)
+    {
+        
+        LineTo(hDc, (int)(m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.struVcaIntrusion[m_iFieldNo].struRegion.struPos[i].fX*m_rcWnd.Width()),\
+                (int)(m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.struVcaIntrusion[m_iFieldNo].struRegion.struPos[i].fY*m_rcWnd.Height()));
+        //Redraw the polygon if the lines are intersectant.
+        
+        if (i>=MIN_PNT_NUM)
+        {
+            if (!m_bMouseMove[0] && (m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.struVcaIntrusion[m_iFieldNo].struRegion.dwPointNum <10))
+            {
+                if (IsCrossLine(&(m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.struVcaIntrusion[m_iFieldNo].struRegion)))
+                {
+                    {
+                        char szLan[128] = {0};
+                        g_StringLanType(szLan,"多边形不相邻的边有相交情况存在,请重新输入!","Edges of Polygon can be intersectant, please redraw.!");
+                        //		AfxMessageBox(szLan);
+                        m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.struVcaIntrusion[m_iFieldNo].struRegion.dwPointNum--;
+                        m_dwPosNum = m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.struVcaIntrusion[m_iFieldNo].struRegion.dwPointNum;
+                        memset(&m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.struVcaIntrusion[m_iFieldNo].struRegion.struPos[m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.struVcaIntrusion[m_iFieldNo].struRegion.dwPointNum], 0, sizeof(NET_VCA_POINT));
+                        break;
+                    }
+                }
+            }
+        }
+//                if(i>=MIN_PNT_NUM && !lpDrawPolygon->bMouseMove && IsCrossLine(&lpDrawPolygon->struVcaPolygon))
+//                {
+//                      char szLan[128] = {0};
+//                      g_StringLanType(szLan,"多边形不相邻的边有相交情况存在,请重新输入!","Edges of Polygon can be intersectant, please redraw.!");
+//                       //AfxMessageBox(szLan);
+//                       lpDrawPolygon->struVcaPolygon.dwPointNum--;
+//                      break;
+//                }
+    }
+    
+    for (i=0; i<(int)m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.struVcaIntrusion[m_iFieldNo].struRegion.dwPointNum ; i++)
+    {
+        if (i == ITC_MAX_POLYGON_POINT_NUM)
+        {
+            break;
+        }
+        
+        point[i].x = (int)(m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.struVcaIntrusion[m_iFieldNo].struRegion.struPos[i].fX*m_rcWnd.Width());
+        point[i].y = (int)(m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.struVcaIntrusion[m_iFieldNo].struRegion.struPos[i].fY*m_rcWnd.Height());
+    }
+    //After drawing the 10th point, connect it with the 1st point.
+    if(ITC_MAX_POLYGON_POINT_NUM == i && !m_bMouseMove[0] && (m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.struVcaIntrusion[m_iFieldNo].struRegion.dwPointNum < 10))
+    {
+        if (IsValidArea(&m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.struVcaIntrusion[m_iFieldNo].struRegion))
+        {
+            graphics.FillPolygon(&brush, (Point *)point, m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.struVcaIntrusion[m_iFieldNo].struRegion.dwPointNum);
+            
+            LineTo(hDc, point[0].x, point[0].y);
+            // TextOut(hDc, point[0].x, point[0].y, lpDrawPolygon->chName, strlen(lpDrawPolygon->chName));
+            
+            m_bCloseIn = TRUE;
+        }else//redraw
+        {
+            
+        }
+        //check if the alarm region is intact
+    }
+    else if(m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.struVcaIntrusion[m_iFieldNo].struRegion.dwPointNum>2 && m_bCloseIn)
+    {
+        if (IsValidArea(&m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.struVcaIntrusion[m_iFieldNo].struRegion))
+        {
+            graphics.FillPolygon(&brush, (Point *)point, m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.struVcaIntrusion[m_iFieldNo].struRegion.dwPointNum);
+            
+            LineTo(hDc, point[0].x, point[0].y);
+            
+            //   TextOut(hDc, point[0].x, point[0].y, lpDrawPolygon->chName, strlen(lpDrawPolygon->chName));
+            //            F_AddLabel(hDc, AlarmArea, dwRuleID);
+        }else
+        {
+            //             m_bNeedRedraw[dwRuleID] = TRUE;
+            //             m_bCloseIn[dwRuleID] = FALSE;
+        }
+    }
+    
+    SelectObject(hDc, pOldPen);
+    DeleteObject(DrawPen);
+}
+
+
+BOOL CDlgPlayMotion::PreDrawPolygonMsg( MSG* pMsg, CPoint &pt )
+{
+	int i=0;
+    BOOL bOneLine = TRUE,bXOneLine = TRUE,bYOneLine = TRUE;
+
+    switch (pMsg->message)
+    {
+    case WM_LBUTTONDOWN:
+        if ((GetAsyncKeyState(VK_LCONTROL)<0 || GetAsyncKeyState(VK_RCONTROL)<0) && 
+            PtInRect(&m_rcWnd,pt))
+        {
+       //     if(m_bNeedRedraw)
+            {
+				if (m_dwPosNum > 9)
+				{
+					m_bCloseIn = TRUE;
+				}
+                if(m_bCloseIn)
+                {
+                    m_dwPosNum = 0;
+					m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.struVcaIntrusion[m_iFieldNo].struRegion.dwPointNum = m_dwPosNum;
+                    memset(&m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.struVcaIntrusion[m_iFieldNo], 0, sizeof(NET_VCA_POLYGON));
+                }
+                if(m_dwPosNum > 9)
+                {
+                    char szLan[128] = {0};
+                    g_StringLanType(szLan,"多边形顶点不能超过10个!","Apexes of polygon should less than 10");
+                    AfxMessageBox(szLan);
+                    return TRUE;
+                }
+				if((float)(pt.x-m_rcWnd.left)/(float)m_rcWnd.Width() <= m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.struVcaIntrusion[m_iFieldNo].struRegion.struPos[m_dwPosNum-1].fX+0.01 && (float)(pt.x-m_rcWnd.left)/(float)m_rcWnd.Width() >= m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.struVcaIntrusion[m_iFieldNo].struRegion.struPos[m_dwPosNum-1].fX-0.01\
+                    && (float)(pt.y-m_rcWnd.top)/(float)m_rcWnd.Height() <= m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.struVcaIntrusion[m_iFieldNo].struRegion.struPos[m_dwPosNum-1].fY+0.01 && (float)(pt.y-m_rcWnd.top)/(float)m_rcWnd.Height() >= m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.struVcaIntrusion[m_iFieldNo].struRegion.struPos[m_dwPosNum-1].fY-0.01)
+                {
+                    char szLan[128] = {0};
+                    g_StringLanType(szLan, "不能连续在同一点上画区域", "Can't draw region on the point used");
+                    AfxMessageBox(szLan);
+                    return TRUE;
+                }
+                m_bCloseIn = FALSE;
+                m_bMouseMovePolygon = FALSE;
+                m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.struVcaIntrusion[m_iFieldNo].struRegion.struPos[m_dwPosNum].fX = (float)(pt.x-m_rcWnd.left)/(float)m_rcWnd.Width();
+                m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.struVcaIntrusion[m_iFieldNo].struRegion.struPos[m_dwPosNum].fY = (float)(pt.y-m_rcWnd.top)/(float)m_rcWnd.Height();
+                m_dwPosNum++;
+                m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.struVcaIntrusion[m_iFieldNo].struRegion.dwPointNum = m_dwPosNum;	
+            }
+            
+        }
+        break;
+    case WM_MOUSEMOVE:
+        if ((GetAsyncKeyState(VK_LCONTROL)<0 || GetAsyncKeyState(VK_RCONTROL)<0) && 
+            PtInRect(&m_rcWnd,pt))
+        {
+                if(PtInRect(&m_rcWnd,pt))
+                {
+                    if(m_dwPosNum > 9)
+                    {
+                        return TRUE;
+                    }
+                    if( !m_bCloseIn)
+                    {
+                        m_bMouseMovePolygon = TRUE;
+                        m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.struVcaIntrusion[m_iFieldNo].struRegion.struPos[m_dwPosNum].fX = (float)(pt.x-m_rcWnd.left)/(float)m_rcWnd.Width();
+                        m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.struVcaIntrusion[m_iFieldNo].struRegion.struPos[m_dwPosNum].fY = (float)(pt.y-m_rcWnd.top)/(float)m_rcWnd.Height();
+                        m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.struVcaIntrusion[m_iFieldNo].struRegion.dwPointNum = m_dwPosNum+1;				
+                    }
+                }
+        }
+
+        break;
+    case WM_RBUTTONDOWN:
+        if((GetAsyncKeyState(VK_LCONTROL)<0 || GetAsyncKeyState(VK_RCONTROL)<0) 
+            && PtInRect(&m_rcWnd,pt))
+        {
+                if(m_dwPosNum > 9)
+                {
+                    return TRUE;
+                }
+                for(i=0; i<m_dwPosNum; i++)
+                {
+                    if(m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.struVcaIntrusion[m_iFieldNo].struRegion.struPos[i].fX != m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.struVcaIntrusion[m_iFieldNo].struRegion.struPos[i+1].fX)
+                    {
+                        bXOneLine = FALSE;
+                        break;
+                    }
+                }
+                for(i=0; i<m_dwPosNum; i++)
+                {
+                    if(m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.struVcaIntrusion[m_iFieldNo].struRegion.struPos[i].fY != m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.struVcaIntrusion[m_iFieldNo].struRegion.struPos[i+1].fY)
+                    {
+                        bYOneLine = FALSE;
+                        break;
+                    }
+                }
+                bOneLine = bXOneLine||bYOneLine;
+                if(bOneLine)
+                {
+                    char szlan[128] = {0};
+                    g_StringLanType(szlan, "所画点成一线，无法构成区域!","The points is on a line and can't create a rectangle!");
+                    AfxMessageBox(szlan);
+                    return TRUE;
+                }
+                if( !m_bCloseIn)
+                {
+                    if(m_bMouseMovePolygon)
+                    {
+                        m_bMouseMovePolygon = FALSE;
+                        m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.struVcaIntrusion[m_iFieldNo].struRegion.dwPointNum--;
+                        m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.struVcaIntrusion[m_iFieldNo].struRegion.struPos[m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.struVcaIntrusion[m_iFieldNo].struRegion.dwPointNum].fX = 0;
+                        m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.struVcaIntrusion[m_iFieldNo].struRegion.struPos[m_struSmartSearchV40.uSmartSearchCond.struIntrusionCond.struVcaIntrusion[m_iFieldNo].struRegion.dwPointNum].fY = 0;
+                    }
+                    m_bCloseIn = TRUE;
+                }
+		}
+        break;
+    }
+     return TRUE;
+}
+
+BOOL CDlgPlayMotion::PreDrawLineMsg( MSG* pMsg, CPoint &pt )
+{
+    UpdateData(TRUE);
+    CString strTemp = _T("");
+    DWORD i=0;
+    BOOL bOneLine = TRUE,bXOneLine = TRUE,bYOneLine = TRUE;
+    int dwTest1 = GetAsyncKeyState(VK_LCONTROL);
+    int dwTest2 = GetAsyncKeyState(VK_RCONTROL);
+    switch(pMsg->message)  // Message of Draw
+    {
+    case WM_LBUTTONDOWN:
+        if( (m_cmbSearchType.GetCurSel() == 1) &&
+            ((dwTest1 < 0 ) || (GetAsyncKeyState(VK_RCONTROL) < 0)))//Press CTRL to draw
+        {
+            if(!m_bMouseMove[0]) 
+            {
+                m_struSmartSearchV40.uSmartSearchCond.struTraversPlaneCond.struVcaTraversePlane[m_iLineNo].struPlaneBottom.struStart.fX = (float)(pt.x-m_rcWnd.left)/(float)m_rcWnd.Width();
+                m_struSmartSearchV40.uSmartSearchCond.struTraversPlaneCond.struVcaTraversePlane[m_iLineNo].struPlaneBottom.struStart.fY = (float)(pt.y-m_rcWnd.top)/(float)m_rcWnd.Height();		
+                m_struSmartSearchV40.uSmartSearchCond.struTraversPlaneCond.struVcaTraversePlane[m_iLineNo].struPlaneBottom.struEnd.fX = (float)(pt.x-m_rcWnd.left)/(float)m_rcWnd.Width();
+                m_struSmartSearchV40.uSmartSearchCond.struTraversPlaneCond.struVcaTraversePlane[m_iLineNo].struPlaneBottom.struEnd.fY = (float)(pt.y-m_rcWnd.top)/(float)m_rcWnd.Height();			
+                m_bMouseMove[0] = TRUE;
+            }
+            else
+            {
+                if ((float)(pt.x-m_rcWnd.left)/(float)m_rcWnd.Width() <= m_struSmartSearchV40.uSmartSearchCond.struTraversPlaneCond.struVcaTraversePlane[m_iLineNo].struPlaneBottom.struStart.fX+0.01 && (float)(pt.x-m_rcWnd.left)/(float)m_rcWnd.Width() >= m_struSmartSearchV40.uSmartSearchCond.struTraversPlaneCond.struVcaTraversePlane[m_iLineNo].struPlaneBottom.struStart.fX-0.01\
+                    && (float)(pt.y-m_rcWnd.top)/(float)m_rcWnd.Height() <= m_struSmartSearchV40.uSmartSearchCond.struTraversPlaneCond.struVcaTraversePlane[m_iLineNo].struPlaneBottom.struStart.fY+0.01 && (float)(pt.y-m_rcWnd.top)/(float)m_rcWnd.Height() >= m_struSmartSearchV40.uSmartSearchCond.struTraversPlaneCond.struVcaTraversePlane[m_iLineNo].struPlaneBottom.struStart.fY-0.01)
+                {
+                    char szLan[128] = {0};
+                    g_StringLanType(szLan, "不能连续在同一点上画区域", "Can't draw region on the point used");
+                    AfxMessageBox(szLan);
+                    return TRUE;
+                }
+                m_struSmartSearchV40.uSmartSearchCond.struTraversPlaneCond.struVcaTraversePlane[m_iLineNo].struPlaneBottom.struEnd.fX = (float)(pt.x-m_rcWnd.left)/(float)m_rcWnd.Width();
+                m_struSmartSearchV40.uSmartSearchCond.struTraversPlaneCond.struVcaTraversePlane[m_iLineNo].struPlaneBottom.struEnd.fY = (float)(pt.y-m_rcWnd.top)/(float)m_rcWnd.Height();			
+                m_bMouseMove[0] = FALSE;
+            }
+        }
+        break;
+    case WM_MOUSEMOVE:
+        if( (m_cmbSearchType.GetCurSel() == 1)  && (GetAsyncKeyState(VK_LCONTROL)<0 || GetAsyncKeyState(VK_RCONTROL)<0))
+        {
+            if(PtInRect(&m_rcWnd,pt))
+            {
+                if(m_bMouseMove[0])
+                {
+                    m_struSmartSearchV40.uSmartSearchCond.struTraversPlaneCond.struVcaTraversePlane[m_iLineNo].struPlaneBottom.struEnd.fX = (float)(pt.x-m_rcWnd.left)/(float)m_rcWnd.Width();
+                    m_struSmartSearchV40.uSmartSearchCond.struTraversPlaneCond.struVcaTraversePlane[m_iLineNo].struPlaneBottom.struEnd.fY = (float)(pt.y-m_rcWnd.top)/(float)m_rcWnd.Height();			
+                }
+            }
+        }
+        break;
+    case WM_RBUTTONDOWN://Click right mouse to close the rectangle. 
+        break;
+    default:
+        break;
+    }
+    return TRUE;
+}
+
+BOOL CDlgPlayMotion::PreDrawMotionMsg(MSG* pMsg, CPoint &pt1)
+{
+    CPoint pt(0,0);
+    CRect  rcWnd(0,0,0,0);
+    GetDlgItem(IDC_PIC_MOTION_DETECT)->GetWindowRect(&rcWnd);
+    
+    GetCursorPos(&pt);
+    int i1 = PtInRect(&rcWnd, pt);
+    int i2 = GetAsyncKeyState(VK_LCONTROL);
+    int i3 = GetAsyncKeyState(VK_RCONTROL);
+    switch (pMsg->message)
+    {
+    case WM_LBUTTONDOWN:
+        if (PtInRect(&rcWnd, pt) && (GetAsyncKeyState(VK_LCONTROL)<0 || GetAsyncKeyState(VK_RCONTROL)<0))
+        {
+            for (int nMotionIndex = 0; nMotionIndex < MOTION_NUM; nMotionIndex++)
+            {
+                //AfxMessageBox("nim");
+                if (m_bDrawed[nMotionIndex] == FALSE)
+                {
+                    //Get the Drawing Rect Index
+                    m_iDrawingIndex = nMotionIndex;  
+                    m_struRect[m_iDrawingIndex].fX = (float)(pt.x-rcWnd.left)/(float)rcWnd.Width();
+                    m_struRect[m_iDrawingIndex].fY = (float)(pt.y-rcWnd.top)/(float)rcWnd.Height();
+                    m_bMouseMove[m_iDrawingIndex] = TRUE;
+                    TRACE("m_struRect.fX =%f m_struRect.fY =%f\n", m_struRect[m_iDrawingIndex].fX,m_struRect[m_iDrawingIndex].fY);
+                    break;
+                }
+            }
+        }
+        break;
+    case WM_LBUTTONUP:
+        if (PtInRect(&rcWnd, pt) && (GetAsyncKeyState(VK_LCONTROL)<0 || GetAsyncKeyState(VK_RCONTROL)<0))
+        {
+            m_bMouseMove[m_iDrawingIndex] = FALSE;
+            m_bDrawed[m_iDrawingIndex] = TRUE;
+            break;
+        }
+        break;
+    case WM_MOUSEMOVE:
+        if (PtInRect(&rcWnd, pt)  && m_bMouseMove[m_iDrawingIndex] && (GetAsyncKeyState(VK_LCONTROL)<0 || GetAsyncKeyState(VK_RCONTROL)<0))
+        {   
+            m_struRect[m_iDrawingIndex].fWidth = (float)(pt.x-rcWnd.left)/(float)rcWnd.Width() -  m_struRect[m_iDrawingIndex].fX;
+            m_struRect[m_iDrawingIndex].fHeight = (float)(pt.y-rcWnd.top)/(float)rcWnd.Height() -  m_struRect[m_iDrawingIndex].fY;
+            
+            
+            TRACE("WM_MOUSEMOVE  MotionIndex[%d] fWidth[%f] fHeight[%f]\n", m_iDrawingIndex, m_struRect[m_iDrawingIndex].fWidth, m_struRect[m_iDrawingIndex].fHeight);
+            
+            for(int i = int(m_struRect[m_iDrawingIndex].fX * 22); i <= int((m_struRect[m_iDrawingIndex].fX +m_struRect[m_iDrawingIndex].fWidth)*22); i++)
+            {
+                for (int j = int(m_struRect[m_iDrawingIndex].fY*18); j <= int((m_struRect[m_iDrawingIndex].fY + m_struRect[m_iDrawingIndex].fHeight)*18); j++)
+                {
+                    m_struSmartSearchV40.uSmartSearchCond.byMotionScope[j][i] = 1;
+                }
+            }
+            break;
+        }
+        break;
+    case WM_RBUTTONDOWN:
+        if (PtInRect(&rcWnd, pt) && (GetAsyncKeyState(VK_LCONTROL)<0 || GetAsyncKeyState(VK_RCONTROL)<0))
+        {
+            memset(&m_struRect, 0, sizeof(m_struRect));
+            memset(m_struSmartSearchV40.uSmartSearchCond.byMotionScope, 0, sizeof(m_struSmartSearchV40.uSmartSearchCond.byMotionScope));
+            for (int i = 0; i < MOTION_NUM; i++)
+            {
+                m_bDrawed[i] = FALSE;
+                m_bMouseMove[i] = FALSE;
+            }
+        }
+    }
+	//return CDialog::PreTranslateMessage(pMsg);
+    return TRUE;
+}
+
+void CDlgPlayMotion::OnBtnGetPtz() 
+{
+	// TODO: Add your control notification handler code here
+	   char szLan[1024] = {0};
+       g_StringLanType(szLan,"请先预览", "Please RealPlay First!");
+    if (m_lRealPlayHandle < 0)
+	{
+        AfxMessageBox(szLan);
+        return;
+	}
+
+    long lPlayPort = NET_DVR_GetRealPlayerIndex(m_lRealPlayHandle);
+    LONG dwRetLen = 0;
+    memset(&m_struPTZInfo,0,sizeof(m_struPTZInfo));
+    BYTE*pRecvBuf = NULL;
+    if (PlayM4_GetStreamAdditionalInfo(lPlayPort,1, NULL,&dwRetLen))
+    {
+        g_pMainDlg->AddLog(m_iDevIndex, OPERATION_SUCC_T, "PlayM4_GetStreamAdditionalInfo");
+    }
+    else
+    {
+        //g_pMainDlg->AddLog(m_iDevIndex, OPERATION_FAIL_T, "PlayM4_GetStreamAdditionalInfo");
+        
+
+        if (dwRetLen != 0)
+        {
+            pRecvBuf = new BYTE[dwRetLen];
+            if (pRecvBuf != NULL)
+            {
+                memset(pRecvBuf,0,dwRetLen);
+            }
+            if (!PlayM4_GetStreamAdditionalInfo(lPlayPort,1, pRecvBuf,&dwRetLen))
+            {
+                g_StringLanType(szLan,"获取PTZ信息失败", "Get PTZ Info Failed!");
+            }
+        }
+    }
+
+    if (pRecvBuf != NULL && dwRetLen == sizeof(m_struPTZInfo))
+    {
+        memcpy(&m_struPTZInfo,pRecvBuf,sizeof(m_struPTZInfo));
+        
+        delete[] pRecvBuf;
+        pRecvBuf = NULL;
+    }
+
+    m_fPanPos   = m_struPTZInfo.dwP/10.0;
+    m_fTitlePos = m_struPTZInfo.dwT/10.0;
+    m_fZoomPos  = m_struPTZInfo.dwZ/10.0;
+
+    UpdateData(FALSE);
+}
+
+void CDlgPlayMotion::AddHumanFeatureInfo()
+{    
+    m_cmbRes.ResetContent();
+    DWORD dwIndex = 0;
+    char szTemp[128] = {0};   
+    m_cmbRes.SetCurSel(0);
+    
+    dwIndex = 0;
+    
+    
+    m_cmbEyeGlass.ResetContent();
+    
+    g_StringLanType(szTemp,"不关注","No Attention");
+    m_cmbEyeGlass.AddString(szTemp);
+    m_cmbEyeGlass.SetItemData(dwIndex,0xff);
+    dwIndex++;
+    
+    g_StringLanType(szTemp,"不带","NO");
+    m_cmbEyeGlass.AddString(szTemp);
+    m_cmbEyeGlass.SetItemData(dwIndex,1);
+    dwIndex++;
+
+    g_StringLanType(szTemp,"带","YES");
+    m_cmbEyeGlass.AddString(szTemp);
+    m_cmbEyeGlass.SetItemData(dwIndex,2);
+    dwIndex++;
+    
+
+    m_cmbEyeGlass.SetCurSel(0);
+    
+    
+    dwIndex = 0;
+    m_cmbSex.ResetContent();
+    
+    g_StringLanType(szTemp,"不关注","No Attention");
+    m_cmbSex.AddString(szTemp);
+    m_cmbSex.SetItemData(dwIndex,0xff);
+    dwIndex++;
+    
+    g_StringLanType(szTemp,"男","MAN");
+    m_cmbSex.AddString(szTemp);
+    m_cmbSex.SetItemData(dwIndex,1);
+    dwIndex++;
+    
+    g_StringLanType(szTemp,"女","WOMEN");
+    m_cmbSex.AddString(szTemp);
+    m_cmbSex.SetItemData(dwIndex,2);
+    dwIndex++;
+    m_cmbSex.SetCurSel(0);
+}
+
+void CDlgPlayMotion::AddObjectIFeatureInfo()
+{
+    m_cmbColorR.ResetContent();
+    m_cmbColorG.ResetContent();
+    m_cmbColorB.ResetContent();
+    DWORD dwIndex = 0;
+    char szTemp[128] = {0};
+
+   for (int i =0; i < 256;i++)
+   {
+       sprintf(szTemp,"%d",i);
+       m_cmbColorR.AddString(szTemp) ;
+       m_cmbColorG.AddString(szTemp) ;
+       m_cmbColorB.AddString(szTemp) ;
+   }
+   m_cmbColorR.SetCurSel(255);
+   m_cmbColorG.SetCurSel(0);
+   m_cmbColorB.SetCurSel(0);
+
+   m_cmbColorRate.ResetContent();
+   for (int j = 0; j <= 100; j++)
+   {
+       sprintf(szTemp,"%d",j);
+       m_cmbColorRate.AddString(szTemp) ;
+   }
+   m_cmbColorRate.SetCurSel(50);
+
+   UpdateData(FALSE);
+
+}

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgRecordHostFilePublish.h

@@ -0,0 +1,74 @@
+#include "afxwin.h"
+#if !defined(AFX_DLGRECORDHOSTFILEPUBLISH_H__C83496A1_D72A_4FDE_874B_FC95211415EE__INCLUDED_)
+#define AFX_DLGRECORDHOSTFILEPUBLISH_H__C83496A1_D72A_4FDE_874B_FC95211415EE__INCLUDED_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif // _MSC_VER > 1000
+// DlgRecordHostFilePublish.h : header file
+//
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgRecordHostFilePublish dialog
+
+class CDlgRecordHostFilePublish : public CDialog
+{
+// Construction
+public:
+	CDlgRecordHostFilePublish(CWnd* pParent = NULL);   // standard constructor
+    virtual BOOL OnInitDialog();
+
+// Dialog Data
+	//{{AFX_DATA(CDlgRecordHostFilePublish)
+	enum { IDD = IDD_DLG_RECORD_HOST_FILE_PUBLISH };
+		// NOTE: the ClassWizard will add data members here
+    CComboBox	m_comPubilshStatus;
+	CComboBox	m_comCMDType;
+    CComboBox   m_comChannel;
+	CString	m_csFileID;
+	CString	m_csFileIDCond;
+    CString m_csCourseName;
+    CString m_csInstructorName;
+    CString m_csCoureDescription;
+	BYTE	m_byPubilshPercent;
+	COleDateTime	m_startDate;
+	COleDateTime	m_startTime;
+	COleDateTime	m_stopDate;
+	COleDateTime	m_stopTime;
+	//}}AFX_DATA
+
+
+// Overrides
+	// ClassWizard generated virtual function overrides
+	//{{AFX_VIRTUAL(CDlgRecordHostFilePublish)
+	protected:
+	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
+	//}}AFX_VIRTUAL
+
+// Implementation
+protected:
+
+	// Generated message map functions
+	//{{AFX_MSG(CDlgRecordHostFilePublish)
+	afx_msg void OnButtonSetRecordingPublishFile();
+	afx_msg void OnButtonGetPublishProgress();
+    afx_msg void OnButtonGetPublishFileInfo();
+    afx_msg void OnButtonSetPublishFileInfo();
+    afx_msg void OnButtonRecordingPublishFile();
+    afx_msg void OnButtonPublishProgress();
+    afx_msg void OnButtonPublishInfo();
+	//}}AFX_MSG
+	DECLARE_MESSAGE_MAP()
+
+public:
+    LONG m_lLoginID;
+    INT  m_iDeviceIndex;
+	LONG m_lChannel;
+    char    m_szStatusBuf[ISAPI_STATUS_LEN];
+    CComboBox m_ComboFileType;
+};
+
+//{{AFX_INSERT_LOCATION}}
+// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
+
+#endif // !defined(AFX_DLGRECORDHOSTFILEPUBLISH_H__C83496A1_D72A_4FDE_874B_FC95211415EE__INCLUDED_)

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgRemoteControlAbility.h

@@ -0,0 +1,56 @@
+#if !defined(AFX_DLGREMOTECONTROLABILITY_H__6A56DD74_CD30_43AB_934E_D56EFBA9EEE8__INCLUDED_)
+#define AFX_DLGREMOTECONTROLABILITY_H__6A56DD74_CD30_43AB_934E_D56EFBA9EEE8__INCLUDED_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif // _MSC_VER > 1000
+// DlgRemoteControlAbility.h : header file
+//
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgRemoteControlAbility dialog
+
+class CDlgRemoteControlAbility : public CDialog
+{
+// Construction
+public:
+	CDlgRemoteControlAbility(CWnd* pParent = NULL);   // standard constructor
+
+// Dialog Data
+	//{{AFX_DATA(CDlgRemoteControlAbility)
+	enum { IDD = IDD_DLG_REMOTE_CONTROL_ABILITY };
+		// NOTE: the ClassWizard will add data members here
+	//}}AFX_DATA
+
+
+// Overrides
+	// ClassWizard generated virtual function overrides
+	//{{AFX_VIRTUAL(CDlgRemoteControlAbility)
+	protected:
+	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
+	virtual BOOL OnInitDialog();
+	//}}AFX_VIRTUAL
+
+// Implementation
+protected:
+
+	// Generated message map functions
+	//{{AFX_MSG(CDlgRemoteControlAbility)
+	afx_msg void OnDestroy();
+	//}}AFX_MSG
+	DECLARE_MESSAGE_MAP()
+
+public:
+    LONG    m_lServerID;
+    int     m_iDevIndex;
+    char    *m_pRecvBuf;
+    char    *m_pSendBuf;
+	
+	BOOL    WirteBufToFile(char *pBuf, DWORD dwBufSize);
+	BOOL GetITCAbility();
+};
+
+//{{AFX_INSERT_LOCATION}}
+// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
+
+#endif // !defined(AFX_DLGREMOTECONTROLABILITY_H__6A56DD74_CD30_43AB_934E_D56EFBA9EEE8__INCLUDED_)

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgRemoteHideAlarm.cpp

@@ -0,0 +1,1068 @@
+/**********************************************************
+FileName:    DlgRemoteHideAlarm.cpp
+Description: remote view tamper alarm handling      
+Date:        2008/05/17
+Note: 		<Global>struct, macro refer to GeneralDef.h, global variants and API refer to ClientDemo.cpp   
+Modification History:      
+    <version> <time>         <desc>
+    <1.0    > <2008/05/17>       <created>
+***********************************************************/
+
+
+#include "stdafx.h"
+#include "ClientDemo.h"
+#include "DlgRemoteHideAlarm.h"
+#include ".\dlgremotehidealarm.h"
+
+
+// CDlgRemoteHideAlarm dialog
+extern LPNET_DVR_HIDEALARM_V30 g_lpHideAlarm;//view tamper area
+extern LPNET_DVR_HIDEALARM_V40 g_lpHideAlarmV40;//view tamper area
+RECT g_rectHideAlarmShow;
+RECT g_rectHideAlarmSetArea;
+
+/*********************************************************
+  Function:	HideAlarmGetCallBack
+  Desc:		
+  Input:	
+  Output:	
+  Return:	
+**********************************************************/
+void CALLBACK HideAlarmGetCallBack(LONG nPort,HDC hDc,DWORD nUser)
+{
+	CRect rect;
+	CPoint point;
+	rect.left = g_rectHideAlarmSetArea.left;
+	rect.top = g_rectHideAlarmSetArea.top;
+	rect.right = g_rectHideAlarmSetArea.right;
+	rect.bottom = g_rectHideAlarmSetArea.bottom;
+	::DrawEdge(hDc,&rect,BDR_SUNKENOUTER,BF_RECT);
+	SetBkMode(hDc,TRANSPARENT);
+}
+
+void CALLBACK HideAlarmSetCallBack(LONG nPort,HDC hDc,DWORD nUser)
+{
+	::DrawEdge(hDc,&g_rectHideAlarmShow,BDR_SUNKENOUTER,BF_RECT);
+	SetBkMode(hDc,TRANSPARENT);
+}
+/*********************************************************
+  Function:	CDlgRemoteHideAlarm
+  Desc:		Constructor
+  Input:	
+  Output:	
+  Return:	
+**********************************************************/
+IMPLEMENT_DYNAMIC(CDlgRemoteHideAlarm, CDialog)
+CDlgRemoteHideAlarm::CDlgRemoteHideAlarm(CWnd* pParent /*=NULL*/)
+	: CDialog(CDlgRemoteHideAlarm::IDD, pParent)
+	, m_bChkMonitorAlarm(FALSE)
+	, m_bChkAudioAlarm(FALSE)
+	, m_bChkReportCenter(FALSE)
+	, m_bChkInvokeAlarmOut(FALSE)
+	, m_bChkInvokeJpegCapture(FALSE)
+	, m_bChkPicFtp(FALSE)
+    , m_bChkPicCloud(FALSE)
+    , m_bChkWirelessSoundLightAlarm(FALSE)
+	, m_bChkEmapAlarmOut(FALSE)
+	, m_iHour11(0)
+	, m_iMin11(0)
+	, m_iHour12(0)
+	, m_iMin12(0)
+	, m_iHour21(0)
+	, m_iMin21(0)
+	, m_iHour22(0)
+	, m_iMin22(0)
+	, m_iHour31(0)
+	, m_iMin31(0)
+	, m_iHour32(0)
+	, m_iMin32(0)
+	, m_iHour41(0)
+	, m_iMin41(0)
+	, m_iHour42(0)
+	, m_iMin42(0)
+	, m_iHour51(0)
+	, m_iMin51(0)
+	, m_iHour52(0)
+	, m_iMin52(0)
+	, m_iHour61(0)
+	, m_iMin61(0)
+	, m_iHour62(0)
+	, m_iMin62(0)
+	, m_iHour71(0)
+	, m_iMin71(0)
+	, m_iHour72(0)
+	, m_iMin72(0)
+	, m_iHour81(0)
+	, m_iMin81(0)
+	, m_iHour82(0)
+	, m_iMin82(0)
+	, m_bChkHideAlarmShow(FALSE)
+	, m_bChkHideAlarmSet(FALSE)
+	, m_iChanShowNum(0)
+	, m_lLoginID(-1)
+	, m_bDrawdetect(FALSE)
+	, m_lPlayHandle(NULL)
+	, m_dwAlarmOutNum(0)
+	, m_dwDevIndex(0)
+{
+	m_pbAlarmOut = new BOOL[MAX_ALARMOUT_V40];
+    if (m_pbAlarmOut != NULL)
+    {
+        memset(m_pbAlarmOut,0, sizeof(BOOL)*MAX_ALARMOUT_V40);
+    }
+    memset(&m_struHideHolidayHandle, 0, sizeof(m_struHideHolidayHandle));
+
+}
+
+/*********************************************************
+  Function:	~CDlgRemoteHideAlarm
+  Desc:		destructor
+  Input:	
+  Output:	
+  Return:	
+**********************************************************/
+CDlgRemoteHideAlarm::~CDlgRemoteHideAlarm()
+{
+}
+/*********************************************************
+Function:	DoDataExchange
+Desc:		the map between control and variable
+Input:	
+Output:	
+Return:	
+**********************************************************/
+void CDlgRemoteHideAlarm::DoDataExchange(CDataExchange* pDX)
+{
+	CDialog::DoDataExchange(pDX);
+	//{{AFX_DATA_MAP(CDlgRemoteHideAlarm)
+	DDX_Control(pDX, IDC_TREE_ALARM_OUT, m_treeAlarmOut);
+	DDX_Control(pDX, IDC_COMBO_HIDE_ALARM_SENSITIVE, m_comboHideAlarmSensitive);
+	DDX_Control(pDX, IDC_PIC_HIDE_ALARM, m_picHideAlarm);
+	DDX_Check(pDX, IDC_CHK_HA_MONITOR_ALARM, m_bChkMonitorAlarm);
+	DDX_Check(pDX, IDC_CHK_HA_AUDIO_ALARM, m_bChkAudioAlarm);
+	DDX_Check(pDX, IDC_CHK_HA_REPORT_CENTER, m_bChkReportCenter);
+	DDX_Check(pDX, IDC_CHK_HA_INVOKE_ALARM_OUT, m_bChkInvokeAlarmOut);
+	DDX_Check(pDX, IDC_CHK_INVOKE_JPEG_CAPTURE, m_bChkInvokeJpegCapture);
+	DDX_Check(pDX, IDC_CHK_ALARMOUT_EMAP, m_bChkEmapAlarmOut);
+	DDX_Control(pDX, IDC_COMBO_HA_WEEKDAY, m_comboWeekday);
+	DDX_Control(pDX, IDC_COMBO_HIDE_ALARM_DAY_COPY, m_comboDayCopy);
+	DDX_Text(pDX, IDC_EDIT_HOUR11, m_iHour11);
+	DDX_Text(pDX, IDC_EDIT_MIN11, m_iMin11);
+	DDX_Text(pDX, IDC_EDIT_HOUR12, m_iHour12);
+	DDX_Text(pDX, IDC_EDIT_MIN12, m_iMin12);
+	DDX_Text(pDX, IDC_EDIT_HOUR21, m_iHour21);
+	DDX_Text(pDX, IDC_EDIT_MIN21, m_iMin21);
+	DDX_Text(pDX, IDC_EDIT_HOUR22, m_iHour22);
+	DDX_Text(pDX, IDC_EDIT_MIN22, m_iMin22);
+	DDX_Text(pDX, IDC_EDIT_HOUR31, m_iHour31);
+	DDX_Text(pDX, IDC_EDIT_MIN31, m_iMin31);
+	DDX_Text(pDX, IDC_EDIT_HOUR32, m_iHour32);
+	DDX_Text(pDX, IDC_EDIT_MIN32, m_iMin32);
+	DDX_Text(pDX, IDC_EDIT_HOUR41, m_iHour41);
+	DDX_Text(pDX, IDC_EDIT_MIN41, m_iMin41);
+	DDX_Text(pDX, IDC_EDIT_HOUR42, m_iHour42);
+	DDX_Text(pDX, IDC_EDIT_MIN42, m_iMin42);
+	DDX_Text(pDX, IDC_EDIT_HOUR51, m_iHour51);
+	DDX_Text(pDX, IDC_EDIT_MIN51, m_iMin51);
+	DDX_Text(pDX, IDC_EDIT_HOUR52, m_iHour52);
+	DDX_Text(pDX, IDC_EDIT_MIN52, m_iMin52);
+	DDX_Text(pDX, IDC_EDIT_HOUR61, m_iHour61);
+	DDX_Text(pDX, IDC_EDIT_MIN61, m_iMin61);
+	DDX_Text(pDX, IDC_EDIT_HOUR62, m_iHour62);
+	DDX_Text(pDX, IDC_EDIT_MIN62, m_iMin62);
+	DDX_Text(pDX, IDC_EDIT_HOUR71, m_iHour71);
+	DDX_Text(pDX, IDC_EDIT_MIN71, m_iMin71);
+	DDX_Text(pDX, IDC_EDIT_HOUR72, m_iHour72);
+	DDX_Text(pDX, IDC_EDIT_MIN72, m_iMin72);
+	DDX_Text(pDX, IDC_EDIT_HOUR81, m_iHour81);
+	DDX_Text(pDX, IDC_EDIT_MIN81, m_iMin81);
+	DDX_Text(pDX, IDC_EDIT_HOUR82, m_iHour82);
+	DDX_Text(pDX, IDC_EDIT_MIN82, m_iMin82);
+	DDX_Check(pDX, IDC_CHK_HIDE_ALARM_SHOW, m_bChkHideAlarmShow);
+	DDX_Check(pDX, IDC_CHK_HIDE_ALARM_SET, m_bChkHideAlarmSet);
+	DDX_Check(pDX, IDC_CHK_PIC_FTP, m_bChkPicFtp);
+    DDX_Check(pDX, IDC_CHK_PIC_CLOUD, m_bChkPicCloud);
+    DDX_Check(pDX, IDC_CHK_WIRELESS_SOUND_LIGHT_ALARM, m_bChkWirelessSoundLightAlarm);
+	//}}AFX_DATA_MAP
+
+}
+
+
+/*********************************************************
+Function:	BEGIN_MESSAGE_MAP
+Desc:		the map between control and function
+Input:	
+Output:	
+Return:	
+**********************************************************/
+BEGIN_MESSAGE_MAP(CDlgRemoteHideAlarm, CDialog)
+	//{{AFX_MSG_MAP(CDlgRemoteHideAlarm)	
+	ON_WM_LBUTTONDOWN()
+	ON_WM_MOUSEMOVE()
+	ON_BN_CLICKED(IDC_BTN_HIDE_ALARM_DAY_OK, OnBnClickedBtnHaDayOk)
+	ON_BN_CLICKED(IDC_CHK_HIDE_ALARM_SHOW, OnBnClickedChkHideAlarmShow)
+	ON_BN_CLICKED(IDC_CHK_HIDE_ALARM_SET, OnBnClickedChkHideAlarmSet)
+	ON_BN_CLICKED(ID_BTN_HIDE_ALARM_OK, OnBnClickedBtnHideAlarmOk)
+	ON_BN_CLICKED(ID_BTN_HIDE_ALARM_EXIT, OnBnClickedBtnHideAlarmExit)
+	ON_BN_CLICKED(IDC_CHK_HA_INVOKE_ALARM_OUT, OnBnClickedChkHaInvokeAlarmOut)
+	ON_BN_CLICKED(IDC_BTN_HA_DAY_COPY, OnBnClickedBtnHaDayCopy)
+	ON_CBN_SELCHANGE(IDC_COMBO_HA_WEEKDAY, OnCbnSelchangeComboHaWeekday)
+	ON_NOTIFY(NM_CLICK, IDC_TREE_ALARM_OUT, OnClickTreeAlarmOut)
+	ON_WM_PAINT()
+	ON_BN_CLICKED(IDC_BTN_SELECTALL, OnBtnSelectall)
+	//}}AFX_MSG_MAP
+END_MESSAGE_MAP()
+
+
+// CDlgRemoteHideAlarm message handlers
+/*********************************************************
+Function:	OnInitDialog
+Desc:		Initialize the dialog
+Input:	
+Output:	
+Return:	
+**********************************************************/
+BOOL CDlgRemoteHideAlarm::OnInitDialog() 
+{
+	CDialog::OnInitDialog();
+	m_picHideAlarm.MoveWindow(DETECT_AREA_LEFT,DETECT_AREA_TOP, 352, 288);
+
+	g_rectHideAlarmSetArea.left = g_lpHideAlarmV40->wHideAlarmAreaTopLeftX/2;
+	g_rectHideAlarmSetArea.top = g_lpHideAlarmV40->wHideAlarmAreaTopLeftY/2;
+	g_rectHideAlarmSetArea.bottom = (g_lpHideAlarmV40->wHideAlarmAreaTopLeftY + g_lpHideAlarmV40->wHideAlarmAreaHeight)/2;
+	g_rectHideAlarmSetArea.right = (g_lpHideAlarmV40->wHideAlarmAreaTopLeftX + g_lpHideAlarmV40->wHideAlarmAreaWidth)/2;
+	
+    GetHideHolidayHandle(m_struHideHolidayHandle);
+	NET_DVR_CLIENTINFO struPlayInfo;
+	struPlayInfo.hPlayWnd = m_picHideAlarm.GetSafeHwnd();
+	struPlayInfo.lChannel = m_iChanShowNum;
+	struPlayInfo.lLinkMode = 0;
+	struPlayInfo.sMultiCastIP = "";	 
+
+	m_lPlayHandle = NET_DVR_RealPlay(m_lLoginID, &struPlayInfo);	
+	if (m_lPlayHandle == -1)
+	{
+		char szLan[128] = {0};
+		g_StringLanType(szLan, "网络连接失败", "Network connection failure");
+		AfxMessageBox(szLan);
+	}	
+	m_bDrawdetect = FALSE;
+	m_bChkMonitorAlarm = g_lpHideAlarmV40->dwHandleType &0x01;
+	m_bChkAudioAlarm = (g_lpHideAlarmV40->dwHandleType>>1)&0x01;
+	m_bChkReportCenter = (g_lpHideAlarmV40->dwHandleType>>2)&0x01;
+	m_bChkInvokeAlarmOut = (g_lpHideAlarmV40->dwHandleType>>3)&0x01;
+	m_bChkInvokeJpegCapture = (g_lpHideAlarmV40->dwHandleType>>4)&0x01;
+	m_bChkEmapAlarmOut = (g_lpHideAlarmV40->dwHandleType>>6)&0x01;
+	m_bChkPicFtp = (g_lpHideAlarmV40->dwHandleType>>9)&0x01;
+    m_bChkPicCloud = (g_lpHideAlarmV40->dwHandleType >> 12) & 0x01;
+    m_bChkWirelessSoundLightAlarm = (g_lpHideAlarmV40->dwHandleType >> 5) & 0x01;
+	int i=0;
+// 	for (i=0; i<MAX_ALARMOUT_V30; i++)
+// 	{
+// 		m_bAlarmOut[i] = g_lpHideAlarm->strHideAlarmHandleType.byRelAlarmOut[i];
+// 	}
+	for(i =0; i < MAX_ALARMOUT_V40 ; i++)
+    {
+        m_pbAlarmOut[i] = FALSE; 
+    }
+    for (i=0; i< MAX_ALARMOUT_V40; i++)
+    {
+        if (g_lpHideAlarmV40->dwRelAlarmOut[i] != 0xffffffff)
+        {
+            m_pbAlarmOut[g_lpHideAlarmV40->dwRelAlarmOut[i]] = TRUE; 
+        }
+    }
+
+	m_treeAlarmOut.EnableWindow(m_bChkInvokeAlarmOut);
+
+	m_comboWeekday.SetCurSel(0);
+	m_comboDayCopy.SetCurSel(0);
+	m_iHour11 = g_lpHideAlarmV40->struAlarmTime[0][0].byStartHour;
+	m_iMin11 = g_lpHideAlarmV40->struAlarmTime[0][0].byStartMin;
+	m_iHour12 = g_lpHideAlarmV40->struAlarmTime[0][0].byStopHour;
+	m_iMin12 = g_lpHideAlarmV40->struAlarmTime[0][0].byStopMin;
+	m_iHour21 = g_lpHideAlarmV40->struAlarmTime[0][1].byStartHour;
+	m_iMin21 = g_lpHideAlarmV40->struAlarmTime[0][1].byStartMin;
+	m_iHour22 = g_lpHideAlarmV40->struAlarmTime[0][1].byStopHour;
+	m_iMin22 = g_lpHideAlarmV40->struAlarmTime[0][1].byStopMin;
+	m_iHour31 = g_lpHideAlarmV40->struAlarmTime[0][2].byStartHour;
+	m_iMin31 = g_lpHideAlarmV40->struAlarmTime[0][2].byStartMin;
+	m_iHour32 = g_lpHideAlarmV40->struAlarmTime[0][2].byStopHour;
+	m_iMin32 = g_lpHideAlarmV40->struAlarmTime[0][2].byStopMin;
+	m_iHour41 = g_lpHideAlarmV40->struAlarmTime[0][3].byStartHour;
+	m_iMin41 = g_lpHideAlarmV40->struAlarmTime[0][3].byStartMin;
+	m_iHour42 = g_lpHideAlarmV40->struAlarmTime[0][3].byStopHour;
+	m_iMin42 = g_lpHideAlarmV40->struAlarmTime[0][3].byStopMin;
+	m_iHour51 = g_lpHideAlarmV40->struAlarmTime[0][4].byStartHour;
+	m_iMin51 = g_lpHideAlarmV40->struAlarmTime[0][4].byStartMin;
+	m_iHour52 = g_lpHideAlarmV40->struAlarmTime[0][4].byStopHour;
+	m_iMin52 = g_lpHideAlarmV40->struAlarmTime[0][4].byStopMin;
+	m_iHour61 = g_lpHideAlarmV40->struAlarmTime[0][5].byStartHour;
+	m_iMin61 = g_lpHideAlarmV40->struAlarmTime[0][5].byStartMin;
+	m_iHour62 = g_lpHideAlarmV40->struAlarmTime[0][5].byStopHour;
+	m_iMin62 = g_lpHideAlarmV40->struAlarmTime[0][5].byStopMin;
+	m_iHour71 = g_lpHideAlarmV40->struAlarmTime[0][6].byStartHour;
+	m_iMin71 = g_lpHideAlarmV40->struAlarmTime[0][6].byStartMin;
+	m_iHour72 = g_lpHideAlarmV40->struAlarmTime[0][6].byStopHour;
+	m_iMin72 = g_lpHideAlarmV40->struAlarmTime[0][6].byStopMin;
+	m_iHour81 = g_lpHideAlarmV40->struAlarmTime[0][7].byStartHour;
+	m_iMin81 = g_lpHideAlarmV40->struAlarmTime[0][7].byStartMin;
+	m_iHour82 = g_lpHideAlarmV40->struAlarmTime[0][7].byStopHour;
+	m_iMin82 = g_lpHideAlarmV40->struAlarmTime[0][7].byStopMin;
+	GetDlgItem(IDC_CHK_HIDE_ALARM_SHOW)->EnableWindow(TRUE);
+	GetDlgItem(IDC_CHK_HIDE_ALARM_SET)->EnableWindow(TRUE);
+	if (g_lpHideAlarmV40->dwEnableHideAlarm > 0)
+	{
+		m_comboHideAlarmSensitive.SetCurSel(g_lpHideAlarmV40->dwEnableHideAlarm -1);
+	}
+	else
+	{
+		m_comboHideAlarmSensitive.SetCurSel(0);
+	}
+	UpdateData(FALSE);
+	return TRUE; 
+}
+
+/*********************************************************
+Function:	TimeTest
+Desc:		Time checking
+Input:	
+Output:	
+Return:		TRUE,Correct time table;FALSE,incorrect time table;
+**********************************************************/
+BOOL CDlgRemoteHideAlarm::TimeTest()
+{
+	int i = 0;
+	int j = 0;
+	WORD wStartTime[MAX_TIMESEGMENT_V30], wStopTime[MAX_TIMESEGMENT_V30];
+	char szLan[128] = {0};
+	UpdateData(TRUE);
+	if ((m_iHour11 < 0) || (m_iHour11 > 24) || (m_iHour12 < 0) || (m_iHour12 > 24) ||	\
+		(m_iHour21 < 0) || (m_iHour21 > 24) || (m_iHour22 < 0) || (m_iHour22 > 24) ||	\
+		(m_iHour31 < 0) || (m_iHour31 > 24) || (m_iHour32 < 0) || (m_iHour32 > 24) ||	\
+		(m_iHour41 < 0) || (m_iHour41 > 24) || (m_iHour42 < 0) || (m_iHour42 > 24) ||   \
+		(m_iHour51 < 0) || (m_iHour51 > 24) || (m_iHour52 < 0) || (m_iHour52 > 24) ||	\
+		(m_iHour61 < 0) || (m_iHour61 > 24) || (m_iHour62 < 0) || (m_iHour62 > 24) ||	\
+		(m_iHour71 < 0) || (m_iHour71 > 24) || (m_iHour72 < 0) || (m_iHour72 > 24) ||	\
+		(m_iHour81 < 0) || (m_iHour81 > 24) || (m_iHour82 < 0) || (m_iHour82 > 24))
+	{
+		g_StringLanType(szLan, "小时范围在0 -- 24之间", "Hour between 0 - 24 ");
+		AfxMessageBox(szLan);
+		return FALSE;
+	}
+	if ((m_iMin11 < 0) || (m_iMin11 > 60) || (m_iMin12 < 0) || (m_iMin12 > 60) ||	\
+		(m_iMin21 < 0) || (m_iMin21 > 60) || (m_iMin22 < 0) || (m_iMin22 > 60) ||	\
+		(m_iMin31 < 0) || (m_iMin31 > 60) || (m_iMin32 < 0) || (m_iMin32 > 60) ||	\
+		(m_iMin41 < 0) || (m_iMin41 > 60) || (m_iMin42 < 0) || (m_iMin42 > 60) ||   \
+		(m_iMin51 < 0) || (m_iMin51 > 60) || (m_iMin52 < 0) || (m_iMin52 > 60) ||	\
+		(m_iMin61 < 0) || (m_iMin61 > 60) || (m_iMin62 < 0) || (m_iMin62 > 60) ||	\
+		(m_iMin71 < 0) || (m_iMin71 > 60) || (m_iMin72 < 0) || (m_iMin72 > 60) ||	\
+		(m_iMin81 < 0) || (m_iMin81 > 60) || (m_iMin82 < 0) || (m_iMin82 > 60))
+	{
+		g_StringLanType(szLan, "分钟范围在0 -- 60之间", "Minute between 0 - 60 ");
+		AfxMessageBox(szLan);
+		return FALSE;
+	}
+	wStartTime[0] = (WORD)(m_iHour11 * 100 + m_iMin11);
+	wStartTime[1] = (WORD)(m_iHour21 * 100 + m_iMin21);
+	wStartTime[2] = (WORD)(m_iHour31 * 100 + m_iMin31);
+	wStartTime[3] = (WORD)(m_iHour41 * 100 + m_iMin41);
+	wStopTime[0] = (WORD)(m_iHour12 * 100 + m_iMin12);
+	wStopTime[1] = (WORD)(m_iHour22 * 100 + m_iMin22);
+	wStopTime[2] = (WORD)(m_iHour32 * 100 + m_iMin32);
+	wStopTime[3] = (WORD)(m_iHour42 * 100 + m_iMin42);
+	wStartTime[4] = (WORD)(m_iHour51 * 100 + m_iMin51);
+	wStartTime[5] = (WORD)(m_iHour61 * 100 + m_iMin61);
+	wStartTime[6] = (WORD)(m_iHour71 * 100 + m_iMin71);
+	wStartTime[7] = (WORD)(m_iHour81 * 100 + m_iMin81);
+	wStopTime[4] = (WORD)(m_iHour52 * 100 + m_iMin52);
+	wStopTime[5] = (WORD)(m_iHour62 * 100 + m_iMin62);
+	wStopTime[6] = (WORD)(m_iHour72 * 100 + m_iMin72);
+	wStopTime[7] = (WORD)(m_iHour82 * 100 + m_iMin82);
+	for (i = 0; i < MAX_TIMESEGMENT_V30; i++)
+	{
+		if ((wStartTime[i] > 2400) || (wStopTime[i] > 2400))
+		{
+			g_StringLanType(szLan, "布防时间不能超过24:00", "Fortify time can not be more than 24:00");
+			AfxMessageBox(szLan);
+			return FALSE;
+		}
+		if (wStartTime[i] > wStopTime[i])
+		{
+			g_StringLanType(szLan, "布防起始时间不能大于停止时间", "Fortify start time can not be larger than the record to stop time");
+			AfxMessageBox(szLan);
+			return FALSE;
+		}
+		for (j = 0; j < MAX_TIMESEGMENT_V30; j++)
+		{
+			if (i == j)
+			{
+				continue;
+			}
+			if ((wStartTime[i] > wStartTime[j]) && (wStartTime[i] < wStopTime[j]) ||	\
+				(wStopTime[i] > wStartTime[j]) && (wStopTime[i] < wStopTime[j]))
+			{
+				g_StringLanType(szLan, "时间段不能重复", "time can not be repeated");
+				AfxMessageBox(szLan);
+				return FALSE;
+			}
+		}
+	}
+	return TRUE;
+}
+
+/*********************************************************
+  Function:	OnLButtonDown
+  Desc:		select view tamper area recording
+  Input:	
+  Output:	
+  Return:	
+**********************************************************/
+void CDlgRemoteHideAlarm::OnLButtonDown(UINT nFlags, CPoint point) 
+{
+	if (m_bDrawdetect)
+	{
+		if (MK_CONTROL&nFlags)
+		{
+			NET_DVR_RigisterDrawFun(m_lPlayHandle, HideAlarmSetCallBack, 0);
+			point.x -= DETECT_AREA_LEFT;
+			point.y -= DETECT_AREA_TOP;
+			if (point.x < 0)
+			{
+				point.x = 0;
+			}
+			g_rectHideAlarmSetArea.left=point.x/16*16;
+			if (point.y < 0)
+			{
+				point.y = 0;
+			}
+			g_rectHideAlarmSetArea.top=point.y/16*16;
+			g_rectHideAlarmSetArea.right=g_rectHideAlarmSetArea.left;
+			g_rectHideAlarmSetArea.bottom=g_rectHideAlarmSetArea.top;
+			POINT tPoint=point;
+			g_rectHideAlarmShow.left=tPoint.x/16*16;
+			g_rectHideAlarmShow.top=tPoint.y/16*16;
+			g_rectHideAlarmShow.right=tPoint.x/16*16+1;
+			g_rectHideAlarmShow.bottom=tPoint.y/16*16+1;
+		}
+	}	
+	CDialog::OnLButtonDown(nFlags, point);
+}
+
+/*********************************************************
+  Function:	OnMouseMove
+  Desc:		select view tamper area recording
+  Input:	nFlags,function key status;point,mouse position
+  Output:	
+  Return:	
+**********************************************************/
+void CDlgRemoteHideAlarm::OnMouseMove(UINT nFlags, CPoint point) 
+{
+	// TODO: Add your message handler code here and/or call default
+	if (m_bDrawdetect)
+	{
+		if (MK_CONTROL&nFlags&&MK_LBUTTON&nFlags)
+		{
+			point.x -= DETECT_AREA_LEFT;
+			point.y -= DETECT_AREA_TOP;
+			if (point.x > 352)
+			{
+				point.x = 352;
+			}
+			g_rectHideAlarmSetArea.right=point.x/16*16;
+			if (point.y > 288)
+			{
+				point.y = 288;
+			}
+			g_rectHideAlarmSetArea.bottom=point.y/16*16;
+			POINT tPoint=point;
+			g_rectHideAlarmShow.right=tPoint.x/16*16;
+			g_rectHideAlarmShow.bottom=tPoint.y/16*16;
+		}
+	}	
+	CDialog::OnMouseMove(nFlags, point);
+}
+
+/*********************************************************
+Function:	OnBnClickedBtnAlarmInTimeOk
+Desc:		finish time table settings, check and update the time table on relative structure
+Input:	
+Output:	
+Return:	
+**********************************************************/
+void CDlgRemoteHideAlarm::OnBnClickedBtnHaDayOk()
+{
+	UpdateData(TRUE);
+	if (!TimeTest())
+	{
+		return;
+	}
+    int	i = m_comboWeekday.GetCurSel();	
+    if (7 == i)
+    {
+        m_struHideHolidayHandle.struAlarmTime[0].byStartHour = (BYTE)m_iHour11;
+        m_struHideHolidayHandle.struAlarmTime[0].byStartMin = (BYTE)m_iMin11;
+        m_struHideHolidayHandle.struAlarmTime[0].byStopHour = (BYTE)m_iHour12;
+        m_struHideHolidayHandle.struAlarmTime[0].byStopMin = (BYTE)m_iMin12;
+        m_struHideHolidayHandle.struAlarmTime[1].byStartHour = (BYTE)m_iHour21;
+        m_struHideHolidayHandle.struAlarmTime[1].byStartMin = (BYTE)m_iMin21;
+        m_struHideHolidayHandle.struAlarmTime[1].byStopHour = (BYTE)m_iHour22;
+        m_struHideHolidayHandle.struAlarmTime[1].byStopMin = (BYTE)m_iMin22;
+        m_struHideHolidayHandle.struAlarmTime[2].byStartHour = (BYTE)m_iHour31;
+        m_struHideHolidayHandle.struAlarmTime[2].byStartMin = (BYTE)m_iMin31;
+        m_struHideHolidayHandle.struAlarmTime[2].byStopHour = (BYTE)m_iHour32;
+        m_struHideHolidayHandle.struAlarmTime[2].byStopMin = (BYTE)m_iMin32;
+        m_struHideHolidayHandle.struAlarmTime[3].byStartHour = (BYTE)m_iHour41;
+        m_struHideHolidayHandle.struAlarmTime[3].byStartMin = (BYTE)m_iMin41;
+        m_struHideHolidayHandle.struAlarmTime[3].byStopHour = (BYTE)m_iHour42;
+        m_struHideHolidayHandle.struAlarmTime[3].byStopMin = (BYTE)m_iMin42;
+        m_struHideHolidayHandle.struAlarmTime[4].byStartHour = (BYTE)m_iHour51;
+        m_struHideHolidayHandle.struAlarmTime[4].byStartMin = (BYTE)m_iMin51;
+        m_struHideHolidayHandle.struAlarmTime[4].byStopHour = (BYTE)m_iHour52;
+        m_struHideHolidayHandle.struAlarmTime[4].byStopMin = (BYTE)m_iMin52;
+        m_struHideHolidayHandle.struAlarmTime[5].byStartHour = (BYTE)m_iHour61;
+        m_struHideHolidayHandle.struAlarmTime[5].byStartMin = (BYTE)m_iMin61;
+        m_struHideHolidayHandle.struAlarmTime[5].byStopHour = (BYTE)m_iHour62;
+        m_struHideHolidayHandle.struAlarmTime[5].byStopMin = (BYTE)m_iMin62;
+        m_struHideHolidayHandle.struAlarmTime[6].byStartHour = (BYTE)m_iHour71;
+        m_struHideHolidayHandle.struAlarmTime[6].byStartMin = (BYTE)m_iMin71;
+        m_struHideHolidayHandle.struAlarmTime[6].byStopHour = (BYTE)m_iHour72;
+        m_struHideHolidayHandle.struAlarmTime[6].byStopMin = (BYTE)m_iMin72;
+        m_struHideHolidayHandle.struAlarmTime[7].byStartHour = (BYTE)m_iHour81;
+        m_struHideHolidayHandle.struAlarmTime[7].byStartMin = (BYTE)m_iMin81;
+        m_struHideHolidayHandle.struAlarmTime[7].byStopHour = (BYTE)m_iHour82;
+        m_struHideHolidayHandle.struAlarmTime[7].byStopMin = (BYTE)m_iMin82;
+        if (!SetHideHolidayHandle(m_struHideHolidayHandle))
+        {
+            AfxMessageBox("Fail to set holiday handle");
+        }
+    }
+    else
+    {
+        g_lpHideAlarmV40->struAlarmTime[i][0].byStartHour = (BYTE)m_iHour11;
+	    g_lpHideAlarmV40->struAlarmTime[i][0].byStartMin = (BYTE)m_iMin11;
+	    g_lpHideAlarmV40->struAlarmTime[i][0].byStopHour = (BYTE)m_iHour12;
+	    g_lpHideAlarmV40->struAlarmTime[i][0].byStopMin = (BYTE)m_iMin12;
+	    g_lpHideAlarmV40->struAlarmTime[i][1].byStartHour = (BYTE)m_iHour21;
+	    g_lpHideAlarmV40->struAlarmTime[i][1].byStartMin = (BYTE)m_iMin21;
+	    g_lpHideAlarmV40->struAlarmTime[i][1].byStopHour = (BYTE)m_iHour22;
+	    g_lpHideAlarmV40->struAlarmTime[i][1].byStopMin = (BYTE)m_iMin22;
+	    g_lpHideAlarmV40->struAlarmTime[i][2].byStartHour = (BYTE)m_iHour31;
+	    g_lpHideAlarmV40->struAlarmTime[i][2].byStartMin = (BYTE)m_iMin31;
+	    g_lpHideAlarmV40->struAlarmTime[i][2].byStopHour = (BYTE)m_iHour32;
+	    g_lpHideAlarmV40->struAlarmTime[i][2].byStopMin = (BYTE)m_iMin32;
+	    g_lpHideAlarmV40->struAlarmTime[i][3].byStartHour = (BYTE)m_iHour41;
+	    g_lpHideAlarmV40->struAlarmTime[i][3].byStartMin = (BYTE)m_iMin41;
+	    g_lpHideAlarmV40->struAlarmTime[i][3].byStopHour = (BYTE)m_iHour42;
+	    g_lpHideAlarmV40->struAlarmTime[i][3].byStopMin = (BYTE)m_iMin42;
+	    g_lpHideAlarmV40->struAlarmTime[i][4].byStartHour = (BYTE)m_iHour51;
+	    g_lpHideAlarmV40->struAlarmTime[i][4].byStartMin = (BYTE)m_iMin51;
+	    g_lpHideAlarmV40->struAlarmTime[i][4].byStopHour = (BYTE)m_iHour52;
+	    g_lpHideAlarmV40->struAlarmTime[i][4].byStopMin = (BYTE)m_iMin52;
+	    g_lpHideAlarmV40->struAlarmTime[i][5].byStartHour = (BYTE)m_iHour61;
+	    g_lpHideAlarmV40->struAlarmTime[i][5].byStartMin = (BYTE)m_iMin61;
+	    g_lpHideAlarmV40->struAlarmTime[i][5].byStopHour = (BYTE)m_iHour62;
+	    g_lpHideAlarmV40->struAlarmTime[i][5].byStopMin = (BYTE)m_iMin62;
+	    g_lpHideAlarmV40->struAlarmTime[i][6].byStartHour = (BYTE)m_iHour71;
+	    g_lpHideAlarmV40->struAlarmTime[i][6].byStartMin = (BYTE)m_iMin71;
+	    g_lpHideAlarmV40->struAlarmTime[i][6].byStopHour = (BYTE)m_iHour72;
+	    g_lpHideAlarmV40->struAlarmTime[i][6].byStopMin = (BYTE)m_iMin72;
+	    g_lpHideAlarmV40->struAlarmTime[i][7].byStartHour = (BYTE)m_iHour81;
+	    g_lpHideAlarmV40->struAlarmTime[i][7].byStartMin = (BYTE)m_iMin81;
+	    g_lpHideAlarmV40->struAlarmTime[i][7].byStopHour = (BYTE)m_iHour82;
+	    g_lpHideAlarmV40->struAlarmTime[i][7].byStopMin = (BYTE)m_iMin82;
+    }
+	GetDlgItem(IDC_COMBO_HIDE_ALARM_DAY_COPY)->EnableWindow(TRUE);
+}
+
+/*********************************************************
+  Function:	OnBnClickedChkHideAlarmShow
+  Desc:		View Tampler Area display
+  Input:	
+  Output:	
+  Return:	
+**********************************************************/
+void CDlgRemoteHideAlarm::OnBnClickedChkHideAlarmShow()
+{
+	if (m_lPlayHandle < 0)
+	{
+		return;
+	}
+	UpdateData(TRUE);
+	if (m_bChkHideAlarmSet)
+	{
+		m_bChkHideAlarmSet = FALSE;
+		m_bDrawdetect = FALSE;
+		UpdateData(FALSE);
+		GetDlgItem(ID_BTN_HIDE_ALARM_OK)->EnableWindow(FALSE);
+	}
+	if (m_bChkHideAlarmShow)
+	{
+		NET_DVR_RigisterDrawFun(m_lPlayHandle,NULL, 0);
+		Sleep(200);
+		NET_DVR_RigisterDrawFun(m_lPlayHandle,HideAlarmGetCallBack, 0);
+	}
+	else
+	{
+		NET_DVR_RigisterDrawFun(m_lPlayHandle,NULL, 0);
+	}
+}
+
+/*********************************************************
+  Function:	OnBnClickedChkHideAlarmSet
+  Desc:		Set view tamper area
+  Input:	
+  Output:	
+  Return:	
+**********************************************************/
+void CDlgRemoteHideAlarm::OnBnClickedChkHideAlarmSet()
+{
+	if (m_lPlayHandle < 0)
+	{
+		return;
+	}
+	UpdateData(TRUE);
+	if (m_bChkHideAlarmShow)
+	{
+		m_bChkHideAlarmShow = FALSE;
+		UpdateData(FALSE);
+	}
+	if (m_bChkHideAlarmSet)
+	{
+		NET_DVR_RigisterDrawFun(m_lPlayHandle,NULL,0);
+		m_bDrawdetect = TRUE;
+		GetDlgItem(ID_BTN_HIDE_ALARM_OK)->EnableWindow(TRUE);
+	}
+	else
+	{
+		m_bDrawdetect = FALSE;
+		NET_DVR_RigisterDrawFun(m_lPlayHandle,NULL,0);
+		GetDlgItem(ID_BTN_HIDE_ALARM_OK)->EnableWindow(FALSE);
+	}
+}
+
+/*********************************************************
+Function:	OnBnClickedBtnHideAlarmOk
+Desc:		finish time table settings, check and update the time table on relative structure
+Input:	
+Output:	
+Return:	
+**********************************************************/
+void CDlgRemoteHideAlarm::OnBnClickedBtnHideAlarmOk()
+{
+	UpdateData(TRUE);
+	if (!TimeTest())
+	{
+		return;
+	}
+	int	i = m_comboWeekday.GetCurSel();	
+	g_lpHideAlarmV40->struAlarmTime[i][0].byStartHour = (BYTE)m_iHour11;
+	g_lpHideAlarmV40->struAlarmTime[i][0].byStartMin = (BYTE)m_iMin11;
+	g_lpHideAlarmV40->struAlarmTime[i][0].byStopHour = (BYTE)m_iHour12;
+	g_lpHideAlarmV40->struAlarmTime[i][0].byStopMin = (BYTE)m_iMin12;
+	g_lpHideAlarmV40->struAlarmTime[i][1].byStartHour = (BYTE)m_iHour21;
+	g_lpHideAlarmV40->struAlarmTime[i][1].byStartMin = (BYTE)m_iMin21;
+	g_lpHideAlarmV40->struAlarmTime[i][1].byStopHour = (BYTE)m_iHour22;
+	g_lpHideAlarmV40->struAlarmTime[i][1].byStopMin = (BYTE)m_iMin22;
+	g_lpHideAlarmV40->struAlarmTime[i][2].byStartHour = (BYTE)m_iHour31;
+	g_lpHideAlarmV40->struAlarmTime[i][2].byStartMin = (BYTE)m_iMin31;
+	g_lpHideAlarmV40->struAlarmTime[i][2].byStopHour = (BYTE)m_iHour32;
+	g_lpHideAlarmV40->struAlarmTime[i][2].byStopMin = (BYTE)m_iMin32;
+	g_lpHideAlarmV40->struAlarmTime[i][3].byStartHour = (BYTE)m_iHour41;
+	g_lpHideAlarmV40->struAlarmTime[i][3].byStartMin = (BYTE)m_iMin41;
+	g_lpHideAlarmV40->struAlarmTime[i][3].byStopHour = (BYTE)m_iHour42;
+	g_lpHideAlarmV40->struAlarmTime[i][3].byStopMin = (BYTE)m_iMin42;
+
+	g_lpHideAlarmV40->struAlarmTime[i][4].byStartHour = (BYTE)m_iHour51;
+	g_lpHideAlarmV40->struAlarmTime[i][4].byStartMin = (BYTE)m_iMin51;
+	g_lpHideAlarmV40->struAlarmTime[i][4].byStopHour = (BYTE)m_iHour52;
+	g_lpHideAlarmV40->struAlarmTime[i][4].byStopMin = (BYTE)m_iMin52;
+	g_lpHideAlarmV40->struAlarmTime[i][5].byStartHour = (BYTE)m_iHour61;
+	g_lpHideAlarmV40->struAlarmTime[i][5].byStartMin = (BYTE)m_iMin61;
+	g_lpHideAlarmV40->struAlarmTime[i][5].byStopHour = (BYTE)m_iHour62;
+	g_lpHideAlarmV40->struAlarmTime[i][5].byStopMin = (BYTE)m_iMin62;
+	g_lpHideAlarmV40->struAlarmTime[i][6].byStartHour = (BYTE)m_iHour71;
+	g_lpHideAlarmV40->struAlarmTime[i][6].byStartMin = (BYTE)m_iMin71;
+	g_lpHideAlarmV40->struAlarmTime[i][6].byStopHour = (BYTE)m_iHour72;
+	g_lpHideAlarmV40->struAlarmTime[i][6].byStopMin = (BYTE)m_iMin72;
+	g_lpHideAlarmV40->struAlarmTime[i][7].byStartHour = (BYTE)m_iHour81;
+	g_lpHideAlarmV40->struAlarmTime[i][7].byStartMin = (BYTE)m_iMin81;
+	g_lpHideAlarmV40->struAlarmTime[i][7].byStopHour = (BYTE)m_iHour82;
+	g_lpHideAlarmV40->struAlarmTime[i][7].byStopMin = (BYTE)m_iMin82;
+	if (g_rectHideAlarmSetArea.top <= g_rectHideAlarmSetArea.bottom)
+	{
+		if (g_rectHideAlarmSetArea.left <= g_rectHideAlarmSetArea.right)
+		{
+			g_lpHideAlarmV40->wHideAlarmAreaHeight = (WORD)((g_rectHideAlarmSetArea.bottom-g_rectHideAlarmSetArea.top)*2);
+			g_lpHideAlarmV40->wHideAlarmAreaWidth = (WORD)((g_rectHideAlarmSetArea.right-g_rectHideAlarmSetArea.left)*2);
+			g_lpHideAlarmV40->wHideAlarmAreaTopLeftX = (WORD)(g_rectHideAlarmSetArea.left*2);
+			g_lpHideAlarmV40->wHideAlarmAreaTopLeftY = (WORD)(g_rectHideAlarmSetArea.top*2);
+		}
+		else
+		{
+			g_lpHideAlarmV40->wHideAlarmAreaHeight = (WORD)((g_rectHideAlarmSetArea.bottom-g_rectHideAlarmSetArea.top)*2);
+			g_lpHideAlarmV40->wHideAlarmAreaWidth = (WORD)((g_rectHideAlarmSetArea.left-g_rectHideAlarmSetArea.right)*2);
+			g_lpHideAlarmV40->wHideAlarmAreaTopLeftX = (WORD)(g_rectHideAlarmSetArea.right*2);
+			g_lpHideAlarmV40->wHideAlarmAreaTopLeftY = (WORD)(g_rectHideAlarmSetArea.top*2);
+		}	
+	}
+	else
+	{
+		if (g_rectHideAlarmSetArea.left <= g_rectHideAlarmSetArea.right)
+		{
+			g_lpHideAlarmV40->wHideAlarmAreaHeight = (WORD)((g_rectHideAlarmSetArea.top-g_rectHideAlarmSetArea.bottom)*2);
+			g_lpHideAlarmV40->wHideAlarmAreaWidth = (WORD)((g_rectHideAlarmSetArea.right-g_rectHideAlarmSetArea.left)*2);
+			g_lpHideAlarmV40->wHideAlarmAreaTopLeftX = (WORD)(g_rectHideAlarmSetArea.left*2);
+			g_lpHideAlarmV40->wHideAlarmAreaTopLeftY = (WORD)(g_rectHideAlarmSetArea.bottom*2);
+		}
+		else
+		{
+			g_lpHideAlarmV40->wHideAlarmAreaHeight = (WORD)((g_rectHideAlarmSetArea.top-g_rectHideAlarmSetArea.bottom)*2);
+			g_lpHideAlarmV40->wHideAlarmAreaWidth = (WORD)((g_rectHideAlarmSetArea.left-g_rectHideAlarmSetArea.right)*2);
+			g_lpHideAlarmV40->wHideAlarmAreaTopLeftX = (WORD)(g_rectHideAlarmSetArea.right*2);
+			g_lpHideAlarmV40->wHideAlarmAreaTopLeftY = (WORD)(g_rectHideAlarmSetArea.bottom*2);
+		}
+	}
+	g_lpHideAlarmV40->dwEnableHideAlarm = m_comboHideAlarmSensitive.GetCurSel()+1;	
+
+	g_lpHideAlarmV40->dwHandleType = 0;
+	g_lpHideAlarmV40->dwHandleType |= (m_bChkMonitorAlarm << 0);
+	g_lpHideAlarmV40->dwHandleType |= (m_bChkAudioAlarm << 1);
+	g_lpHideAlarmV40->dwHandleType |= (m_bChkReportCenter << 2);
+	g_lpHideAlarmV40->dwHandleType |= (m_bChkInvokeAlarmOut << 3);
+	g_lpHideAlarmV40->dwHandleType |= (m_bChkInvokeJpegCapture <<4);
+	g_lpHideAlarmV40->dwHandleType |= (m_bChkEmapAlarmOut<<6);
+	g_lpHideAlarmV40->dwHandleType |= (m_bChkPicFtp << 9);
+    g_lpHideAlarmV40->dwHandleType |= (m_bChkPicCloud << 12);
+    g_lpHideAlarmV40->dwHandleType |= (m_bChkWirelessSoundLightAlarm << 5);
+// 	for (i=0; i<MAX_ALARMOUT_V30; i++)
+// 	{
+// 		g_lpHideAlarm->strHideAlarmHandleType.byRelAlarmOut[i] = (BYTE)m_bAlarmOut[i];
+// 	}
+	memset(g_lpHideAlarmV40->dwRelAlarmOut, 0xffffffff, sizeof(DWORD)*MAX_ALARMOUT_V40);
+	DWORD dwRelAlarmOutChanNum = 0;
+    for (i=0; i<MAX_ALARMOUT_V40; i++)
+    {
+        if (TRUE == m_pbAlarmOut[i])
+        {
+            g_lpHideAlarmV40->dwRelAlarmOut[dwRelAlarmOutChanNum++] = i;
+        }
+	}
+}
+
+/*********************************************************
+  Function:	OnBnClickedBtnHideAlarmExit
+  Desc:		cancle view tamper area settings
+  Input:	
+  Output:	
+  Return:	
+**********************************************************/
+void CDlgRemoteHideAlarm::OnBnClickedBtnHideAlarmExit()
+{
+	if (m_lPlayHandle >= 0)
+	{
+		NET_DVR_RigisterDrawFun(m_lPlayHandle,NULL, 0);
+		NET_DVR_StopRealPlay(m_lPlayHandle);
+		m_lPlayHandle = -1;
+	}
+	CDialog::OnOK();
+}
+
+/*********************************************************
+  Function:	OnBnClickedChkHaInvokeAlarmOut
+  Desc:		trigger alarm output
+  Input:	
+  Output:	
+  Return:	
+**********************************************************/
+void CDlgRemoteHideAlarm::OnBnClickedChkHaInvokeAlarmOut()
+{
+	UpdateData(TRUE);
+	m_treeAlarmOut.EnableWindow(m_bChkInvokeAlarmOut);
+}
+
+/*********************************************************
+  Function:	OnBnClickedBtnHaDayCopy
+  Desc:		copy time schedule to certain date
+  Input:	
+  Output:	
+  Return:	
+**********************************************************/
+void CDlgRemoteHideAlarm::OnBnClickedBtnHaDayCopy()
+{
+	UpdateData(TRUE);
+	int j,k;
+	int i = m_comboWeekday.GetCurSel();
+	int m_nCopyTime = m_comboDayCopy.GetCurSel() - 1;
+
+	if (m_nCopyTime == -1)
+	{
+		for (j=0; j<MAX_DAYS; j++)
+		{
+			if (j == i)
+			{
+				continue;
+			}
+			for (k=0; k<MAX_TIMESEGMENT_V30; k++)
+			{
+				memcpy(&(g_lpHideAlarmV40->struAlarmTime[j][k]), &(g_lpHideAlarmV40->struAlarmTime[i][k]), sizeof(NET_DVR_SCHEDTIME));
+			}
+		}
+	}
+    else if (m_nCopyTime == 7)
+    {
+        for (k = 0; k < MAX_TIMESEGMENT_V30; k++)
+        {
+            memcpy(&m_struHideHolidayHandle.struAlarmTime[k], &g_lpHideAlarmV40->struAlarmTime[i][k], sizeof(NET_DVR_SCHEDTIME));
+        }
+        if (!SetHideHolidayHandle(m_struHideHolidayHandle))
+        {
+            AfxMessageBox("Fail to set holiday handle");
+        }
+    }
+	else
+	{
+		for (k=0; k<MAX_TIMESEGMENT_V30; k++)
+		{
+			memcpy(&(g_lpHideAlarmV40->struAlarmTime[m_nCopyTime][k]), &(g_lpHideAlarmV40->struAlarmTime[i][k]), sizeof(NET_DVR_SCHEDTIME));
+		}
+	}
+}
+
+/*********************************************************
+  Function:	OnCbnSelchangeComboHaWeekday
+  Desc:		select time schedule 
+  Input:	
+  Output:	
+  Return:	
+**********************************************************/
+void CDlgRemoteHideAlarm::OnCbnSelchangeComboHaWeekday()
+{
+	UpdateData(TRUE);
+	int	i = m_comboWeekday.GetCurSel();	
+    if (7 == i) // 假日布防时间段
+    {
+        m_iHour11 = m_struHideHolidayHandle.struAlarmTime[0].byStartHour;
+        m_iMin11 = m_struHideHolidayHandle.struAlarmTime[0].byStartMin;
+        m_iHour12 = m_struHideHolidayHandle.struAlarmTime[0].byStopHour;
+        m_iMin12 = m_struHideHolidayHandle.struAlarmTime[0].byStopMin;
+        m_iHour21 = m_struHideHolidayHandle.struAlarmTime[1].byStartHour;
+        m_iMin21 = m_struHideHolidayHandle.struAlarmTime[1].byStartMin;
+        m_iHour22 = m_struHideHolidayHandle.struAlarmTime[1].byStopHour;
+        m_iMin22 = m_struHideHolidayHandle.struAlarmTime[1].byStopMin;
+        m_iHour31 = m_struHideHolidayHandle.struAlarmTime[2].byStartHour;
+        m_iMin31 = m_struHideHolidayHandle.struAlarmTime[2].byStartMin;
+        m_iHour32 = m_struHideHolidayHandle.struAlarmTime[2].byStopHour;
+        m_iMin32 = m_struHideHolidayHandle.struAlarmTime[2].byStopMin;
+        m_iHour41 = m_struHideHolidayHandle.struAlarmTime[3].byStartHour;
+        m_iMin41 = m_struHideHolidayHandle.struAlarmTime[3].byStartMin;
+        m_iHour42 = m_struHideHolidayHandle.struAlarmTime[3].byStopHour;
+        m_iMin42 = m_struHideHolidayHandle.struAlarmTime[3].byStopMin;
+        m_iHour51 = m_struHideHolidayHandle.struAlarmTime[4].byStartHour;
+        m_iMin51 = m_struHideHolidayHandle.struAlarmTime[4].byStartMin;
+        m_iHour52 = m_struHideHolidayHandle.struAlarmTime[4].byStopHour;
+        m_iMin52 = m_struHideHolidayHandle.struAlarmTime[4].byStopMin;
+        m_iHour61 = m_struHideHolidayHandle.struAlarmTime[5].byStartHour;
+        m_iMin61 = m_struHideHolidayHandle.struAlarmTime[5].byStartMin;
+        m_iHour62 = m_struHideHolidayHandle.struAlarmTime[5].byStopHour;
+        m_iMin62 = m_struHideHolidayHandle.struAlarmTime[5].byStopMin;
+        m_iHour71 = m_struHideHolidayHandle.struAlarmTime[6].byStartHour;
+        m_iMin71 = m_struHideHolidayHandle.struAlarmTime[6].byStartMin;
+        m_iHour72 = m_struHideHolidayHandle.struAlarmTime[6].byStopHour;
+        m_iMin72 = m_struHideHolidayHandle.struAlarmTime[6].byStopMin;
+        m_iHour81 = m_struHideHolidayHandle.struAlarmTime[7].byStartHour;
+        m_iMin81 = m_struHideHolidayHandle.struAlarmTime[7].byStartMin;
+        m_iHour82 = m_struHideHolidayHandle.struAlarmTime[7].byStopHour;
+        m_iMin82 = m_struHideHolidayHandle.struAlarmTime[7].byStopMin;
+    }
+    else
+    {
+        m_iHour11 = g_lpHideAlarmV40->struAlarmTime[i][0].byStartHour;
+        m_iMin11 = g_lpHideAlarmV40->struAlarmTime[i][0].byStartMin;
+        m_iHour12 = g_lpHideAlarmV40->struAlarmTime[i][0].byStopHour;
+        m_iMin12 = g_lpHideAlarmV40->struAlarmTime[i][0].byStopMin;
+        m_iHour21 = g_lpHideAlarmV40->struAlarmTime[i][1].byStartHour;
+        m_iMin21 = g_lpHideAlarmV40->struAlarmTime[i][1].byStartMin;
+        m_iHour22 = g_lpHideAlarmV40->struAlarmTime[i][1].byStopHour;
+        m_iMin22 = g_lpHideAlarmV40->struAlarmTime[i][1].byStopMin;
+        m_iHour31 = g_lpHideAlarmV40->struAlarmTime[i][2].byStartHour;
+        m_iMin31 = g_lpHideAlarmV40->struAlarmTime[i][2].byStartMin;
+        m_iHour32 = g_lpHideAlarmV40->struAlarmTime[i][2].byStopHour;
+        m_iMin32 = g_lpHideAlarmV40->struAlarmTime[i][2].byStopMin;
+        m_iHour41 = g_lpHideAlarmV40->struAlarmTime[i][3].byStartHour;
+        m_iMin41 = g_lpHideAlarmV40->struAlarmTime[i][3].byStartMin;
+        m_iHour42 = g_lpHideAlarmV40->struAlarmTime[i][3].byStopHour;
+        m_iMin42 = g_lpHideAlarmV40->struAlarmTime[i][3].byStopMin;
+        m_iHour51 = g_lpHideAlarmV40->struAlarmTime[i][4].byStartHour;
+        m_iMin51 = g_lpHideAlarmV40->struAlarmTime[i][4].byStartMin;
+        m_iHour52 = g_lpHideAlarmV40->struAlarmTime[i][4].byStopHour;
+        m_iMin52 = g_lpHideAlarmV40->struAlarmTime[i][4].byStopMin;
+        m_iHour61 = g_lpHideAlarmV40->struAlarmTime[i][5].byStartHour;
+        m_iMin61 = g_lpHideAlarmV40->struAlarmTime[i][5].byStartMin;
+        m_iHour62 = g_lpHideAlarmV40->struAlarmTime[i][5].byStopHour;
+        m_iMin62 = g_lpHideAlarmV40->struAlarmTime[i][5].byStopMin;
+        m_iHour71 = g_lpHideAlarmV40->struAlarmTime[i][6].byStartHour;
+        m_iMin71 = g_lpHideAlarmV40->struAlarmTime[i][6].byStartMin;
+        m_iHour72 = g_lpHideAlarmV40->struAlarmTime[i][6].byStopHour;
+        m_iMin72 = g_lpHideAlarmV40->struAlarmTime[i][6].byStopMin;
+        m_iHour81 = g_lpHideAlarmV40->struAlarmTime[i][7].byStartHour;
+        m_iMin81 = g_lpHideAlarmV40->struAlarmTime[i][7].byStartMin;
+        m_iHour82 = g_lpHideAlarmV40->struAlarmTime[i][7].byStopHour;
+        m_iMin82 = g_lpHideAlarmV40->struAlarmTime[i][7].byStopMin;
+    }
+	UpdateData(FALSE);
+}
+
+
+/*********************************************************
+  Function:	CreateTree
+  Desc:		Create connection between alarm output-channel 
+  Input:	
+  Output:	
+  Return:	
+**********************************************************/
+void CDlgRemoteHideAlarm::CreateTree(void)
+{
+	g_CreateAlarmOutTree(m_treeAlarmOut, m_dwDevIndex, m_pbAlarmOut);
+}
+
+/*********************************************************
+  Function:	OnClickTreeAlarmOut
+  Desc:		select the alarm out channel
+  Input:	none
+  Output:	none
+  Return:	none
+**********************************************************/
+void CDlgRemoteHideAlarm::OnClickTreeAlarmOut(NMHDR* pNMHDR, LRESULT* pResult) 
+{
+	UpdateData(TRUE);
+	CPoint pt(0,0);
+	CRect rc(0,0,0,0);
+	GetCursorPos(&pt);
+	GetDlgItem(IDC_TREE_ALARM_OUT)->GetWindowRect(&rc);
+	ScreenToClient(&rc);
+	ScreenToClient(&pt);
+	pt.x = pt.x - rc.left;
+	pt.y = pt.y - rc.top;
+
+	UINT uFlag = 0;
+	HTREEITEM hSelect = m_treeAlarmOut.HitTest(pt, &uFlag);
+
+	if (NULL == hSelect) 
+	{
+		return;
+	}
+	m_treeAlarmOut.SelectItem(hSelect);
+	DWORD dwIndex = m_treeAlarmOut.GetItemData(hSelect)%1000;
+	BOOL bCheck = m_treeAlarmOut.GetCheck(hSelect);
+	m_pbAlarmOut[dwIndex] = !bCheck;
+	//switch checkbox status on click
+	if (uFlag != LVHT_TOLEFT)
+	{
+		m_treeAlarmOut.SetCheck(hSelect, !bCheck);
+	}
+	else
+	{
+		m_treeAlarmOut.SetCheck(hSelect, bCheck);
+	}
+
+	*pResult = 0;
+}
+
+/*********************************************************
+  Function:	OnPaint
+  Desc:		need to draw the alarm out channel when paint
+  Input:	none
+  Output:	none
+  Return:	none
+**********************************************************/
+void CDlgRemoteHideAlarm::OnPaint() 
+{
+	 CreateTree();
+	 CDialog::OnPaint();
+	 // Do not call CDialog::OnPaint() for painting messages
+}
+
+BOOL CDlgRemoteHideAlarm::GetHideHolidayHandle(NET_DVR_HOLIDAY_HANDLE &struHolidayHandle)
+{
+    DWORD dwReturn = 0;
+    if (NET_DVR_GetDVRConfig(m_lLoginID, NET_DVR_GET_HIDE_HOLIDAY_HANDLE, m_iChanShowNum, &struHolidayHandle, sizeof(struHolidayHandle), &dwReturn))
+    {
+        g_pMainDlg->AddLog(m_dwDevIndex, OPERATION_SUCC_T, "NET_DVR_GET_HIDE_HILIDAY_HANDLE");
+        return TRUE;
+    }
+    else
+    {
+        g_pMainDlg->AddLog(m_dwDevIndex, OPERATION_FAIL_T, "NET_DVR_GET_HIDE_HILIDAY_HANDLE");
+        return FALSE;
+    }
+}
+
+BOOL CDlgRemoteHideAlarm::SetHideHolidayHandle(NET_DVR_HOLIDAY_HANDLE &struHolidayHandle)
+{
+    if (NET_DVR_SetDVRConfig(m_lLoginID, NET_DVR_SET_HIDE_HOLIDAY_HANDLE, m_iChanShowNum, &struHolidayHandle, sizeof(struHolidayHandle)))
+    {
+        g_pMainDlg->AddLog(m_dwDevIndex, OPERATION_SUCC_T, "NET_DVR_SET_HIDE_HILIDAY_HANDLE");
+        return TRUE;
+    }
+    else
+    {
+        g_pMainDlg->AddLog(m_dwDevIndex, OPERATION_FAIL_T, "NET_DVR_SET_HIDE_HILIDAY_HANDLE");
+        return FALSE;
+    }
+}
+
+void CDlgRemoteHideAlarm::OnBtnSelectall() 
+{
+	// TODO: Add your control notification handler code here
+    
+    CString struAlarmOutText = "";
+    DWORD dwID = 0;
+    char szLan[1024] = {0};
+    char szLanCn[1024] = {0};
+    char szLanEn[1024] = {0};
+
+    GetDlgItem(IDC_BTN_SELECTALL)->GetWindowText(struAlarmOutText);
+
+
+    if( (struAlarmOutText.Find("全选") != -1) ||  (struAlarmOutText.Find("Sel All") != -1))
+    {
+        memcpy(szLanCn,"全不选",strlen("全不选"));
+        memcpy(szLanEn,"Uncheck All",strlen("Uncheck All"));
+        
+        g_StringLanType(szLan, szLanCn, szLanEn);
+
+        for (int i  = 0; i < MAX_ALARMOUT_V40 ; i++ )
+        {
+            if ((i <  g_struDeviceInfo[m_dwDevIndex].iAlarmOutNum))
+            {                
+                m_pbAlarmOut[i] = 1;
+            }
+            else if (i >= MAX_ANALOG_ALARMOUT)
+            {
+                dwID = g_struDeviceInfo[m_dwDevIndex].pStruIPAlarmOutCfgV40->struIPAlarmOutInfo[i-MAX_ANALOG_ALARMOUT].dwIPID;
+                if (dwID != 0)
+                {
+                    m_pbAlarmOut[i] = 1;
+                }
+                
+            }
+            
+        }     
+    }
+    else   
+    {
+        memcpy(szLanCn,"全选",strlen("全选"));
+        memcpy(szLanEn,"Sel All",strlen("Sel All"));
+        
+        g_StringLanType(szLan, szLanCn, szLanEn);
+        
+        
+        for (int i  = 0; i < MAX_ALARMOUT_V40 ; i++ )
+        {
+            m_pbAlarmOut[i] = 0;
+        }
+    }    
+    GetDlgItem(IDC_BTN_SELECTALL)->SetWindowText(szLan);	
+    CreateTree();
+}

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgSignalLightSync.h

@@ -0,0 +1,51 @@
+#if !defined(AFX_DLGSIGNALLIGHTSYNC_H__0904CEC1_2BC7_4EC5_9DC7_1FC963795251__INCLUDED_)
+#define AFX_DLGSIGNALLIGHTSYNC_H__0904CEC1_2BC7_4EC5_9DC7_1FC963795251__INCLUDED_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif // _MSC_VER > 1000
+// DlgSignalLightSync.h : header file
+//
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgSignalLightSync dialog
+
+class CDlgSignalLightSync : public CDialog
+{
+// Construction
+public:
+	long m_iCurChanNO;
+	long m_lUserID;
+	CDlgSignalLightSync(CWnd* pParent = NULL);   // standard constructor
+
+// Dialog Data
+	//{{AFX_DATA(CDlgSignalLightSync)
+	enum { IDD = IDD_DLG_SIGNALLIGHT_SYNC };
+	CComboBox	m_cbLinkLock;
+	int	m_wPhase;
+	//}}AFX_DATA
+
+
+// Overrides
+	// ClassWizard generated virtual function overrides
+	//{{AFX_VIRTUAL(CDlgSignalLightSync)
+	protected:
+	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
+	//}}AFX_VIRTUAL
+
+// Implementation
+protected:
+
+	// Generated message map functions
+	//{{AFX_MSG(CDlgSignalLightSync)
+	afx_msg void OnBtnGet();
+	afx_msg void OnBtnSet();
+	virtual BOOL OnInitDialog();
+	//}}AFX_MSG
+	DECLARE_MESSAGE_MAP()
+};
+
+//{{AFX_INSERT_LOCATION}}
+// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
+
+#endif // !defined(AFX_DLGSIGNALLIGHTSYNC_H__0904CEC1_2BC7_4EC5_9DC7_1FC963795251__INCLUDED_)

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgSizeFilter.cpp

@@ -0,0 +1,412 @@
+// DlgSizeFilter.cpp : implementation file
+//
+
+#include "stdafx.h"
+#include "clientdemo.h"
+#include "DlgSizeFilter.h"
+#include "DrawFun.h"
+
+#ifdef _DEBUG
+#define new DEBUG_NEW
+#undef THIS_FILE
+static char THIS_FILE[] = __FILE__;
+#endif
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgSizeFilter dialog
+CDlgSizeFilter *g_pDlgSizeFilter = NULL;
+
+void  CALLBACK g_DrawSizeFilter(LONG lRealHandle, HDC hDc, DWORD dwUser)
+{
+    g_pDlgSizeFilter->F_DrawFun(lRealHandle, hDc, dwUser);
+}
+
+CDlgSizeFilter::CDlgSizeFilter(CWnd* pParent /*=NULL*/)
+	: CDialog(CDlgSizeFilter::IDD, pParent)
+{
+	//{{AFX_DATA_INIT(CDlgSizeFilter)
+	m_bActive = FALSE;
+	m_fMaxHeight = 0.0f;
+	m_fMaxWidth = 0.0f;
+	m_fMinHeight = 0.0f;
+	m_fMinWidth = 0.0f;
+	m_bSetMaxFilter = FALSE;
+	m_bSetMiniFilter = FALSE;
+	//}}AFX_DATA_INIT
+    m_lServerID = -1;
+    m_lChannel = -1;
+    m_iDevIndex = -1;
+    memset(&m_struSizeFilter, 0, sizeof(m_struSizeFilter));
+    m_bPreview = FALSE;
+    m_lPlayHandle = -1;
+    memset(&m_rcWnd, 0, sizeof(m_rcWnd));
+    m_lPUServerID = -1;
+    memset(&m_struPuStream, 0, sizeof(m_struPuStream));
+    m_nFilterMode = -1;
+}
+
+
+void CDlgSizeFilter::DoDataExchange(CDataExchange* pDX)
+{
+	CDialog::DoDataExchange(pDX);
+	//{{AFX_DATA_MAP(CDlgSizeFilter)
+	DDX_Control(pDX, IDC_COMBO_MODE, m_comboMode);
+	DDX_Check(pDX, IDC_CHK_ACTIVE, m_bActive);
+	DDX_Text(pDX, IDC_EDIT_MAX_HEIGHT, m_fMaxHeight);
+	DDX_Text(pDX, IDC_EDIT_MAX_WIDTH, m_fMaxWidth);
+	DDX_Text(pDX, IDC_EDIT_MIN_HEIGHT, m_fMinHeight);
+	DDX_Text(pDX, IDC_EDIT_MIN_WIDTH, m_fMinWidth);
+	DDX_Check(pDX, IDC_CHECK_SET_MAX_FILTER, m_bSetMaxFilter);
+	DDX_Check(pDX, IDC_CHECK_SET_MINI_FILTER, m_bSetMiniFilter);
+	//}}AFX_DATA_MAP
+}
+
+BEGIN_MESSAGE_MAP(CDlgSizeFilter, CDialog)
+	//{{AFX_MSG_MAP(CDlgSizeFilter)
+	ON_BN_CLICKED(IDC_BTN_SET_SIZE_FILTER, OnBtnSetSizeFilter)
+	ON_CBN_SELCHANGE(IDC_COMBO_MODE, OnSelchangeComboMode)
+	ON_BN_CLICKED(IDC_CHK_ACTIVE, OnChkActive)
+	ON_BN_CLICKED(IDC_CHECK_SET_MINI_FILTER, OnCheckSetMiniFilter)
+	ON_BN_CLICKED(IDC_CHECK_SET_MAX_FILTER, OnCheckSetMaxFilter)
+	ON_BN_CLICKED(IDC_BTN_PREVIEW, OnBtnPreview)
+	//}}AFX_MSG_MAP
+END_MESSAGE_MAP()
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgSizeFilter message handlers
+
+void CDlgSizeFilter::OnCancel() 
+{
+	// TODO: Add extra cleanup here
+	
+	CDialog::OnCancel();
+}
+
+void CDlgSizeFilter::OnBtnSetSizeFilter() 
+{
+    char szLan[256] ={0};
+    UpdateData(TRUE);
+    m_struSizeFilter.byActive = m_bActive;
+    m_struSizeFilter.byMode = m_comboMode.GetCurSel();
+    if (IMAGE_PIX_MODE == m_comboMode.GetCurSel())
+    {
+    }
+    else if (REAL_WORLD_MODE == m_comboMode.GetCurSel())
+    {
+        m_struSizeFilter.struMaxRect.fHeight = m_fMaxHeight;
+        m_struSizeFilter.struMaxRect.fWidth= m_fMaxWidth;
+        
+        m_struSizeFilter.struMiniRect.fHeight = m_fMinHeight;
+        m_struSizeFilter.struMiniRect.fWidth= m_fMinWidth;
+    }
+
+    if (!NET_DVR_SetDVRConfig(m_lServerID, NET_VCA_SET_SIZE_FILTER, m_lChannel, &m_struSizeFilter, sizeof(m_struSizeFilter)))
+    {
+        g_pMainDlg->AddLog(m_iDevIndex, OPERATION_FAIL_T, "NET_VCA_SET_SIZE_FILTER");
+        g_StringLanType(szLan, "设置尺寸过滤器失败", "Fail to set size filter");
+        AfxMessageBox(szLan);
+    }
+    else
+    {
+        g_pMainDlg->AddLog(m_iDevIndex, OPERATION_SUCC_T, "NET_VCA_SET_SIZE_FILTER");
+        g_StringLanType(szLan, "设置尺寸过滤器成功", "Success to set size filter");
+        AfxMessageBox(szLan);
+    }
+    	
+}
+
+BOOL CDlgSizeFilter::OnInitDialog() 
+{
+	CDialog::OnInitDialog();
+    g_pDlgSizeFilter = this;
+
+    InitWnd();
+
+    DWORD dwReturn = 0;
+    char szLan[256] = {0};
+    if (!NET_DVR_GetDVRConfig(m_lServerID, NET_VCA_GET_SIZE_FILTER, m_lChannel, &m_struSizeFilter, sizeof(m_struSizeFilter), &dwReturn))
+    {
+        g_pMainDlg->AddLog(m_iDevIndex, OPERATION_FAIL_T, "NET_VCA_GET_SIZE_FILTER");
+        g_StringLanType(szLan, "获取尺寸过滤器失败", "Fail to get size filter");
+        AfxMessageBox(szLan);
+    }
+    else
+    {
+        g_pMainDlg->AddLog(m_lServerID, OPERATION_SUCC_T, "NET_VCA_GET_SIZE_FILTER");
+    }
+
+    m_bActive = m_struSizeFilter.byActive;
+    m_fMaxHeight = m_struSizeFilter.struMaxRect.fHeight;
+    m_fMaxWidth = m_struSizeFilter.struMaxRect.fWidth;
+
+    m_fMinHeight = m_struSizeFilter.struMiniRect.fHeight;
+    m_fMinWidth = m_struSizeFilter.struMiniRect.fWidth;
+
+    m_comboMode.SetCurSel(m_struSizeFilter.byMode);
+    OnSelchangeComboMode();
+
+    UpdateData(FALSE);
+    return TRUE;  // return TRUE unless you set the focus to a control
+	              // EXCEPTION: OCX Property Pages should return FALSE
+}
+
+void CDlgSizeFilter::InitWnd()
+{
+    char szLan[128] = {0};
+    m_comboMode.ResetContent();
+
+    g_StringLanType(szLan, "像素模式", "Image pix mode");
+    m_comboMode.AddString(szLan);
+
+    g_StringLanType(szLan, "实际模式", "Real word mode");
+    m_comboMode.AddString(szLan);
+}
+
+void CDlgSizeFilter::OnSelchangeComboMode() 
+{
+    m_nFilterMode = m_comboMode.GetCurSel();
+    GetDlgItem(IDC_EDIT_MAX_HEIGHT)->EnableWindow(FALSE);
+    GetDlgItem(IDC_EDIT_MAX_WIDTH)->EnableWindow(FALSE);
+    GetDlgItem(IDC_EDIT_MIN_HEIGHT)->EnableWindow(FALSE);
+    GetDlgItem(IDC_EDIT_MIN_WIDTH)->EnableWindow(FALSE);
+    GetDlgItem(IDC_CHECK_SET_MAX_FILTER)->EnableWindow(FALSE);
+    GetDlgItem(IDC_CHECK_SET_MINI_FILTER)->EnableWindow(FALSE);
+    int iFilterMode = m_comboMode.GetCurSel();
+
+    if (IMAGE_PIX_MODE == iFilterMode)
+    {
+        GetDlgItem(IDC_CHECK_SET_MAX_FILTER)->EnableWindow(TRUE);
+        GetDlgItem(IDC_CHECK_SET_MINI_FILTER)->EnableWindow(TRUE);
+    }
+    else if (REAL_WORLD_MODE == iFilterMode)
+    {
+        GetDlgItem(IDC_EDIT_MAX_HEIGHT)->EnableWindow(TRUE);
+        GetDlgItem(IDC_EDIT_MAX_WIDTH)->EnableWindow(TRUE);
+        GetDlgItem(IDC_EDIT_MIN_HEIGHT)->EnableWindow(TRUE);
+        GetDlgItem(IDC_EDIT_MIN_WIDTH)->EnableWindow(TRUE);
+    }
+}
+
+
+
+void CDlgSizeFilter::OnChkActive() 
+{
+	UpdateData(TRUE);
+}
+
+void CDlgSizeFilter::OnCheckSetMiniFilter() 
+{
+    UpdateData(TRUE);
+    if (m_bSetMiniFilter)
+    {
+        m_bSetMaxFilter = FALSE;
+        UpdateData(FALSE);
+    }
+}
+
+void CDlgSizeFilter::OnCheckSetMaxFilter() 
+{
+	UpdateData(TRUE);
+    if (m_bSetMaxFilter)
+    {
+        m_bSetMiniFilter = FALSE;
+        UpdateData(FALSE);
+    }
+}
+
+void CDlgSizeFilter::OnBtnPreview() 
+{
+	if (m_bPreview)
+	{
+        StopPlay();
+        GetDlgItem(IDC_BTN_PREVIEW)->SetWindowText("Preview");
+        m_bPreview = FALSE;
+	}
+    else
+    {
+        if (-1 != StartPlay())
+        {
+            GetDlgItem(IDC_BTN_PREVIEW)->SetWindowText("Stop");
+            m_bPreview = TRUE;
+        }
+        else
+        {
+            AfxMessageBox("Fail to preview");
+        }
+    }
+    Invalidate(TRUE);
+}
+
+LONG CDlgSizeFilter::StartPlay()
+{
+    if (GetPuStreamCfg(m_struPuStream))
+    {
+        NET_DVR_DEVICEINFO_V30 struDeviceInfo = {0};
+        
+        m_lPUServerID = NET_DVR_Login_V30(m_struPuStream.struDevChanInfo.struIP.sIpV4, m_struPuStream.struDevChanInfo.wDVRPort,
+            (char*)m_struPuStream.struDevChanInfo.sUserName, (char*)m_struPuStream.struDevChanInfo.sPassword, &struDeviceInfo);
+        if (m_lPUServerID < 0)
+        {
+            AfxMessageBox("Fail to login front device");
+            return m_lPUServerID;
+        }
+        
+        NET_DVR_CLIENTINFO struPlay;
+        struPlay.hPlayWnd 	= GetDlgItem(IDC_PLAYWND)->GetSafeHwnd();
+        struPlay.lChannel 	= m_struPuStream.struDevChanInfo.byChannel; 
+        struPlay.lLinkMode 	= 0;
+        struPlay.sMultiCastIP = "";	
+        
+        m_lPlayHandle = NET_DVR_RealPlay_V30(m_lPUServerID, &struPlay, NULL, NULL, TRUE); 
+        
+        BOOL bRet = FALSE;
+        if (m_lPlayHandle < 0)
+        {
+            g_pMainDlg->AddLog(-1, OPERATION_FAIL_T, "NET_DVR_RealPlay_V30");
+            AfxMessageBox("NET_DVR_RealPlay_V30 FAIL");		
+        }
+        else
+        {
+            g_pMainDlg->AddLog(-1, OPERATION_SUCC_T, "NET_DVR_RealPlay_V30");
+            bRet = NET_DVR_RigisterDrawFun(m_lPlayHandle, g_DrawSizeFilter, 0);//DC Draw callback
+        }
+        return m_lPlayHandle;
+    }
+    else // 到设备去取流预览
+    {
+    NET_DVR_CLIENTINFO struPlay;
+    struPlay.hPlayWnd 	= GetDlgItem(IDC_PLAYWND)->GetSafeHwnd();
+    struPlay.lChannel 	= m_lChannel; 
+    struPlay.lLinkMode 	= 0;
+    struPlay.sMultiCastIP = "";	
+    
+    m_lPlayHandle = NET_DVR_RealPlay_V30(m_lServerID, &struPlay, NULL, NULL, TRUE); 
+    BOOL bRet = FALSE;
+    if (m_lPlayHandle < 0)
+    {
+        g_pMainDlg->AddLog(-1, OPERATION_FAIL_T, "NET_DVR_RealPlay_V30");
+        AfxMessageBox("NET_DVR_RealPlay_V30 FAIL");		
+    }
+    else
+    {
+        g_pMainDlg->AddLog(-1, OPERATION_SUCC_T, "NET_DVR_RealPlay_V30");
+            g_pDlgSizeFilter = this;
+        bRet = NET_DVR_RigisterDrawFun(m_lPlayHandle, g_DrawSizeFilter, 0);//DC Draw callback
+            
+    }
+    return m_lPlayHandle;
+}
+}
+
+BOOL CDlgSizeFilter::StopPlay()
+{
+    if (m_lPlayHandle >= 0)
+    {
+        NET_DVR_StopRealPlay(m_lPlayHandle);
+        m_lPlayHandle = -1;
+    }
+    
+    if (m_lPUServerID >= 0)
+    {
+        NET_DVR_Logout_V30(m_lPUServerID);
+        m_lPUServerID = -1;
+    }
+    return TRUE;
+}
+
+void CDlgSizeFilter::PostNcDestroy() 
+{
+    StopPlay();	
+	CDialog::PostNcDestroy();
+}
+
+BOOL CDlgSizeFilter::PreTranslateMessage(MSG* pMsg) 
+{
+	
+    GetDlgItem(IDC_PLAYWND)->GetWindowRect(&m_rcWnd);
+    
+    CPoint pt(0,0);
+    GetCursorPos(&pt);
+
+    PreDrawSizeFilterMsg(pMsg, pt);
+    return CDialog::PreTranslateMessage(pMsg);
+}
+
+BOOL CDlgSizeFilter::PreDrawSizeFilterMsg(MSG* pMsg, CPoint &pt)
+{
+    switch (pMsg->message)
+    {
+    case WM_LBUTTONDOWN:
+        if(m_bSetMiniFilter && (GetAsyncKeyState(VK_LCONTROL)<0 || GetAsyncKeyState(VK_RCONTROL)<0))
+        {
+            if(PtInRect(&m_rcWnd,pt))
+            {
+                m_struSizeFilter.struMiniRect.fX = (float)(pt.x-m_rcWnd.left)/(float)m_rcWnd.Width();
+                m_struSizeFilter.struMiniRect.fY = (float)(pt.y-m_rcWnd.top)/(float)m_rcWnd.Height();
+            }
+        }//First coordinate of Maximal Rectangle
+        else if(m_bSetMaxFilter && (GetAsyncKeyState(VK_LCONTROL)<0 || GetAsyncKeyState(VK_RCONTROL)<0))
+        {
+            if(PtInRect(&m_rcWnd,pt))
+            {
+                m_struSizeFilter.struMaxRect.fX = (float)(pt.x-m_rcWnd.left)/(float)m_rcWnd.Width();
+                m_struSizeFilter.struMaxRect.fY = (float)(pt.y-m_rcWnd.top)/(float)m_rcWnd.Height();
+            }
+        }
+        break;
+    case WM_MOUSEMOVE:
+        if(m_bSetMiniFilter && (GetAsyncKeyState(VK_LCONTROL)<0 || GetAsyncKeyState(VK_RCONTROL)<0)) //尺寸过滤器
+        {
+            if(PtInRect(&m_rcWnd,pt))
+            {
+                m_struSizeFilter.struMiniRect.fWidth = (float)(pt.x-m_rcWnd.left)/(float)m_rcWnd.Width() - m_struSizeFilter.struMiniRect.fX;
+                m_struSizeFilter.struMiniRect.fHeight = (float)(pt.y-m_rcWnd.top)/(float)m_rcWnd.Height() - m_struSizeFilter.struMiniRect.fY;
+            }
+            
+        }
+        else if(m_bSetMaxFilter && (GetAsyncKeyState(VK_LCONTROL)<0 || GetAsyncKeyState(VK_RCONTROL)<0)) //尺寸过滤器
+        {
+            if(PtInRect(&m_rcWnd,pt))
+            {	
+                m_struSizeFilter.struMaxRect.fWidth = (float)(pt.x-m_rcWnd.left)/(float)m_rcWnd.Width() - m_struSizeFilter.struMaxRect.fX;
+                m_struSizeFilter.struMaxRect.fHeight = (float)(pt.y-m_rcWnd.top)/(float)m_rcWnd.Height() - m_struSizeFilter.struMaxRect.fY;
+            }
+        }
+        break;
+    }
+    return TRUE;
+}
+
+void CDlgSizeFilter::F_DrawFun(long lPlayHandle, HDC hDc, DWORD dwUser)
+{
+    if (IMAGE_PIX_MODE == m_nFilterMode)
+    {
+        DRAW_RECT_PARAM struDrawRect;
+        memset(&struDrawRect, 0, sizeof(struDrawRect));
+        struDrawRect.color = RGB(0, 255, 125);
+        memcpy(&struDrawRect.rcWnd, &m_rcWnd, sizeof(struDrawRect.rcWnd));
+        memcpy(&struDrawRect.struVcaRect, &m_struSizeFilter.struMaxRect, sizeof(struDrawRect.struVcaRect));
+        CDrawFun::DrawVcaRect(hDc, &struDrawRect);
+        
+        memset(&struDrawRect, 0, sizeof(struDrawRect));
+        struDrawRect.color = RGB(0, 255, 125);
+        memcpy(&struDrawRect.rcWnd, &m_rcWnd, sizeof(struDrawRect.rcWnd));
+		memcpy(&struDrawRect.struVcaRect, &m_struSizeFilter.struMiniRect, sizeof(struDrawRect.struVcaRect));
+        CDrawFun::DrawVcaRect(hDc, &struDrawRect);
+    }
+}
+
+BOOL CDlgSizeFilter::GetPuStreamCfg(NET_DVR_PU_STREAM_CFG &struPUStream)
+{
+    DWORD dwReturn = 0;
+    if (NET_DVR_GetDVRConfig(m_lServerID, NET_DVR_GET_PU_STREAMCFG,m_lChannel, &struPUStream, sizeof(struPUStream), &dwReturn))
+    {
+        g_pMainDlg->AddLog(m_iDevIndex, OPERATION_SUCC_T, "NET_DVR_GET_PU_STREAMCFG");
+        return TRUE;
+    }
+    else
+    {
+        g_pMainDlg->AddLog(m_iDevIndex, OPERATION_FAIL_T, "NET_DVR_GET_PU_STREAMCFG");
+        return FALSE;
+    }
+}

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgSplitterTransparent.cpp

@@ -0,0 +1,431 @@
+// DlgSplitterTransparent.cpp : implementation file
+//
+
+#include "stdafx.h"
+#include "clientdemo.h"
+#include "DlgSplitterTransparent.h"
+
+#ifdef _DEBUG
+#define new DEBUG_NEW
+#undef THIS_FILE
+static char THIS_FILE[] = __FILE__;
+#endif
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgSplitterTransparent dialog
+#include "DlgSplitterStartTrans.h"
+
+CDlgSplitterTransparent::CDlgSplitterTransparent(CWnd* pParent /*=NULL*/)
+	: CDialog(CDlgSplitterTransparent::IDD, pParent)
+{
+	//{{AFX_DATA_INIT(CDlgSplitterTransparent)
+	m_bEnable = FALSE;
+	m_csRemoteIp = _T("");
+	m_wPort = 0;
+	m_wLocalPort = 0;
+	//}}AFX_DATA_INIT
+}
+
+
+void CDlgSplitterTransparent::DoDataExchange(CDataExchange* pDX)
+{
+	CDialog::DoDataExchange(pDX);
+	//{{AFX_DATA_MAP(CDlgSplitterTransparent)
+	DDX_Control(pDX, IDC_COMBO_SERIAL_TYPE, m_comboSerialType);
+	DDX_Control(pDX, IDC_COMBO_TRANSPARENT_MODE, m_comboTransparentMode);
+	DDX_Control(pDX, IDC_COMBO_TRANSPARENT_NUM, m_comboTransparentNum);
+	DDX_Control(pDX, IDC_COMBO_RS485_NUM, m_comboRs485Num);
+	DDX_Check(pDX, IDC_CHECK_ENABLE, m_bEnable);
+	DDX_Text(pDX, IDC_EDIT_REMOTE_HOST_IP, m_csRemoteIp);
+	DDX_Text(pDX, IDC_EDIT_PORT, m_wPort);
+	DDX_Text(pDX, IDC_EDIT_LOCAL_PORT, m_wLocalPort);
+	//}}AFX_DATA_MAP
+}
+
+
+BEGIN_MESSAGE_MAP(CDlgSplitterTransparent, CDialog)
+	//{{AFX_MSG_MAP(CDlgSplitterTransparent)
+	ON_BN_CLICKED(IDC_BTN_SAVE_PARA, OnBtnSavePara)
+	ON_CBN_SELCHANGE(IDC_COMBO_TRANSPARENT_MODE, OnSelchangeComboTransparentMode)
+	ON_BN_CLICKED(IDC_BTN_SET, OnBtnSet)
+	ON_BN_CLICKED(IDC_BTN_COPY_ALL, OnBtnCopyAll)
+	ON_CBN_SELCHANGE(IDC_COMBO_TRANSPARENT_NUM, OnSelchangeComboTransparentNum)
+	ON_CBN_SELCHANGE(IDC_COMBO_RS485_NUM, OnSelchangeComboRs485Num)
+	ON_BN_CLICKED(IDC_BTN_START_TRANSPARENT, OnBtnStartTransparent)
+	ON_CBN_SELCHANGE(IDC_COMBO_SERIAL_TYPE, OnSelchangeComboSerialType)
+	//}}AFX_MSG_MAP
+END_MESSAGE_MAP()
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgSplitterTransparent message handlers
+
+BOOL CDlgSplitterTransparent::OnInitDialog() 
+{
+	CDialog::OnInitDialog();	
+	// TODO: Add extra initialization here	
+	m_iDeviceIndex = g_pMainDlg->GetCurDeviceIndex();
+
+	m_comboSerialType.SetCurSel(1);
+	OnSelchangeComboSerialType();
+	memset(m_struTransChanCfgServer, 0, sizeof(m_struTransChanCfgServer));
+	memset(m_struTransChanCfgClinet, 0, sizeof(m_struTransChanCfgClinet));
+	int i = 0;
+	for (i = 0; i < 9; i++)
+	{
+		m_struTransChanCfgClinet[i].dwSize = sizeof(m_struTransChanCfgClinet[0]);
+		m_struTransChanCfgServer[i].dwSize = sizeof(m_struTransChanCfgServer[0]);
+		m_struTransChanCfgClinet[i].byWorkMode = 1;
+		m_struTransChanCfgServer[i].byWorkMode = 2;
+	}
+	
+	OnSelchangeComboTransparentMode();
+	return TRUE;  // return TRUE unless you set the focus to a control
+	              // EXCEPTION: OCX Property Pages should return FALSE
+}
+
+void CDlgSplitterTransparent::OnBtnSavePara() 
+{
+	// TODO: Add your control notification handler code here
+	UpdateData(TRUE);
+
+	int iSel = m_comboTransparentNum.GetCurSel();
+	int iType = m_comboSerialType.GetCurSel();
+	int iChannel = m_comboRs485Num.GetCurSel() + 1;
+
+	if (-1 == iSel)
+	{
+		return;
+	}
+	if (m_comboTransparentMode.GetCurSel() == 0)
+	{
+		if (iType == 0)
+		{
+			m_struTransChanCfgClinet[0].struTransparentPara.struClientMode.struClientSingle[iSel].byEnable = m_bEnable;
+			strncpy(m_struTransChanCfgClinet[0].struTransparentPara.struClientMode.struClientSingle[iSel].struIP.sIpV4, m_csRemoteIp, 16);
+			m_struTransChanCfgClinet[0].struTransparentPara.struClientMode.struClientSingle[iSel].wPort = m_wPort;
+		}
+		else
+		{
+			m_struTransChanCfgClinet[iChannel].struTransparentPara.struClientMode.struClientSingle[iSel].byEnable = m_bEnable;
+			strncpy(m_struTransChanCfgClinet[iChannel].struTransparentPara.struClientMode.struClientSingle[iSel].struIP.sIpV4, m_csRemoteIp, 16);
+			m_struTransChanCfgClinet[iChannel].struTransparentPara.struClientMode.struClientSingle[iSel].wPort = m_wPort;
+		}
+				
+	}
+	else
+	{
+		if (iType == 0)
+		{
+			m_struTransChanCfgServer[0].struTransparentPara.struServerMode.struServerSingle[iSel].byEnable = m_bEnable;
+			strncpy(m_struTransChanCfgServer[0].struTransparentPara.struServerMode.struServerSingle[iSel].struIP.sIpV4, m_csRemoteIp, 16);
+			m_struTransChanCfgServer[0].struTransparentPara.struServerMode.wPort = m_wLocalPort;
+		}
+		else
+		{
+			m_struTransChanCfgServer[iChannel].struTransparentPara.struServerMode.struServerSingle[iSel].byEnable = m_bEnable;
+			strncpy(m_struTransChanCfgServer[iChannel].struTransparentPara.struServerMode.struServerSingle[iSel].struIP.sIpV4, m_csRemoteIp, 16);
+			m_struTransChanCfgServer[iChannel].struTransparentPara.struServerMode.wPort = m_wLocalPort;
+		}		
+	}
+}
+
+void CDlgSplitterTransparent::OnSelchangeComboTransparentMode() 
+{
+	// TODO: Add your control notification handler code here
+	int iSel = m_comboTransparentMode.GetCurSel();
+	char szLan[128] = {0};
+
+	switch (iSel)
+	{
+	case 0:
+		g_StringLanType(szLan, "客户端模式", "Client mode");
+		GetDlgItem(IDC_STATIC_GROUP_MODE)->SetWindowText(szLan);
+		g_StringLanType(szLan, "远程主机IP", "Remote host IP");
+		GetDlgItem(IDC_STATIC_IP)->SetWindowText(szLan);
+		GetDlgItem(IDC_STATIC_LOCAL_PORT)->ShowWindow(SW_HIDE);
+		GetDlgItem(IDC_EDIT_LOCAL_PORT)->ShowWindow(SW_HIDE);
+		GetDlgItem(IDC_STATIC_PORT)->ShowWindow(SW_SHOW);
+		GetDlgItem(IDC_EDIT_PORT)->ShowWindow(SW_SHOW);
+		break;
+	case 1:
+		g_StringLanType(szLan, "服务器模式", "Server mode");
+		GetDlgItem(IDC_STATIC_GROUP_MODE)->SetWindowText(szLan);
+		g_StringLanType(szLan, "允许接入IP", "Allow Access IP");
+		GetDlgItem(IDC_STATIC_IP)->SetWindowText(szLan);
+		GetDlgItem(IDC_STATIC_LOCAL_PORT)->ShowWindow(SW_SHOW);
+		GetDlgItem(IDC_EDIT_LOCAL_PORT)->ShowWindow(SW_SHOW);
+		GetDlgItem(IDC_STATIC_PORT)->ShowWindow(SW_HIDE);
+		GetDlgItem(IDC_EDIT_PORT)->ShowWindow(SW_HIDE);
+		break;
+	default:
+		g_StringLanType(szLan, "远程主机IP", "Remote host IP");
+		GetDlgItem(IDC_STATIC_IP)->SetWindowText(szLan);
+		GetDlgItem(IDC_STATIC_LOCAL_PORT)->ShowWindow(SW_HIDE);
+		GetDlgItem(IDC_EDIT_LOCAL_PORT)->ShowWindow(SW_HIDE);
+		GetDlgItem(IDC_STATIC_PORT)->ShowWindow(SW_SHOW);
+		GetDlgItem(IDC_EDIT_PORT)->ShowWindow(SW_SHOW);
+		break;
+	}
+
+	m_comboTransparentNum.SetCurSel(0);
+	OnSelchangeComboTransparentNum();
+
+	UpdateData(FALSE);	
+}
+
+void CDlgSplitterTransparent::OnBtnSet() 
+{
+	// TODO: Add your control notification handler code here
+	UpdateData(TRUE);
+	OnBtnSavePara();
+
+	DWORD dwChannel = m_comboRs485Num.GetCurSel() + 1;
+	if (m_comboSerialType.GetCurSel() == 0)
+	{
+		dwChannel |= 0x80000000;
+	}
+
+	NET_DVR_TRANSPARENT_CHAN_CFG m_struTransChanCfg = {0};
+	m_struTransChanCfg.dwSize = sizeof(m_struTransChanCfg);
+	if (m_comboTransparentMode.GetCurSel() == 0)
+	{
+		if (m_comboSerialType.GetCurSel() == 0)
+		{
+			memcpy(&m_struTransChanCfg, &m_struTransChanCfgClinet[0], sizeof(m_struTransChanCfg));
+		}
+		else
+		{
+			memcpy(&m_struTransChanCfg, &m_struTransChanCfgClinet[dwChannel], sizeof(m_struTransChanCfg));
+		}		
+	}
+	else
+	{
+		if (m_comboSerialType.GetCurSel() == 0)
+		{
+			memcpy(&m_struTransChanCfg, &m_struTransChanCfgServer[0], sizeof(m_struTransChanCfg));
+			m_struTransChanCfgServer[0].struTransparentPara.struServerMode.wPort = m_wLocalPort;
+		}
+		else
+		{
+			memcpy(&m_struTransChanCfg, &m_struTransChanCfgServer[dwChannel], sizeof(m_struTransChanCfg));
+			m_struTransChanCfgServer[dwChannel].struTransparentPara.struServerMode.wPort = m_wLocalPort;
+		}
+	}
+// 	m_struTansChanCfg.dwSize = sizeof(m_struTansChanCfg);
+// 	m_struTansChanCfg.byWorkMode = m_comboTransparentMode.GetCurSel() + 1;
+// 	if (m_struTansChanCfg.byWorkMode == 2)
+// 	{
+// 		m_struTansChanCfg.struTransparentPara.struServerMode.wPort = m_wLocalPort;
+// 	}
+	if (!NET_DVR_SetDVRConfig(m_lServerID, NET_DVR_SET_SPLITTER_TRANS_CHAN_CFG, dwChannel, &m_struTransChanCfg, sizeof(m_struTransChanCfg)))
+	{
+		g_pMainDlg->AddLog(m_iDeviceIndex, OPERATION_FAIL_T, "NET_DVR_SET_SPLITTER_TRANS_CHAN_CFG");
+		AfxMessageBox(NET_DVR_GetErrorMsg());
+	}
+	else
+	{
+		g_pMainDlg->AddLog(m_iDeviceIndex, OPERATION_SUCC_T, "NET_DVR_SET_SPLITTER_TRANS_CHAN_CFG");
+		AfxMessageBox("Success");
+	}
+}
+
+void CDlgSplitterTransparent::OnBtnCopyAll() 
+{
+	// TODO: Add your control notification handler code here
+	UpdateData(TRUE);
+	OnBtnSavePara();
+	
+	DWORD dwChannel = 0;
+	NET_DVR_TRANSPARENT_CHAN_CFG m_struTransChanCfg = {0};
+	int iSel = m_comboTransparentNum.GetCurSel();
+	int iType = m_comboSerialType.GetCurSel();
+	
+	if (iType == 0)
+	{
+		if (m_comboTransparentMode.GetCurSel() == 0)
+		{
+			memcpy(&m_struTransChanCfg, &m_struTransChanCfgClinet[0], sizeof(m_struTransChanCfg));
+		}
+		else
+		{
+			memcpy(&m_struTransChanCfg, &m_struTransChanCfgServer[0], sizeof(m_struTransChanCfg));
+		}
+	}
+	else
+	{
+		if (m_comboTransparentMode.GetCurSel() == 0)
+		{
+			memcpy(&m_struTransChanCfg, &m_struTransChanCfgClinet[iSel], sizeof(m_struTransChanCfg));
+		}
+		else
+		{
+			memcpy(&m_struTransChanCfg, &m_struTransChanCfgServer[iSel], sizeof(m_struTransChanCfg));
+		}
+	}
+// 	m_struTansChanCfg.dwSize = sizeof(m_struTansChanCfg);
+// 	m_struTansChanCfg.byWorkMode = m_comboTransparentMode.GetCurSel() + 1;
+
+	for (dwChannel = 1; dwChannel < m_comboRs485Num.GetCount() + 1; dwChannel++)
+	{	
+		if (m_comboSerialType.GetCurSel() == 0)
+		{
+			dwChannel |= 0x80000000;
+		}
+		if (!NET_DVR_SetDVRConfig(m_lServerID, NET_DVR_SET_SPLITTER_TRANS_CHAN_CFG, dwChannel, &m_struTransChanCfg, sizeof(m_struTransChanCfg)))
+		{
+			g_pMainDlg->AddLog(m_iDeviceIndex, OPERATION_FAIL_T, "Channel:[%d]NET_DVR_SET_SPLITTER_TRANS_CHAN_CFG", dwChannel);
+			AfxMessageBox(NET_DVR_GetErrorMsg());
+			return;
+		}
+		else
+		{
+			g_pMainDlg->AddLog(m_iDeviceIndex, OPERATION_SUCC_T, "Channel:[%d]NET_DVR_SET_SPLITTER_TRANS_CHAN_CFG", dwChannel);			
+		}
+	}
+	
+	AfxMessageBox("Success");
+}
+
+void CDlgSplitterTransparent::OnSelchangeComboTransparentNum() 
+{
+	// TODO: Add your control notification handler code here
+	//UpdateData(TRUE);
+
+	int iSel = m_comboTransparentNum.GetCurSel();
+	int iType = m_comboSerialType.GetCurSel();
+	int iChannel = m_comboRs485Num.GetCurSel() + 1;
+
+	if (iSel == -1)
+	{
+		return;
+	}
+
+	if (m_comboTransparentMode.GetCurSel() == 0)
+	{
+		if (iType == 0)
+		{
+			m_bEnable = m_struTransChanCfgClinet[0].struTransparentPara.struClientMode.struClientSingle[iSel].byEnable;
+			m_csRemoteIp = m_struTransChanCfgClinet[0].struTransparentPara.struClientMode.struClientSingle[iSel].struIP.sIpV4;
+			m_wPort = m_struTransChanCfgClinet[0].struTransparentPara.struClientMode.struClientSingle[iSel].wPort;
+		}
+		else
+		{
+			m_bEnable = m_struTransChanCfgClinet[iChannel].struTransparentPara.struClientMode.struClientSingle[iSel].byEnable;
+			m_csRemoteIp = m_struTransChanCfgClinet[iChannel].struTransparentPara.struClientMode.struClientSingle[iSel].struIP.sIpV4;
+			m_wPort = m_struTransChanCfgClinet[iChannel].struTransparentPara.struClientMode.struClientSingle[iSel].wPort;
+		}		
+	}
+	else
+	{
+		if (iType == 0)
+		{
+			m_bEnable = m_struTransChanCfgServer[0].struTransparentPara.struServerMode.struServerSingle[iSel].byEnable;
+			m_csRemoteIp = m_struTransChanCfgServer[0].struTransparentPara.struServerMode.struServerSingle[iSel].struIP.sIpV4;
+		}
+		else
+		{
+			m_bEnable = m_struTransChanCfgServer[iChannel].struTransparentPara.struServerMode.struServerSingle[iSel].byEnable;
+			m_csRemoteIp = m_struTransChanCfgServer[iChannel].struTransparentPara.struServerMode.struServerSingle[iSel].struIP.sIpV4;
+		}		
+		//m_wLocalPort = m_struTansChanCfg.struTransparentPara.struServerMode.wPort;
+	}
+
+	UpdateData(FALSE);
+	
+}
+
+void CDlgSplitterTransparent::OnSelchangeComboRs485Num() 
+{
+	// TODO: Add your control notification handler code here
+	UpdateData(TRUE);
+
+	DWORD dwChannel = m_comboRs485Num.GetCurSel() + 1;
+
+	if (dwChannel == 0)
+	{
+		return;
+	}
+
+	if (m_comboSerialType.GetCurSel() == 0)
+	{
+		dwChannel |= 0x80000000;
+	}
+
+	DWORD dwReturned = 0;
+	NET_DVR_TRANSPARENT_CHAN_CFG m_struTransChanCfg = {0};
+	if (!NET_DVR_GetDVRConfig(m_lServerID,  NET_DVR_GET_SPLITTER_TRANS_CHAN_CFG, dwChannel, &m_struTransChanCfg, sizeof(m_struTransChanCfg), &dwReturned))
+	{
+		g_pMainDlg->AddLog(m_iDeviceIndex, OPERATION_FAIL_T, "NET_DVR_GET_SPLITTER_TRANS_CHAN_CFG");
+		AfxMessageBox(NET_DVR_GetErrorMsg());
+	}
+	else
+	{
+		m_comboTransparentMode.SetCurSel(m_struTransChanCfg.byWorkMode - 1);		
+
+		if (m_struTransChanCfg.byWorkMode == 1)
+		{
+			m_comboTransparentMode.SetCurSel(0);
+			m_comboTransparentNum.SetCurSel(0);
+			m_bEnable = m_struTransChanCfg.struTransparentPara.struClientMode.struClientSingle[0].byEnable;
+			m_csRemoteIp = m_struTransChanCfg.struTransparentPara.struClientMode.struClientSingle[0].struIP.sIpV4;
+			m_wPort = m_struTransChanCfg.struTransparentPara.struClientMode.struClientSingle[0].wPort;
+			if (m_comboSerialType.GetCurSel() == 0)
+			{
+				memcpy(&m_struTransChanCfgClinet[0], &m_struTransChanCfg, sizeof(m_struTransChanCfg));
+			}
+			else
+			{
+				memcpy(&m_struTransChanCfgClinet[dwChannel], &m_struTransChanCfg, sizeof(m_struTransChanCfg));
+			}			
+		}
+		else
+		{
+			m_comboTransparentMode.SetCurSel(1);
+			m_comboTransparentNum.SetCurSel(0);
+			m_bEnable = m_struTransChanCfg.struTransparentPara.struServerMode.struServerSingle[0].byEnable;
+			m_csRemoteIp = m_struTransChanCfg.struTransparentPara.struServerMode.struServerSingle[0].struIP.sIpV4;
+			m_wLocalPort = m_struTransChanCfg.struTransparentPara.struServerMode.wPort;
+			if (m_comboSerialType.GetCurSel() == 0)
+			{
+				memcpy(&m_struTransChanCfgServer[0], &m_struTransChanCfg, sizeof(m_struTransChanCfg));
+			}
+			else
+			{
+				memcpy(&m_struTransChanCfgServer[dwChannel], &m_struTransChanCfg, sizeof(m_struTransChanCfg));
+			}			
+		}
+
+		OnSelchangeComboTransparentMode();
+		UpdateData(FALSE);
+	}
+}
+
+void CDlgSplitterTransparent::OnBtnStartTransparent() 
+{
+	// TODO: Add your control notification handler code here
+	CDlgSplitterStartTrans dlg;
+	dlg.m_lServerID = m_lServerID;
+	dlg.DoModal();
+}
+
+void CDlgSplitterTransparent::OnSelchangeComboSerialType() 
+{
+	// TODO: Add your control notification handler code here
+	CString cs;
+	int i = 0;
+
+	if (m_comboSerialType.GetCurSel() == 0)
+	{
+		m_comboRs485Num.ResetContent();
+		m_comboRs485Num.AddString("1");
+	}
+	else
+	{
+		m_comboRs485Num.ResetContent();
+		for (i = 0; i < 8; i++)
+		{
+			cs.Format("%d", i + 1);
+			m_comboRs485Num.AddString(cs);
+		}
+	}
+}

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgStreamManualRecordAndLock.h

@@ -0,0 +1,79 @@
+#if !defined(AFX_DLGSTREAMMANUALRECORDANDLOCK_H__C024DFB1_488B_449B_A643_83DC1323F361__INCLUDED_)
+#define AFX_DLGSTREAMMANUALRECORDANDLOCK_H__C024DFB1_488B_449B_A643_83DC1323F361__INCLUDED_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif // _MSC_VER > 1000
+// DlgStreamManualRecordAndLock.h : header file
+//
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgStreamManualRecordAndLock dialog
+
+class CDlgStreamManualRecordAndLock : public CDialog
+{
+// Construction
+public:
+	CDlgStreamManualRecordAndLock(CWnd* pParent = NULL);   // standard constructor
+
+// Dialog Data
+	//{{AFX_DATA(CDlgStreamManualRecordAndLock)
+	enum { IDD = IDD_DLG_STREAM_MANUAL_RECORD_AND_LOCK };
+    CComboBox	m_cmbChannel;
+	CComboBox	m_cmbLockRecordType;
+	CComboBox	m_cmbManualRecordType;
+	int		m_iChannel;
+	CString	m_strStreamID;
+	CTime	m_ctDateEnd;
+	CTime	m_ctDateStart;
+	CTime	m_ctTimeEnd;
+	CTime	m_ctTimeStart;
+	int		m_iLockDuration;
+	CTime	m_ctDateEndReturn;
+	CTime	m_ctDateStartReturn;
+	CTime	m_ctTimeEndReturn;
+	CTime	m_ctTimeStartReturn;
+	CTime	m_ctUnlockTimePointDate;
+	CTime	m_ctUnlockTimePointTime;
+    BOOL	m_bAllAnalogChan;
+	BOOL	m_bAllIPChan;
+	//}}AFX_DATA
+
+
+// Overrides
+	// ClassWizard generated virtual function overrides
+	//{{AFX_VIRTUAL(CDlgStreamManualRecordAndLock)
+	protected:
+	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
+	//}}AFX_VIRTUAL
+
+// Implementation
+protected:
+
+	virtual BOOL OnInitDialog();
+	afx_msg void OnButtonLock();
+	afx_msg void OnButtonUnlock();
+	afx_msg void OnButtonStart();
+	afx_msg void OnButtonStop();
+	// Generated message map functions
+	//{{AFX_MSG(CDlgStreamManualRecordAndLock)
+		// NOTE: the ClassWizard will add member functions here
+	//}}AFX_MSG
+	DECLARE_MESSAGE_MAP()
+public:
+    void InitWindows();
+private:
+	int m_iDeviceIndex;
+	LONG	m_lLoginID;
+public:
+    BOOL m_byISO8601Enabled;
+    int m_iHourDiffWithUTC;
+    int m_iMinuteDiffWithUTC;
+    int m_iHourDiffWithUTCReturn;
+    int m_iMinuteDiffWithUTCReturn;
+};
+
+//{{AFX_INSERT_LOCATION}}
+// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
+
+#endif // !defined(AFX_DLGSTREAMMANUALRECORDANDLOCK_H__C024DFB1_488B_449B_A643_83DC1323F361__INCLUDED_)

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgTalkMREx.cpp

@@ -0,0 +1,1481 @@
+/**********************************************************
+FileName:    DlgTalkMR.cpp
+Description: voice media redirect      
+Date:        2008/12/18
+Note: 		the global Macro definition and structure is in "GeneralDef.h", global variable and function is in "ClientDemo.cpp"
+Modification History:      
+    <version> <time>         <desc>
+    <1.0    > <2008/12/18>       <created>
+***********************************************************/
+
+#include "stdafx.h"
+#include "DlgTalkMREx.h"
+#include "HCNetSDK.h"
+
+#ifdef _DEBUG
+#define new DEBUG_NEW
+#undef THIS_FILE
+static char THIS_FILE[] = __FILE__;
+#endif
+
+
+//#define  RECORD
+
+CDlgTalkMREx* g_pDlgTalkMR = NULL;
+
+
+/*********************************************************
+  Function:	fVoiceDataCallBack
+  Desc:		call back the audio data from device/从回调中得到设备的音频数据
+  Input:	lVoiceComHandle,handle of voice communication;pRecvDataBuffer, buffer for voice data; dwBufSize, voice data length; pUser, User data;
+  Output:	none
+  Return:	none
+**********************************************************/
+void CALLBACK fVoiceDataCallBackEx(LONG lVoiceComHandle, char *pRecvDataBuffer, DWORD dwBufSize, BYTE byAudioFlag, void* pUser)
+{
+	LPTALK_MR lpTalkMr = (LPTALK_MR)pUser;	
+	switch(byAudioFlag)
+	{
+	case 0:
+		TRACE("local audio data\n");
+		break;
+	case 1:
+		g_pDlgTalkMR->PutIntoBuf(pRecvDataBuffer, (int)dwBufSize, lpTalkMr);
+	//	TRACE("Input data size[%d]\n", dwBufSize);
+		break;
+	case 2:
+		TRACE("audio sending and recving thread exit\n");
+		break;
+	default:
+		break;
+	}	
+}
+
+/*********************************************************
+  Function:	DataFromSoundIn
+  Desc:		get local audio data and send to device
+  Input:	buffer, local voice data buffer; dwSize, data length; dwOwner, owner data;
+  Output:	none
+  Return:	none
+**********************************************************/
+void CALLBACK DataFromSoundInEx(char* buffer, DWORD dwSize, void *pOwner)
+{
+    //buffer为原始PCM音频数据
+    ASSERT(pOwner);
+    CDlgTalkMREx* p = (CDlgTalkMREx*)pOwner;
+    p->SendDataToDVR(buffer, dwSize);
+}
+
+
+/////////////////////////////////////////////////////////////////////////////
+/*********************************************************
+  Function:	CDlgTalkMR
+  Desc:		Constructor
+  Input:	pParent, parent window pointer
+  Output:	none
+  Return:	none
+**********************************************************/
+CDlgTalkMREx::CDlgTalkMREx(CWnd* pParent /*=NULL*/)
+	: CDialog(CDlgTalkMREx::IDD, pParent)
+{
+	m_bWaveDeal = FALSE;
+	m_iDeviceIndex = -1;
+	//{{AFX_DATA_INIT(CDlgTalkMR)
+	//}}AFX_DATA_INIT
+	
+	m_hFile = NULL;
+    m_hExitEvent = INVALID_HANDLE_VALUE;
+	memset(&m_hHaveRDataRV, 0, sizeof(HANDLE) * MAX_SOUND_OUT);
+	memset(&m_hPlayHandle, -1, sizeof(HANDLE) * MAX_SOUND_OUT);
+	m_pEncoder = NULL;
+
+	m_pG726Enc = NULL;
+	m_pG726EncM = NULL;
+    m_pG711Enc = NULL;
+	m_bReset = TRUE;
+    m_byAudioEncType = -1;
+
+	memset(m_bOpenWavOut, 0 , sizeof(BOOL) * MAX_SOUND_OUT);
+	m_bOpenWavIn = FALSE;
+
+	m_dwBufSize = AUDENCSIZE;
+	m_dwBufNum = 6;
+	//init WAVEFORMATEX
+	m_struWaveFormat.cbSize =			sizeof(WAVEFORMATEX);
+	m_struWaveFormat.nBlockAlign =		CHANNEL * BITS_PER_SAMPLE / 8;
+	m_struWaveFormat.nChannels =		CHANNEL;
+	m_struWaveFormat.nSamplesPerSec =	SAMPLES_PER_SECOND;
+	m_struWaveFormat.wBitsPerSample =	BITS_PER_SAMPLE;
+	m_struWaveFormat.nAvgBytesPerSec =	SAMPLES_PER_SECOND * m_struWaveFormat.nBlockAlign;
+	m_struWaveFormat.wFormatTag =		WAVE_FORMAT_PCM;
+
+	memset(m_pRenderBuf, 0, sizeof(LPBYTE) * MAX_SOUND_OUT);
+	memset(m_nBufNo, 0, sizeof(int) * MAX_SOUND_OUT);
+	memset(m_rIndexRV, 0 , sizeof(int) * MAX_SOUND_OUT);
+	memset(m_ReceiveIndexRV, 0 , sizeof(int) * MAX_SOUND_OUT);
+	memset(m_bOpenPlayThread, 0, sizeof(BOOL) * MAX_SOUND_OUT);
+
+    memset(m_byAudioTemp, 0, AUDENCSIZE);
+    memset(m_talkMr, 0, sizeof(TALK_MR) * MAX_SOUND_OUT);
+	memset(m_talkIndex, 0 , sizeof(int) * MAX_DEVICES * MAX_AUDIO_V40);
+	// Note that LoadIcon does not require a subsequent DestroyIcon in Win32
+	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
+}
+
+void CDlgTalkMREx::DoDataExchange(CDataExchange* pDX)
+{
+	CDialog::DoDataExchange(pDX);
+	//{{AFX_DATA_MAP(CDlgTalkMR)
+	DDX_Control(pDX, IDC_COMBO_AUDIO_ENC_TYPE, m_comAudioEncType);
+	DDX_Control(pDX, IDC_TREE_DEV, m_treeBroadCast);
+	DDX_Control(pDX, IDC_BUTTALK, m_btTalk);
+	//}}AFX_DATA_MAP
+}
+
+BEGIN_MESSAGE_MAP(CDlgTalkMREx, CDialog)
+	//{{AFX_MSG_MAP(CDlgTalkMR)
+	ON_BN_CLICKED(IDC_BUTTALK, OnButtalk)
+	ON_BN_CLICKED(IDC_BTN_EXIT, OnBtnExit)
+	ON_NOTIFY(NM_CLICK, IDC_TREE_DEV, OnClickTreeDev)
+	ON_BN_CLICKED(IDC_BTN_REFRESH, OnBtnRefresh)
+	//}}AFX_MSG_MAP
+END_MESSAGE_MAP()
+
+/////////////////////////////////////////////////////////////////////////////
+/*********************************************************
+  Function:	OnInitDialog
+  Desc:		Initialize the dialog
+  Input:	none
+  Output:	none
+  Return:	none
+**********************************************************/
+BOOL CDlgTalkMREx::OnInitDialog()
+{
+	CDialog::OnInitDialog();
+	// TODO: Add extra initialization here
+	
+#ifdef RECORD 
+	CreateWaveFile("record.wav");
+#endif
+	g_pDlgTalkMR = this;
+	GetDlgItem(IDC_BUTTALK)->EnableWindow(TRUE);
+
+	m_hExitEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
+	int i = 0;
+	for (i = 0; i < MAX_SOUND_OUT; i++)
+	{
+		m_hHaveRDataRV[i] = CreateEvent(NULL, TRUE, FALSE, NULL);
+	}	
+
+#if (!defined _WIN64)
+	//encoder 722
+	m_pEncoder = NET_DVR_InitG722Encoder();
+
+#elif (defined _WIN64)
+    //722
+    NET_DVR_AUDIOENC_INFO struEncInfo = { 0 };
+    m_pEncoder = NET_DVR_InitG722Encoder(&struEncInfo);
+    
+    //711
+    NET_DVR_AUDIOENC_INFO struEncInfo711 = { 0 };
+    m_pG711Enc = NET_DVR_InitG711Encoder(&struEncInfo711);
+#endif
+
+    //g726
+    m_pG726Enc = NET_DVR_InitG726Encoder(&m_pG726EncM);
+	
+	LoadTreeImage();
+	CreateTree();
+	GetDlgItem(IDC_TREE_DEV)->EnableWindow(TRUE);
+	return TRUE;  // return TRUE  unless you set the focus to a control
+}
+
+/*********************************************************
+  Function:	CreateWaveFile
+  Desc:		create the file to save wave data
+  Input:	sFileName, point to file name;
+  Output:	none
+  Return:	none
+**********************************************************/
+BOOL CDlgTalkMREx::CreateWaveFile(char* sFileName)
+{
+	// check if file is already open
+	if (m_hFile) 
+	{
+		return FALSE;	
+	}
+	
+	// open file
+	m_hFile = ::mmioOpen(sFileName,NULL, MMIO_CREATE|MMIO_WRITE|MMIO_EXCLUSIVE | MMIO_ALLOCBUF);
+	if(m_hFile == NULL) 
+	{
+		return FALSE;
+	}
+	
+	ZeroMemory(&m_MMCKInfoParent, sizeof(MMCKINFO));
+	m_MMCKInfoParent.fccType = mmioFOURCC('W','A','V','E');
+	
+	MMRESULT mmResult = ::mmioCreateChunk( m_hFile,&m_MMCKInfoParent, MMIO_CREATERIFF);
+	
+	ZeroMemory(&m_MMCKInfoChild, sizeof(MMCKINFO));
+	m_MMCKInfoChild.ckid = mmioFOURCC('f','m','t',' ');
+	m_MMCKInfoChild.cksize = sizeof(WAVEFORMATEX) + m_struWaveFormat.cbSize;
+	mmResult = ::mmioCreateChunk(m_hFile, &m_MMCKInfoChild, 0);
+	mmResult = ::mmioWrite(m_hFile, (char*)&m_struWaveFormat, sizeof(WAVEFORMATEX) + m_struWaveFormat.cbSize); 
+	mmResult = ::mmioAscend(m_hFile, &m_MMCKInfoChild, 0);
+	m_MMCKInfoChild.ckid = mmioFOURCC('d', 'a', 't', 'a');
+	mmResult = ::mmioCreateChunk(m_hFile, &m_MMCKInfoChild, 0);
+	
+	return TRUE;
+}
+
+/*********************************************************
+  Function:	OnButtalk
+  Desc:		begin get client audio data and send to device/获取本地数据并发送给设备
+  Input:	none
+  Output:	none
+  Return:	none
+**********************************************************/
+void CDlgTalkMREx::OnButtalk()
+{
+    char szLan[32] = { 0 };
+    if (!m_bWaveDeal)
+    {
+        m_bReset = TRUE;
+
+        WAVEFORMATEX struWaveFormat = { 0 };
+
+        //open wavout
+        DWORD dwBufSize = AUDENCSIZE;	//G722
+        memcpy(&struWaveFormat, &m_struWaveFormat, sizeof(WAVEFORMATEX));
+
+        if (m_comAudioEncType.GetCurSel() != AUDIOTALKTYPE_G722)
+        {
+            //struWaveFormat.nSamplesPerSec = SAMPLES_PER_SECOND / 2;
+            //struWaveFormat.nAvgBytesPerSec = SAMPLES_PER_SECOND * m_struWaveFormat.nBlockAlign / 2;
+            if (m_comAudioEncType.GetCurSel() == 4)
+            {
+                dwBufSize = G726_AUDENCSIZE; //G726
+            }
+            else if (m_comAudioEncType.GetCurSel() == 1 || m_comAudioEncType.GetCurSel() == 2)
+            {
+                dwBufSize = G711_AUDENCSIZE; //G711
+            }
+            else if (m_comAudioEncType.GetCurSel() == 6)//PCM
+            {
+                dwBufSize = PCM_AUDENCSIZE;
+            }
+            else if (m_comAudioEncType.GetCurSel() == 3) //MP2L2
+            {
+                dwBufSize = MP2L2_AUDDECSIZE;
+            }
+        }
+
+        //目前支持一路转发听声音
+        if (m_SoundOut[0].OpenSound(struWaveFormat, m_dwBufNum, dwBufSize, CALLBACK_FUNCTION, 0))
+        {
+            g_pMainDlg->AddLog(-1, OPERATION_SUCC_T, "open wavout");
+            if (m_SoundOut[0].PlaySound())
+            {
+                g_pMainDlg->AddLog(-1, OPERATION_SUCC_T, "play wavout");
+                m_bOpenWavOut[0] = TRUE;
+                //m_SoundOut.SetVolume(0x7fff7fff);
+            }
+        }
+        else
+        {
+            g_pMainDlg->AddLog(-1, OPERATION_FAIL_T, "play wavout failed");
+        }
+
+        //open wavin
+        m_SoundIn.SetSoundInDataCB(DataFromSoundInEx, this);
+        if (m_SoundIn.Start(&struWaveFormat, m_dwBufNum, dwBufSize))
+        {
+            g_pMainDlg->AddLog(-1, OPERATION_SUCC_T, "open wave in");
+            m_bOpenWavIn = TRUE;
+        }
+        else
+        {
+            m_SoundIn.Stop();
+            g_pMainDlg->AddLog(-1, OPERATION_FAIL_T, "open wave in failed");
+        }
+        GetDlgItem(IDC_TREE_DEV)->EnableWindow(TRUE);
+        g_StringLanType(szLan, "停止转发", "Stop Talk MR");
+        m_btTalk.SetWindowText(szLan);
+    }
+    else
+    {
+        StopSoundInAndSoundOut();
+        g_StringLanType(szLan, "开始转发", "Start Talk MR");
+        m_btTalk.SetWindowText(szLan);
+    }
+    m_bWaveDeal = !m_bWaveDeal;
+}
+
+/*********************************************************
+  Function:	SendDataToDVR
+  Desc:		send client audio data to device
+  Input:	buf, the audio data buffer;
+			dwSize, data length;
+  Output:	none
+  Return:	TRUE/FALSE
+**********************************************************/
+BOOL CDlgTalkMREx::SendDataToDVR(char *buf, DWORD dwSize)
+{
+    if (!m_bWaveDeal)
+    {
+        return FALSE;
+    }
+    //G722规定输入数据的大小为1280字节,编码后的输出数据大小为80字节
+
+    //G726规定输入数据的大小为640字节,编码后的输出数据大小为80字节
+    BYTE G726EncOutBuf[G726_AUDDECSIZE] = { 0 };
+
+    //G711规定输入数据的大小为320字节, 编码后的输出数据大小为160字节
+    BYTE G711EncBuf[G711_AUDDECSIZE * 2] = { 0 };
+    BYTE G711EncBufA[G711_AUDDECSIZE * 2] = { 0 };
+
+    if (m_byAudioEncType == AUDIOTALKTYPE_G711_A)
+    {
+#if (!defined _WIN64)
+        NET_DVR_EncodeG711Frame(1, (BYTE*)buf, G711EncBufA);
+#elif(defined _WIN64)
+        NET_DVR_AUDIOENC_PROCESS_PARAM struEncProcParam = { 0 };
+        struEncProcParam.g711_type = 1;
+        struEncProcParam.in_buf = (BYTE*)buf;
+        struEncProcParam.out_buf = G711EncBufA;
+        NET_DVR_EncodeG711Frame(m_pG711Enc, &struEncProcParam);
+#endif
+    }
+    else if (m_byAudioEncType == AUDIOTALKTYPE_G711_MU)
+    {
+#if (!defined _WIN64)
+        NET_DVR_EncodeG711Frame(0, (BYTE*)buf, G711EncBuf);
+#elif(defined _WIN64)
+        NET_DVR_AUDIOENC_PROCESS_PARAM struEncProcParam = { 0 };
+        struEncProcParam.g711_type = 0;
+        struEncProcParam.in_buf = (BYTE*)buf;
+        struEncProcParam.out_buf = G711EncBuf;
+        NET_DVR_EncodeG711Frame(m_pG711Enc, &struEncProcParam);
+#endif
+    }
+    else if (m_byAudioEncType == 4)
+    {
+        if (NULL != m_pG726EncM)
+        {
+            NET_DVR_EncodeG726Frame(m_pG726EncM, (BYTE*)buf, G726EncOutBuf, m_bReset);
+            m_bReset = 0;
+        }
+    }
+    else if (m_byAudioEncType == AUDIOTALKTYPE_G722)
+    {
+        if (NULL != m_pEncoder)
+        {
+#if (!defined _WIN64)
+            NET_DVR_EncodeG722Frame(m_pEncoder, (BYTE*)buf, m_byEncBuf);
+            //TRACE("NET_DVR_EncodeG722Frame failed\n");
+            //return FALSE;
+#elif (defined _WIN64)
+            NET_DVR_AUDIOENC_PROCESS_PARAM struEncProcParam = { 0 };
+            struEncProcParam.in_buf = (unsigned char *)buf;
+            struEncProcParam.out_buf = (unsigned char *)&m_byEncBuf;
+            NET_DVR_EncodeG722Frame(m_pEncoder, &struEncProcParam);
+#endif
+
+        }
+    }
+
+    int i = 0, j=0;
+
+#ifdef RECORD 
+    if (mmioWrite(m_hFile, buf, dwSize) != dwSize)
+    {
+        TRACE("mmioWrite failed\n");
+    }
+#endif
+
+    //send to dvr
+    for (i = 0; i < MAX_DEVICES; i++)
+    {
+        if (g_struDeviceInfo[i].lLoginID >= 0)
+        {
+            for (j = 0; j < g_struDeviceInfo[i].iAudioNum; j++)
+            {
+                if (g_struDeviceInfo[i].lVoiceCom[j] >= 0)
+                {
+                    if (g_struDeviceInfo[i].iAudioEncType == AUDIOTALKTYPE_G722)
+                    {
+                        if (!NET_DVR_VoiceComSendData(g_struDeviceInfo[i].lVoiceCom[j], (char*)m_byEncBuf, AUDDECSIZE))
+                        {
+                            g_pMainDlg->AddLog(i, OPERATION_FAIL_T, "NET_DVR_VoiceComSendData audioindex[%d]", j);
+                        }
+                    }
+                    else if (g_struDeviceInfo[i].iAudioEncType == AUDIOTALKTYPE_G711_MU)
+                    {
+                        if (!NET_DVR_VoiceComSendData(g_struDeviceInfo[i].lVoiceCom[j], (char*)G711EncBuf, G711_AUDDECSIZE))
+                        {
+                            g_pMainDlg->AddLog(i, OPERATION_FAIL_T, "NET_DVR_VoiceComSendData audioindex[%d]", j);
+                        }
+                    }
+                    else if (g_struDeviceInfo[i].iAudioEncType == AUDIOTALKTYPE_G711_A)
+                    {
+                        if (!NET_DVR_VoiceComSendData(g_struDeviceInfo[i].lVoiceCom[j], (char*)G711EncBufA, G711_AUDDECSIZE))
+                        {
+                            g_pMainDlg->AddLog(i, OPERATION_FAIL_T, "NET_DVR_VoiceComSendData audioindex[%d]", j);
+                        }
+                    }
+                    else if (g_struDeviceInfo[i].iAudioEncType == AUDIOTALKTYPE_G726)
+                    {
+                        if (!NET_DVR_VoiceComSendData(g_struDeviceInfo[i].lVoiceCom[j], (char*)G726EncOutBuf, G726_AUDDECSIZE))
+                        {
+                            g_pMainDlg->AddLog(i, OPERATION_FAIL_T, "NET_DVR_VoiceComSendData audioindex[%d]", j);
+                        }
+                    }
+                    else if (g_struDeviceInfo[i].iAudioEncType == AUDIOTALKTYPE_PCM)
+                    {
+                        if (!NET_DVR_VoiceComSendData(g_struDeviceInfo[i].lVoiceCom[j], buf, dwSize))
+                        {
+                            g_pMainDlg->AddLog(i, OPERATION_FAIL_T, "NET_DVR_VoiceComSendData audioindex[%d]", j);
+                        }
+                    }
+                    //	else
+                    //	{
+                    //	g_struDeviceInfo[i].lVoiceCom[j] = -1;
+                    //	g_pMainDlg->AddLog(i, OPERATION_SUCC_T, "NET_DVR_VoiceComSendData audioindex[%d]", j);
+                    //	}			
+                }
+            }
+        }
+    }
+
+    return TRUE; 
+}
+
+
+/*********************************************************
+  Function:	PutIntoBuf
+  Desc:		input the device audio data to buffer for decoding better/对收到的音频数据做缓冲处理
+  Input:	lpTemp, voice data buffer;
+			Bytes, voice data lenght;
+  Output:	none
+  Return:	none
+**********************************************************/
+BOOL CDlgTalkMREx::PutIntoBuf(char *lpTemp, int Bytes, LPTALK_MR lpTalkMR)
+{
+	int nTemp = 0;
+	int nPacketStart = 0;
+	DWORD dwAudDecSize = 0;
+	if (lpTalkMR->byAudioType == AUDIOTALKTYPE_G722)
+	{
+		dwAudDecSize = AUDDECSIZE;
+	}
+	else if (lpTalkMR->byAudioType == AUDIOTALKTYPE_G726)
+	{
+		dwAudDecSize = G726_AUDDECSIZE;
+	}
+    else if (lpTalkMR->byAudioType == AUDIOTALKTYPE_PCM)
+    {
+        dwAudDecSize = PCM_AUDENCSIZE;
+    }
+    else
+    {
+        dwAudDecSize = G711_AUDDECSIZE;
+    }
+
+	try{
+		if ((m_ReceiveIndexRV[lpTalkMR->byIndex] + Bytes) <= AUDIOBUF)
+		{
+			if (!m_bOpenPlayThread[lpTalkMR->byIndex])
+			{
+				memcpy(m_pRenderBuf[lpTalkMR->byIndex]+m_ReceiveIndexRV[lpTalkMR->byIndex], lpTemp, Bytes);
+				m_ReceiveIndexRV[lpTalkMR->byIndex] += Bytes;
+				//m_ReceiveIndexRV[lpTalkMR->byIndex] = m_ReceiveIndexRV[lpTalkMR->byIndex] % AUDIOBUF;
+			}
+			else
+			{
+				if (((m_ReceiveIndexRV[lpTalkMR->byIndex] + Bytes) >= m_rIndexRV[lpTalkMR->byIndex])  
+					&& (m_ReceiveIndexRV[lpTalkMR->byIndex] < m_rIndexRV[lpTalkMR->byIndex]))
+				{   //buffer1 overflow
+					TRACE("buffer overflow.");
+					//::SetEvent(m_hHaveRDataRV[lpTalkMR->byIndex]);
+					nPacketStart = (m_rIndexRV[lpTalkMR->byIndex] - dwAudDecSize + m_ReceiveIndexRV[lpTalkMR->byIndex] % dwAudDecSize);
+					if ((nPacketStart + Bytes) <= (DWORD)AUDIOBUF)
+					{
+						memcpy(m_pRenderBuf[lpTalkMR->byIndex] + nPacketStart, lpTemp, Bytes);
+						m_ReceiveIndexRV[lpTalkMR->byIndex] = nPacketStart + Bytes;
+					}
+					else
+					{
+						nTemp = AUDIOBUF - nPacketStart;
+						memcpy(m_pRenderBuf[lpTalkMR->byIndex] + nPacketStart, lpTemp, nTemp);
+						memcpy(m_pRenderBuf[lpTalkMR->byIndex], lpTemp + nTemp, Bytes - nTemp);
+						m_ReceiveIndexRV[lpTalkMR->byIndex] = Bytes - nTemp;
+					}
+				}
+				else	
+				{
+					memcpy(m_pRenderBuf[lpTalkMR->byIndex] + m_ReceiveIndexRV[lpTalkMR->byIndex], lpTemp, Bytes);
+					m_ReceiveIndexRV[lpTalkMR->byIndex] += Bytes;
+					//m_ReceiveIndexRV[lpTalkMR->byIndex] = m_ReceiveIndexRV[lpTalkMR->byIndex] % AUDIOBUF;
+				}
+			}
+		}
+		else
+		{
+			if (m_bOpenPlayThread[lpTalkMR->byIndex])
+			{
+                if (m_ReceiveIndexRV[lpTalkMR->byIndex] + Bytes >= m_rIndexRV[lpTalkMR->byIndex] + AUDIOBUF)
+                {
+                    TRACE("buffer overflow.");
+                    //SetEvent(m_hHaveRDataRV[lpTalkMR->byIndex]);
+
+					if (m_rIndexRV[lpTalkMR->byIndex] != 0)
+					{
+						nPacketStart = (m_rIndexRV[lpTalkMR->byIndex] - dwAudDecSize + m_ReceiveIndexRV[lpTalkMR->byIndex] % dwAudDecSize);
+					}
+					else
+					{
+						nPacketStart = (m_rIndexRV[lpTalkMR->byIndex] + AUDIOBUF - dwAudDecSize + m_ReceiveIndexRV[lpTalkMR->byIndex] % dwAudDecSize);
+					}
+					if ((nPacketStart + Bytes) <= (DWORD)AUDIOBUF)
+					{
+						memcpy(m_pRenderBuf[lpTalkMR->byIndex] + nPacketStart, lpTemp, Bytes);
+						m_ReceiveIndexRV[lpTalkMR->byIndex] = nPacketStart + Bytes;
+					}
+					else
+					{
+						nTemp = AUDIOBUF - nPacketStart;
+                        if(nTemp < 0)
+                        {
+                            nTemp = 0;
+                        }
+						memcpy(m_pRenderBuf[lpTalkMR->byIndex] + nPacketStart, lpTemp, nTemp);
+						memcpy(m_pRenderBuf[lpTalkMR->byIndex], lpTemp + nTemp, Bytes - nTemp);
+						m_ReceiveIndexRV[lpTalkMR->byIndex] = Bytes - nTemp;
+					}
+				}
+				else
+				{
+                    nTemp = AUDIOBUF - m_ReceiveIndexRV[lpTalkMR->byIndex];
+                    if(nTemp < 0)
+                    {
+                        nTemp = 0;
+                    }
+                    memcpy(m_pRenderBuf[lpTalkMR->byIndex] + m_ReceiveIndexRV[lpTalkMR->byIndex], lpTemp, nTemp);
+					memcpy(m_pRenderBuf[lpTalkMR->byIndex], lpTemp + nTemp, Bytes - nTemp);
+					m_ReceiveIndexRV[lpTalkMR->byIndex] = Bytes - nTemp;
+				}
+			}
+		}
+	}
+	catch(...)
+	{
+		return FALSE;
+	}
+    //	TRACE("number:%d, m_nBufNo:%d\n", (m_ReceiveIndexRV[lpTalkMR->byIndex] + AUDIOBUF - m_rIndexRV[lpTalkMR->byIndex]) % (AUDIOBUF), m_nBufNo[lpTalkMR->byIndex]*dwAudDecSize);
+    // 	if ((((m_ReceiveIndexRV[lpTalkMR->byIndex] + AUDIOBUF - m_rIndexRV[lpTalkMR->byIndex]) % (AUDIOBUF)) >= (m_nBufNo[lpTalkMR->byIndex] * dwAudDecSize)))
+    // 	{
+    // 		::SetEvent(m_hHaveRDataRV[lpTalkMR->byIndex]);
+    // 		m_nBufNo[lpTalkMR->byIndex] = 1;
+    //         if (!m_bOpenPlayThread[lpTalkMR->byIndex] && m_bWaveDeal) //开启播放时再开启线程回调
+    // 		{
+    //             m_hPlayHandle[0] = CreateThread(NULL, 0, PlayAudioThread, lpTalkMR, 0, NULL);
+    // 			m_bOpenPlayThread[lpTalkMR->byIndex] = TRUE;
+    // 		}
+    // 	}
+    //m_nBufNo[lpTalkMR->byIndex] = 1;
+    if (!m_bOpenPlayThread[lpTalkMR->byIndex] && m_bWaveDeal) //开启播放时再开启线程回调
+    {
+        m_hPlayHandle[lpTalkMR->byIndex] = CreateThread(NULL, 0, PlayAudioThread, lpTalkMR, 0, NULL);
+        m_bOpenPlayThread[lpTalkMR->byIndex] = TRUE;
+    }
+    SetEvent(m_hHaveRDataRV[lpTalkMR->byIndex]);
+
+	return TRUE;
+}
+
+/*********************************************************
+  Function:	CopyAudioData
+  Desc:		deal the audio data from device/从接收缓冲区中拷贝数据出来解码
+  Input:	lpTemp, data buffer; dwReadLength, data length;
+  Output:	none
+  Return:	TRUE/FALSE
+**********************************************************/
+BOOL CDlgTalkMREx::CopyAudioData(PBYTE lpTemp, DWORD dwReadLength, int nIndex)
+{
+	DWORD dwTemp;
+	int  dwPacketNumber = 0;
+	int itemp = 0;
+	__try
+	{
+		if (m_rIndexRV[nIndex] == m_ReceiveIndexRV[nIndex])
+		{
+			dwPacketNumber = 0;
+			m_nBufNo[nIndex] = 6;
+			::ResetEvent(m_hHaveRDataRV[nIndex]);
+			itemp = 0;
+			return FALSE;
+		}
+		else if (m_rIndexRV[nIndex] < m_ReceiveIndexRV[nIndex])    //read < write
+		{
+			if (dwReadLength > (DWORD)(m_ReceiveIndexRV[nIndex]-m_rIndexRV[nIndex]))
+			{
+				dwPacketNumber = 0;
+				m_nBufNo[nIndex] = 6;
+				::ResetEvent(m_hHaveRDataRV[nIndex]);
+				itemp = 0;
+				return FALSE;
+			}
+			else
+			{
+				CopyMemory(lpTemp, m_pRenderBuf[nIndex] + m_rIndexRV[nIndex], dwReadLength);
+				m_rIndexRV[nIndex] += dwReadLength;
+				dwPacketNumber = (m_ReceiveIndexRV[nIndex] - m_rIndexRV[nIndex]) / dwReadLength;
+				itemp = 1;
+			}
+		}
+		else	//read > write
+		{
+			if (dwReadLength > (DWORD)(AUDIOBUF - m_rIndexRV[nIndex]))
+			{
+				dwTemp = AUDIOBUF - m_rIndexRV[nIndex];
+				if ((dwReadLength-dwTemp) < (DWORD)(m_ReceiveIndexRV[nIndex] + 1))
+				{
+					CopyMemory(lpTemp, m_pRenderBuf[nIndex] + m_rIndexRV[nIndex], dwTemp);
+					CopyMemory(lpTemp + dwTemp, m_pRenderBuf[nIndex], dwReadLength - dwTemp);
+					m_rIndexRV[nIndex] = dwReadLength - dwTemp;
+					dwPacketNumber = (m_ReceiveIndexRV[nIndex] - m_rIndexRV[nIndex]) / dwReadLength;
+					itemp = 2;
+				}
+				else
+				{
+					dwPacketNumber = 0;
+					::ResetEvent(m_hHaveRDataRV[nIndex]);
+					m_nBufNo[nIndex] = 6;
+					itemp = 3;
+					return FALSE;	
+				}
+			}
+			else
+			{
+				itemp = 4;
+				CopyMemory(lpTemp, m_pRenderBuf[nIndex] + m_rIndexRV[nIndex], dwReadLength);
+				m_rIndexRV[nIndex] += dwReadLength;
+				dwPacketNumber = (AUDIOBUF + m_ReceiveIndexRV[nIndex] - m_rIndexRV[nIndex]) / dwReadLength;
+			}
+		}
+	}
+	__except(EXCEPTION_EXECUTE_HANDLER)
+	{
+		return FALSE;
+	}
+	return TRUE;
+}
+
+/*********************************************************
+  Function:	InputAudioData
+  Desc:		input the device audio data to decoder and decode/取出音频数据并解码
+  Input:	none
+  Output:	none
+  Return:	none
+**********************************************************/
+void CDlgTalkMREx::InputAudioData(LPTALK_MR lpTalkMR)
+{
+	HANDLE hWaitEvents[2];
+	hWaitEvents[0] = m_hExitEvent;
+	hWaitEvents[1] = m_hHaveRDataRV[lpTalkMR->byIndex];
+	
+	void*	pDecoder = NULL;//g722 decoder
+	void*	pG726Dec = NULL;//g726解码句柄
+    void*	pG711Dec = NULL;//g711解码句柄 win64
+	void*	pG726DecM = NULL;//g726解码模块句柄
+
+	DWORD dwReadLength = 0;
+	DWORD dwPlayLength = 0;
+	if (lpTalkMR->byAudioType == AUDIOTALKTYPE_G722)
+	{
+		dwReadLength = AUDDECSIZE;
+		dwPlayLength = AUDENCSIZE;
+		//decoder
+#if (!defined _WIN64)
+	    pDecoder = NET_DVR_InitG722Decoder(BIT_RATE_16000);
+#elif (defined _WIN64)
+        pDecoder = NET_DVR_InitG722Decoder();
+#endif
+	}
+	else if (lpTalkMR->byAudioType == AUDIOTALKTYPE_G726)
+	{
+		dwReadLength = G726_AUDDECSIZE;
+		dwPlayLength = G726_AUDENCSIZE;
+		pG726Dec = NET_DVR_InitG726Decoder(&pG726DecM);
+	}
+    else if (lpTalkMR->byAudioType == AUDIOTALKTYPE_PCM)
+    {
+        dwReadLength = PCM_AUDENCSIZE;
+        dwPlayLength = PCM_AUDENCSIZE;
+    }
+    else if (lpTalkMR->byAudioType == AUDIOTALKTYPE_MP2L2)
+    {
+        dwReadLength = MP2L2_AUDDECSIZE;
+        dwPlayLength = MP2L2_AUDENCSIZE;
+    }
+	else
+	{
+		dwReadLength = G711_AUDDECSIZE;
+		dwPlayLength = G711_AUDENCSIZE;
+#if (defined _WIN64)
+        pG711Dec = NET_DVR_InitG711Decoder();
+#endif
+	}
+
+	BYTE  *lpTemp = NULL;
+	lpTemp = new BYTE[dwReadLength];
+	BYTE  *lpPlayBuf = NULL;
+	lpPlayBuf = new BYTE[dwPlayLength];
+	DWORD dwWaitResult = 0;
+	int i = 0;
+	BYTE byReset = 1;
+	try
+	{
+        while (m_bOpenWavOut[lpTalkMR->byIndex])
+        {
+            dwWaitResult = WaitForMultipleObjects(2, hWaitEvents, FALSE, 500);
+            if (WAIT_OBJECT_0 == dwWaitResult || WAIT_FAILED == dwWaitResult)
+            {
+                break;
+            }
+            else if (WAIT_TIMEOUT == dwWaitResult)
+            {
+                continue;
+            }
+
+			if (CopyAudioData(lpTemp, dwReadLength, lpTalkMR->byIndex))
+			{
+				if (lpTalkMR->byAudioType == AUDIOTALKTYPE_G722)
+				{
+					if (NULL != pDecoder)
+					{
+#if (!defined _WIN64)
+						NET_DVR_DecodeG722Frame(pDecoder, (BYTE*)lpTemp, lpPlayBuf);
+#elif (defined _WIN64)
+                        NET_DVR_AUDIODEC_PROCESS_PARAM struEncProcParam = { 0 };
+                        struEncProcParam.in_buf = (BYTE*)lpTemp;
+                        struEncProcParam.out_buf = lpPlayBuf;
+                        struEncProcParam.in_data_size = dwReadLength;
+                        NET_DVR_DecodeG722Frame(pDecoder, &struEncProcParam);
+#endif
+					}					
+				}				
+				else if (lpTalkMR->byAudioType == AUDIOTALKTYPE_G711_MU)
+				{
+#if (!defined _WIN64)
+					NET_DVR_DecodeG711Frame(0,(BYTE*)lpTemp,lpPlayBuf);
+#elif (defined _WIN64)
+                    NET_DVR_AUDIODEC_PROCESS_PARAM struEncProcParam = { 0 };
+                    struEncProcParam.in_buf = (BYTE*)lpTemp;
+                    struEncProcParam.out_buf = lpPlayBuf;
+                    struEncProcParam.in_data_size = dwReadLength;
+                    if (!NET_DVR_DecodeG711Frame(pG711Dec, &struEncProcParam))
+                    {
+                    }
+#endif
+				}
+				else if (lpTalkMR->byAudioType == AUDIOTALKTYPE_G711_A)
+				{
+#if (!defined _WIN64)
+					NET_DVR_DecodeG711Frame(1,(BYTE*)lpTemp,lpPlayBuf);
+#elif (defined _WIN64)
+                    NET_DVR_AUDIODEC_PROCESS_PARAM struEncProcParam = { 0 };
+                    struEncProcParam.in_buf = (BYTE*)lpTemp;
+                    struEncProcParam.out_buf = lpPlayBuf;
+                    struEncProcParam.in_data_size = dwReadLength;
+                    struEncProcParam.g711_type = 1;
+                    NET_DVR_DecodeG711Frame(pG711Dec, &struEncProcParam);
+#endif
+				}
+				else if (lpTalkMR->byAudioType == AUDIOTALKTYPE_G726)
+				{
+					if (NULL != pG726DecM)
+					{
+						NET_DVR_DecodeG726Frame(pG726DecM, (BYTE*)lpTemp, lpPlayBuf, byReset);
+						byReset = 0;
+					}
+				}				
+                else if (lpTalkMR->byAudioType == AUDIOTALKTYPE_PCM)
+                {
+                    memcpy(lpPlayBuf, lpTemp, PCM_AUDENCSIZE);
+                }
+
+				for (i=0; i<35; i++)
+				{				
+					if (m_SoundOut[lpTalkMR->byIndex].InputData((BYTE*)lpPlayBuf, 0))
+					{
+						break;
+					}
+					Sleep(1);
+				}				
+			}
+			else if (m_pRenderBuf[lpTalkMR->byIndex] == NULL)
+			{
+                break;
+			}
+		}	
+	}
+	catch (...)
+	{
+		TRACE("InputAudioData exception\n");
+        ExitPlayAudio(lpTemp, lpPlayBuf, pDecoder, pG726Dec, pG726DecM, pG711Dec, lpTalkMR->byIndex);
+		return ;
+	}
+
+    ResetEvent(m_hExitEvent);
+    ExitPlayAudio(lpTemp, lpPlayBuf, pDecoder, pG726Dec, pG726DecM, pG711Dec, lpTalkMR->byIndex);
+	return ;
+}
+
+/*********************************************************
+  Function:	PlayAudioThread
+  Desc:		play the audio data from device
+  Input:	pParam, point to current dialog
+  Output:	none
+  Return:	0
+**********************************************************/
+DWORD WINAPI CDlgTalkMREx::PlayAudioThread(LPVOID pParam)
+{
+	ASSERT(pParam);
+//	CDlgTalkMREx * pClient = (CDlgTalkMREx *)pParam;
+	try
+	{
+	//	pClient->InputAudioData();
+		g_pDlgTalkMR->InputAudioData((LPTALK_MR)pParam);
+	}
+	catch (...)
+	{
+		TRACE("Input data exception\n");
+		return 1;
+	}
+	
+	return 0;
+}
+
+/*********************************************************
+  Function:	OnBtnExit
+  Desc:		exit the dialog
+  Input:	none
+  Output:	none
+  Return:	none
+**********************************************************/
+void CDlgTalkMREx::OnBtnExit() 
+{
+    if (m_bWaveDeal)
+    {
+        OnButtalk();
+    }
+
+	int i=0;
+	int j=0;
+
+		
+	if (m_pEncoder)
+	{
+		NET_DVR_ReleaseG722Encoder(m_pEncoder);
+		m_pEncoder = NULL;
+	}
+	
+	if (m_pG726Enc)
+	{
+		NET_DVR_ReleaseG726Encoder(m_pG726Enc);
+		m_pG726Enc = NULL;
+		m_pG726EncM = NULL;
+	}
+
+    if (m_pG711Enc)
+    {
+#if (defined _WIN64)
+        NET_DVR_ReleaseG711Encoder(m_pG711Enc);
+#endif
+        m_pG711Enc = NULL;
+        m_pG711Enc = NULL;
+    }
+    	
+    if (INVALID_HANDLE_VALUE != m_hExitEvent)
+    {
+        CloseHandle(m_hExitEvent);
+        m_hExitEvent = INVALID_HANDLE_VALUE;
+    }
+
+	for (i=0; i<MAX_DEVICES; i++)
+	{
+		if (g_struDeviceInfo[i].lLoginID >= 0)
+		{
+			for (j=0; j<g_struDeviceInfo[i].iAudioNum; j++)
+			{
+				if (g_struDeviceInfo[i].lVoiceCom[j]>=0)
+				{
+					if (!NET_DVR_StopVoiceCom(g_struDeviceInfo[i].lVoiceCom[j]))
+					{
+						g_pMainDlg->AddLog(i, OPERATION_FAIL_T, "NET_DVR_StopVoiceCom audioindex[%d]", j);
+					}
+					else
+					{
+						g_struDeviceInfo[i].lVoiceCom[j] = -1;
+						g_pMainDlg->AddLog(i, OPERATION_SUCC_T, "NET_DVR_StopVoiceCom audioindex[%d]", j);
+					}
+					
+				}
+			}
+		}
+	}
+	for (i = 0; i < MAX_SOUND_OUT; i++)
+	{
+		if (m_hHaveRDataRV[i])
+		{
+			CloseHandle(m_hHaveRDataRV[i]);	
+			m_hHaveRDataRV[i] = NULL;
+		}
+		
+		if (m_pRenderBuf[i])
+		{
+			//	::VirtualFree(m_pRenderBuf[i], 0, MEM_RELEASE);
+			delete []m_pRenderBuf[i];
+			m_pRenderBuf[i] = NULL;
+		//	memset(&m_talkMr[i], 0, sizeof(TALK_MR));
+			m_talkMr[i].byAudioType = 0;
+			m_talkMr[i].byFlag = 0;
+		}
+	}
+
+	CDialog::OnCancel();
+}
+
+/*********************************************************
+  Function:	CreateTree
+  Desc:		create the voice channels of all devices/创建语音通道树
+  Input:	none
+  Output:	none
+  Return:	none
+**********************************************************/
+void CDlgTalkMREx::CreateTree(void)
+{
+	char szLan[1024] = {0};
+	g_StringLanType(szLan, "所有设备", "All Devices");
+	m_treeBroadCast.DeleteAllItems();
+	HTREEITEM hRoot = m_treeBroadCast.InsertItem(szLan, TREE_ALL, TREE_ALL,TVI_ROOT);
+	CString strTemp =_T("");
+	CString strChanTmp = _T("");
+	int i = 0;
+	int iData =0;
+	int j = 0;
+	HTREEITEM hDevice = NULL;
+	HTREEITEM hChanItem = NULL;
+	NET_DVR_WORKSTATE_V30 struWorkState;
+	for (i = 0; i < MAX_DEVICES; i++)
+	{
+		if (g_struDeviceInfo[i].iDeviceChanNum != -1)
+		{
+			strTemp.Format("%s", g_struDeviceInfo[i].chLocalNodeName);
+			if (g_struDeviceInfo[i].lLoginID >= 0)
+			{
+				hDevice =  m_treeBroadCast.InsertItem(strTemp, DEVICE_LOGIN, DEVICE_LOGIN, hRoot);
+				m_treeBroadCast.SetItemData(hDevice, DEVICE_LOGIN*1000 + g_struDeviceInfo[i].iDeviceIndex);
+
+				memset(&struWorkState, 0, sizeof(NET_DVR_WORKSTATE_V30));
+				if (!NET_DVR_GetDVRWorkState_V30(g_struDeviceInfo[i].lLoginID, &struWorkState))
+				{
+					g_pMainDlg->AddLog(i, OPERATION_FAIL_T, "NET_DVR_GetDVRWorkState_V30 before Talk MR");
+				}
+							
+				for (j=0; j<g_struDeviceInfo[i].iAudioNum; j++)
+				{
+					if (struWorkState.byAudioChanStatus[j] == 1)
+					{
+						strTemp.Format("audio%d-used", j+1);
+						iData = 3*1000 + struWorkState.byAudioChanStatus[j]*100 + j;
+					}
+					else if (struWorkState.byAudioChanStatus[j] == 0)
+					{
+						strTemp.Format("audio%d-not used", j+1);
+						iData = 3*1000 + struWorkState.byAudioChanStatus[j]*100 + j;
+					}
+					else if (struWorkState.byAudioChanStatus[j] == 0xff)
+					{
+						strTemp.Format("audio%d", j+1);
+						iData = 3*1000 + j;
+					}
+					 			
+					hChanItem =  m_treeBroadCast.InsertItem(strTemp, 3, 3, hDevice);
+					m_treeBroadCast.SetItemData(hChanItem, iData);
+					//is talking, set check box
+					if (g_struDeviceInfo[i].lVoiceCom[j] >= 0)
+					{
+						m_treeBroadCast.SetCheck(hChanItem, TRUE);
+					}				
+				}
+				m_treeBroadCast.Expand(hDevice,TVE_EXPAND);
+			}
+			else
+			{
+				hDevice =  m_treeBroadCast.InsertItem(strTemp, DEVICE_LOGOUT, DEVICE_LOGOUT,hRoot);
+				m_treeBroadCast.SetItemData(hDevice, DEVICE_LOGOUT*1000 + g_struDeviceInfo[i].iDeviceIndex);
+			}	
+		}
+	}
+	m_treeBroadCast.Expand(hRoot,TVE_EXPAND);
+	m_treeBroadCast.Expand(m_treeBroadCast.GetRootItem(),TVE_EXPAND);
+}
+
+/*********************************************************
+  Function:	OnClickTreeDev
+  Desc:		create the device tree
+  Input:	pNMHDR, point the NMHEADER which contains the click information;
+			pResult, point to the result;
+  Output:	none
+  Return:	none
+**********************************************************/
+void CDlgTalkMREx::OnClickTreeDev(NMHDR* pNMHDR, LRESULT* pResult) 
+{
+	CPoint pt(0,0);
+	CRect rc(0,0,0,0);
+	GetCursorPos(&pt);
+	GetDlgItem(IDC_TREE_DEV)->GetWindowRect(&rc);
+	ScreenToClient(&rc);
+	ScreenToClient(&pt);
+	pt.x = pt.x - rc.left;
+	pt.y = pt.y - rc.top;
+
+	UINT uFlag = 0;
+	HTREEITEM hSelect= m_treeBroadCast.HitTest(pt, &uFlag);
+
+	if (NULL == hSelect) 
+	{
+		return;
+	}
+	
+	m_treeBroadCast.SelectItem(hSelect);
+
+	BOOL bCheck = m_treeBroadCast.GetCheck(hSelect);
+	bCheck = !bCheck;
+	int iDevIndex = 0;
+	int iType = m_treeBroadCast.GetItemData(hSelect)/1000;
+	if (TREE_ALL_T == iType)
+	{
+		CheckAllDevState(hSelect, bCheck, uFlag);
+	}
+	else if (DEVICE_LOGIN == iType)
+	{
+		CheckAllAudioState(hSelect, bCheck, uFlag);
+	}
+	else if (3 == iType)
+	{
+		HTREEITEM hDevItem = m_treeBroadCast.GetParentItem(hSelect);
+        int iAudioIndex = m_treeBroadCast.GetItemData(hSelect) % 100; //刷新状态时，有status*100，故此处应对100取余！！！
+        iDevIndex = m_treeBroadCast.GetItemData(hDevItem)%1000;
+
+		if ((m_treeBroadCast.GetItemData(hDevItem)%1000)/100 ==1)
+		{
+			AfxMessageBox("the audio port of device is using!");
+		}
+		if (uFlag != LVHT_TOLEFT )
+		{
+			m_treeBroadCast.SetCheck(hSelect, bCheck);
+		}
+		else
+		{
+			m_treeBroadCast.SetCheck(hSelect, !bCheck);
+		}
+		StartMR(iDevIndex, iAudioIndex, bCheck);
+	}
+
+	*pResult = 0;
+}
+
+/*********************************************************
+  Function:	CheckAllDevState
+  Desc:		check the status of all devices
+  Input:	hRoot, root node;bCheck, status of the check box; uFlag, the click item flag data
+  Output:	none
+  Return:	none
+**********************************************************/
+void CDlgTalkMREx::CheckAllDevState(HTREEITEM hRoot, BOOL bCheck, int uFlag)
+{
+	if (uFlag == LVHT_TOLEFT)
+	{
+		m_treeBroadCast.SetCheck(hRoot, !bCheck);
+	}
+	else
+	{
+		m_treeBroadCast.SetCheck(hRoot, bCheck);
+	}	
+
+	HTREEITEM hChild = m_treeBroadCast.GetChildItem(hRoot);
+	int iDevIndex = 0;
+	while (hChild)
+	{
+		iDevIndex = m_treeBroadCast.GetItemData(hChild)%1000;
+		
+		if (g_struDeviceInfo[iDevIndex].lLoginID >= 0)
+		{
+			m_treeBroadCast.SetCheck(hChild, bCheck);
+			CheckAllAudioState(hChild, bCheck, 0);
+		}
+
+		hChild = m_treeBroadCast.GetNextSiblingItem(hChild);
+	}
+}
+
+/*********************************************************
+  Function:	LoadTreeImage
+  Desc:		load the tree image
+  Input:	none
+  Output:	none
+  Return:	none
+**********************************************************/
+void CDlgTalkMREx::LoadTreeImage(void)
+{
+	CBitmap bmp[4];
+
+	m_TreeImage.Create(16,16,ILC_COLOR32 | ILC_MASK,1,1);
+	bmp[TREE_ALL].LoadBitmap(IDB_BITMAP_TREE);
+	m_TreeImage.Add(&bmp[TREE_ALL],RGB(1,1,1));
+	bmp[DEVICE_LOGOUT].LoadBitmap(IDB_BITMAP_LOGOUT);
+	m_TreeImage.Add(&bmp[DEVICE_LOGOUT],RGB(1,1,1));
+	bmp[DEVICE_LOGIN].LoadBitmap(IDB_BITMAP_LOGIN);
+	m_TreeImage.Add(&bmp[DEVICE_LOGIN],RGB(1,1,1));
+	bmp[3].LoadBitmap(IDB_BITMAP_AUDIO);
+	m_TreeImage.Add(&bmp[3],RGB(1,1,1));
+	
+	m_treeBroadCast.SetImageList(&m_TreeImage, LVSIL_NORMAL);
+}
+ 
+/*********************************************************
+  Function:	StartMR
+  Desc:		start to create redirect transmission/开始创建语音转发通道
+  Input:	iDeviceIndex,device index;
+			iAudiIndex, audio index;
+			bCheck, begin transmiting or not;
+  Output:	
+  Return:	
+**********************************************************/
+BOOL CDlgTalkMREx::StartMR(int iDeviceIndex, int iAudioIndex, BOOL bCheck)
+{
+	BOOL bRet = FALSE;
+	DWORD dwUserData = iDeviceIndex*100+iAudioIndex;
+	if (bCheck)
+	{
+		if (g_struDeviceInfo[iDeviceIndex].lVoiceCom[iAudioIndex] < 0)  
+		{
+			NET_DVR_COMPRESSION_AUDIO struCodeType;
+			memset(&struCodeType,0,sizeof(NET_DVR_COMPRESSION_AUDIO));
+			if (!NET_DVR_GetCurrentAudioCompress(g_struDeviceInfo[iDeviceIndex].lLoginID, &struCodeType))
+			{
+				g_pMainDlg->AddLog(iDeviceIndex, OPERATION_FAIL_T, "NET_DVR_GetCurrentAudioCompress");
+			}
+			else
+			{
+                m_comAudioEncType.SetCurSel(struCodeType.byAudioEncType);
+                m_byAudioEncType = struCodeType.byAudioEncType;
+                if (5 == struCodeType.byAudioEncType)
+                {
+                    m_comAudioEncType.SetCurSel(3);
+                    m_byAudioEncType = 3;
+                } 
+                else if (6 == struCodeType.byAudioEncType)
+                {
+                    m_comAudioEncType.SetCurSel(4);
+                    m_byAudioEncType = 4;
+                }
+                else if (7 == struCodeType.byAudioEncType)
+                {
+                    m_comAudioEncType.SetCurSel(5);
+                    m_byAudioEncType = 5;
+                }
+                else if (8 == struCodeType.byAudioEncType)
+                {
+                    m_comAudioEncType.SetCurSel(6);
+                    m_byAudioEncType = 6;
+                }
+                SetWaveFormat(struCodeType);
+				g_struDeviceInfo[iDeviceIndex].iAudioEncType = struCodeType.byAudioEncType;
+				g_pMainDlg->AddLog(iDeviceIndex, OPERATION_SUCC_T, "NET_DVR_GetCurrentAudioCompress");
+			}
+
+			int i = 0;
+			for (i = 0; i < MAX_SOUND_OUT; i++)
+			{
+				if (m_talkMr[i].byFlag == 0)
+				{
+					break;
+				}
+			}
+			if (i == MAX_SOUND_OUT)
+			{
+				AfxMessageBox("转发数量超过限制!");
+				return FALSE;
+			}
+			
+			//audio buffer
+		//	m_pRenderBuf[i] = (PBYTE)::VirtualAlloc(NULL, 160*40L, MEM_RESERVE|MEM_COMMIT, PAGE_READWRITE);
+            m_pRenderBuf[i] = new BYTE[AUDIOBUF];
+            if (m_pRenderBuf[i] == NULL)
+            {
+                return FALSE;
+            }
+			m_talkMr[i].byFlag = 1;
+			m_talkMr[i].byAudioType = g_struDeviceInfo[iDeviceIndex].iAudioEncType;
+			m_talkMr[i].byIndex = i;
+			m_talkIndex[iDeviceIndex][iAudioIndex] = i;
+			g_struDeviceInfo[iDeviceIndex].lVoiceCom[iAudioIndex] = NET_DVR_StartVoiceCom_MR_V30(g_struDeviceInfo[iDeviceIndex].lLoginID, iAudioIndex+1, fVoiceDataCallBackEx, &m_talkMr[i]);
+			if (g_struDeviceInfo[iDeviceIndex].lVoiceCom[iAudioIndex] >=0 )
+			{
+				g_pMainDlg->AddLog(iDeviceIndex, OPERATION_SUCC_T, "NET_DVR_StartVoiceCom_MR_V30 audio index[%d]", iAudioIndex);
+                NET_DVR_LINK_ADDR struParam = { 0 };
+                if (NET_DVR_GetLinkAddr(g_struDeviceInfo[iDeviceIndex].lVoiceCom[iAudioIndex], ENUM_LINK_VOICEPLAY, &struParam))
+                {
+                    g_pMainDlg->AddLog(iDeviceIndex, OPERATION_SUCC_T, "NET_DVR_GetLinkAddr, dev addr[%s:%d], local addr[%s:%d]", \
+                        &(struParam.uDevIP), struParam.wDevPort[0], &(struParam.uLocalIP), struParam.wLocalPort[0]);
+                }
+                else
+                {
+                    g_pMainDlg->AddLog(iDeviceIndex, OPERATION_FAIL_T, "NET_DVR_GetLinkAddr");
+                }
+				bRet = TRUE;			
+			}
+			else
+			{
+				g_pMainDlg->AddLog(iDeviceIndex, OPERATION_FAIL_T, "NET_DVR_StartVoiceCom_MR_V30 audio index[%d]", iAudioIndex);
+			//	memset(&m_talkMr[i], 0, sizeof(TALK_MR));
+				m_talkMr[i].byAudioType = 0;
+				m_talkMr[i].byFlag = 0;
+			}
+		}
+	}
+	else
+	{
+		//delete device from broadcast list
+		
+		if (g_struDeviceInfo[iDeviceIndex].lVoiceCom[iAudioIndex] >= 0)
+		{
+			
+			bRet = NET_DVR_StopVoiceCom(g_struDeviceInfo[iDeviceIndex].lVoiceCom[iAudioIndex]);	
+			
+			if (bRet)
+			{
+				g_pMainDlg->AddLog(iDeviceIndex, OPERATION_SUCC_T, "NET_DVR_StopVoiceCom");
+				g_struDeviceInfo[iDeviceIndex].lVoiceCom[iAudioIndex] = -1;				
+			}
+			else
+			{
+				g_pMainDlg->AddLog(iDeviceIndex, OPERATION_FAIL_T, "NET_DVR_StopVoiceCom");
+			}			
+		}
+		if (m_pRenderBuf[m_talkIndex[iDeviceIndex][iAudioIndex]])
+        {
+			delete []m_pRenderBuf[m_talkIndex[iDeviceIndex][iAudioIndex]];				
+			//	::VirtualFree(m_pRenderBuf[m_talkIndex[iAudioIndex * iDeviceIndex]], 0, MEM_RELEASE);
+			m_pRenderBuf[m_talkIndex[iDeviceIndex][iAudioIndex]] = NULL;				
+		}
+	//	memset(&m_talkMr[m_talkIndex[iDeviceIndex][iAudioIndex]], 0, sizeof(TALK_MR));
+		m_talkMr[m_talkIndex[iDeviceIndex][iAudioIndex]].byAudioType = 0;
+		m_talkMr[m_talkIndex[iDeviceIndex][iAudioIndex]].byFlag = 0;
+	}
+
+	return bRet;
+}
+
+void CDlgTalkMREx::SetWaveFormat(NET_DVR_COMPRESSION_AUDIO &struCodeType)
+{
+    //音频采样率
+    switch (struCodeType.byAudioSamplingRate)
+    {
+    case 1:m_struWaveFormat.nSamplesPerSec = 16000; break;
+    case 2:m_struWaveFormat.nSamplesPerSec = 32000; break;
+    case 3:m_struWaveFormat.nSamplesPerSec = 48000; break;
+    case 4:m_struWaveFormat.nSamplesPerSec = 44100; break;
+    case 5:m_struWaveFormat.nSamplesPerSec = 8000; break;
+    default:break;
+    }
+    ////音频码率
+    //switch (struCodeType.byAudioBitRate)
+    //{
+    //case 1:m_struWaveFormat.wBitsPerSample = 8; break;
+    //case 2:m_struWaveFormat.wBitsPerSample = 16; break;
+    //case 3:m_struWaveFormat.wBitsPerSample = 32; break;
+    //case 4:m_struWaveFormat.wBitsPerSample = 64; break;
+    //case 5:m_struWaveFormat.wBitsPerSample = 128; break;
+    //default:break; //还有其他用到再补充，参考BITRATE_ENCODE_INDEX
+    //}
+    m_struWaveFormat.nAvgBytesPerSec = m_struWaveFormat.nSamplesPerSec * m_struWaveFormat.nBlockAlign;
+}
+
+/*********************************************************
+  Function:	CheckAllDevState
+  Desc:		begin to redirect audio data 
+  Input:	hDev, device node item; bCheck, add or delete
+  Output:	none
+  Return:	none
+**********************************************************/
+void CDlgTalkMREx::CheckAllAudioState(HTREEITEM hDev, BOOL bCheck, int uFlag)
+{
+	if (uFlag == LVHT_TOLEFT)
+	{
+		m_treeBroadCast.SetCheck(hDev, !bCheck);
+	}
+	else
+	{
+		m_treeBroadCast.SetCheck(hDev, bCheck);
+	}	
+	int iAudioIndex = 0;
+	int iDevIndex = m_treeBroadCast.GetItemData(hDev)%1000;
+	if (iDevIndex < 0)
+	{
+		return;
+	}
+	HTREEITEM hChild = m_treeBroadCast.GetChildItem(hDev);
+	while (hChild)
+	{
+		iAudioIndex = m_treeBroadCast.GetItemData(hChild)%1000;
+		m_treeBroadCast.SetCheck(hChild, bCheck);
+		g_struDeviceInfo[iDevIndex].bCheckBroadcast[iAudioIndex] = bCheck;
+		StartMR(iDevIndex, iAudioIndex, bCheck);
+		hChild = m_treeBroadCast.GetNextSiblingItem(hChild);
+	}
+}
+
+/*********************************************************
+  Function:	OnBtnRefresh
+  Desc:		refresh the state of the device audio channels
+  Input:	none
+  Output:	none
+  Return:	none
+**********************************************************/
+void CDlgTalkMREx::OnBtnRefresh() 
+{
+	// TODO: Add your control notification handler code here
+	CreateTree();
+}
+
+/***************************************************************
+Function:     AudioBufDownScale
+Description:  音频数据减少一倍
+Input:        in:       数据输入
+inputLen: 输入数据长度
+Output:    out:      数据输出
+Returns:      void
+****************************************************************/
+void CDlgTalkMREx::AudioBufDownScale(char const*in, char* out, int inbufLen) const
+{
+    if (m_comAudioEncType.GetCurSel() == AUDIOTALKTYPE_G711_A || m_comAudioEncType.GetCurSel() == AUDIOTALKTYPE_G711_MU)
+    {
+        int i = 0;
+        for (i = 0; i < inbufLen; i++)
+        {
+            out[i] = in[i * 4];
+        }
+    }
+    else if (m_comAudioEncType.GetCurSel() == 4)
+    {
+        int i = 0;
+        for (i = 0; i < inbufLen; i++)
+        {
+            out[i] = in[i * 2];
+        }
+    }
+    else
+    {
+
+    }
+}
+
+/***************************************************************
+Function:     StopSoundInAndSoundOut
+Description:  停止录音和本地解码播放
+Returns:      void
+****************************************************************/
+void CDlgTalkMREx::StopSoundInAndSoundOut()
+{
+    //close wavin
+    if (m_bOpenWavIn)
+    {
+        m_SoundIn.Stop();
+        m_bOpenWavIn = FALSE;
+        g_pMainDlg->AddLog(-1, OPERATION_SUCC_T, "close wave in");
+
+#ifdef RECORD
+        if (m_hFile)
+        {
+            ::mmioAscend(m_hFile, &m_MMCKInfoChild, 0);
+            ::mmioAscend(m_hFile, &m_MMCKInfoParent, 0);
+            ::mmioClose(m_hFile, 0);
+            m_hFile = NULL;
+        }
+#endif
+    }
+
+    //close wavout
+    SetEvent(m_hExitEvent);
+    int i = 0;
+    for (i = 0; i < MAX_SOUND_OUT; i++)
+    {
+        BOOL bOpenWaveOutTemp = m_bOpenWavOut[i];
+        m_bOpenWavOut[i] = FALSE;
+        if (m_hPlayHandle[i] != INVALID_HANDLE_VALUE)
+        {
+            WaitForSingleObject(m_hPlayHandle[i], INFINITE);
+            m_hPlayHandle[i] = INVALID_HANDLE_VALUE;
+        }
+
+        if (bOpenWaveOutTemp)
+        {
+            m_SoundOut[i].CloseSound();
+            g_pMainDlg->AddLog(-1, OPERATION_SUCC_T, "close wave out");
+        }
+    }
+}
+
+/***************************************************************
+Function:     ExitPlayAudio
+Description:  退出播放线程时，释放资源
+Input:        
+	lpTemp: 待解码数据
+	lpPlayBuf: 解码后数据
+	pDecoder: g722解码句柄
+	pG726Dec: g726解码句柄
+	pG726DecM: g726解码模块句柄
+	byIndex:	线程对应的序号
+Output:    
+Returns:      void
+****************************************************************/
+void CDlgTalkMREx::ExitPlayAudio(BYTE *lpTemp, BYTE *lpPlayBuf, void *pDecoder, void *pG726Dec, void *pG726DecM, void *pG711Dec, BYTE byIndex)
+{
+	m_bOpenPlayThread[byIndex] = FALSE;
+	if (lpTemp != NULL)
+	{
+		delete []lpTemp;
+		lpTemp = NULL;
+	}
+	if (lpPlayBuf != NULL)
+	{
+		delete []lpPlayBuf;
+		lpPlayBuf = NULL;
+	}
+	if (pDecoder)
+	{
+		NET_DVR_ReleaseG722Decoder(pDecoder);
+		pDecoder = NULL;
+	}
+	if (pG726Dec)
+	{
+		NET_DVR_ReleaseG726Decoder(pG726Dec);
+		pG726Dec = NULL;
+		pG726DecM = NULL;
+	}
+    if (pG711Dec)
+    {
+#if (defined _WIN64)
+        NET_DVR_ReleaseG711Encoder(pG711Dec);
+        pG711Dec = NULL;
+        pG711Dec = NULL;
+#endif
+    }
+    
+}

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgTrialAudioActivation.h

@@ -0,0 +1,69 @@
+#if !defined(AFX_DLGTRIALAUDIOACTIVATION_H__386ED7EB_F681_4E33_B20A_F193675E7641__INCLUDED_)
+#define AFX_DLGTRIALAUDIOACTIVATION_H__386ED7EB_F681_4E33_B20A_F193675E7641__INCLUDED_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif // _MSC_VER > 1000
+// DlgTrialAudioActivation.h : header file
+//
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgTrialAudioActivation dialog
+
+class CDlgTrialAudioActivation : public CDialog
+{
+// Construction
+public:
+	CDlgTrialAudioActivation(CWnd* pParent = NULL);   // standard constructor
+
+// Dialog Data
+	//{{AFX_DATA(CDlgTrialAudioActivation)
+	enum { IDD = IDD_DLG_TRIAL_AUDIO_ACTIVATION };
+	CComboBox	m_cmbBaseNo;
+	CComboBox	m_cmbPresetNO;
+	CComboBox	m_cmbChan;
+	CComboBox	m_cmbAudioActivation;
+	BOOL	m_bEnable;
+	UINT	m_wDelayTime;
+	BYTE	m_bySensitivity;
+	BYTE	m_byPriority;
+	BOOL	m_bPreset;
+	BOOL	m_bChkVGA1;
+	BOOL	m_bChkVGA2;
+	BOOL	m_bChkVGA3;
+	BOOL	m_bChkVGA4;
+	BOOL	m_bChkVGA5_10;
+	BOOL	m_bChkHDMI1;
+	BOOL	m_bChkHDMI2;
+	//}}AFX_DATA
+
+
+// Overrides
+	// ClassWizard generated virtual function overrides
+	//{{AFX_VIRTUAL(CDlgTrialAudioActivation)
+	protected:
+	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
+	//}}AFX_VIRTUAL
+
+// Implementation
+protected:
+
+	// Generated message map functions
+	//{{AFX_MSG(CDlgTrialAudioActivation)
+	afx_msg void OnBtnGet();
+	virtual BOOL OnInitDialog();
+	afx_msg void OnBtnSet();
+	afx_msg void OnSelchangeCmbAudioInputNo();
+	//}}AFX_MSG
+	DECLARE_MESSAGE_MAP()
+public:
+    int m_lUserID;
+    int m_iDevIndex;
+    NET_DVR_AUDIO_ACTIVATION_CFG m_struAudioActCfg;
+    NET_DVR_TRIAL_SYSTEM_INFO m_struSystemInfo;
+};
+
+//{{AFX_INSERT_LOCATION}}
+// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
+
+#endif // !defined(AFX_DLGTRIALAUDIOACTIVATION_H__386ED7EB_F681_4E33_B20A_F193675E7641__INCLUDED_)

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgTrialDVR.cpp

@@ -0,0 +1,516 @@
+// DlgTrialDVR.cpp : implementation file
+//
+
+#include "stdafx.h"
+#include "clientdemo.h"
+#include "DlgTrialDVR.h"
+#include "DlgTrialAudioActivation.h"
+#include "DlgInfrared.h"
+#include "DlgTrialPIPCfg.h"
+#include "DlgAccessCameraCfg.h"
+#include "DlgMixAudioInCfg.h"
+#include "DlgWifiDHCPCfg.h"
+#include "DlgGetWifiClientListInfo.h"
+#include "DlgAudioDiacriticalCfg.h"
+#include "DlgMultilStreamRelChanCfg.h"
+#include "DlgVideoOutResolutionCfg.h"
+#include "DlgMixAudioOutCfg.h"
+#include "DlgRemoteControlPlay.h"
+#include "DlgCaseInfo.h"
+#include "DlgMicrophoneStatus.h"
+#include "DlgTrialHostStatus.h"
+#include "DlgLocalInputInfo.h"
+#include "DlgLampCfg.h"
+#include "DlgLampControl.h"
+#include "DlgAudioOutVolumeCfg.h"
+#include "DlgAudioInVolumeCfg1.h"
+#include "DlgAreaMaskCfg.h"
+#include "DlgInChanVideoLostCfg.h"
+#include "DLGTrialAudioMix.h"
+
+#ifdef _DEBUG
+#define new DEBUG_NEW
+#undef THIS_FILE
+static char THIS_FILE[] = __FILE__;
+#endif
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgTrialDVR dialog
+
+
+CDlgTrialDVR::CDlgTrialDVR(CWnd* pParent /*=NULL*/)
+	: CDialog(CDlgTrialDVR::IDD, pParent)
+    ,m_lUserID(-1)
+    ,m_iDevIndex(-1)
+
+{
+	//{{AFX_DATA_INIT(CDlgTrialDVR)
+	m_wHDMINum = 0;
+	m_wIPNum = 0;
+	m_wPIPNum = 0;
+	m_wSDINum = 0;
+	m_wHDMIStartNo = 0;
+	m_wIPStartNo = 0;
+	m_wPIPStartNo = 0;
+	m_wSDIStartNo = 0;
+	m_wVGAStartNo = 0;
+	m_wVGANum = 0;
+	m_wPOEStartNo = 0;
+	m_wYPBPRStartNo = 0;
+	m_wPOENum = 0;
+	m_wYPBPRNum = 0;
+	//}}AFX_DATA_INIT
+}
+
+
+void CDlgTrialDVR::DoDataExchange(CDataExchange* pDX)
+{
+	CDialog::DoDataExchange(pDX);
+	//{{AFX_DATA_MAP(CDlgTrialDVR)
+	DDX_Text(pDX, IDC_EDIT_HDMI_NUM, m_wHDMINum);
+	DDX_Text(pDX, IDC_EDIT_IP_NUM, m_wIPNum);
+	DDX_Text(pDX, IDC_EDIT_PIP_NUM, m_wPIPNum);
+	DDX_Text(pDX, IDC_EDIT_SDI_NUM, m_wSDINum);
+	DDX_Text(pDX, IDC_EDIT_START_NO_HDMI, m_wHDMIStartNo);
+	DDX_Text(pDX, IDC_EDIT_START_NO_IP, m_wIPStartNo);
+	DDX_Text(pDX, IDC_EDIT_START_NO_PIP, m_wPIPStartNo);
+	DDX_Text(pDX, IDC_EDIT_START_NO_SDI, m_wSDIStartNo);
+	DDX_Text(pDX, IDC_EDIT_START_NO_VGA, m_wVGAStartNo);
+	DDX_Text(pDX, IDC_EDIT_VGA_NUM, m_wVGANum);
+	DDX_Text(pDX, IDC_EDIT_START_NO_POE, m_wPOEStartNo);
+	DDX_Text(pDX, IDC_EDIT_START_NO_YPBPR, m_wYPBPRStartNo);
+	DDX_Text(pDX, IDC_EDIT_POE_NUM, m_wPOENum);
+	DDX_Text(pDX, IDC_EDIT_YPBPR_NUM, m_wYPBPRNum);
+	//}}AFX_DATA_MAP
+}
+
+
+BEGIN_MESSAGE_MAP(CDlgTrialDVR, CDialog)
+	//{{AFX_MSG_MAP(CDlgTrialDVR)
+	ON_BN_CLICKED(IDC_BTN_AUDIO_ACTIVATION, OnBtnAudioActivation)
+	ON_BN_CLICKED(IDC_BTN_INFRARED, OnBtnInfrared)
+	ON_BN_CLICKED(IDC_BTN_GET_SYSTEM_INFO, OnBtnGetSystemInfo)
+	ON_BN_CLICKED(IDC_BTN_PIP_CFG, OnBtnPipCfg)
+	ON_BN_CLICKED(IDC_BTN_REMOTE_PLAY, OnBtnRemotePlay)
+	ON_BN_CLICKED(IDC_BTN_CASE_INFO, OnBtnCaseInfo)
+	ON_BN_CLICKED(IDC_BTN_MICROPHONE_STATUS, OnBtnMicrophoneStatus)
+	ON_BN_CLICKED(IDC_BTN_TRIAL_HOST_STATUS, OnBtnTrialHostStatus)
+	ON_BN_CLICKED(IDC_BTN_LOCAL_INPUT, OnBtnLocalInput)
+	ON_BN_CLICKED(IDC_BTN_LAMP_INFO, OnBtnLampInfo)
+	ON_BN_CLICKED(IDC_BTN_LAMP_CONTROL, OnBtnLampControl)
+	ON_BN_CLICKED(IDC_BUTTON_CONFIG_CAMERA_TYPE, OnButtonConfigCameraType)
+	ON_BN_CLICKED(IDC_BTN_MIX_AUDIOIN_CFG, OnButtonMixAudioInParamCfg)
+ 	ON_BN_CLICKED(IDC_BTN_MIX_AUDIOOUT_CFG, OnButtonMixAudioOutParamCfg)
+	ON_BN_CLICKED(IDC_BTN_AUDIOIN_VOLUME_CFG, OnButtonAudioInVolumeCfg)
+	ON_BN_CLICKED(IDC_BTN_AUDIOOUT_VOLUME_CFG, OnButtonAudioOutVolumeCfg)
+	ON_BN_CLICKED(IDC_BTN_AREA_MASK_CFG, OnButtonMaskAreaParamCfg)
+	ON_BN_CLICKED(IDC_BTN_AUDIO_DIACRITICAL_CFG, OnButtonAudioDiacriticalCfg)
+	ON_BN_CLICKED(IDC_BTN_VIDEO_OUT_RESOLUTION_CFG, OnButtonVideoOutResolutionCfg)
+	ON_BN_CLICKED(IDC_BTN_MULTISTREAM_RELATION_CHAN_CFG, OnButtonMultilStreamRelChanCfg)
+	ON_BN_CLICKED(IDC_BTN_REMOTECONTROL_POWER_ON, OnButtonRemotePowerOn)
+	ON_BN_CLICKED(IDC_BTN_WIFI_DHCP_ADDR_CFG, OnButtonWifiDHCPCfg)
+ 	ON_BN_CLICKED(IDC_BTN_WIFI_CLIENT_LIST_INFO, OnButtonGetWifiClientListInfo)
+    ON_BN_CLICKED(IDC_BTN_INCHANNEL_VIDEO,OnBtnInChannelVideLossCfg)
+	//}}AFX_MSG_MAP
+    ON_BN_CLICKED(IDC_BTN_AUDIO_MIX, &CDlgTrialDVR::OnBnClickedBtnAudioMix)
+END_MESSAGE_MAP()
+
+/////////////////////////////////////////////////////////////////////////////
+// CDlgTrialDVR message handlers
+
+void CDlgTrialDVR::OnCancel() 
+{
+	// TODO: Add extra cleanup here
+	
+	CDialog::OnCancel();
+}
+
+void CDlgTrialDVR::OnBtnAudioActivation() 
+{
+	// TODO: Add your control notification handler code here
+    CDlgTrialAudioActivation dlg;
+    dlg.m_lUserID = m_lUserID;
+    dlg.m_iDevIndex = m_iDevIndex;
+    memcpy(&(dlg.m_struSystemInfo),&m_struTrialSysInfo,sizeof(m_struTrialSysInfo));
+    dlg.DoModal();
+}
+
+void CDlgTrialDVR::OnBtnInfrared() 
+{
+	// TODO: Add your control notification handler code here
+    CDlgInfrared dlg;
+    dlg.m_lUserID = m_lUserID;
+    dlg.m_iDevIndex = m_iDevIndex;
+ 
+    dlg.DoModal();
+}
+
+void CDlgTrialDVR::OnBtnGetSystemInfo() 
+{
+	// TODO: Add your control notification handler code here
+	memset(&m_struTrialSysInfo,0,sizeof(m_struTrialSysInfo));
+
+    if (m_iDevIndex < 0)
+    {
+        return;
+    }
+
+    DWORD dwRet = 0 ;
+    if (!NET_DVR_GetDVRConfig(m_lUserID,NET_DVR_GET_TRIAL_SYSTEM_CFG,NULL,&m_struTrialSysInfo,sizeof(m_struTrialSysInfo),&dwRet))
+    {
+        g_pMainDlg->AddLog(m_iDevIndex,OPERATION_FAIL_T,"NET_DVR_GET_TRIAL_SYSTEM_CFG");
+        return;
+    }
+    else
+    {
+        g_pMainDlg->AddLog(m_iDevIndex,OPERATION_SUCC_T,"NET_DVR_GET_TRIAL_SYSTEM_CFG");
+    }
+
+    for (int i = 0; i < m_struTrialSysInfo.byVideoInTypeNum; i++)
+    {
+        switch (m_struTrialSysInfo.struVideoIn[i].wInType)
+        {
+        case 0:
+            m_wSDINum = m_struTrialSysInfo.struVideoIn[i].wInNum;
+            m_wSDIStartNo = m_struTrialSysInfo.struVideoIn[i].wStartNo;
+            break;
+        case  1:
+            m_wVGANum = m_struTrialSysInfo.struVideoIn[i].wInNum;
+            m_wVGAStartNo = m_struTrialSysInfo.struVideoIn[i].wStartNo;
+            break;
+        case 2:
+            m_wHDMINum = m_struTrialSysInfo.struVideoIn[i].wInNum;
+            m_wHDMIStartNo = m_struTrialSysInfo.struVideoIn[i].wStartNo;
+            break;
+        case 3:
+            m_wIPNum = m_struTrialSysInfo.struVideoIn[i].wInNum;
+            m_wIPStartNo = m_struTrialSysInfo.struVideoIn[i].wStartNo;
+            break;
+        case 4:
+            m_wPIPNum = m_struTrialSysInfo.struVideoIn[i].wInNum;
+            m_wPIPStartNo = m_struTrialSysInfo.struVideoIn[i].wStartNo;
+            break;
+        case 5:
+            m_wPOENum = m_struTrialSysInfo.struVideoIn[i].wInNum;
+            m_wPOEStartNo = m_struTrialSysInfo.struVideoIn[i].wStartNo;
+            break;
+        case 6:
+            m_wYPBPRNum = m_struTrialSysInfo.struVideoIn[i].wInNum;
+            m_wYPBPRStartNo = m_struTrialSysInfo.struVideoIn[i].wStartNo;
+            break;
+        default:
+            break;
+        }
+    }
+    
+    UpdateData(FALSE);
+
+}
+
+BOOL CDlgTrialDVR::OnInitDialog() 
+{
+	CDialog::OnInitDialog();
+	memset(&m_struTrialSysInfo,0,sizeof(m_struTrialSysInfo));
+	// TODO: Add extra initialization here
+	OnBtnGetSystemInfo();
+	return TRUE;  // return TRUE unless you set the focus to a control
+	              // EXCEPTION: OCX Property Pages should return FALSE
+}
+
+void CDlgTrialDVR::OnBtnPipCfg() 
+{
+	// TODO: Add your control notification handler code here
+	CDlgTrialPIPCfg dlg;
+    dlg.m_lUserID = m_lUserID;
+    dlg.m_iDevIndex = m_iDevIndex;
+       memcpy(&(dlg.m_struSystemInfo),&m_struTrialSysInfo,sizeof(m_struTrialSysInfo));
+    dlg.DoModal();
+}
+
+
+void CDlgTrialDVR::OnBtnRemotePlay() 
+{
+	// TODO: Add your control notification handler code here
+	CDlgRemoteControlPlay dlg;
+	dlg.DoModal();
+}
+
+void CDlgTrialDVR::OnBtnCaseInfo() 
+{
+	// TODO: Add your control notification handler code here
+	CDlgCaseInfo dlg;
+	dlg.DoModal();
+}
+
+void CDlgTrialDVR::OnBtnMicrophoneStatus() 
+{
+	// TODO: Add your control notification handler code here
+	CDlgMicrophoneStatus dlg;
+	dlg.DoModal();
+}
+
+void CDlgTrialDVR::OnBtnTrialHostStatus() 
+{
+	// TODO: Add your control notification handler code here
+	CDlgTrialHostStatus dlg;
+	dlg.DoModal();
+}
+
+void CDlgTrialDVR::OnBtnLocalInput() 
+{
+	// TODO: Add your control notification handler code here
+	CDlgLocalInputInfo dlg;
+	dlg.setParam(m_struTrialSysInfo);
+	dlg.DoModal();
+}
+
+
+void CDlgTrialDVR::OnBtnLampInfo() 
+{
+	// TODO: Add your control notification handler code here
+	CDlgLampCfg dlg;
+	dlg.DoModal();
+}
+
+
+void CDlgTrialDVR::OnBtnLampControl() 
+{
+	// TODO: Add your control notification handler code here
+	CDlgLampControl dlg;
+	dlg.DoModal();
+}
+
+
+void CDlgTrialDVR::OnButtonConfigCameraType() 
+{
+	// TODO: Add your control notification handler code here
+	CDlgAccessCameraCfg dlg;
+	dlg.m_lUserID = m_lUserID;
+    dlg.m_dwDevIndex = m_iDevIndex;
+
+	int iChanIndex = g_pMainDlg->GetCurChanIndex();
+    if (iChanIndex < 0)
+    {
+        iChanIndex = 0;//default to config channel one
+    }
+	m_lChannel= iChanIndex+g_struDeviceInfo[m_iDevIndex].iStartChan;
+    dlg.m_bTrialChannelFlag = 1;
+    dlg.DoModal();
+}
+
+void CDlgTrialDVR::OnButtonMixAudioInParamCfg() 
+{
+	// TODO: Add your control notification handler code here
+	CDlgMixAudioInCfg dlg;
+	dlg.m_lUserID = m_lUserID;
+    dlg.m_dwDevIndex = m_iDevIndex;
+	
+    dlg.DoModal();
+}
+
+void CDlgTrialDVR::OnButtonMixAudioOutParamCfg() 
+{
+	// TODO: Add your control notification handler code here
+	CDlgMixAudioOutCfg dlg;
+	dlg.m_lUserID = m_lUserID;
+    dlg.m_dwDevIndex = m_iDevIndex;
+	
+    dlg.DoModal();
+}
+
+
+void CDlgTrialDVR::OnButtonVideoOutResolutionCfg()
+{
+	// TODO: Add your control notification handler code here
+	CDlgVideoOutResolutionCfg dlg;
+	dlg.m_lUserID = m_lUserID;
+    dlg.m_dwDevIndex = m_iDevIndex;
+	
+    dlg.DoModal();
+}
+
+
+void CDlgTrialDVR::OnButtonMultilStreamRelChanCfg() 
+{
+	// TODO: Add your control notification handler code here
+	CDlgMultilStreamRelChanCfg dlg;
+	dlg.m_lUserID = m_lUserID;
+    dlg.m_dwDevIndex = m_iDevIndex;
+	
+    dlg.DoModal();
+}
+
+void CDlgTrialDVR::OnButtonWifiDHCPCfg() 
+{
+	// TODO: Add your control notification handler code here
+	CDlgWifiDHCPCfg dlg;
+	dlg.m_lUserID = m_lUserID;
+    dlg.m_dwDevIndex = m_iDevIndex;
+	
+    dlg.DoModal();
+}
+
+
+void CDlgTrialDVR::OnButtonGetWifiClientListInfo()
+{
+	// TODO: Add your control notification handler code here
+	CDlgGetWifiClientListInfo dlg;
+	dlg.m_lUserID = m_lUserID;
+    dlg.m_dwDevIndex = m_iDevIndex;
+	
+    dlg.DoModal();
+}
+
+
+void CDlgTrialDVR::OnButtonAudioDiacriticalCfg() 
+{
+	// TODO: Add your control notification handler code here
+	CDlgAudioDiacriticalCfg dlg;
+	dlg.m_lUserID = m_lUserID;
+    dlg.m_dwDevIndex = m_iDevIndex;
+	
+    dlg.DoModal();
+}
+
+void CDlgTrialDVR::OnButtonAudioInVolumeCfg() 
+{
+	// TODO: Add your control notification handler code here
+	CDlgAudioInVolumeCfg dlg;
+	dlg.m_lUserID = m_lUserID;
+    dlg.m_dwDevIndex = m_iDevIndex;
+	
+    dlg.DoModal();
+}
+
+
+void CDlgTrialDVR::OnButtonAudioOutVolumeCfg() 
+{
+	// TODO: Add your control notification handler code here
+	CDlgAudioOutVolumeCfg dlg;
+	dlg.m_lUserID = m_lUserID;
+    dlg.m_dwDevIndex = m_iDevIndex;
+	
+    dlg.DoModal();
+}
+
+
+void CDlgTrialDVR::OnButtonMaskAreaParamCfg() 
+{
+	// TODO: Add your control notification handler code here
+	CDlgAreaMaskCfg dlg;
+	dlg.m_lUserID = m_lUserID;
+    dlg.m_dwDevIndex = m_iDevIndex;
+
+	int iChanIndex = g_pMainDlg->GetCurChanIndex();
+    if (iChanIndex < 0)
+    {
+        iChanIndex = 0;//default to config channel one
+    }
+	m_lChannel= iChanIndex+g_struDeviceInfo[m_iDevIndex].iStartChan;
+	dlg.m_lChannel = m_lChannel;
+	
+    dlg.DoModal();
+}
+
+
+void CDlgTrialDVR::OnButtonRemotePowerOn() 
+{
+	// TODO: Add your control notification handler code here
+	char szLan[128] = {0};
+	
+	/*if (!NET_DVR_RemoteControl(m_lUserID, NET_DVR_REMOTECONTROL_POWER_ON, NULL, 0))
+	{
+		g_pMainDlg->AddLog(m_iDevIndex, OPERATION_FAIL_T, "NET_DVR_RemoteControl NET_DVR_REMOTECONTROL_POWER_ON ");
+		g_StringLanType(szLan, "²Ù×÷ʧ°Ü", "control failed");
+		AfxMessageBox(szLan);
+	}
+	else
+	{
+		g_pMainDlg->AddLog(m_iDevIndex, OPERATION_SUCC_T, "NET_DVR_RemoteControl NET_DVR_REMOTECONTROL_POWER_ON");
+	}
+    */
+}
+
+void CDlgTrialDVR::OnBtnInChannelVideLossCfg()
+{
+    CDlgInChanVideoLostCfg dlg;
+    dlg.m_lLoginID = m_lUserID;
+   // dlg.m_dwAlarmOutNum = m_dwAlarmOutNum;
+    dlg.m_iDevIndex = m_iDevIndex;
+    memcpy(&(dlg.m_struSystemInfo),&m_struTrialSysInfo,sizeof(m_struTrialSysInfo));
+    dlg.DoModal();
+
+//ConvertVilostV40T0V30();
+    /*g_lpVILostV40 = &(m_pStruPicCfgV40[m_iCurChanIndex].struVILost);
+    dlg.m_iChanShowNum = m_iChanShowNum;
+
+    if (dlg.DoModal() == IDOK)
+    {
+        
+	}  
+    */
+}
+
+void  CDlgTrialDVR::ConvertVilostV40T0V30(NET_DVR_VILOST_V40 *pViLostV40, NET_DVR_VILOST_V30 *pViLostV30,BOOL bV40ToV30)
+{
+    if (pViLostV30== NULL || pViLostV40==NULL)
+    {
+        return;
+    }
+
+    int i =0 ;
+    DWORD dwIndex = 0;
+
+    if(bV40ToV30)
+    {
+        memset(pViLostV30,0,sizeof(NET_DVR_VILOST_V30));
+        pViLostV30->byEnableHandleVILost = pViLostV40->dwEnableVILostAlarm;
+        pViLostV30->strVILostHandleType.dwHandleType = pViLostV40->dwHandleType;
+        for (i =0; i< MAX_ALARMOUT_V40;i++)
+        {
+            if(pViLostV40->dwRelAlarmOut[i] != 0xffffffff && i < MAX_ALARMOUT_V30)
+            {
+                pViLostV30->strVILostHandleType.byRelAlarmOut[i] = pViLostV40->dwRelAlarmOut[i];
+            }
+            else
+            {
+                break;
+            }
+        }
+
+        memcpy(&pViLostV30->struAlarmTime[0],&pViLostV40->struAlarmTime[0],sizeof(pViLostV30->struAlarmTime));
+
+    }
+    else
+    {
+        memset(pViLostV40,0,sizeof(NET_DVR_VILOST_V40));
+        memset(pViLostV40->dwRelAlarmOut,0xff,sizeof(DWORD)*MAX_ALARMOUT_V40);
+        pViLostV40->dwEnableVILostAlarm = pViLostV30->byEnableHandleVILost;
+        pViLostV40->dwHandleType = pViLostV30->strVILostHandleType.dwHandleType;
+        for (i = 0; i< MAX_ALARMOUT_V30; i++)
+        {
+            if (pViLostV30->strVILostHandleType.byRelAlarmOut[i] == 1)
+            {
+                pViLostV40->dwRelAlarmOut[dwIndex] = i;
+                dwIndex++;
+            }
+        }
+        memcpy(&pViLostV40->struAlarmTime[0],&pViLostV30->struAlarmTime[0],sizeof(pViLostV30->struAlarmTime));
+    }
+}
+
+void CDlgTrialDVR::OnBnClickedBtnAudioMix()
+{
+    CDLGTrialAudioMix dlg;
+    dlg.m_lUserID = m_lUserID;
+    dlg.m_dwDevIndex = m_iDevIndex;
+
+    int iChanIndex = g_pMainDlg->GetCurChanIndex();
+    if (iChanIndex < 0)
+    {
+        iChanIndex = 0;//default to config channel one
+    }
+    m_lChannel = iChanIndex + g_struDeviceInfo[m_iDevIndex].iStartChan;
+
+    dlg.DoModal();
+}

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgUHFBasicInfo.h

@@ -0,0 +1,58 @@
+#pragma once
+#include "afxwin.h"
+#include "afxdtctl.h"
+#include "atltime.h"
+#include "ATLComTime.h"
+
+
+// CDlgUHFBasicInfo 对话框
+
+class CDlgUHFBasicInfo : public CDialogEx
+{
+	DECLARE_DYNAMIC(CDlgUHFBasicInfo)
+
+public:
+	CDlgUHFBasicInfo(CWnd* pParent = NULL);   // 标准构造函数
+	virtual ~CDlgUHFBasicInfo();
+
+// 对话框数据
+	enum { IDD = IDD_DLG_UHF_BASIC_INFO };
+
+protected:
+	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV 支持
+
+	DECLARE_MESSAGE_MAP()
+public:
+    afx_msg void OnBnClickedButtonGet();
+    afx_msg void OnBnClickedButtonSet();
+
+    LONG m_lUserID;
+    int m_iDeviceIndex;
+    BOOL CreateUHFBasicInfo(char* pBuf, DWORD dwBufLen, int &dwRet);
+    CComboBox m_comboReadWriteMode;
+    CComboBox m_comboWorkFrequencyType;
+    CComboBox m_comboWorkMode;
+    int m_iOutputPower;
+    int m_iRepeatLabelFilterTime;
+    int m_iStartHour1;
+    int m_iStartHour2;
+    int m_iStartHour3;
+    int m_iStartMinute1;
+    int m_iStartMinute2;
+    int m_iStartMinute3;
+    int m_iStopHour1;
+    int m_iStopHour2;
+    int m_iStopHour3;
+    int m_iStopMinute1;
+    int m_iStopMinute2;
+    int m_iStopMinute3;
+    afx_msg void OnBnClickedButtonGetTime();
+    afx_msg void OnBnClickedButtonSetTime();
+    COleDateTime m_ctDate;
+    COleDateTime m_ctTime;
+    COleDateTime m_ctDateMS;
+    COleDateTime m_ctTimeMS;
+    afx_msg void OnBnClickedButtonGetTimems();
+    afx_msg void OnBnClickedButtonSetTimems();
+    int m_iMS;
+};

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgUpgradeSelectDev.cpp

@@ -0,0 +1,188 @@
+// DlgUpgradeSelectDev.cpp : 实现文件
+//
+
+#include "stdafx.h"
+#include "ClientDemo.h"
+#include "DlgUpgradeSelectDev.h"
+#include "DlgUpgrade.h"
+#include "afxdialogex.h"
+
+
+// CDlgUpgradeSelectDev 对话框
+
+IMPLEMENT_DYNAMIC(CDlgUpgradeSelectDev, CDialog)
+
+CDlgUpgradeSelectDev::CDlgUpgradeSelectDev(CWnd* pParent /*=NULL*/)
+	: CDialog(CDlgUpgradeSelectDev::IDD, pParent)
+    , m_bHost(FALSE)
+    , m_bLamp(FALSE)
+    , m_bKey(FALSE)
+    , m_bKeyBoard(FALSE)
+    , m_bSwipeCard(FALSE)
+    , m_bDisplay(FALSE)
+{
+
+}
+
+CDlgUpgradeSelectDev::~CDlgUpgradeSelectDev()
+{
+}
+
+BOOL CDlgUpgradeSelectDev::OnInitDialog()
+{
+    CDialog::OnInitDialog();
+
+    // TODO:  在此添加额外的初始化
+    UpdateData(TRUE);
+    m_dwAcsNo = 0;
+    return FALSE;
+}
+
+void CDlgUpgradeSelectDev::DoDataExchange(CDataExchange* pDX)
+{
+    CDialog::DoDataExchange(pDX);
+    DDX_Check(pDX, IDC_CHK_UPGRADE_HOST, m_bHost);
+    DDX_Check(pDX, IDC_CHK_UPGRADE_LAMP, m_bLamp);
+    DDX_Check(pDX, IDC_CHK_UPGARDE_KEY, m_bKey);
+    DDX_Check(pDX, IDC_CHK_UPGRADE_KEYBOARD, m_bKeyBoard);
+    DDX_Check(pDX, IDC_CHK_URGRADE_CARD, m_bSwipeCard);
+    DDX_Check(pDX, IDC_CHK_UPGRADE_DISPLAY, m_bDisplay);
+}
+
+
+BEGIN_MESSAGE_MAP(CDlgUpgradeSelectDev, CDialog)
+    ON_BN_CLICKED(IDC_BTN_EXIT, &CDlgUpgradeSelectDev::OnBnClickedBtnExit)
+    ON_BN_CLICKED(IDC_BTN_OK, &CDlgUpgradeSelectDev::OnBnClickedBtnOk)
+    ON_BN_CLICKED(IDC_CHK_UPGRADE_HOST, &CDlgUpgradeSelectDev::OnBnClickedChkUpgradeHost)
+    ON_BN_CLICKED(IDC_CHK_UPGRADE_DISPLAY, &CDlgUpgradeSelectDev::OnBnClickedChkUpgradeDisplay)
+    ON_BN_CLICKED(IDC_CHK_UPGRADE_LAMP, &CDlgUpgradeSelectDev::OnBnClickedChkUpgradeLamp)
+    ON_BN_CLICKED(IDC_CHK_UPGARDE_KEY, &CDlgUpgradeSelectDev::OnBnClickedChkUpgardeKey)
+    ON_BN_CLICKED(IDC_CHK_UPGRADE_KEYBOARD, &CDlgUpgradeSelectDev::OnBnClickedChkUpgradeKeyboard)
+    ON_BN_CLICKED(IDC_CHK_URGRADE_CARD, &CDlgUpgradeSelectDev::OnBnClickedChkUrgradeCard)
+END_MESSAGE_MAP()
+
+
+// CDlgUpgradeSelectDev 消息处理程序
+
+
+void CDlgUpgradeSelectDev::OnBnClickedBtnExit()
+{
+    // TODO:  在此添加控件通知处理程序代码
+    CDialog::OnCancel();
+}
+
+void CDlgUpgradeSelectDev::OnBnClickedBtnOk()
+{
+    // TODO:  在此添加控件通知处理程序代码
+    UpdateData(TRUE);
+    if (m_bHost)
+    {
+        m_dwAcsNo = 0;
+    }
+    if (m_bLamp)
+    {
+        m_dwAcsNo |= 0x10100;
+    }
+    if (m_bKey)
+    {
+        m_dwAcsNo |= 0x10200;
+    }
+    if (m_bKeyBoard)
+    {
+        m_dwAcsNo |= 0x10400;
+    }
+    if (m_bSwipeCard)
+    {
+        m_dwAcsNo |= 0x10800;
+    }
+    if (m_bDisplay)
+    {
+        m_dwAcsNo |= 0x20000;
+    }
+    CDlgUpgrade *pDlg = (CDlgUpgrade *)this->GetParent();
+    pDlg->m_dwAcsNo = m_dwAcsNo;
+    CDialog::OnOK();
+}
+
+void CDlgUpgradeSelectDev::OnBnClickedChkUpgradeHost()
+{
+    // TODO:  在此添加控件通知处理程序代码
+    UpdateData(TRUE);
+    if (m_bHost)
+    {
+        m_bDisplay = FALSE;
+        m_bKey = FALSE;
+        m_bKeyBoard = FALSE;
+        m_bLamp = FALSE;
+        m_bSwipeCard = FALSE;
+    }
+    UpdateData(FALSE);
+}
+
+
+void CDlgUpgradeSelectDev::OnBnClickedChkUpgradeDisplay()
+{
+    // TODO:  在此添加控件通知处理程序代码
+    UpdateData(TRUE);
+    if (m_bDisplay)
+    {
+        m_bHost = FALSE;
+        m_bKey = FALSE;
+        m_bKeyBoard = FALSE;
+        m_bLamp = FALSE;
+        m_bSwipeCard = FALSE;
+    }
+    UpdateData(FALSE);
+}
+
+
+void CDlgUpgradeSelectDev::OnBnClickedChkUpgradeLamp()
+{
+    // TODO:  在此添加控件通知处理程序代码
+    UpdateData(TRUE);
+    if (m_bLamp)
+    {
+        m_bHost = FALSE;
+        m_bDisplay = FALSE;
+    }
+    UpdateData(FALSE);
+}
+
+
+void CDlgUpgradeSelectDev::OnBnClickedChkUpgardeKey()
+{
+    // TODO:  在此添加控件通知处理程序代码
+    UpdateData(TRUE);
+    if (m_bKey)
+    {
+        m_bHost = FALSE;
+        m_bDisplay = FALSE;
+    }
+    UpdateData(FALSE);
+}
+
+
+void CDlgUpgradeSelectDev::OnBnClickedChkUpgradeKeyboard()
+{
+    // TODO:  在此添加控件通知处理程序代码
+    UpdateData(TRUE);
+    if (m_bKeyBoard)
+    {
+        m_bHost = FALSE;
+        m_bDisplay = FALSE;
+    }
+    UpdateData(FALSE);
+}
+
+
+void CDlgUpgradeSelectDev::OnBnClickedChkUrgradeCard()
+{
+    // TODO:  在此添加控件通知处理程序代码
+    UpdateData(TRUE);
+    if (m_bSwipeCard)
+    {
+        m_bHost = FALSE;
+        m_bDisplay = FALSE;
+    }
+    UpdateData(FALSE);
+}

service-sas/CH-HCNetSDKV6.1.9.48_build20230410_win64_20251013160408/CH-HCNetSDKV6.1.9.48_build20230410_win64/Demo示例/1- MFC综合示例/DlgUploadHd.h

@@ -0,0 +1,45 @@
+#pragma once
+#include "VcaCommonOperations.h"
+#include "afxwin.h"
+
+// CDlgUploadHd 对话框
+#define MAX_BUFFER_LEN   (32*1024)
+
+class CDlgUploadHd : public CDialogEx, public CVcaCommonOperations
+{
+	DECLARE_DYNAMIC(CDlgUploadHd)
+
+public:
+	CDlgUploadHd(CWnd* pParent = NULL);   // 标准构造函数
+	virtual ~CDlgUploadHd();
+
+// 对话框数据
+	enum { IDD = IDD_DLG_UPLOAD_HD };
+
+protected:
+	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV 支持
+    static DWORD WINAPI UpLoadSendThread(LPVOID pParam);
+	DECLARE_MESSAGE_MAP()
+public:
+    virtual BOOL OnInitDialog();
+    CString m_csFilePath;
+    LONG    m_lUploadHandle;
+    BOOL    m_bUpLoading;
+    HANDLE	m_hUpLoadThread;
+    afx_msg void OnBnClickedBtnFilePath();
+    afx_msg void OnBnClickedBtnFileUpload();
+    CRect   m_rcPlayWnd;
+    afx_msg void OnBnClickedBtnSnap();
+    CString m_csUploadFilePath;
+    BOOL m_bUploadCalib;
+    BOOL m_bUploadClient;
+    afx_msg void OnBnClickedBtnFilePathUpload();
+    afx_msg void OnBnClickedBtnFileUpload3200w();
+    CString m_csDowmloadFilePath;
+    afx_msg void OnBnClickedBtnFilePathDownload();
+    afx_msg void OnBnClickedBtnFileDownload3200w();
+    LONG m_lDownloadHandle;
+    CComboBox m_combUploadType;
+    CComboBox m_combDownloadType;
+    afx_msg void OnBnClickedBtnFileUploadDownload();
+};