repos_ecs/源数据/PC环境监控/tryto v1.0.0.3/只编辑 IDE/IDE/MainFrm.cpp

// MainFrm.cpp : CMainFrame 类的实现
//

#include "stdafx.h"
#include "IDE.h"

#include "MainFrm.h"
#include ".\mainfrm.h"

#include <afxwin.h>
#include <afxext.h>
#include <math.h>
#include <io.h>
#include <time.h>
#include <afxdao.h>
//#include <afxtempl.h>
#include "Shlwapi.h"

#include "DrawObj.h"
#include "Graph.h"

#include "ViewNameDlg.h"
#include "Login.h"
#include "IDEView.h"
#include "SystemParaSetDlg.h"
#include "public.h"
#include "SysLib.h"
#include "analogdlg.h"
#include "ffsco.h"
#include "Wizard.h"
#include "Serial.h"
#include "Network.h"
#include "DlgUserManager.h"
#include "Dlg_GroupManage.h"
#include "ScriptSetDlg.h"
#include "DlgEditPwd.h"
#include "DlgQueryWarningRec.h"
#include "DlgSystemLog.h"
#include "DlgNoticeRec.h"

using namespace helper_coffs;

#pragma warning  ( disable: 4800 )

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

#if USE_TRAYICON
#define WM_MY_TRAY_NOTIFICATION			WM_USER + 1

const   UINT   WM_TASKBARCREATED   =     
        ::RegisterWindowMessage(_T("TaskbarCreated"));
#endif

// CMainFrame

IMPLEMENT_DYNAMIC(CMainFrame, CMDIAutoHideFrame)

BEGIN_MESSAGE_MAP(CMainFrame, CMDIAutoHideFrame)
	ON_WM_CREATE()
	ON_COMMAND(IP_SUPER_END, OnSuperEnd)
	ON_COMMAND(ID_TRAY_OPEN, OnTrayOpen)
#if USE_TRAYICON
	ON_MESSAGE(WM_MY_TRAY_NOTIFICATION, OnTrayNotification)
	ON_REGISTERED_MESSAGE(WM_TASKBARCREATED, OnTaskBarCreated)   
#endif
	ON_WM_CLOSE()
	ON_COMMAND(ID_ADDDEVOCE, OnAdddevoce)
	ON_UPDATE_COMMAND_UI(ID_ADDDEVOCE, OnUpdateAdddevoce)
	ON_COMMAND(ID_DELETEPORT, OnDeleteport)
	ON_UPDATE_COMMAND_UI(ID_DELETEPORT, OnUpdateDeleteport)
	ON_COMMAND(ID_ADD_PORT, OnAddPort)
	ON_UPDATE_COMMAND_UI(ID_ADD_PORT, OnUpdateAddPort)
	ON_COMMAND(ID_ADD_SCRIPT, OnAddScript)
	ON_UPDATE_COMMAND_UI(ID_ADD_SCRIPT, OnUpdateAddScript)
	ON_COMMAND(ID_ADDVIEW, OnAddview)
	ON_UPDATE_COMMAND_UI(ID_ADDVIEW, OnUpdateAddview)
	ON_COMMAND(ID_ADDVIEW2, OnAddview2)
	ON_UPDATE_COMMAND_UI(ID_ADDVIEW2, OnUpdateAddview2)
	ON_COMMAND(ID_DELETEDEVICE, OnDeletedevice)
	ON_UPDATE_COMMAND_UI(ID_DELETEDEVICE, OnUpdateDeletedevice)
	ON_COMMAND(ID_DELETEVIEW, OnDeleteview)
	ON_UPDATE_COMMAND_UI(ID_DELETEVIEW, OnUpdateDeleteview)
	ON_COMMAND(ID_DELETESCRIPT, OnDeletescript)
	ON_UPDATE_COMMAND_UI(ID_DELETESCRIPT, OnUpdateDeletescript)
	ON_COMMAND(ID_SETSCRIPT, OnSetscript)
	ON_UPDATE_COMMAND_UI(ID_SETSCRIPT, OnUpdateSetscript)
	ON_COMMAND(ID_EDITSCRIPT, OnEditscript)
	ON_UPDATE_COMMAND_UI(ID_EDITSCRIPT, OnUpdateEditscript)
	ON_COMMAND(ID_USERS, OnUsers)
	ON_UPDATE_COMMAND_UI(ID_USERS, OnUpdateUsers)
	ON_COMMAND(ID_EDITPWD, OnEditPwdTool)
	ON_UPDATE_COMMAND_UI(ID_EDITPWD, OnUpdateEditPwd)
	ON_COMMAND(ID_SYSPARE, OnSysPara)
	ON_UPDATE_COMMAND_UI(ID_SYSPARE, OnUpdateSysPare)
	ON_COMMAND(ID_EVENTMANAGE, OnEventmanage)
	ON_COMMAND(ID_EVENT, OnEvent)
	ON_COMMAND(ID_SUMMARY_LOG, OnSummaryLog)
	ON_UPDATE_COMMAND_UI(ID_EVENT, OnUpdateEvent)
	ON_UPDATE_COMMAND_UI(ID_SUMMARY_LOG, OnUpdateSummaryLog)
	ON_COMMAND(ID_CONTROLDIALOG, OnControldialog)
	ON_WM_DESTROY()
	ON_WM_TIMER()

	ON_COMMAND(ID_SYSTEMLOG, OnSystemLog)
	ON_UPDATE_COMMAND_UI(ID_SYSTEMLOG, OnUpdateSystemLog)
	ON_COMMAND(ID_NOTICEREC, OnNoticeRec)
	ON_UPDATE_COMMAND_UI(ID_NOTICEREC, OnUpdateNoticeRec)

	ON_COMMAND(ID_USER_MANAGER, OnUserManager)
	ON_COMMAND(ID_EDIT_PWD, OnEditPwd)
	ON_COMMAND(ID_GROUP_MANAGER, OnGroupManager)
	ON_COMMAND(ID_SINGLE_ANALOG, OnSingleAnalog)
	ON_UPDATE_COMMAND_UI(ID_SINGLE_ANALOG, OnUpdateSingleAnalog)
	ON_UPDATE_COMMAND_UI(ID_FILE_PRINT, OnUpdatePrint)
END_MESSAGE_MAP()

static UINT indicators[] =
{
	ID_SEPARATOR,           // 状态行指示器
	ID_INDICATOR_CAPS,
	ID_INDICATOR_NUM,
	ID_INDICATOR_SCRL,
};

HANDLE m_hFreshVarThread;
HANDLE m_hReConnectSrvThread;

static DWORD WINAPI FreshVarThread( void *pData );
static DWORD WINAPI FreshVarCurPicThread( void *pData );
CStringArray g_saCurPicVar;
CRITICAL_SECTION  g_CSLimit;
// CMainFrame 构造/析构

CMainFrame::CMainFrame():m_trayIcon(IDR_TRAYICON)
{
	// TODO: 在此添加成员初始化代码
	m_bShowTrayNotifications = TRUE;//zxn
	m_bShutdown = FALSE;//zxn

	g_bRun=FALSE;
	g_nElementNo=0; //选择
	g_bEdit=TRUE;
	m_bHideLeft=FALSE;

	m_mousePoint=CPoint(0,0);

	// View个数
	m_nViewCount = 0;

	m_nPortNum = 0;

	m_nScripts = 0;

	int i, j;

	//mdi子窗体
	for( i = 0; i < MAX_VIEW_NUM; i++ )
	{
		m_pViewIDE[i] = NULL;
	}

	//串口设备
	for( i = 0; i < MAX_SERIAL_NUM; i++ )
	{
		for( j = 0; j < MAX_DEVICE_NUM; j++ )
		{
			m_hSerialDev[i][j] = NULL;
		}
	}

	//串口组
	for( i = 0; i < MAX_SERIAL_NUM; i++ )
	{
		m_hSerialGroup[i] = NULL;
	}

	//以太网设备
	for( i = 0; i < MAX_NETWORK_NUM; i++ )
	{
		m_hNetworkDev[i] = NULL;
	}

	//脚本
	for( i = 0; i < MAX_SCRIPT_NUM; i++ )
	{
		m_hScriptGroup[i] = NULL;
	}

	m_bEvent = true;
	m_bPrint = true;
	m_bUsers = true;
	m_bSysPare = true;
	m_bAnalog = true;
	m_bDeviceLog = true;
	m_bSystemLog = true;
	m_bNoticeRec = true;
	m_bEditPwd = true;

	m_hCurrent = NULL;

	for( int i=0;i<100;i++ )
	{
		m_PIC_VAR[i].sPicPath = "";
		for( int j=0;j<1000;j++ )
		{
			m_PIC_VAR[i].sCaption[j] = "";
			m_PIC_VAR[i].nType[i] = 0;
		}
	}
}

CMainFrame::~CMainFrame()
{

}

#if USE_TRAYICON
BOOL CMainFrame::InstallIcons()   
{   
	return Shell_NotifyIcon(NIM_ADD, &m_trayIcon.m_nid);   
}   

LRESULT CMainFrame::OnTaskBarCreated(WPARAM wp, LPARAM lp)   
{   
	VERIFY(InstallIcons());   
	return 0;   
}

//////////////////
// Handle notification from tray icon: display a message.
//
LRESULT CMainFrame::OnTrayNotification(WPARAM uID, LPARAM lEvent)
{
	if (m_bShowTrayNotifications) {
		static LPCSTR MouseMessages[] = { "WM_MOUSEMOVE",
			"WM_LBUTTONDOWN", "WM_LBUTTONUP", "WM_LBUTTONDBLCLK",
			"WM_RBUTTONDOWN", "WM_RBUTTONUP", "WM_RBUTTONDBLCLK",
			"WM_MBUTTONDOWN", "WM_MBUTTONUP", "WM_MBUTTONDBLCLK" };
	}

	// let tray icon do default stuff
	return m_trayIcon.OnTrayNotification(uID, lEvent);
}
#endif
bool GetDZDataFormString( CString sOldData,CString &sData2 )
{
	bool bRet = false;
	CString str;
	int nLen=0;
	int nPos=-1;

	int nTemp = atoi( sOldData )+1;
	str.Format( "%07d",nTemp );

	int n1=0,n2=0,n3=0,n4=0,n5=0,n6=0,n7=0;
	CString s1,s2,s3,s4,s5,s6,s7;

	while( 1 )
	{
		s1 = str.Mid(0,1);	n1 = atoi(s1);
		s2 = str.Mid(1,1);	n2 = atoi(s2);
		s3 = str.Mid(2,1);	n3 = atoi(s3);
		s4 = str.Mid(3,1);	n4 = atoi(s4);
		s5 = str.Mid(4,1);	n5 = atoi(s5);
		s6 = str.Mid(5,1);	n6 = atoi(s6);
		s7 = str.Mid(6,1);	n7 = atoi(s7);
		
		if( n1<n2 &&  n2<n3 && n3<n4 && n4<n5 && n5<n6 && n6<n7 )
		{
			sData2 = str;
			return true;
		}
		else
		{
			nTemp++;
			str.Format( "%07d",nTemp );
			if( atoi(str)>3456789 )
				return false;
		}
	}

	return bRet;
}

int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
	if (CMDIFrameWnd::OnCreate(lpCreateStruct) == -1)
		return -1;

	if (!m_wndTree.Create(WS_CHILD|WS_VISIBLE|
		TVS_HASLINES|TVS_HASBUTTONS|TVS_LINESATROOT,
		CRect(0, 0, 0, 0), this, IDD_TREE_LEFT))
	{
		TRACE0("Failed to create instant bar child\n");
		return -1;
	}
	
	if (!m_wndToolBar.CreateEx(this, TBSTYLE_FLAT, WS_CHILD | WS_VISIBLE | CBRS_TOP
		| CBRS_GRIPPER | CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC) ||
		!m_wndToolBar.LoadToolBar(IDR_MAINFRAME))
	{
		TRACE0(g_strTrace2);
		return -1;      // 未能创建
	}

	if (!m_wndDrawToolBar.CreateEx(this, TBSTYLE_FLAT, WS_CHILD | WS_VISIBLE | CBRS_TOP
		| CBRS_GRIPPER | CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC) ||
		!m_wndDrawToolBar.LoadToolBar(IDR_DRAWTOOLS))
	{
		TRACE0("Failed to create toolbar\n");
		return -1;      // fail to create
	}

	if (!m_wndDrawAlignBar.CreateEx(this, TBSTYLE_FLAT, WS_CHILD | WS_VISIBLE | CBRS_TOP
		| CBRS_GRIPPER | CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC) ||
		!m_wndDrawAlignBar.LoadToolBar(IDR_ALIGN))
	{
		TRACE0("Failed to create toolbar\n");
		return -1;      // fail to create
	}

	if (!m_wndRunToolBar.Create(this) ||
		!m_wndRunToolBar.LoadToolBar(IDR_RUNTOOLBAR))
	{
		TRACE0("Failed to create toolbar\n");
		return -1;      // fail to create
	}

	if (!m_wndStatusBar.Create(this) ||
		!m_wndStatusBar.SetIndicators(indicators,
		  sizeof(indicators)/sizeof(UINT)))
	{
		TRACE0("未能创建状态栏\n");
		return -1;      // 未能创建
	}

    m_wndRunToolBar.SetBitmap( IDB_LG, COOBmpToolBar::LargeHot, RGB( 33, 231, 222 ) );
    m_wndRunToolBar.SetBitmap( IDB_LG, COOBmpToolBar::LargeStandard, RGB( 33, 231, 222 ) );
    m_wndRunToolBar.InitImageList();
	m_wndRunToolBar.SetTextMode(TRUE);

	// TODO: 如果不需要工具栏可停靠，则删除这三行
	m_wndToolBar.EnableDocking(CBRS_ALIGN_ANY);
	m_wndDrawToolBar.EnableDocking(CBRS_ALIGN_ANY);
	m_wndDrawAlignBar.EnableDocking(CBRS_ALIGN_ANY);
	EnableDocking(CBRS_ALIGN_ANY);
	DockControlBar(&m_wndToolBar);

	m_wndStatusBar.SetPaneInfo(1, ID_INDICATOR_LOG, SBPS_NOBORDERS,160);
	m_wndStatusBar.SetPaneInfo(3, ID_INDICATOR_LOG, SBPS_NOBORDERS,80);

	RecalcLayout();   
	CRect rect;   
	m_wndToolBar.GetWindowRect(rect);   
	rect.OffsetRect(1, 0);	//偏移一个位置   

	DockControlBar(&m_wndDrawAlignBar, CBRS_ALIGN_ANY, rect);  
	DockControlBar(&m_wndDrawToolBar);
	m_wndRunToolBar.EnableDocking(FALSE);

	m_wndRunToolBar.ShowWindow(SW_HIDE);

	if (!m_wndDockPageBar1.Create(_T("DockPageBar1"), this, CSize(230,260),TRUE,123))
	{
		TRACE0("Failed to create DockPageBar.\n");
		return -1;
	}
	m_wndDockPageBar1.SetBarStyle(m_wndDockPageBar1.GetBarStyle() |
		CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC );
	m_wndDockPageBar1.EnableDocking (CBRS_ALIGN_ANY);

	DockControlBar(&m_wndDockPageBar1, AFX_IDW_DOCKBAR_LEFT);

	CString strTitle;
	strTitle.LoadString(IDS_TREE_TITLE);
	m_wndDockPageBar1.AddPage(&m_wndTree, strTitle, IDR_MAINFRAME);

	CDrawObj::RegisterClass(g_strTline,RUNTIME_CLASS(CDrawTLine));
	CDrawObj::RegisterClass(g_strText,RUNTIME_CLASS(CDrawText));
	CDrawObj::RegisterClass(g_strRect,RUNTIME_CLASS(CDrawRect));
	CDrawObj::RegisterClass(g_strOval,RUNTIME_CLASS(CDrawOval));
	CDrawObj::RegisterClass(g_strButton,RUNTIME_CLASS(CDrawButton));
	CDrawObj::RegisterClass(g_strData,RUNTIME_CLASS(CDrawDatabox));
	CDrawObj::RegisterClass(g_strLed,RUNTIME_CLASS(CDraw3dCircle));
	CDrawObj::RegisterClass(g_strBar,RUNTIME_CLASS(CDrawBar));
	CDrawObj::RegisterClass(g_strCurve,RUNTIME_CLASS(CDrawCurve));
	CDrawObj::RegisterClass(g_strLine,RUNTIME_CLASS(CDrawLine));
	CDrawObj::RegisterClass(g_strBreaker,RUNTIME_CLASS(CDrawBreaker));
	CDrawObj::RegisterClass(g_strSwitch,RUNTIME_CLASS(CDrawSwitch));
	CDrawObj::RegisterClass(g_strGrid,RUNTIME_CLASS(CDrawGrid));
	CDrawObj::RegisterClass(g_strBitmap,RUNTIME_CLASS(CDrawBitmap));
	//CDrawObj::RegisterClass(g_strGif, RUNTIME_CLASS(CDrawGif));
	CDrawObj::RegisterClass(g_strTransfer,RUNTIME_CLASS(CDrawTransfer));
	CDrawObj::RegisterClass(g_strArc,RUNTIME_CLASS(CDrawArc));
	CDrawObj::RegisterClass(g_strArrow,RUNTIME_CLASS(CDrawArrow));
	CDrawObj::RegisterClass(g_strPoly,RUNTIME_CLASS(CDrawPoly));
	CDrawObj::RegisterClass(g_strMLine,RUNTIME_CLASS(CDrawMLine));
	CDrawObj::RegisterClass(g_strPipe,RUNTIME_CLASS(CDrawPipe));
	CDrawObj::RegisterClass(g_strZhePipe,RUNTIME_CLASS(CDrawZhePipe));
	CDrawObj::RegisterClass(g_strYPipe,RUNTIME_CLASS(CDrawYPipe));
	CDrawObj::RegisterClass(g_strWatch,RUNTIME_CLASS(CDrawWatch));
	CDrawObj::RegisterClass(g_strSingleBar,RUNTIME_CLASS(CDrawSingleBar));
	CDrawObj::RegisterClass(g_strRoundRect,RUNTIME_CLASS(CDrawRoundRect));
	CDrawObj::RegisterClass(g_strPie,RUNTIME_CLASS(CDrawPie));
	CDrawObj::RegisterClass(g_strFan,RUNTIME_CLASS(CDrawFan));
	CDrawObj::RegisterClass(g_strHisCurve,RUNTIME_CLASS(CDrawHisCurve));
	CDrawObj::RegisterClass(g_strTable,RUNTIME_CLASS(CDrawTable));
	CDrawObj::RegisterClass(g_strComposite,RUNTIME_CLASS(CDrawComposite));	
	CDrawObj::RegisterClass(g_strOCX,RUNTIME_CLASS(CDrawOCX));	
	//CDrawObj::RegisterClass(g_strGIF,RUNTIME_CLASS(CDrawGif));	
	CDrawObj::RegisterClass(g_strFlash,RUNTIME_CLASS(CDrawFlash));
	CDrawObj::RegisterClass(g_strRadio,RUNTIME_CLASS(CDrawBtnRadio));
	CDrawObj::RegisterClass(g_strCheck,RUNTIME_CLASS(CDrawBtnCheck));

	pDevicesManager = new CDevicesManager;
	pVariantsManager = new CVariantsManager;

	pVariantsManager->SetDBType(g_strDBType);
	pVariantsManager->m_strLowerLimit = CString(g_strLowerLimit)+CString(g_strAlarm);
	pVariantsManager->m_strUpperLimit = CString(g_strUpperLimit)+CString(g_strAlarm);
	pVariantsManager->m_strCurrValue = CString(g_strCurrValue);
	pVariantsManager->m_strReturnNormal = CString(g_strReturnNormal2);

	pEventServer = new CEventServer;
	pEventServer->m_bValid = true;
	pEventServer->Validate( g_bEventAlarm );

	// 一定要先load设备管理，否则变量无法关联到设备
	pDevicesManager->Load(g_strDirectory);
	pVariantsManager->Load(g_strDirectory);

	LoadRunPara();


#if 1
		bool bIsBoxAppear = false;
		for( int iPortIndex=0;iPortIndex<2;iPortIndex++ )
		{
			CString sPortTemp;
			sPortTemp.Format("%d",atoi(g_strServerPort)+iPortIndex );
			if( !pDevicesManager->Connection(g_strServerIP,sPortTemp) )
			{
				LOG4C((LOG_NOTICE, "Socket Port %s 连接失败",sPortTemp));
				if( !bIsBoxAppear )
					MessageBox(g_strConnectionFailed, g_strTip, MB_ICONINFORMATION);
				bIsBoxAppear = true;
				pDevicesManager->SetSocketStatus(FALSE,sPortTemp);
				break;
			}
			else
			{
				pDevicesManager->SetSocketStatus(TRUE,sPortTemp);
				pVariantsManager->SetSysComunicationVar( 0.0 );
				if( TRUE == pDevicesManager->GetSocketStatus( sPortTemp ) )
				{
					LOG4C((LOG_NOTICE, "Socket Port %s 连接成功",sPortTemp));
				}
			}
		}
#else
		bool bIsBoxAppear = false;
		int nVarSize = pVariantsManager->m_analog.GetSize();
		int nVarUseSize=0;
		for( int i=0;i<nVarSize;i++ )
		{
			if( pVariantsManager->m_analog.GetAt(i)->m_pDevice==NULL )
				continue;
			if( pVariantsManager->m_analog.GetAt(i)->m_pDevice->m_bUsed )
				nVarUseSize++;
		}
		int nPortSize = nVarUseSize/VARNUM2PORT;
		if( nPortSize%VARNUM2PORT==0 && nPortSize>0 )
			nPortSize--;
		for( int iPortIndex=0;iPortIndex<=nPortSize;iPortIndex++ )
		{
			CString sPortTemp;
			sPortTemp.Format("%d",atoi(g_strServerPort)+iPortIndex );
			if( !pDevicesManager->Connection(g_strServerIP,sPortTemp) )
			{
				LOG4C((LOG_NOTICE, "Socket Port %s 连接失败",sPortTemp));
				if( !bIsBoxAppear )
					MessageBox(g_strConnectionFailed, g_strTip, MB_ICONINFORMATION);
				bIsBoxAppear = true;
				pDevicesManager->SetSocketStatus(FALSE,sPortTemp);
				break;
			}
			else
			{
				//LOG4C((LOG_NOTICE, "Socket 连接成功"));
				pDevicesManager->SetSocketStatus(TRUE,sPortTemp);
				pVariantsManager->SetSysComunicationVar( 0.0 );
				if( TRUE == pDevicesManager->GetSocketStatus( sPortTemp ) )
				{
					LOG4C((LOG_NOTICE, "Socket Port %s 连接成功",sPortTemp));
				}
			}
		}
#endif

	CRect rect1;
	GetWindowRect(&rect1);
	ScreenToClient(&rect1);

	pVariantsManager->m_bAnalogAlarm = g_bYcEvent;

	if( g_nAlarmModeIsDlg )
	{
		int screenx=GetSystemMetrics(SM_CXSCREEN);
		int screeny=GetSystemMetrics(SM_CYSCREEN);

		//系统任务栏的高度
		HWND   hWnd   =   ::FindWindow("Shell_TrayWnd",   NULL);   
		RECT   rc;   
		::GetWindowRect(hWnd,   &rc);   
		int nHeight = rc.bottom-rc.top;

		m_dlgEvent = new CRealEventDlg();	
		m_dlgEvent->Create(IDD_REALEVENT, this);
		m_dlgEvent->ShowWindow(SW_HIDE);
		CRect rct;
		m_dlgEvent->GetWindowRect(&rct);
		m_dlgEvent->SetWindowPos(&wndTop, (screenx-rct.Width())/2, screeny-rct.Height()-nHeight, rct.Width(), rct.Height(), SWP_NOZORDER);

		m_dlgControl = new CDlgBmp();
		m_dlgControl->Create(IDD_DIALOGCONTROL, this);
		m_dlgControl->ShowWindow(SW_HIDE);
		CRect rct1;
		m_dlgControl->GetWindowRect(&rct1);
		m_dlgControl->SetWindowPos(&wndTop, screenx-rct1.Width(), screeny-rct1.Height(), rct1.Width(), rct1.Height(), SWP_NOZORDER);
	}

	// 初始化左边树形
	InitTreeInfo();

		//LONG style=::GetWindowLong(m_hWnd,GWL_STYLE);
		//style&=~WS_CAPTION;
		//style&=~WS_BORDER;
		//::SetWindowLong(m_hWnd,GWL_STYLE,style);
		int screenx=GetSystemMetrics(SM_CXSCREEN);
		int screeny=GetSystemMetrics(SM_CYSCREEN);

		//系统任务栏的高度
		HWND   hWnd   =   ::FindWindow("Shell_TrayWnd",   NULL);   
		RECT   rc;   
		::GetWindowRect(hWnd,   &rc);   
		int   nHeight   =   rc.bottom   -rc.top;

		if( !g_bFullScreen )
			SetWindowPos(NULL,0,0,screenx,screeny-nHeight,SWP_NOZORDER);
		else
			SetWindowPos(NULL,0,0,screenx,screeny,SWP_NOZORDER);// 全屏
	

#if USE_TRAYICON
	m_trayIcon.SetNotificationWnd(this, WM_MY_TRAY_NOTIFICATION);
	m_trayIcon.SetIcon(IDR_MAINFRAME);
#endif

	// Install the tab view here
	VERIFY(m_MDIClient.SubclassMDIClient(this, &m_wndViewManager));

	if( g_nToolbarTop )
	{
		m_wndViewManager.ShowWindow(SW_SHOW);
	}
	else
	{
		m_wndViewManager.ShowWindow(SW_HIDE);
	}

	if( g_strStartPic.Compare("") )
	{
		char picDir[_MAX_PATH] = {0};
		strcpy(picDir, g_strDirectory);
		strcat(picDir, "\\");
		strcat(picDir, _PICTUREDIR);
		strcat(picDir, g_strStartPic);
		strcat(picDir, ".view");
		AddIDEView( g_strStartPic, CString(picDir) );
	}

	if( g_nIsPoll == 1 )
	{
#if VIEW_USE_THREAD
		MTVERIFY( m_hViewPollThread = ::CreateThread(NULL, 0, ViewPollThread, this, 0, 0) ); 
#else
		SetTimer(1, 1000, NULL);
#endif
	}

	if( -1==PMS_VerifyUserPermit( g_nUserID,PMS_R_ALARM_SEARCH,"" ) )
	{
		m_bEvent = false;
	}
	if( -1==PMS_VerifyUserPermit( g_nUserID,PMS_R_PRINT,"" ) )
	{
		m_bPrint = false;
	}
	if( -1==PMS_VerifyUserPermit( g_nUserID,PMS_R_USER_MANAGE,"" ) )
	{
		m_bUsers = false;
	}
	if( -1==PMS_VerifyUserPermit( g_nUserID,PMS_R_RUNSTATUS,"" ) )
	{
		m_bSysPare = false;
	}
	if( -1==PMS_VerifyUserPermit( g_nUserID,PMS_R_DICT,"" ) )
	{
		m_bAnalog = false;
	}
	if( -1==PMS_VerifyUserPermit( g_nUserID,PMS_R_DEVICELOG,"" ) )
	{
		m_bDeviceLog = false;
	}
	if( -1==PMS_VerifyUserPermit( g_nUserID,PMS_R_SYSTEMLOG,"" ) )
	{
		m_bSystemLog = false;
	}
	if( -1==PMS_VerifyUserPermit( g_nUserID,PMS_R_NITICEREC,"" ) )
	{
		m_bNoticeRec = false;
	}
	if( -1==PMS_VerifyUserPermit( g_nUserID,PMS_R_EDITPWD,"" ) )
	{
		m_bEditPwd = false;
	}
	//展开树
	//m_wndTree.Expand(m_wndTree.GetRootItem(),TVE_EXPAND);
	//HTREEITEM handleTreeItem = m_wndTree.GetRootItem();   
	//while(handleTreeItem)
	//{   
	//	handleTreeItem = m_wndTree.GetChildItem(handleTreeItem);
	//	m_wndTree.Expand(handleTreeItem, TVE_EXPAND);
	//}
	MyExpandTree( m_wndTree.GetRootItem() );
	m_wndStatusBar.SetPaneText(2, "ver");
	m_wndStatusBar.SetPaneText(3, g_strVersion);

	SetTimer(2, 1000*60*1, NULL);//狗信息定时器
	SetTimer(3, 1000*60*2, NULL);//判断变量在这个时间段时否报警

	if( g_nToolbarLeft && g_bStartRun )
		m_wndDockPageBar1.OnStudClick();

	return 0;
}

void CMainFrame::MyExpandTree(HTREEITEM hTreeItem)
{
    if(!m_wndTree.ItemHasChildren(hTreeItem))
    {
        return;
    }
    HTREEITEM hNextItem = m_wndTree.GetChildItem(hTreeItem);
    while (hNextItem != NULL)
    {
        MyExpandTree(hNextItem);
        hNextItem = m_wndTree.GetNextItem(hNextItem, TVGN_NEXT);
    }
    m_wndTree.Expand(hTreeItem,TVE_EXPAND);
}
  

void CMainFrame::LoadRunPara()
{
    char Path[_MAX_PATH] = {0};
	strcat(Path, g_strDirectory);
    strcat(Path,"\\");
	strcat(Path, _PROJECTDIR);
	strcat(Path,"\\");
	strcat(Path, "runpara.ini");
	char RUN[MAX_PATH] = {0};
	memset(RUN, 0, sizeof(RUN));
	//CString str;

	if ( GetPrivateProfileString("RUNPARA", "STARTRUN","",RUN, 10, Path) != 0)
	{
        g_bStartRun = (RUN[0] == '1' ? true:false);
	}

	if ( GetPrivateProfileString("RUNPARA", "STARTPIC","", RUN, sizeof(RUN), Path) != 0)
	{
		g_strStartPic = RUN;
	}

	if ( GetPrivateProfileString("RUNPARA", "STARTPATH","",RUN, sizeof(RUN), Path) != 0)
	{
		g_strStartPath = RUN;
	}

	if ( GetPrivateProfileString("RUNPARA", "ALARM","",RUN, 10, Path) != 0)
	{
		g_bEventAlarm = RUN[0] == '1' ? true:false;
	}

	if ( GetPrivateProfileString("RUNPARA", "VOICE", "",RUN, 10, Path) != 0)
	{
		g_bAlarmVoice = RUN[0] == '1' ? true:false;
	}

	if ( GetPrivateProfileString("RUNPARA", "HIDETASK","",RUN, 10, Path) != 0)
	{
		g_bHideTask = RUN[0] == '1' ? true:false;
	}
}

BOOL CMainFrame::DirSearch(CString strPath, CString strFileName)
{
	BOOL bResult = FALSE;
	long hDir;
	struct _finddata_t fDir;
	int nDone;
	strPath += "*.*";
	hDir = _findfirst( (char *)(LPCTSTR)strPath, &fDir );
	if( -1L != hDir )
	{
		while( !( nDone = _findnext(hDir, &fDir) ) )
		{
			if( !strcmp(fDir.name, "..") ) continue;

			if( (_A_SUBDIR == fDir.attrib) )
			{
				CString str = fDir.name;
				if( !str.Compare(strFileName) )
				{
					bResult = TRUE;
				}
			}
		}
	}

	return bResult;
}

void CMainFrame::FileSearch(HTREEITEM hItem, CString strPath, CString strFileName, int nLayer)
{   
	long hfile;
	struct _finddata_t fFile;   
	CString strCurr = strPath + strFileName;  // + "\\" + 
	HTREEITEM hTemp = hItem;
	int nDone=0;  
	int nTime = 0;
	hfile = _findfirst( (char *)(LPCTSTR)strCurr, &fFile );
	if( -1L != hfile )
	{
		while( !( nDone = _findnext(hfile, &fFile) ) )   
		{   
			if( !strcmp(fFile.name,"..") ) continue;   

			if( (_A_SUBDIR == fFile.attrib) )   
			{               
				strCurr = strPath + "\\" + fFile.name + "\\";   

				int nPos = strCurr.Find("\\\\");
				if( nPos!=-1 )
				{
					strCurr.Delete( nPos );
				}

				CString str = fFile.name;
				HTREEITEM hReturn = hItem;
				hItem = m_wndTree.InsertItem(str, 1, 1, hItem);
				FileSearch(hItem, strCurr, "*.*", nLayer + 1);
				hItem = hReturn;
				
				if( g_bStartRun )
				{
					CString sPath = strCurr;

					int nPos = sPath.Find("*");
					if( nPos!=-1 )
					{
						sPath = sPath.Left( sPath.GetLength()-3 );
					}
					
					sPath = sPath+".view";
					
					nPos = sPath.Find("\\.");
					if( nPos!=-1 )
					{
						sPath.Delete( nPos );
					}

					int nInsertIndex=0;
					if( !GetPicIndexByPicPath( nInsertIndex,sPath ) )
					{
						InsertPicPathToStruct( nInsertIndex,sPath );
						//LOG4C((LOG_NOTICE, "画面%d：%s", nInsertIndex,sPath));
					}
				}
			}   
			else     
			{   
				CString str = fFile.name;
 				if( str.Right(4).Compare("view") ) continue;
				CString strTemp = str.Left(str.GetLength()-5);
				if( !DirSearch(strPath + "\\", strTemp ) )
				{
					m_wndTree.InsertItem(strTemp, 1, 1, hTemp);
				}
				//m_wndTree.SortChildren( hItem );
				if( g_bStartRun )
				{
					CString sPath = strPath;

					int nPos = sPath.Find("*");
					if( nPos!=-1 )
					{
						sPath = sPath.Left( sPath.GetLength()-3 );
					}

					sPath = sPath+strTemp+".view";

					int nInsertIndex=0;
					if( !GetPicIndexByPicPath( nInsertIndex,sPath ) )
					{
						InsertPicPathToStruct( nInsertIndex,sPath );
						//LOG4C((LOG_NOTICE, "画面%d：%s", nInsertIndex,sPath));
					}
				}
			}   
		}           
		_findclose(hfile);
	}
}  

//   删除目录   
void CMainFrame::DeleteDirectory(CString strDir)   
{   
	if(strDir.IsEmpty())   
	{   
		RemoveDirectory(strDir);   
		return;   
	}   
	//   首先删除文件及子文件夹   
	CFileFind   ff;   
	BOOL   bFound   =   ff.FindFile(strDir+"\\*",   0);   
	while(bFound)   
	{   
		bFound   =   ff.FindNextFile();   
		if(ff.GetFileName()=="."||ff.GetFileName()=="..")   continue;   
		//   去掉文件(夹)只读等属性   
		SetFileAttributes(ff.GetFilePath(),   FILE_ATTRIBUTE_NORMAL);   
		if(ff.IsDirectory())   
		{   
			//   递归删除子文件夹   
			DeleteDirectory(ff.GetFilePath());   
			RemoveDirectory(ff.GetFilePath());   
		}   
		else   
		{   
			DeleteFile(ff.GetFilePath());   //   删除文件   
		}   
	}   
	ff.Close();   
	//   然后删除该文件夹   
	RemoveDirectory(strDir);   
}
  
void CMainFrame::InitTreeInfo(void)
{
	m_wndTree.SetItemHeight(20);
	m_wndImageList.DeleteImageList();
	m_wndImageList.Create(IDB_LEFT, 16, 1, RGB(255, 0, 255));	
	m_wndTree.SetImageList(&m_wndImageList, LVSIL_NORMAL);
	m_wndTree.SetBkColor( RGB(230,241,249) );
	m_wndTree.DeleteAllItems();
	m_hMonitor = m_wndTree.InsertItem(g_strMoniterSite,0,0);
	
	if( !g_bStartRun )
	{
		m_hIOGroup = m_wndTree.InsertItem(g_strDevice,2,2);
		m_hEtherNet = m_wndTree.InsertItem(g_strEthernet,3,3,m_hIOGroup);
		m_hSerial = m_wndTree.InsertItem(g_strSerial,4,4,m_hIOGroup);
		
		m_hVariant = m_wndTree.InsertItem(g_strDataDict,11,11);
		m_hAnalog = m_wndTree.InsertItem(g_strVarSet,15,15,m_hVariant);

		m_hScript = m_wndTree.InsertItem(g_strScriptManage,13,13);
		m_hSystem = m_wndTree.InsertItem(g_strSysParam,9,9);


		//插入串口和网络设备
		int nComportSize = pDevicesManager->m_channels.GetSize();
		for (int i = 0; i < nComportSize; i++)
		{
			CChannel* pComport = pDevicesManager->m_channels[i];
			if( pComport->m_nCommunicateType == 0 )			// 串口设备
			{
				m_hSerialGroup[i] = m_wndTree.InsertItem(pComport->m_strName,5,5,m_hSerial);
				m_nPortNum++;
				int nDeviceSize = pComport->m_Devices.GetSize();
				for (int j = 0; j < nDeviceSize; j++)
				{
					CDevice* pDev = pComport->m_Devices[j];
					m_hSerialDev[i][j] = m_wndTree.InsertItem(pDev->m_strName,4,4,m_hSerialGroup[i]);
				}
			}
			else if( pComport->m_nCommunicateType == 1 )	// 网络设备
			{
				int nDeviceSize = pComport->m_Devices.GetSize();
				for( int j = 0; j < nDeviceSize; j++ )
				{
					CDevice *pDev = pComport->m_Devices[j];
					m_hNetworkDev[j] = m_wndTree.InsertItem(pDev->m_strName, 2, 2, m_hEtherNet);
				}
			}
		}
	}

	//显示画面

	CString strFindPicFile = "*.view";
	struct _finddata_t f;
    char szPicDir[MAX_PATH] = {0};

	strcpy(szPicDir, g_strDirectory);
	strcat(szPicDir, "\\");
	strcat(szPicDir, _PICTUREDIR);

	FileSearch(m_hMonitor, szPicDir, "*.*", 0);

	//m_wndTree.SortChildren( m_hMonitor );

	if( !g_bStartRun )
	{
		// 显示脚本
		long hfile;
		strFindPicFile = "*.srp";
		strcpy(szPicDir, g_strDirectory);
		strcat(szPicDir, "\\");
		strcat(szPicDir, _SCRIPTDIR);
		strcat(szPicDir, strFindPicFile);
		hfile = _findfirst((const char*)szPicDir,&f);
		if (-1L != hfile)
		{
			CString strFileName = f.name;
			m_hScriptGroup[m_nScripts++] = m_wndTree.InsertItem(strFileName.Left(strFileName.GetLength()-4),
										1,1,m_hScript);

			while (0 == _findnext(hfile,&f)) 
			{
				strFileName = f.name;
				m_hScriptGroup[m_nScripts++] = m_wndTree.InsertItem(strFileName.Left(strFileName.GetLength()-4),
										1,1,m_hScript);
			}
			_findclose(hfile);
		}
	}
}
void   CMainFrame::OnFullScreen()   
{ 
    GetWindowPlacement(&m_OldWndPlacement); 
    CRect   WindowRect; 
    GetWindowRect(&WindowRect); 
    CRect   ClientRect; 
    RepositionBars(0,   0xffff,   AFX_IDW_PANE_FIRST,   reposQuery,   &ClientRect); 
    ClientToScreen(&ClientRect);//   获取屏幕的分辨率 
    int   nFullWidth=GetSystemMetrics(SM_CXSCREEN); 
    int   nFullHeight=GetSystemMetrics(SM_CYSCREEN);//   将除控制条外的客户区全屏显示到从(0,0)到(nFullWidth,   nFullHeight)区 
//域,   将(0,0)和(nFullWidth,   nFullHeight)两个点外扩充原窗口和除控制条之外的   客 
//户区位置间的差值,   就得到全屏显示的窗口位置 
    m_FullScreenRect.left=0;//WindowRect.left-ClientRect.left-1; 
    m_FullScreenRect.top=0;//WindowRect.top-ClientRect.top-1; 
    m_FullScreenRect.right=WindowRect.right-ClientRect.right+nFullWidth+2; 
    m_FullScreenRect.bottom=nFullHeight;//WindowRect.bottom-ClientRect.bottom+nFullHeight+2; 

    //   进入全屏显示状态 
    WINDOWPLACEMENT   wndpl; 
    wndpl.length=sizeof(WINDOWPLACEMENT); 
    wndpl.flags=0; 
    wndpl.showCmd=SW_SHOWNORMAL; 
    wndpl.rcNormalPosition=m_FullScreenRect; 
    SetWindowPlacement(&wndpl); 
} 

void CMainFrame::OnGetMinMaxInfo(MINMAXINFO* lpMMI)
{
	// TODO: 在此添加消息处理程序代码和/或调用默认值
	//if(g_bFullScreen) 
	//{ 
	//	lpMMI-> ptMaxSize.x=m_FullScreenRect.Width(); 
 //       lpMMI-> ptMaxSize.y=m_FullScreenRect.Height(); 
 //       lpMMI-> ptMaxPosition.x=m_FullScreenRect.Width(); 
 //       lpMMI-> ptMaxPosition.y=m_FullScreenRect.Height(); 
 //       //最大的Track尺寸也要改变 
 //       lpMMI-> ptMaxTrackSize.x=m_FullScreenRect.Width(); 
 //       lpMMI-> ptMaxTrackSize.y=m_FullScreenRect.Height(); 
	//}

	CMDIAutoHideFrame::OnGetMinMaxInfo(lpMMI);
}
void CMainFrame::OnRun() 
{
	g_bRun = TRUE;	//运行否
	g_bEdit = FALSE;   //编辑否
	CDrawObj::bRuning = TRUE;

	m_wndToolBar.ShowWindow(SW_HIDE);
	m_wndDrawToolBar.ShowWindow(SW_HIDE);
	m_wndDrawAlignBar.ShowWindow(SW_HIDE);
	
	if( g_nToolbarRun )//&& !g_bFullScreen )
	{
		m_wndRunToolBar.ShowWindow(SW_SHOW);
	}
	else
	{
		m_wndRunToolBar.ShowWindow(SW_HIDE);
	}

	RecalcLayout();

	if( g_nToolBarStatus )//&& !g_bFullScreen )
	{
		m_wndStatusBar.ShowWindow(SW_SHOW);
	}
	else
	{
		m_wndStatusBar.ShowWindow(SW_HIDE);
	}

	if( g_nToolbarLeft )
	{
		m_wndDockPageBar1.ShowWindow(SW_SHOW);
	}
	else
	{
		m_wndDockPageBar1.ShowWindow(SW_HIDE);
	}

	if ( g_bHideTask )
	{
		HWND wnd = ::FindWindow("Shell_TrayWnd", NULL);
		::ShowWindow(wnd, SW_HIDE);
	}
	//else
	//{
	//	HWND wnd = ::FindWindow("Shell_TrayWnd", NULL);
	//	::ShowWindow(wnd, SW_SHOW);
	//}

	LONG style=::GetWindowLong(m_hWnd,GWL_STYLE);
	style&=~WS_CAPTION;
	style&=~WS_BORDER;
	::SetWindowLong(m_hWnd,GWL_STYLE,style);
	int screenx=GetSystemMetrics(SM_CXSCREEN);
	int screeny=GetSystemMetrics(SM_CYSCREEN);

	//系统任务栏的高度
	HWND   hWnd   =   ::FindWindow("Shell_TrayWnd",   NULL);   
    RECT   rc;   
    ::GetWindowRect(hWnd, &rc);   
    int nHeight = rc.bottom-rc.top;

	if( g_nIsDemo == 0 )
	{
		if(!g_bFullScreen)
		{
			SetWindowPos(NULL,0,0,screenx,screeny-nHeight,SWP_NOZORDER);
		}
		else
		{ 
			SetWindowPos(NULL,0,0,screenx,screeny+0,SWP_FRAMECHANGED);//关于全屏
		}
	}
	else
	{
		char Path[_MAX_PATH] = {0};
		strcat(Path, g_strDirectory);
		strcat(Path,"\\");
		strcat(Path, _PROJECTDIR);
		strcat(Path,"\\");
		strcat(Path, "runpara.ini");
		char RUN[MAX_PATH] = {0};
		memset(RUN, 0, sizeof(RUN));
		//CString str;

		if ( GetPrivateProfileString("RUNPARA", "STARTRUN","",RUN, 10, Path) != 0)
		{
			g_bStartRun = (RUN[0] == '1' ? true:false);
		}

		if ( GetPrivateProfileString("RUNPARA", "FULLSCREEN","",RUN, 10, Path) != 0)
		{
			g_bFullScreen = RUN[0] == '1' ? true:false;
		}

		SetWindowPos(NULL,0,0,screenx,screeny-nHeight,SWP_NOZORDER);
	}
    SetMenu((CMenu*)NULL);
}

BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)
{
	if( !CMDIFrameWnd::PreCreateWindow(cs) )
		return FALSE;
	// TODO: 在此处通过修改 CREATESTRUCT cs 来修改窗口类或
	// 样式

	if (!g_bStartRun)
	{
		cs.style = WS_OVERLAPPED | WS_CAPTION | FWS_ADDTOTITLE
			| WS_THICKFRAME | WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_MAXIMIZE;
	}
	else
	{
		cs.style=WS_OVERLAPPED   |   WS_SYSMENU   |WS_MINIMIZEBOX   |WS_TILED ;
	}


	return TRUE;
}

// CMainFrame 诊断

#ifdef _DEBUG
void CMainFrame::AssertValid() const
{
	CMDIFrameWnd::AssertValid();
}

void CMainFrame::Dump(CDumpContext& dc) const
{
	CMDIFrameWnd::Dump(dc);
}

#endif //_DEBUG


// CMainFrame 消息处理程序

void CMainFrame::OnSuperEnd()
{
	// TODO: 在此添加命令处理程序代码
	m_bShutdown = TRUE;		// really exit
	SendMessage(WM_CLOSE);	
}

void CMainFrame::OnTrayOpen()
{
	// TODO: 在此添加命令处理程序代码
	ShowWindow(SW_MAXIMIZE);	
	SetForegroundWindow();
}

void CMainFrame::OnClose()
{
	// TODO: 在此添加消息处理程序代码和/或调用默认值

#if USE_TRAYICON
#else
	m_bShutdown = TRUE;
#endif
	if( m_bShutdown )
	{
		if( g_nIsDemo == 1 )
		{
			if(MessageBox(g_strExitConfirm, g_strTip, MB_YESNO|MB_ICONQUESTION)==IDNO)
			{
				return;
			}
		}
		else
		{
			CLogin dlg;
			dlg.m_bShutdown = true;
			if (dlg.DoModal()!=IDOK)
			{
				m_bShutdown = false;
				return;
			}
			CString sContent;
			sContent.Format("用戶< %s >注销",dlg.m_sUserID );
			CDBInterface::GetInstancePtr()->InsertLogRecord( LOG_LOGOUT,0,"",(char *)(LPCTSTR)sContent );
		}

		if (!g_bRun )
		{
			pDevicesManager->Store(g_strDirectory);
			pVariantsManager->Store(g_strDirectory);
		}

		// 清除所有事件
		for(POSITION pos = pEventServer->eventList.GetHeadPosition();pos!=NULL;)
		{
			POSITION pos1 = pos ; //要在这里做一个备份
			CAlarmEvent* pEvent = pEventServer->eventList.GetNext(pos);//他会改变 pos的值
			pEventServer->eventList.RemoveAt(pos1);
			if( pEvent )
			{
				delete pEvent;
				pEvent = NULL;
			}
		}

		if( g_nAlarmModeIsDlg )
		{
			delete m_dlgEvent;
			delete m_dlgControl;
		}

		int i;
		for( i = 0; i < MAX_VIEW_NUM; i++ )
		{
			if( m_pViewIDE[ i ] )
			{
				::SendMessage(m_pViewIDE[ i ]->m_hWnd, WM_CLOSE, 0, 0 );
				m_pViewIDE[ i ] = NULL;
			}
		}

		CMDIAutoHideFrame::OnClose();
	}
	else
	{
		ShowWindow(SW_HIDE);
	}
}

void CMainFrame::OnDestroy()
{
	if( g_nIsPoll == 1 )
	{
#if VIEW_USE_THREAD
		if( m_hViewPollThread != NULL )
		{
			MTVERIFY( WaitForSingleObject( m_hViewPollThread, INFINITE ) != WAIT_FAILED );
			MTVERIFY( CloseHandle( m_hViewPollThread ) );
			m_hViewPollThread = NULL;
		}
#else
		KillTimer(1);
#endif
	}

	CMDIAutoHideFrame::OnDestroy();

	// TODO: 在此处添加消息处理程序代码
	int i;
	for( i = 0; i < MAX_VIEW_NUM; i++ )
	{
		if( m_pViewIDE[ i ] )
		{
			::SendMessage(m_pViewIDE[ i ]->m_hWnd, WM_DESTROY, 0, 0 );
			m_pViewIDE[ i ] = NULL;
		}
	}
}

BOOL CMainFrame::FindTreeItem(HTREEITEM hSrcItem, HTREEITEM hDestItem)
{
	HTREEITEM hItem = m_wndTree.GetParentItem( hSrcItem );
	while( hItem != NULL )
	{
		if( hItem == hDestItem ) return TRUE;
		hItem = m_wndTree.GetParentItem( hItem );
	}

	return FALSE;
}

int CMainFrame::ShowDevProperty(HTREEITEM hSelectedItem)
{
	CString strOldUid, strNewUid; 
	int i, j;
	int nChannelIndex = -1, nDeviceIndex = -1;
	int nChannelSize = pDevicesManager->m_channels.GetSize();
	// 串口设备属性设置
	for (i = 0; i < nChannelSize; i++)
	{
		if( nChannelIndex != -1 && nDeviceIndex != -1 ) break;
		int nDeviceSize = pDevicesManager->m_channels[i]->m_Devices.GetSize();
		for( j = 0; j < nDeviceSize; j++)
		{
			if (m_hSerialDev[i][j]==hSelectedItem )
			{
				nChannelIndex = i;
				nDeviceIndex = j;
				break;
			}

			if( m_hNetworkDev[j] == hSelectedItem && pDevicesManager->m_channels[i]->m_nCommunicateType == 1 )
			{
				nChannelIndex = i;
				nDeviceIndex = j;
				break;
			}
		}
	}

	if( nChannelIndex == -1 || nDeviceIndex == -1 ) return -1;

	CChannel* pChannel = pDevicesManager->m_channels[nChannelIndex];
	CDevice* pDev =	pChannel->m_Devices[nDeviceIndex];
	CSerial* pSerial = (CSerial *)pChannel;
	CNetwork *pNetwork = (CNetwork *)pChannel;

	CWizard MyWizard(g_strMywizard,this,1);
	// 通信方式
	m_wndDevice.m_nCommuniteType = pChannel->m_nCommunicateType;
	// 设备驱动名称
	m_wndDevice.m_strDevDriveName = pDev->m_strDevDriveName;
	// 设备厂家名称
	m_wndDevice.m_strDevFactoryName = pDev->m_strDevFactoryName;
	// 设备型号
	m_wndDevice.m_strDevTypeName = pDev->m_strType;
	// 通信协议(例:Modbus rtu, modbus ascii, modbus tcp)
	m_wndDevice.m_nProtocolType = pDev->m_nProtocolType;
	// 配置文件名称
	m_wndDevice.m_strIniName = pDev->m_strIniName;
	// 协议驱动动态库名称
	m_wndDevice.m_strProtocolName = pDev->m_strProtocolName;
	// 是否为采集设备
	m_wndDevice.m_nCollectDev = pDev->m_nIsCollectDev;
	// 是否启用设备
	m_wndDevice.m_nDevEnable = (int)pDev->m_bUsed;

	// CString类型预留
	//m_wndDevice.m_strReserved1 = pDev->m_strReserved1;
	m_wndDevice.m_strReserved2 = pDev->m_strReserved2;
	m_wndDevice.m_strReserved3 = pDev->m_strReserved3;
	m_wndDevice.m_strReserved4 = pDev->m_strReserved4;
	m_wndDevice.m_strReserved5 = pDev->m_strReserved5;

	// Int类型预留
	m_wndDevice.m_nReserved1 = pDev->m_nReserved1;
	m_wndDevice.m_nReserved2 = pDev->m_nReserved2;
	m_wndDevice.m_nReserved3 = pDev->m_nReserved3;
	m_wndDevice.m_nReserved4 = pDev->m_nReserved4;
	m_wndDevice.m_nReserved5 = pDev->m_nReserved5;

	// BOOL类型预留
	m_wndDevice.m_bReserved1 = pDev->m_bReserved1;
	m_wndDevice.m_bReserved2 = pDev->m_bReserved2;
	m_wndDevice.m_bReserved3 = pDev->m_bReserved3;
	m_wndDevice.m_bReserved4 = pDev->m_bReserved4;
	m_wndDevice.m_bReserved5 = pDev->m_bReserved5;

	// 设备UID
	m_wndComport.m_strUID = pDev->m_strUID;
	strOldUid = pDev->m_strUID;
	// 设备名称
	m_wndComport.m_strDevName = pDev->m_strName;
	// 设备所属区域
	m_wndComport.m_strDevArea = pDev->m_strReserved1;
	// 通讯超时
	m_wndComport.m_nTimeout = pDev->m_nTimeout;
	// 设备地址
	m_wndComport.m_nDevAddr = (int)pDev->m_Address;

	// 串行端口
	m_wndComport.m_nCommPort = atoi(pSerial->m_strPort.Mid(3));
	// 数据位
	m_wndComport.m_nDataBit = pSerial->m_nByteSize;
	// 波特率
	m_wndComport.m_nRate = pSerial->m_nBaudRate;
	// 停止位
	m_wndComport.m_nStopBit = pSerial->m_nStopBits;
	// 校验位
	m_wndComport.m_nCheckCode = pSerial->m_nParity;

	// CString类型预留
	m_wndComport.m_strReserved6 = pDev->m_strReserved6;
	m_wndComport.m_strReserved7 = pDev->m_strReserved7;
	m_wndComport.m_strReserved8 = pDev->m_strReserved8;
	m_wndComport.m_strReserved9 = pDev->m_strReserved9;
	m_wndComport.m_strReserved10 = pDev->m_strReserved10;

	// Int类型预留
	m_wndComport.m_nReserved6 = pDev->m_nReserved6;
	m_wndComport.m_nReserved7 = pDev->m_nReserved7;
	m_wndComport.m_nReserved8 = pDev->m_nReserved8;
	m_wndComport.m_nReserved9 = pDev->m_nReserved9;
	m_wndComport.m_nReserved10 = pDev->m_nReserved10;

	// BOOL类型预留
	m_wndComport.m_bReserved6 = pDev->m_bReserved6;
	m_wndComport.m_bReserved7 = pDev->m_bReserved7;
	m_wndComport.m_bReserved8 = pDev->m_bReserved8;
	m_wndComport.m_bReserved9 = pDev->m_bReserved9;
	m_wndComport.m_bReserved10 = pDev->m_bReserved10;

	if( pChannel->m_nCommunicateType == 1 )
	{
		// 设备IP
		m_wndComport.m_nNetIP = htonl(inet_addr(pDev->m_strDevIP));
		// 通讯端口
		m_wndComport.m_nNetPort = pDev->m_nNetPort;
	}

	m_wndDevice.m_operation = CDlgDevice::EDIT;
	MyWizard.AddPage( &m_wndDevice );
	MyWizard.AddPage( &m_wndComport );
	MyWizard.SetWizardMode();
	MyWizard.SetActivePage( &m_wndDevice );

	int nTmpChannelIndex = -1, nTmpDeviceIndex = -1;

	if( MyWizard.DoModal() == ID_WIZFINISH )
	{
		if( !m_wndComport.m_strDevName.Compare("") )
		{
			MessageBox(g_strDevNumCannotBlank, g_strTip, MB_ICONINFORMATION);
			return -1;
		}
		else if( pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex]->m_strName != m_wndComport.m_strDevName )
		{
			if( pDevicesManager->FindDev(m_wndComport.m_strDevName, nTmpChannelIndex, nTmpDeviceIndex) )
			{
				MessageBox(g_strDevNameInUse, g_strTip, MB_ICONINFORMATION);
				return -1;
			}
		}

		int nIP = htonl(m_wndComport.m_nNetIP);

		if( m_wndDevice.m_nCommuniteType == 0 )
		{
			CString strName;
			strName.Format("COM%d", m_wndComport.m_nCommPort);
			CString sTemp;
			sTemp.Format("%s",pDevicesManager->m_channels[nChannelIndex]->m_strName );
			//TRACE("串口名称=%s\r\n", pDevicesManager->m_channels[nChannelIndex]->m_strName);
			if( pDevicesManager->m_channels[nChannelIndex]->m_strName.Compare("") &&
				pDevicesManager->m_channels[nChannelIndex]->m_strName != strName )//以前是串口，现在串口号改变
			{
				int nIndex;
				nIndex = pDevicesManager->FindCommPort(strName);
				if( nIndex == -1 )//串口号不存在
				{
					if( FinishedAddDevice(1, pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex]->m_strUID) == 1 )
					{
						//m_wndTree.DeleteItem( m_hCurrent );
						for( j = nDeviceIndex; j < MAX_DEVICE_NUM; j++ )
						{
							m_hSerialDev[nChannelIndex][j] = m_hSerialDev[nChannelIndex][j+1];
						}
						delete pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex];
						pDevicesManager->m_channels[nChannelIndex]->m_Devices.RemoveAt(nDeviceIndex);

						//InitTreeInfo();
					}
					
					return 1;
				}
				else//串口号存在
				{
					if( pDevicesManager->FindCommPort(strName, m_wndComport.m_nDevAddr, nTmpChannelIndex, nTmpDeviceIndex) )
					{
						MessageBox(g_strSerialPortInUse, g_strTip, MB_ICONINFORMATION);
						return -1;
					}

					if( pDevicesManager->FindDev(strName, nTmpChannelIndex, nTmpDeviceIndex) )
					{
						MessageBox(g_strDevNameInUse, g_strTip, MB_ICONINFORMATION);
						return -1;
					}

					//nChannelIndex = nIndex;

					if( FinishedAddDevice(1, pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex]->m_strUID) == 1 )
					{
						//m_wndTree.DeleteItem( m_hCurrent );
						for( j = nDeviceIndex; j < MAX_DEVICE_NUM; j++ )
						{
							m_hSerialDev[nChannelIndex][j] = m_hSerialDev[nChannelIndex][j+1];
						}
						delete pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex];
						pDevicesManager->m_channels[nChannelIndex]->m_Devices.RemoveAt(nDeviceIndex);
						//DeleteDevInfo((char *)(LPCTSTR)strUid);
					}

					return 1;
					//nDeviceIndex = pDevicesManager->m_channels[nChannelIndex]->m_Devices.GetSize();
				}
			}
			else//1.以前是串口，现在串口号不变，但设备号改变		2.以前是网络设备，现在改成串口
			{
				if( 0==pDevicesManager->m_channels[nChannelIndex]->m_strName.Compare("") )//2.以前是网络设备，现在改成串口
				{
					if( FinishedAddDevice(1, pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex]->m_strUID) == 1 )
					{
						//m_wndTree.DeleteItem( m_hCurrent );
						for( j = nDeviceIndex; j < MAX_DEVICE_NUM; j++ )
						{
							m_hNetworkDev[j] = m_hNetworkDev[j+1];
						}
						delete pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex];
						pDevicesManager->m_channels[nChannelIndex]->m_Devices.RemoveAt(nDeviceIndex);
					}
					
					return 1;
				}
				else
				{
					if( pDevicesManager->FindDev(strName, nTmpChannelIndex, nTmpDeviceIndex) )////1.以前是串口，现在串口号不变，但设备号改变
					{
						MessageBox(g_strDevNameInUse, g_strTip, MB_ICONINFORMATION);
						return -1;
					}
				}
			}
		}
		else//网络通信协议
		{
			CString strName;
			strName.Format("%s", pDevicesManager->m_channels[nChannelIndex]->m_strName);//是網絡的話為空
			if( 0==strName.Compare("") )//以前是网络，现在也网络
			{
				if( m_wndComport.m_nNetIP == 0 )
				{
					MessageBox(g_strIPNotBlank, g_strTip, MB_ICONWARNING);
					pDev->Destroy();
					delete pDev;
					return 0;
				}

				if( m_wndComport.m_nNetPort == 0 )
				{
					MessageBox(g_strComcanNot0, g_strTip, MB_ICONWARNING);
					pDev->Destroy();
					delete pDev;
					return 0;
				}

				CString strIP = inet_ntoa(*(struct in_addr *)&nIP);
				if( (pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex])->m_strDevIP != strIP )
				{
					if( pDevicesManager->FindDev(strIP, m_wndComport.m_nNetPort, nTmpChannelIndex, nTmpDeviceIndex) )
					{
						MessageBox(g_strIPComoccupy, g_strTip, MB_ICONINFORMATION);
						return  -1;
					}
				}
			}
			else//以前是串口，现在是网络
			{
				if( FinishedAddDevice(1, pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex]->m_strUID) == 1 )
				{
					//m_wndTree.DeleteItem( m_hCurrent );
					for( j = nDeviceIndex; j < MAX_DEVICE_NUM; j++ )
					{
						m_hSerialDev[nChannelIndex][j] = m_hSerialDev[nChannelIndex][j+1];
					}
					delete pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex];
					pDevicesManager->m_channels[nChannelIndex]->m_Devices.RemoveAt(nDeviceIndex);
				}
				
				return 1;
			}
		}

		// 通信方式
		pDevicesManager->m_channels[nChannelIndex]->m_nCommunicateType = m_wndDevice.m_nCommuniteType; 
		// 设备驱动名称
		pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex]->m_strDevDriveName = m_wndDevice.m_strDevDriveName;
		// 设备厂家名称
		pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex]->m_strDevFactoryName = m_wndDevice.m_strDevFactoryName;
		// 设备型号
		pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex]->m_strType = m_wndDevice.m_strDevTypeName;
		// 通信协议(例:Modbus rtu, modbus ascii, modbus tcp)
		pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex]->m_nProtocolType = m_wndDevice.m_nProtocolType;
		// 协议驱动动态库名称
		pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex]->m_strProtocolName = m_wndDevice.m_strProtocolName;
		// 是否为采集设备
		pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex]->m_nIsCollectDev = m_wndDevice.m_nCollectDev;
		// 是否启用设备
		pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex]->m_bUsed = (BOOL)m_wndDevice.m_nDevEnable;
		// 设备UID
		pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex]->m_strUID = m_wndComport.m_strUID;
		strNewUid = m_wndComport.m_strUID;
		// 设备名称
		pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex]->m_strName = m_wndComport.m_strDevName;
		// 设备所属区域
		pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex]->m_strReserved1 = m_wndComport.m_strDevArea;
		// 通讯超时
		pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex]->m_nTimeout = m_wndComport.m_nTimeout;
		// 设备地址
		pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex]->m_Address = (BYTE)m_wndComport.m_nDevAddr;

		//配置文件名称
		pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex]->m_strIniName = m_wndDevice.m_strIniName;

		//预留
		//pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex]->m_strReserved1 = m_wndDevice.m_strReserved1;
		pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex]->m_strReserved2 = m_wndDevice.m_strReserved2;
		pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex]->m_strReserved3 = m_wndDevice.m_strReserved3;
		pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex]->m_strReserved4 = m_wndDevice.m_strReserved4;
		pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex]->m_strReserved5 = m_wndDevice.m_strReserved5;
		pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex]->m_strReserved6 = m_wndComport.m_strReserved6;
		pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex]->m_strReserved7 = m_wndComport.m_strReserved7;
		pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex]->m_strReserved8 = m_wndComport.m_strReserved8;
		pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex]->m_strReserved9 = m_wndComport.m_strReserved9;
		pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex]->m_strReserved10 = m_wndComport.m_strReserved10;

		pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex]->m_nReserved1 = m_wndDevice.m_nReserved1;
		pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex]->m_nReserved2 = m_wndDevice.m_nReserved2;
		pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex]->m_nReserved3 = m_wndDevice.m_nReserved3;
		pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex]->m_nReserved4 = m_wndDevice.m_nReserved4;
		pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex]->m_nReserved5 = m_wndDevice.m_nReserved5;
		pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex]->m_nReserved6 = m_wndComport.m_nReserved6;
		pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex]->m_nReserved7 = m_wndComport.m_nReserved7;
		pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex]->m_nReserved8 = m_wndComport.m_nReserved8;
		pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex]->m_nReserved9 = m_wndComport.m_nReserved9;
		pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex]->m_nReserved10 = m_wndComport.m_nReserved10;

		pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex]->m_bReserved1 = m_wndDevice.m_bReserved1;
		pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex]->m_bReserved2 = m_wndDevice.m_bReserved2;
		pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex]->m_bReserved3 = m_wndDevice.m_bReserved3;
		pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex]->m_bReserved4 = m_wndDevice.m_bReserved4;
		pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex]->m_bReserved5 = m_wndDevice.m_bReserved5;
		pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex]->m_bReserved6 = m_wndComport.m_bReserved6;
		pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex]->m_bReserved7 = m_wndComport.m_bReserved7;
		pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex]->m_bReserved8 = m_wndComport.m_bReserved8;
		pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex]->m_bReserved9 = m_wndComport.m_bReserved9;
		pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex]->m_bReserved10 = m_wndComport.m_bReserved10;

		if( m_wndDevice.m_nCommuniteType == 0 )
		{
			pDevicesManager->m_channels[nChannelIndex]->m_strName.Format("COM%d", m_wndComport.m_nCommPort);

			// 串行端口
			((CSerial *)(pDevicesManager->m_channels[nChannelIndex]))->m_strPort.Format("COM%d", m_wndComport.m_nCommPort);

			// 数据位
			((CSerial *)(pDevicesManager->m_channels[nChannelIndex]))->m_nByteSize = m_wndComport.m_nDataBit;

			// 波特率
			((CSerial *)(pDevicesManager->m_channels[nChannelIndex]))->m_nBaudRate = m_wndComport.m_nRate;
			// 停止位
			((CSerial *)(pDevicesManager->m_channels[nChannelIndex]))->m_nStopBits = m_wndComport.m_nStopBit;
			// 校验位
			((CSerial *)(pDevicesManager->m_channels[nChannelIndex]))->m_nParity = m_wndComport.m_nCheckCode;
		}
		else if( m_wndDevice.m_nCommuniteType == 1 )
		{
			// 设备IP
			pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex]->m_strDevIP = inet_ntoa(*(struct in_addr *)&nIP);
			// 通讯端口
			pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex]->m_nNetPort = m_wndComport.m_nNetPort;
		}

		CHAR chDevTypeID[MAX_ID + 1] = {0};
		// 获取设备类型ID
		int nRet = CDBInterface::GetInstancePtr()->GetDevTypeID((char *)(LPCTSTR)m_wndDevice.m_strDevTypeName, chDevTypeID);
		if( -1 == nRet )
		{
			return nRet;
		}
		else
		{
			CDBInterface::GetInstancePtr()->EditDevInfo( 
				(char *)(LPCTSTR)strOldUid, 
				(char *)(LPCTSTR)strNewUid,
				m_wndComport.m_nCommPort,
				m_wndComport.m_nDevAddr,
				(char *)(LPCTSTR)m_wndComport.m_strDevName,
				atoi(chDevTypeID),
				m_wndComport.m_nRate,
				m_wndComport.m_nDataBit,
				m_wndComport.m_nStopBit,
				m_wndComport.m_nCheckCode,
				0,
				inet_ntoa(*(struct in_addr *)&nIP),
				m_wndComport.m_nNetPort,
				m_wndComport.m_nCommunicateMode,
				m_wndDevice.m_nCollectDev,
				m_wndDevice.m_nProtocolType,
				m_wndComport.m_nTimeout,
				m_wndDevice.m_nDevEnable,
				(char *)(LPCTSTR)m_wndDevice.m_strProtocolName,
				(char *)(LPCTSTR)m_wndDevice.m_strIniName,
		        	(char *)(LPCTSTR)m_wndComport.m_strDevArea,
			        //(char *)(LPCTSTR)m_wndDevice.m_strReserved1,
				(char *)(LPCTSTR)m_wndDevice.m_strReserved2,
				(char *)(LPCTSTR)m_wndDevice.m_strReserved3,
				(char *)(LPCTSTR)m_wndDevice.m_strReserved4,
				(char *)(LPCTSTR)m_wndDevice.m_strReserved5,
				(char *)(LPCTSTR)m_wndComport.m_strReserved6,
				(char *)(LPCTSTR)m_wndComport.m_strReserved7,
				(char *)(LPCTSTR)m_wndComport.m_strReserved8,
				(char *)(LPCTSTR)m_wndComport.m_strReserved9,
				(char *)(LPCTSTR)m_wndComport.m_strReserved10,
				m_wndDevice.m_nReserved1,
				m_wndDevice.m_nReserved2,
				m_wndDevice.m_nReserved3,
				m_wndDevice.m_nReserved4,
				m_wndDevice.m_nReserved5,
				m_wndComport.m_nReserved6,
				m_wndComport.m_nReserved7,
				m_wndComport.m_nReserved8,
				m_wndComport.m_nReserved9,
				m_wndComport.m_nReserved10,
				(int)m_wndDevice.m_bReserved1,
				(int)m_wndDevice.m_bReserved2,
				(int)m_wndDevice.m_bReserved3,
				(int)m_wndDevice.m_bReserved4,
				(int)m_wndDevice.m_bReserved5,
				(int)m_wndComport.m_bReserved6,
				(int)m_wndComport.m_bReserved7,
				(int)m_wndComport.m_bReserved8,
				(int)m_wndComport.m_bReserved9,
				(int)m_wndComport.m_bReserved10
			);
		}

		CString sContent;
		sContent.Format("编辑设备< %s >",m_wndComport.m_strDevName.TrimRight() );
		CDBInterface::GetInstancePtr()->InsertLogRecord( LOG_DEV_EDIT,0,"",(char *)(LPCTSTR)sContent );

		pDevicesManager->SendNoticeToServer( CMD_NOTICE_READ_DB_DEV,CMD_OPERATE_EDIT,"",m_wndComport.m_strUID,0,"64320" );
	}

	m_wndTree.SetItemText(hSelectedItem, pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDeviceIndex]->m_strName);

	Invalidate(FALSE);

	return 0;
}

bool CMainFrame::ShowView(void)
{
	HTREEITEM hSelectedItem = m_wndTree.GetSelectedItem();
	HTREEITEM hItem;
	int i;

	m_hCurrent = hSelectedItem;

	//如果是视图
	char szPicDir[MAX_PATH] = {0};
	CString strTempDir = "", strPicFile;

	strcpy(szPicDir, g_strDirectory);
	strcat(szPicDir, "\\");
	strcat(szPicDir, _PICTUREDIR);
	hItem = m_wndTree.GetParentItem( hSelectedItem );
	while( hItem != NULL )
	{
		if( hItem == m_hMonitor )
		{
			CString strSelect = m_wndTree.GetItemText( hSelectedItem );
			if( !strTempDir.Compare("") )
			{
				strPicFile += strSelect;
			}
			else
			{
				strPicFile += strTempDir;
				//strPicFile += "\\";//chn modify 12.28
				strPicFile += strSelect;
			}

			AddIDEView( strSelect, CString(szPicDir) + strPicFile + ".view" );
			return true;
		}
		else
		{
			CString str = m_wndTree.GetItemText( hItem );
			strTempDir = str + "\\" + strTempDir;
			hItem = m_wndTree.GetParentItem( hItem );
		}
	}				

	// 如果是脚本
	for (i = 0; i < MAX_SCRIPT_NUM; i++)
	{
		if (m_hScriptGroup[i] == hSelectedItem) 
		{
			CString scriptFile;
			scriptFile = _SCRIPTDIR;
			scriptFile = g_strDirectory + CString("\\") + scriptFile + m_wndTree.GetItemText(hSelectedItem) + ".srp";
			CString strScript;
			strScript.Format("%s\\ScriptEdit.exe", g_strDirectory); 
			ShellExecute(NULL,"open", (char *)(LPCTSTR)strScript, scriptFile, NULL, SW_SHOWNORMAL);
			return true;
		}
	}

	// 系统参数
	if (hSelectedItem == m_hSystem)
	{	
		SetRunPara();
	}	

	// 变量编辑
	else if (m_hAnalog == hSelectedItem)
	{	
		if( g_nIsDemo == 0 )
		{
			CAnalogDlg dlg;
			dlg.DoModal();
		}
	}
	else	// 设备属性设置xs
	{
		if( g_nIsDemo == 0 )
		{
			int nRet = ShowDevProperty(hSelectedItem);
			if( nRet == 1 )
			{
				if( hSelectedItem )
				{
					// 这里一删除就报异常，只能先注释，待解决 for Jesse 100106
					//m_wndTree.DeleteItem( m_hCurrent );//hSelectedItem
				}
			}
			pDevicesManager->Store(g_strDirectory);
		}
	}
	return true;
}

BOOL CMainFrame::OnNotify(WPARAM wParam, LPARAM lParam, LRESULT* pResult)
{
	// TODO: 在此添加专用代码和/或调用基类

	LPNMHDR pNmhdr = (LPNMHDR)lParam;
	int i, j;
	//if( m_bShutdown ) return FALSE; //chn dele

	int idCtrl = LOWORD(wParam);
	if( idCtrl == IDD_TREE_LEFT ) // Is   my   tree's   id?
	{
		CPoint point;		
		::GetCursorPos(&point); 
		m_wndTree.ScreenToClient(&point);

		switch( pNmhdr->code )
		{
		case NM_CLICK:
			{
				// Get Click item's
				UINT uFlags;
				HTREEITEM hItem = m_wndTree.HitTest(point, &uFlags);
				if((hItem   !=   NULL)   &&   (TVHT_ONITEM   &   uFlags))   
				{   
					m_wndTree.SelectItem(hItem); 
				}  
				return   true;//Already   process   the   notify   
			}
		case NM_RCLICK:
			{
				// Get RightClick item's
				
				if( g_bStartRun ) return true;
				UINT uFlags;
				HTREEITEM hItem = m_wndTree.HitTest(point, &uFlags);

				m_wndTree.SelectItem(hItem);
				if((hItem   !=   NULL)   &&   (TVHT_ONITEM   &   uFlags))   
				{
					GetCursorPos(&m_mousePoint);
					HTREEITEM hSelectedItem = m_wndTree.GetSelectedItem();

					//新建设备
					if( hSelectedItem == m_hIOGroup )
					{
						CMenu menu; 
						menu.LoadMenu(IDR_MENU_ADDDEVICE);
						menu.GetSubMenu(0)->TrackPopupMenu(TPM_LEFTALIGN,m_mousePoint.x,m_mousePoint.y,this); 
					}

					//删除设备
					int nChannelIndex = -1, nDeviceIndex = -1;
					int nChannelSize = pDevicesManager->m_channels.GetSize();
					// 串口设备属性设置
					for (i = 0; i < nChannelSize; i++)
					{
#if 0	// 删除COM时有BUG，待解决 for Jesse 091104
						if( m_hSerialGroup[i] == hSelectedItem )
						{
							CMenu menu;
							menu.LoadMenu(IDR_MENU_DELDEVICE);
							menu.GetSubMenu(0)->TrackPopupMenu(TPM_LEFTALIGN,m_mousePoint.x,m_mousePoint.y,this); 
							return true;
						}
#endif
						int nDeviceSize = pDevicesManager->m_channels[i]->m_Devices.GetSize();
						for( j = 0; j < nDeviceSize; j++)
						{
							if (m_hSerialDev[i][j]==hSelectedItem)
							{
								CMenu menu;
								menu.LoadMenu(IDR_MENU_DELDEVICE);
								menu.GetSubMenu(0)->TrackPopupMenu(TPM_LEFTALIGN,m_mousePoint.x,m_mousePoint.y,this); 
								return true;
							}

							if( m_hNetworkDev[j] == hSelectedItem && 
								pDevicesManager->m_channels[i]->m_nCommunicateType == 1 )
							{
								CMenu menu;
								menu.LoadMenu(IDR_MENU_DELDEVICE);
								menu.GetSubMenu(0)->TrackPopupMenu(TPM_LEFTALIGN,m_mousePoint.x,m_mousePoint.y,this); 
								return true;
							}
						}
					}

					//新建或删除监控画面
					if (hSelectedItem == m_hMonitor) 
					{
						CMenu menu;
						menu.LoadMenu(IDR_MENU_ADDVIEW);
						menu.GetSubMenu(1)->TrackPopupMenu(TPM_LEFTALIGN,m_mousePoint.x,m_mousePoint.y,this); 
					}
					else
					{
						if( FindTreeItem( hSelectedItem, m_hMonitor ) )
						{
							CMenu menu;
							menu.LoadMenu(IDR_MENU_ADDVIEW);
							menu.GetSubMenu(0)->TrackPopupMenu(TPM_LEFTALIGN,m_mousePoint.x,m_mousePoint.y,this); 
						}
					}

					//设定脚本
					for (i = 0; i < MAX_SCRIPT_NUM; i++)
					{
						if (m_hScriptGroup[i] == hSelectedItem) 
						{
							CMenu menu;
							menu.LoadMenu(IDR_MENU_SETSCRIPT);
							menu.GetSubMenu(0)->TrackPopupMenu(TPM_LEFTALIGN,m_mousePoint.x,m_mousePoint.y,this); 
						}
					}

					//新建脚本
					if (hSelectedItem == m_hScript) 
					{
						CMenu menu; 
						menu.LoadMenu(IDR_MENU_ADDSCRIPT);
						menu.GetSubMenu(0)->TrackPopupMenu(TPM_LEFTALIGN,m_mousePoint.x,m_mousePoint.y,this); 
					}
				}

				return   true;//Already   process   the   notify   
			}

		case NM_DBLCLK:
			{
				ShowView();
				return true;
			}
		}   
		return   false; // no   match   
	}   


	return CMDIAutoHideFrame::OnNotify(wParam, lParam, pResult);
}

int CMainFrame::GetFreeSerialTreeItem()
{
	CString str;
#if 1
	for( int i = MAX_SERIAL_NUM-1; i >=0 ; i-- )
	{
		//if( m_hSerialGroup[i] == NULL ) break;
		str = m_wndTree.GetItemText(m_hSerialGroup[i]);
		if( str.Compare("") )
		{
			return i+1;
		}
	}
#else
	for( int i = 0; i < MAX_SERIAL_NUM; i++ )
	{
		//if( m_hSerialGroup[i] == NULL ) break;
		str = m_wndTree.GetItemText(m_hSerialGroup[i]);
		if( !str.Compare("") )
		{
			return i;
		}
	}
#endif
	return 0;
}

int CMainFrame::GetNetworkChannelIndex()
{
	int i;
	int nChannelNo = -1;
	int nChannelSize = pDevicesManager->m_channels.GetSize();

	for (i = 0; i < nChannelSize; i++)
	{
		// 网络设备，在m_channels中永远只有一个
		if( pDevicesManager->m_channels[i]->m_nCommunicateType == 1 )
		{
			return i;
		}
	}

	return -1;
}

int CMainFrame::GetFreeNetworkTreeItem()
{
	CString str;
	for( int i = 0; i < MAX_NETWORK_NUM; i++ )
	{
		//if( m_hNetworkDev[i] == NULL ) break;
		str = m_wndTree.GetItemText(m_hNetworkDev[i]);
		if( !str.Compare("") )
		{
			return i;
		}
	}
	return -1;
}

int CMainFrame::GetIndexSerialTreeItem(CString strSrc)
{
	CString str;
	for( int i = 0; i < MAX_SERIAL_NUM; i++ )
	{
		//if( m_hSerialGroup[i] == NULL ) break;
		str = m_wndTree.GetItemText(m_hSerialGroup[i]);
		if( !str.Compare(strSrc) )
		{
			return i;
		}
	}	
	return -1;
}

int CMainFrame::GetIndexNetworkTreeItem(CString strSrc)
{
	CString str;
	for( int i = 0; i < MAX_NETWORK_NUM; i++ )
	{
		//if( m_hNetworkDev[i] == NULL ) break;
		str = m_wndTree.GetItemText(m_hNetworkDev[i]);
		if( !str.Compare(strSrc) )
		{
			return i;
		}
	}
	return -1;
}

int CMainFrame::FinishedAddDevice(int nIsDelete, CString strUid)
{
	// 加入该设备的参数
	CChannel* pChannel = NULL;
	
	CDevice* pDev = new CDevice();
	pDev->Create();

	int nIP;
	nIP = htonl(m_wndComport.m_nNetIP);

	// 通信协议（例：Modbus rtu, Modbus Ascii, Modbus tcp）
	pDev->m_nProtocolType = m_wndDevice.m_nProtocolType;
	// 协议动态库名称
	pDev->m_strProtocolName = m_wndDevice.m_strProtocolName;
	// 是否为采集模块
	pDev->m_nIsCollectDev = m_wndDevice.m_nCollectDev;
	// 是否启用设备
	pDev->m_bUsed = m_wndDevice.m_nDevEnable;
	// 设备UID
	if( nIsDelete == 1 && m_wndDevice.m_sUidOld!=m_wndComport.m_strUID )
		pDev->m_strUID = m_wndComport.m_strUID2==""?m_wndComport.m_strUID:m_wndComport.m_strUID2;
	else
		pDev->m_strUID = m_wndComport.m_strUID;
	// 设备名称 
	pDev->m_strName = m_wndComport.m_strDevName.Trim();
	// 设备类型
	pDev->m_strType = m_wndDevice.m_strDevTypeName.Trim();
	// 设备地址
	pDev->m_Address = (BYTE)m_wndComport.m_nDevAddr;
	// 驱动名称（例：UPS、空调）
	pDev->m_strDevDriveName = m_wndDevice.m_strDevDriveName;
	// 设备厂家名称
	pDev->m_strDevFactoryName = m_wndDevice.m_strDevFactoryName;
	// 通讯超时
	pDev->m_nTimeout = m_wndComport.m_nTimeout;
	// 网络设备IP
	pDev->m_strDevIP = inet_ntoa(*(struct in_addr *)&nIP);
	// 网络设备通信端口
	pDev->m_nNetPort = m_wndComport.m_nNetPort;
	// 配置文件名称
	pDev->m_strIniName = m_wndDevice.m_strIniName;

	// 预留1 设备所属区域
	pDev->m_strReserved1 = m_wndComport.m_strDevArea.Trim();
	// 预留2
	pDev->m_strReserved2 = m_wndDevice.m_strReserved2;
	// 预留3
	pDev->m_strReserved3 = m_wndDevice.m_strReserved3;
	// 预留4
	pDev->m_strReserved4 = m_wndDevice.m_strReserved4;
	// 预留5
	pDev->m_strReserved5 = m_wndDevice.m_strReserved5;
	// 预留6
	pDev->m_strReserved6 = m_wndComport.m_strReserved6;
	// 预留7
	pDev->m_strReserved7 = m_wndComport.m_strReserved7;
	// 预留8
	pDev->m_strReserved8 = m_wndComport.m_strReserved8;
	// 预留9
	pDev->m_strReserved9 = m_wndComport.m_strReserved9;
	// 预留10
	pDev->m_strReserved10 = m_wndComport.m_strReserved10;

	// 预留1
	pDev->m_nReserved1 = m_wndDevice.m_nReserved1;
	// 预留2
	pDev->m_nReserved2 = m_wndDevice.m_nReserved2;
	// 预留3
	pDev->m_nReserved3 = m_wndDevice.m_nReserved3;
	// 预留4
	pDev->m_nReserved4 = m_wndDevice.m_nReserved4;
	// 预留5
	pDev->m_nReserved5 = m_wndDevice.m_nReserved5;
	// 预留6
	pDev->m_nReserved6 = m_wndComport.m_nReserved6;
	// 预留7
	pDev->m_nReserved7 = m_wndComport.m_nReserved7;
	// 预留8
	pDev->m_nReserved8 = m_wndComport.m_nReserved8;
	// 预留9
	pDev->m_nReserved9 = m_wndComport.m_nReserved9;
	// 预留10
	pDev->m_nReserved10 = m_wndComport.m_nReserved10;

	// 预留1
	pDev->m_bReserved1 = m_wndDevice.m_bReserved1;
	// 预留2
	pDev->m_bReserved2 = m_wndDevice.m_bReserved2;
	// 预留3
	pDev->m_bReserved3 = m_wndDevice.m_bReserved3;
	// 预留4
	pDev->m_bReserved4 = m_wndDevice.m_bReserved4;
	// 预留5
	pDev->m_bReserved5 = m_wndDevice.m_bReserved5;
	// 预留6
	pDev->m_bReserved6 = m_wndComport.m_bReserved6;
	// 预留7
	pDev->m_bReserved7 = m_wndComport.m_bReserved7;
	// 预留8
	pDev->m_bReserved8 = m_wndComport.m_bReserved8;
	// 预留9
	pDev->m_bReserved9 = m_wndComport.m_bReserved9;
	// 预留10
	pDev->m_bReserved10 = m_wndComport.m_bReserved10;

	CString strCommPort;
	int nIndex, nFreeIndex;
	int nChannelSize;
	int nDeviceSize;

	CHAR szMaxID[MAX_ID + 1] = {0};
	CHAR szDevTypeID[MAX_ID + 1] = {0};

	// 获取t_dev_property设备属性表字段ID的最大值
	int nRet = CDBInterface::GetInstancePtr()->GetMaxID("t_dev_property", "id", szMaxID);
	if( -1 == nRet )
	{
		pDev->Destroy();
		delete pDev;
		return -1;
	}

	int nID;
	if( atoi(szMaxID) > 0 )
	{
		nID = atoi(szMaxID) + 1;
	}
	else if( atoi(szMaxID) == 0 )
	{
		nID = 1;
	}

	// 获取设备类型ID
	CDBInterface::GetInstancePtr()->GetDevTypeID((char *)(LPCTSTR)m_wndDevice.m_strDevTypeName, szDevTypeID);

	if( !m_wndComport.m_strDevName.Compare("") )
	{
		MessageBox(g_strDevNumCannotBlank,g_strTip,MB_ICONWARNING);
		pDev->Destroy();
		delete pDev;
		return 0;
	}

	//检查合法值
	if( m_wndDevice.m_operation == CDlgDevice::NEW )
	{
		CHAR szDevName[MAX_DESC + 1] = {0};
		CHAR szDevUID[MAX_DESC + 1] = {0};

		int nRet = CDBInterface::GetInstancePtr()->GetDevName((char *)(LPCTSTR)m_wndComport.m_strUID, szDevName);
		if( nRet > 0 )
		{
			MessageBox(g_strDevUidExist,g_strTip,MB_ICONWARNING);
			pDev->Destroy();
			delete pDev;
			return 0;
		}
		
		nRet = CDBInterface::GetInstancePtr()->GetDevUID( (char *)(LPCTSTR)m_wndComport.m_strDevName, szDevUID );
		if( nRet > 0 )
		{
			MessageBox(g_strDevNameExist,g_strTip,MB_ICONWARNING);
			pDev->Destroy();
			delete pDev;
			return 0;
		}
	}

	// 串口设备
	if( m_wndComport.m_nCommunicateMode == 0 )
	{
		strCommPort.Format("COM%d", m_wndComport.m_nCommPort); 

		nIndex = GetIndexSerialTreeItem(strCommPort);//得到COM的序列号
		if( nIndex == -1 )
		{
			nFreeIndex = GetFreeSerialTreeItem();

			CSerial* pComport = new CSerial();
			// 串行端口
			pComport->m_strPort = strCommPort.Trim();
			// 串行端口地址
			pComport->m_nAddr = m_wndComport.m_nDevAddr;
			// 波特率
			pComport->m_nBaudRate = m_wndComport.m_nRate;			// 1200;2400;4800;9600;14400;19200;38400;57600;115200;128000;256000
			// 数据位
			pComport->m_nByteSize = m_wndComport.m_nDataBit;		// 0-1=7,8
			// 检验位
			pComport->m_nParity = m_wndComport.m_nCheckCode;		// 0-4=no,odd,even,mark
			// 停止位
			pComport->m_nStopBits = m_wndComport.m_nStopBit;		// 0-2=1,1.5,2
			
			pDevicesManager->m_channels.Add(pComport);
			nChannelSize = pDevicesManager->m_channels.GetSize();
			pChannel = pDevicesManager->m_channels[nChannelSize - 1];

			pChannel->m_strName = strCommPort.Trim();
			pChannel->m_nCommunicateType = m_wndComport.m_nCommunicateMode;
			nDeviceSize = pChannel->m_Devices.GetSize();

			//if( m_hCurrent )
			//	m_wndTree.DeleteItem( m_hCurrent );

			m_hSerialGroup[nFreeIndex] = m_wndTree.InsertItem(strCommPort, 4, 4, m_hSerial);			
			m_hSerialDev[nFreeIndex][nDeviceSize] = m_wndTree.InsertItem(m_wndComport.m_strDevName, 4, 4, m_hSerialGroup[nFreeIndex]);
		}
		else
		{
			nChannelSize = pDevicesManager->m_channels.GetSize();
			for( int i = 0; i < nChannelSize; i++ )
			{
				CSerial *pCommPort = (CSerial *)(pDevicesManager->m_channels[i]);
				if( ( !pCommPort->m_strPort.Compare(strCommPort) ) &&
					pCommPort->m_Devices.GetSize() > 0 )
				{
					nDeviceSize = pCommPort->m_Devices.GetSize();
					for( int j = 0; j < nDeviceSize; j++ )
					{
						if( (int)pCommPort->m_Devices[j]->m_Address == m_wndComport.m_nDevAddr )
						{
							MessageBox(g_strSerialPortInUse,g_strTip,MB_ICONWARNING);
							pDev->Destroy();
							delete pDev;
							return 0;
						}
					}
				}
			}

			for( int i = 0; i < nChannelSize; i++ )
			{
				CSerial *pCommPort = (CSerial *)(pDevicesManager->m_channels[i]);
				if( !pCommPort->m_strPort.Compare(strCommPort) )
				{
					pChannel = pDevicesManager->m_channels[i];
					nDeviceSize = pChannel->m_Devices.GetSize();
					break;
				}
			}

			//pChannel = pDevicesManager->m_channels[nChannelSize - 1];
			//nDeviceSize = pChannel->m_Devices.GetSize();
			m_hSerialDev[nIndex][nDeviceSize] = m_wndTree.InsertItem(m_wndComport.m_strDevName, 4, 4, m_hSerialGroup[nIndex]);
		}

		if( pChannel != NULL )
		{
			pDev->m_pChannel = pChannel;
			pChannel->m_Devices.Add(pDev);
		}
	}
	// 网络设备
	else
	{
		int nChannelIndex;
		// 得到m_channels数组中网络设备的索引，有且只有一个
		nIndex = GetIndexNetworkTreeItem( m_wndComport.m_strDevName );
		if( nIndex == -1 )
		{
			if( m_wndComport.m_nNetIP == 0 )
			{
				MessageBox(g_strIPNotBlank, g_strTip, MB_ICONWARNING);
				pDev->Destroy();
				delete pDev;
				return 0;
			}

			if( m_wndComport.m_nNetPort == 0 )
			{
				MessageBox(g_strComcanNot0, g_strTip, MB_ICONWARNING);
				pDev->Destroy();
				delete pDev;
				return 0;
			}

			nChannelIndex = GetNetworkChannelIndex();
			if( nChannelIndex == -1 )
			{

				CNetwork *pNetwork = new CNetwork();
				pNetwork->m_strName = g_strNetDev;

				pDevicesManager->m_channels.Add(pNetwork);

				nChannelIndex = pDevicesManager->m_channels.GetSize() - 1;
			}
			else
			{
				pChannel = pDevicesManager->m_channels[nChannelIndex];
				for( int j = 0; j < pChannel->m_Devices.GetSize(); j ++ )
				{
					if( !m_wndDevice.m_bIsStu2000 )
					{
						if( !(pChannel->m_Devices[j]->m_strDevIP.Compare(inet_ntoa(*(struct in_addr *)&nIP)))  &&
							(pChannel->m_Devices[j]->m_nNetPort == m_wndComport.m_nNetPort ) )
						{
							MessageBox(g_strIPConflict, g_strTip, MB_ICONWARNING);
							pDev->Destroy();
							delete pDev;
							return 0;
						}
					}
					else
					{
						if( !(pChannel->m_Devices[j]->m_strDevIP.Compare(inet_ntoa(*(struct in_addr *)&nIP)))  &&
						(pChannel->m_Devices[j]->m_nNetPort == m_wndComport.m_nNetPort ) && 
						((int)pChannel->m_Devices[j]->m_Address == m_wndComport.m_nDevAddr ) )
						{
							MessageBox(g_strIPConflict, g_strTip, MB_ICONWARNING);
							pDev->Destroy();
							delete pDev;
							return 0;
						}
					}
				}
			}
			
			pChannel = pDevicesManager->m_channels[nChannelIndex];
			pChannel->m_nCommunicateType = m_wndComport.m_nCommunicateMode;

			nDeviceSize = pChannel->m_Devices.GetSize();

			nFreeIndex = GetFreeNetworkTreeItem();

			m_hNetworkDev[nFreeIndex] = m_wndTree.InsertItem( m_wndComport.m_strDevName, 2, 2, m_hEtherNet);

			pDev->m_pChannel = pChannel;
			pChannel->m_Devices.Add(pDev);
		}
		else
		{
			MessageBox(g_strDevNameExist,g_strTip,MB_ICONWARNING);
			pDev->Destroy();
			delete pDev;
			return 0;
		}
	}

	if( nIsDelete == 1 )
	{
		//删除数据库数据
		CDBInterface::GetInstancePtr()->DeleteDevInfo((char *)(LPCTSTR)strUid);
	}

	// 插入设备信息
	CDBInterface::GetInstancePtr()->InsertDevInfo(
		nID, 
		(char *)(LPCTSTR)pDev->m_strUID, 
		m_wndComport.m_nCommPort, 
		m_wndComport.m_nDevAddr, 
		(char *)(LPCTSTR)m_wndComport.m_strDevName,
		atoi(szDevTypeID), 
		m_wndComport.m_nRate, 
		m_wndComport.m_nDataBit, 
		m_wndComport.m_nStopBit,
		m_wndComport.m_nCheckCode, 
		0, 
		inet_ntoa( *(struct in_addr *)&nIP ), 
		m_wndComport.m_nNetPort,
		m_wndComport.m_nCommunicateMode, 
		m_wndDevice.m_nCollectDev, 
		m_wndDevice.m_nProtocolType, 
		m_wndComport.m_nTimeout,
		m_wndDevice.m_nDevEnable, 
		(char *)(LPCTSTR)m_wndDevice.m_strProtocolName,
		(char *)(LPCTSTR)m_wndDevice.m_strIniName,
		(char *)(LPCTSTR)pDev->m_strReserved1,
		//(char *)(LPCTSTR)m_wndDevice.m_strReserved1,
		(char *)(LPCTSTR)m_wndDevice.m_strReserved2,
		(char *)(LPCTSTR)m_wndDevice.m_strReserved3,
		(char *)(LPCTSTR)m_wndDevice.m_strReserved4,
		(char *)(LPCTSTR)m_wndDevice.m_strReserved5,
		(char *)(LPCTSTR)m_wndComport.m_strReserved6,
		(char *)(LPCTSTR)m_wndComport.m_strReserved7,
		(char *)(LPCTSTR)m_wndComport.m_strReserved8,
		(char *)(LPCTSTR)m_wndComport.m_strReserved9,
		(char *)(LPCTSTR)m_wndComport.m_strReserved10,
		m_wndDevice.m_nReserved1,
		m_wndDevice.m_nReserved2,
		m_wndDevice.m_nReserved3,
		m_wndDevice.m_nReserved4,
		m_wndDevice.m_nReserved5,
		m_wndComport.m_nReserved6,
		m_wndComport.m_nReserved7,
		m_wndComport.m_nReserved8,
		m_wndComport.m_nReserved9,
		m_wndComport.m_nReserved10,
		(int)m_wndDevice.m_bReserved1,
		(int)m_wndDevice.m_bReserved2,
		(int)m_wndDevice.m_bReserved3,
		(int)m_wndDevice.m_bReserved4,
		(int)m_wndDevice.m_bReserved5,
		(int)m_wndComport.m_bReserved6,
		(int)m_wndComport.m_bReserved7,
		(int)m_wndComport.m_bReserved8,
		(int)m_wndComport.m_bReserved9,
		(int)m_wndComport.m_bReserved10
	);

	return 1;
}

void CMainFrame::AddDevice()
{
	CWizard MyWizard(g_strMywizard,this,1);
	MyWizard.AddPage( &m_wndDevice );
	MyWizard.AddPage( &m_wndComport );
	MyWizard.SetWizardMode();
	MyWizard.SetActivePage( &m_wndDevice );

	m_wndDevice.m_operation = CDlgDevice::NEW;
	void* pType = NULL;
	if( MyWizard.DoModal() == ID_WIZFINISH )
	{
		int nRet = FinishedAddDevice(0, "");
		if( -1!=nRet && 0!=nRet )
		{
			CString sContent;
			sContent.Format("%s %s< %s >",g_strAdd,g_strDevice1,m_wndComport.m_strDevName );
			CDBInterface::GetInstancePtr()->InsertLogRecord( LOG_DEV_ADD,0,"",(char *)(LPCTSTR)sContent );
			
			pDevicesManager->SendNoticeToServer( CMD_NOTICE_READ_DB_DEV,CMD_OPERATE_ADD,"",m_wndComport.m_strUID,0,"64320" );

			MyWizard.RemovePage( &m_wndDevice );
			MyWizard.RemovePage( &m_wndComport );
		}

		if( 0==nRet )
		{
			MyWizard.RemovePage( &m_wndDevice );
			MyWizard.RemovePage( &m_wndComport );

			AddDevice();
		}
	}
}

void CMainFrame::OnAdddevoce()
{
	// TODO: 在此添加命令处理程序代码

	AddDevice();
}

void CMainFrame::OnUpdateAdddevoce(CCmdUI *pCmdUI)
{
	// TODO: 在此添加命令更新用户界面处理程序代码
}

void CMainFrame::OnDeleteport()
{
	// TODO: 在此添加命令处理程序代码
}

void CMainFrame::OnUpdateDeleteport(CCmdUI *pCmdUI)
{
	// TODO: 在此添加命令更新用户界面处理程序代码
}

void CMainFrame::OnAddPort()
{
	// TODO: 在此添加命令处理程序代码
}

void CMainFrame::OnUpdateAddPort(CCmdUI *pCmdUI)
{
	// TODO: 在此添加命令更新用户界面处理程序代码
}

void CMainFrame::OnAddScript()
{
	// TODO: 在此添加命令处理程序代码
	CScriptSetDlg dlg;
	if (dlg.DoModal() == IDOK)
	{
		m_hScriptGroup[m_nScripts++] = m_wndTree.InsertItem(dlg.m_strName,1,1,m_hScript);
		
		CString strFileName = dlg.m_strName;
		strFileName = CString(g_strDirectory) + "\\" + _SCRIPTDIR + strFileName;
		strFileName = strFileName + ".srp";
		
		CFile fileSpt;
		if (fileSpt.Open(strFileName, CFile::modeCreate))   // | CFile::modeWrite
		{
			fileSpt.Close();
		}

		strFileName.Replace(".srp", ".con");

		if ( dlg.m_bUsed )
		{
			WritePrivateProfileString("RUNPARA", "USE", "1", strFileName);
		}
		else
		{
			WritePrivateProfileString("RUNPARA", "USE", "0", strFileName);
		}
		WritePrivateProfileString("RUNPARA", "CONDITON", dlg.m_strCondition, strFileName);
		char tmp[10];
		sprintf(tmp, "%d", dlg.m_nType);
		WritePrivateProfileString("RUNPARA", "TYPE", tmp, strFileName);
		sprintf(tmp, "%d", dlg.m_nCircle);
		WritePrivateProfileString("RUNPARA", "CIRCLE", tmp, strFileName);
	}
}

void CMainFrame::OnUpdateAddScript(CCmdUI *pCmdUI)
{
	// TODO: 在此添加命令更新用户界面处理程序代码
}

void CMainFrame::HideRunBar()
{
	m_wndRunToolBar.ShowWindow(SW_HIDE);
}

void CMainFrame::OnAddview()
{
	// TODO: 在此添加命令处理程序代码
	CViewNameDlg dlg;
	if (dlg.DoModal() == IDOK) 
    {
		if( dlg.m_strViewName.Compare("")==0 )
		{
			MessageBox(g_strMonitorNameIsBlank, g_strTip, MB_ICONINFORMATION);
			return;
		}
		char szPicDir[MAX_PATH] = {0};
		CString strTempDir = "";

		strcpy(szPicDir, g_strDirectory);
		strcat(szPicDir, "\\");
		strcat(szPicDir, _PICTUREDIR);

		int cx=GetSystemMetrics(SM_CXSCREEN)-10;
		int cy=GetSystemMetrics(SM_CYSCREEN)-100;
		CGraph* pic=new CGraph(CSize(cx, cy));
		pic->m_strPicFile = CString(szPicDir);

		HTREEITEM hSelectedItem = m_wndTree.GetSelectedItem();
		HTREEITEM hItem;
		m_wndTree.InsertItem(dlg.m_strViewName, 1, 1, hSelectedItem);

		if( hSelectedItem == m_hMonitor )	
		{
			pic->m_strPicFile = pic->m_strPicFile + dlg.m_strViewName + ".view";
			pic->Store();
		}
		else 
		{
			hItem = m_wndTree.GetParentItem( hSelectedItem );
			while( hItem != NULL )
			{
				if( hItem == m_hMonitor )
				{
					CString strSelect = m_wndTree.GetItemText( hSelectedItem );
					if( !strTempDir.Compare("") )
					{
						pic->m_strPicFile += strSelect;
					}
					else
					{
						pic->m_strPicFile += strTempDir;
						pic->m_strPicFile += "\\";
						pic->m_strPicFile += strSelect;
					}

					if( !PathFileExists(pic->m_strPicFile) )
					{
						SECURITY_ATTRIBUTES sa;
						sa.nLength = sizeof(SECURITY_ATTRIBUTES);   
						sa.lpSecurityDescriptor = NULL;   
						sa.bInheritHandle = 0;
						int nRet = CreateDirectory(pic->m_strPicFile, &sa); 
						if( !nRet )
						{
							MessageBox(g_strCannotCreateDirecitory,g_strTip,MB_ICONWARNING);
							delete pic;	
							return;
						}
					}

					pic->m_strPicFile = pic->m_strPicFile + "\\" + dlg.m_strViewName + ".view";
					pic->Store();

					delete pic;
					return;
				}
				else
				{
					CString str = m_wndTree.GetItemText( hItem );
					strTempDir = str + "\\" + strTempDir;
					hItem = m_wndTree.GetParentItem( hItem );					
				}
			}
		}

		delete pic;	

		CString sContent;
		sContent.Format("添加画面< %s >",dlg.m_strViewName.TrimRight() );
		CDBInterface::GetInstancePtr()->InsertLogRecord( LOG_MONITOR_ADD,0,"",(char *)(LPCTSTR)sContent );
	}
}
void CMainFrame::OnAddview2()
{
	OnAddview();
}
void CMainFrame::OnUpdateAddview(CCmdUI *pCmdUI)
{
	// TODO: 在此添加命令更新用户界面处理程序代码
}
void CMainFrame::OnUpdateAddview2(CCmdUI *pCmdUI)
{
	// TODO: 在此添加命令更新用户界面处理程序代码
}
void CMainFrame::DeleteDev(int nIsHint)
{
	int i, j;
	CString strMessage, strSelect;
	HTREEITEM hSelectedItem = m_wndTree.GetSelectedItem();
	strSelect = m_wndTree.GetItemText( hSelectedItem );

	int nChannelNo = -1, nDeviceNo = -1;
	int nChannelSize = pDevicesManager->m_channels.GetSize();
	// 串口设备属性设置
	for (i = 0; i < nChannelSize; i++)
	{
		if( nChannelNo != -1 && nDeviceNo != -1 ) break;

		int nDeviceSize = pDevicesManager->m_channels[i]->m_Devices.GetSize();
		for( j = 0; j < nDeviceSize; j++)
		{
			if (m_hSerialDev[i][j]==hSelectedItem && 
				pDevicesManager->m_channels[i]->m_nCommunicateType == 0 )
			{
				nChannelNo = i;
				nDeviceNo = j;
				break;
			}

			if( m_hNetworkDev[j] == hSelectedItem && 
				pDevicesManager->m_channels[i]->m_nCommunicateType == 1 )
			{
				nChannelNo = i;
				nDeviceNo = j;
				break;
			}
		}
	}

	CChannel* pChannel = pDevicesManager->m_channels[nChannelNo];
	CDevice* pDev = pChannel->m_Devices[nDeviceNo];

	if( nIsHint )
	{
		strMessage.Format(g_strDelDev,pDev->m_strName);
		if (MessageBox(strMessage,g_strConfirm,MB_YESNO|MB_ICONQUESTION) == IDNO) return;
	}
	m_wndTree.DeleteItem(hSelectedItem);

	if( pChannel->m_nCommunicateType == 0 )
	{
		for( j = nDeviceNo; j < MAX_DEVICE_NUM; j++ )
		{
			m_hSerialDev[nChannelNo][j] = m_hSerialDev[nChannelNo][j+1];
		}
	}
	else if( pChannel->m_nCommunicateType = 1 )
	{
		for( j = nDeviceNo; j < MAX_DEVICE_NUM; j++ )
		{
			m_hNetworkDev[j] = m_hNetworkDev[j+1];
		}
	}

	if( nIsHint )
	{
		CString sContent;
		sContent.Format("%s %s< %s >",g_strAdd,g_strDevice1,strSelect );
		CDBInterface::GetInstancePtr()->InsertLogRecord( LOG_DEV_DELETE,0,"",(char *)(LPCTSTR)sContent );

		pDevicesManager->SendNoticeToServer( CMD_NOTICE_READ_DB_DEV,CMD_OPERATE_DELETE,"",(char *)(LPCTSTR)pChannel->m_Devices[nDeviceNo]->m_strUID,0,"64320" );

		CDBInterface::GetInstancePtr()->DelTableData( "t_dev_variant_item","uid",(char *)(LPCTSTR)pChannel->m_Devices[nDeviceNo]->m_strUID,1,"64320" );
	}
	
	CDBInterface::GetInstancePtr()->DeleteDevInfo( (char *)(LPCTSTR)pChannel->m_Devices[nDeviceNo]->m_strUID );
	delete pChannel->m_Devices[nDeviceNo];
	pChannel->m_Devices.RemoveAt(nDeviceNo);
}

void CMainFrame::OnDeletedevice()
{
	// TODO: 在此添加命令处理程序代码
	DeleteDev(1);

}

void CMainFrame::OnUpdateDeletedevice(CCmdUI *pCmdUI)
{
	// TODO: 在此添加命令更新用户界面处理程序代码
	pCmdUI->Enable(TRUE);
}

void CMainFrame::OnDeleteview()
{
	// TODO: 在此添加命令处理程序代码
	//删除文件，同时再数状控件中删除
	CString strPath, strTemp;

	strPath = g_strDirectory + CString("\\") + CString(_PICTUREDIR);
	ffsco o;
	o.dirs(1);	//查找子目录
	o.find( LPCSTR(strPath), "*.view" );
	ffsco::typeT coo;
	ffsco::typeT::iterator it;

	HTREEITEM hSelectedItem = m_wndTree.GetSelectedItem();

	if( m_hMonitor==hSelectedItem )
	{
		MessageBox(g_strMonitorNameCannotDel, g_strTip, MB_ICONINFORMATION);
		return;
	}

	CString strSelect = m_wndTree.GetItemText( hSelectedItem );

	CString strMessage;
	strMessage.Format(g_strDelView,strSelect);
	if (MessageBox(strMessage,g_strConfirm,MB_YESNO|MB_ICONQUESTION) == IDNO) 
		return;

	//文件
	coo = o.co_file();
	for (it = coo.begin(); coo.end() != it; it++)
	{
		strTemp = (*it).c_str();
		strPath = strTemp;
		strTemp = strTemp.Right( strTemp.GetLength() - strTemp.ReverseFind('\\') - 1 );
		if( !strTemp.Compare(strSelect + ".view") )
		{
			CFile::Remove( strPath );
			m_wndTree.DeleteItem(hSelectedItem);
		}
	}

	//目录
	coo = o.co_dir();
	for( it = coo.begin(); coo.end() != it; it++ ) 
	{
		strTemp = (*it).c_str();
		strPath = strTemp;
		int nFind = strTemp.ReverseFind('\\');
		strTemp = strTemp.Left( nFind );
		strTemp = strTemp.Right( strTemp.GetLength() - strTemp.ReverseFind('\\') - 1 );
		if( !strTemp.Compare(strSelect) )
		{
			DeleteDirectory( strPath );
			m_wndTree.DeleteItem(hSelectedItem);
		}
	}

	CString sContent;
	sContent.Format("删除画面< %s >",strSelect.TrimRight() );
	CDBInterface::GetInstancePtr()->InsertLogRecord( LOG_MONITOR_DELETE,0,"",(char *)(LPCTSTR)sContent );
}

void CMainFrame::OnUpdateDeleteview(CCmdUI *pCmdUI)
{
	// TODO: 在此添加命令更新用户界面处理程序代码
}

void CMainFrame::OnDeletescript()
{
	// TODO: 在此添加命令处理程序代码
	HTREEITEM hSelectedItem = m_wndTree.GetSelectedItem();
	CFile::Remove( _SCRIPTDIR + m_wndTree.GetItemText(hSelectedItem) + ".srp");
	CFile::Remove( _SCRIPTDIR + m_wndTree.GetItemText(hSelectedItem) + ".con");
	m_wndTree.DeleteItem(hSelectedItem);

    int nPos = -1;
	for(int i = 0; i < m_nScripts; i++)
    {
        if (hSelectedItem == m_hScriptGroup[i])
        {
			nPos = i;
        }
    }
	
	for( i = nPos; i < m_nScripts; i++)
    {
        m_hScriptGroup[i] = m_hScriptGroup[i+1];
    }
}

void CMainFrame::OnUpdateDeletescript(CCmdUI *pCmdUI)
{
	// TODO: 在此添加命令更新用户界面处理程序代码
}

void CMainFrame::OnSetscript()
{
	// TODO: 在此添加命令处理程序代码
	HTREEITEM hSelectedItem = m_wndTree.GetSelectedItem();
	for (int m = 0; m < 32; m++)
	{
		if (m_hScriptGroup[m] == hSelectedItem) 
		{
			CString conFile;
			//SetCurrentDirectory(g_CurrentDir);
			conFile = CString(g_strDirectory) + "\\" + _SCRIPTDIR;
			conFile = conFile + m_wndTree.GetItemText(hSelectedItem) + ".con";
			
			CScriptSetDlg dlg;
			dlg.m_nCircle = GetPrivateProfileInt("RUNPARA", "CIRCLE", -1, conFile);
			dlg.m_nType = GetPrivateProfileInt("RUNPARA", "TYPE", -1, conFile);
			dlg.m_bUsed = GetPrivateProfileInt("RUNPARA", "USE", -1, conFile);
			
            char szCon[MAX_PATH] = {0};
			GetPrivateProfileString("RUNPARA", "CONDITON", "", szCon, MAX_PATH, conFile);
			dlg.m_strCondition = szCon;
			dlg.m_strName = m_wndTree.GetItemText(hSelectedItem);

			if (dlg.DoModal() == IDOK)
			{
				WritePrivateProfileString("RUNPARA", "CONDITON", dlg.m_strCondition, conFile);
				char tmp[10];
				sprintf(tmp, "%d", dlg.m_nType);
				WritePrivateProfileString("RUNPARA", "TYPE", tmp, conFile);
				sprintf(tmp, "%d", dlg.m_nCircle);
				WritePrivateProfileString("RUNPARA", "CIRCLE", tmp, conFile);

				if ( dlg.m_bUsed )
				{
					WritePrivateProfileString("RUNPARA", "USE", "1", conFile);
				}
				else
				{
					WritePrivateProfileString("RUNPARA", "USE", "0", conFile);
				}
			}
		}
	}
}

void CMainFrame::OnUpdateSetscript(CCmdUI *pCmdUI)
{
	// TODO: 在此添加命令更新用户界面处理程序代码
}

void CMainFrame::OnEditscript()
{
	// TODO: 在此添加命令处理程序代码
	HTREEITEM hSelectedItem = m_wndTree.GetSelectedItem();
	for (int m = 0; m < 32; m++)
	{
		if (m_hScriptGroup[m] == hSelectedItem) 
		{
			CString scriptFile;
			scriptFile = CString(g_strDirectory) + "\\" + _SCRIPTDIR;
			scriptFile = scriptFile + m_wndTree.GetItemText(hSelectedItem) + ".srp";
			ShellExecute(NULL,"open", "ScriptEdit.exe", scriptFile, NULL, SW_SHOWNORMAL);
		}
	}
}

void CMainFrame::OnUpdateEditscript(CCmdUI *pCmdUI)
{
	// TODO: 在此添加命令更新用户界面处理程序代码
}

void CMainFrame::SetRunPara()
{
	OnSysPara();
}

int CMainFrame::GetIDEViewIndex(CString strPath)
{
	int i;
	for( i = 0; i < MAX_VIEW_NUM; i++ )
	{
		if( !m_pViewIDE[i] ) continue;
		CString str;
		str = m_pViewIDE[i]->m_strPath;
		str.Replace("\\\\", "\\");
		strPath.Replace("\\\\", "\\");
		if( !str.Compare(strPath) )
		{
			return i;
		}
	}

	return -1;
}

int CMainFrame::GetIDEViewFreeIndex(CString strPath)
{
	int i;
	for( i = 0; i < MAX_VIEW_NUM; i++ )
	{
		if( !m_pViewIDE[i] ) return i;
		if(  m_pViewIDE[i]->m_bClose ) continue;
		if( !m_pViewIDE[i]->m_strPath.Compare("") )
		{
			return i;
		}
	}

	return -1;
}

void CMainFrame::AddIDEView(CString strDesc, CString strPath)
{
	//如果是当前画面，退出
	if( g_strViewName==strPath )
		return;
	// 打开新的画面，先保存旧的。
	CIDEView *pView = (CIDEView *)m_pActiveView;
	if( pView )
	{
		pView->ChangeView();
	}
	
	int nIndex = GetIDEViewIndex(strPath);
	if( nIndex == -1 )
	{
		nIndex = GetIDEViewFreeIndex(strPath);
		if( nIndex == -1 )  nIndex = 0;

		CCreateContext context;
		m_pViewIDE[nIndex] = new CChildFrame;
		m_pViewIDE[nIndex]->m_strPath = strPath;
		m_pViewIDE[nIndex]->m_strDesc = strDesc;

		context.m_pCurrentDoc = m_pDoc;
		context.m_pNewDocTemplate = m_pDoc->GetDocTemplate();
		context.m_pNewViewClass = RUNTIME_CLASS( CIDEView );
		context.m_pCurrentFrame = this; 
		context.m_pLastView = NULL;

		if( !m_pViewIDE[nIndex]->LoadFrame(IDI_SUMMARY, WS_MAXIMIZE|WS_OVERLAPPEDWINDOW, this, &context) )
		{
			return;
		}

		m_pViewIDE[nIndex]->ShowWindow(SW_SHOWMAXIMIZED);
		m_pViewIDE[nIndex]->InitialUpdateFrame(m_pDoc,true);
		m_pViewIDE[nIndex]->MDIActivate();

		m_nViewCount++;
	}
	else
	{
		m_pActiveView = (CFormView *)m_pViewIDE[nIndex]->GetActiveView();
		m_pViewIDE[nIndex]->MDIActivate();
	}

	m_pViewIDE[ nIndex ]->m_bClose = FALSE;
	m_pActiveView = (CFormView *)m_pViewIDE[nIndex]->GetActiveView();
	g_strViewName = strPath;
	((CIDEView *)m_pActiveView)->ChangeView();

	//取当前所有的变量到SA中
	GetCurPicVarToSArray( strPath );
}

void CMainFrame::OnUsers() 
{
	if( g_nIsDemo == 0 )
	{
		CDlgUserManager dlg;
		if( dlg.DoModal() == IDOK )
		{
		}
	}
}
void CMainFrame::OnEditPwdTool() 
{
	if( g_nIsDemo == 0 )
	{
		CDlgEditPwd dlg;
		if( dlg.DoModal() == IDOK )
		{
			CString sContent;
			sContent.Format("%s%s",g_strEdit,g_strPwd );
			CDBInterface::GetInstancePtr()->InsertLogRecord( LOG_PWD_EDIT,0,"",(char *)(LPCTSTR)sContent );
		}
	}
}
void CMainFrame::OnSysPara() 
{	
	CSystemParaSetDlg dlg;
	dlg.m_bStartRun = g_bStartRun;
	dlg.m_bAlarmVoice = g_bAlarmVoice;
	dlg.m_bEventAlarm = g_bEventAlarm;
	dlg.m_bHideTask = g_bHideTask;
	dlg.m_strStartPic = g_strStartPic;
	dlg.m_strStartPath = g_strStartPath;
	if ( dlg.DoModal() == IDOK )
	{
#if 0	//程序退出之前不改变状态
		g_bStartRun = dlg.m_bStartRun;
#endif
		//int nPos = dlg.m_strStartPath.Find("\\\\");
		//if( nPos!=-1 )
		//{
		//	dlg.m_strStartPath.Delete( nPos );
		//}
		//
		//int nLen = dlg.m_strStartPath.GetLength();
		//nPos = dlg.m_strStartPath.Find("SToneU");
		//CString sTemp;
		//if( nPos<nLen-7 )
		//	sTemp = dlg.m_strStartPath.Right( nLen-nPos-7 );
		//if( sTemp!="" )
		//	g_strStartPic = sTemp+"\\"+dlg.m_strStartPic;
		//else
		g_strStartPic = dlg.m_strStartPic;
		g_strStartPath = dlg.m_strStartPath;
		g_bEventAlarm = dlg.m_bEventAlarm;
		g_bAlarmVoice = dlg.m_bAlarmVoice;
		g_bHideTask = dlg.m_bHideTask;
		StoreRunPara(dlg.m_bStartRun);
	}
}

void CMainFrame::OnEventmanage() 
{
#if 0
	CEventSetDlg dlg;
	dlg.m_bControlEvent = g_bControlEvent;
	dlg.g_strYkWave =g_strYkWave; 
	dlg.m_bLoginEvent = g_bLoginEvent;
	dlg.m_strLoginWave = g_strLoginWave;
	dlg.m_bReguEvent = g_bReguEvent;
	dlg.m_strReguWave = g_strReguWave;
	dlg.m_bSetEvent = g_bSetEvent;
	dlg.m_strSetWave = g_strSetWave;
	dlg.m_bYcEvent = g_bYcEvent;
	dlg.m_strYcWave = g_strYcWave;
	dlg.m_bYxChangeEve = g_bYxChangeEve;
	dlg.m_strYxChangeWave = g_strYxChangeWave;
	if (dlg.DoModal() == IDOK)
	{
		g_bControlEvent = dlg.m_bControlEvent;
		g_strYkWave = dlg.g_strYkWave; 
		g_bLoginEvent = dlg.m_bLoginEvent;
		g_strLoginWave = dlg.m_strLoginWave;
		g_bReguEvent = dlg.m_bReguEvent;
		g_strReguWave = dlg.m_strReguWave;
		g_bSetEvent = dlg.m_bSetEvent;
		g_strSetWave = dlg.m_strSetWave;
		g_bYcEvent = dlg.m_bYcEvent;
		g_strYcWave = dlg.m_strYcWave;
		g_bYxChangeEve = dlg.m_bYxChangeEve;
		g_strYxChangeWave = dlg.m_strYxChangeWave;
		StoreEventPara();
		pVariantsManager->m_bDigitalAlarm = g_bYxChangeEve;
		pVariantsManager->m_bAnalogAlarm = g_bYcEvent;
	}
#endif
}

void CMainFrame::OnEvent() 
{
	if( g_nIsDemo == 0 )
	{
		CDlgQueryWarningRec dlg;
		if( dlg.DoModal() == IDOK )
		{
		}
	}
}
void CMainFrame::OnSystemLog() 
{
	if( g_nIsDemo == 0 )
	{
		CDlgSystemLog dlg;
		dlg.DoModal();
	}
}
void CMainFrame::OnNoticeRec() 
{
	if( g_nIsDemo == 0 )
	{
		CDlgNoticeRec dlg;
		dlg.DoModal();
	}
}
void CMainFrame::OnUpdateEvent(CCmdUI* pCmdUI) 
{
	// TODO: Add your command update UI handler code here
	pCmdUI->Enable(m_bEvent);
}
void CMainFrame::OnUpdateSystemLog(CCmdUI* pCmdUI) 
{
	// TODO: Add your command update UI handler code here
	pCmdUI->Enable(m_bSystemLog);
}
void CMainFrame::OnUpdateNoticeRec(CCmdUI* pCmdUI) 
{
	// TODO: Add your command update UI handler code here
	pCmdUI->Enable(m_bNoticeRec);
}
void CMainFrame::OnUpdateUsers(CCmdUI* pCmdUI) 
{
	// TODO: Add your command update UI handler code here
	pCmdUI->Enable(m_bUsers);
}
void CMainFrame::OnUpdateEditPwd(CCmdUI* pCmdUI) 
{
	// TODO: Add your command update UI handler code here
	pCmdUI->Enable(m_bEditPwd);
}
void CMainFrame::OnUpdateSysPare(CCmdUI* pCmdUI) 
{
	// TODO: Add your command update UI handler code here
	pCmdUI->Enable(m_bSysPare);
}
void CMainFrame::OnUpdateSingleAnalog(CCmdUI* pCmdUI) 
{
	// TODO: Add your command update UI handler code here
	pCmdUI->Enable(m_bAnalog);
}
void CMainFrame::OnUpdatePrint(CCmdUI* pCmdUI) 
{
	// TODO: Add your command update UI handler code here
	pCmdUI->Enable(m_bPrint);
}

void CMainFrame::OnSummaryLog() 
{
	if( g_nIsDemo == 0 )
	{
#if 0
		CDlgQuerySummaryLog dlg;
		if( dlg.DoModal() == IDOK )
		{
		}
#endif
		CString strFileName;
		strFileName.Format("%s\\Query.exe", g_strDirectory); 
		ShellExecute(0, "open", strFileName, NULL, NULL, SW_SHOWNORMAL); 
	}
}

void CMainFrame::OnUpdateSummaryLog(CCmdUI* pCmdUI) 
{
	// TODO: Add your command update UI handler code here
	pCmdUI->Enable(m_bDeviceLog);
}

void CMainFrame::StoreRunPara(BOOL bStartRun)
{
    char Path[_MAX_PATH] = {0};
	strcat(Path, g_strDirectory);
    strcat(Path,"\\");
	strcat(Path, _PROJECTDIR);
	strcat(Path,"\\");
	strcat(Path, "runpara.ini");

    if ( bStartRun )
	{
		WritePrivateProfileString("RUNPARA", "STARTRUN", "1", Path);
	}
	else
	{
		WritePrivateProfileString("RUNPARA", "STARTRUN", "0", Path);
	}

	if ( g_bEventAlarm )
	{
		WritePrivateProfileString("RUNPARA", "ALARM", "1", Path);
	}
	else
	{
		WritePrivateProfileString("RUNPARA", "ALARM", "0", Path);
	}

	if ( g_bAlarmVoice )
	{
		WritePrivateProfileString("RUNPARA", "VOICE", "1", Path);
	}
	else
	{
		WritePrivateProfileString("RUNPARA", "VOICE", "0", Path);
	}

	if ( g_bHideTask )
	{
		WritePrivateProfileString("RUNPARA",  "HIDETASK", "1", Path);
	}
	else
	{
		WritePrivateProfileString("RUNPARA", "HIDETASK", "0", Path);
	}

	if ( g_bFullScreen )
	{
		WritePrivateProfileString("RUNPARA",  "FULLSCREEN", "1", Path);
	}
	else
	{
		WritePrivateProfileString("RUNPARA", "FULLSCREEN", "0", Path);
	}

	WritePrivateProfileString("RUNPARA", "STARTPIC", g_strStartPic, Path);
	WritePrivateProfileString("RUNPARA", "STARTPATH", g_strStartPath, Path);
}

// 存储事件参数
void CMainFrame::StoreEventPara()
{
    char Path[_MAX_PATH] = {0};
    strcat(Path, g_strDirectory);
    strcat(Path,"\\");
	strcat(Path, _PROJECTDIR);
	strcat(Path,"\\");
	strcat(Path, "event.ini");
	
	if ( g_bControlEvent )
	{
		WritePrivateProfileString("IFALARM", "CONTROL", "1", Path);
	}
	else
	{
		WritePrivateProfileString("IFALARM", "CONTROL", "0", Path);
	}

	if ( g_bLoginEvent )
	{
		WritePrivateProfileString("IFALARM", "LOGIN", "1", Path);
	}
	else
	{
		WritePrivateProfileString("IFALARM", "LOGIN", "0", Path);
	}

	if ( g_bSetEvent )
	{
		WritePrivateProfileString("IFALARM", "SET", "1", Path);
	}
	else
	{
		WritePrivateProfileString("IFALARM", "SET", "0", Path);
	}

	if ( g_bReguEvent )
	{
		WritePrivateProfileString("IFALARM", "REGU", "1", Path);
	}
	else
	{
		WritePrivateProfileString("IFALARM", "REGU", "0", Path);
	}

	if ( g_bYxChangeEve )
	{
		WritePrivateProfileString("IFALARM", "YXCHANGE", "1", Path);
	}
	else
	{
		WritePrivateProfileString("IFALARM", "YXCHANGE", "0", Path);
	}

	if ( g_bYcEvent )
	{
		WritePrivateProfileString("IFALARM", "YCOVERLIMIT", "1", Path);
	}
	else
	{
		WritePrivateProfileString("IFALARM", "YCOVERLIMIT", "0", Path);
	}

	WritePrivateProfileString("WAVEFILE", "CONTROL", g_strYkWave, Path); 
	WritePrivateProfileString("WAVEFILE", "LOGIN", g_strLoginWave, Path);
	WritePrivateProfileString("WAVEFILE", "SET", g_strSetWave, Path);
	WritePrivateProfileString("WAVEFILE", "REGU", g_strReguWave, Path);
	WritePrivateProfileString("WAVEFILE", "YXCHANGE", g_strYxChangeWave, Path);
	WritePrivateProfileString("WAVEFILE", "YCOVERLIMIT", g_strYcWave, Path);
}

void CMainFrame::OnControldialog() 
{
	CRect rctDlg;
	int screenx = GetSystemMetrics(SM_CXSCREEN);
	int screeny = GetSystemMetrics(SM_CYSCREEN);
	m_dlgControl->GetWindowRect(&rctDlg);
	m_dlgControl->SetWindowPos(&wndTop, screenx - rctDlg.Width(), screeny - rctDlg.Height(), 
        rctDlg.Width(), rctDlg.Height(), SWP_NOZORDER);

	m_dlgControl->ShowWindow(SW_SHOW);
}

void CMainFrame::OnTimer(UINT nIDEvent)
{
	// TODO: 在此添加消息处理程序代码和/或调用默认值
	if( nIDEvent == 1 )
	{
		if (g_bStartRun && g_nIsPoll == 1)
		{
			for( int i = 0; i < g_nPollCount; i++ )
			{
				if( g_dwTick == 0 )
				{
					if( g_nPollIndex == i )
					{
						g_dwTick = GetTickCount();

						TRACE("Enter AddIDEView %s, %s\r\n", g_strPollPath, g_strPollDesc);
						AddIDEView(g_strPollDesc[i], g_strPollPath[i]);
						TRACE("Leave AddIDEView\r\n");
					}
				}
				else if( GetTickCount() - g_dwTick > (DWORD)g_nPollInterval * 1000 )
				{
					if( g_nPollIndex == g_nPollCount - 1 )
					{
						g_nPollIndex = 0;
					}
					else
					{
						g_nPollIndex++;
					}
					g_dwTick = 0;
				}
			}
		}
	}
	if( nIDEvent==2 )//定时得到狗信息/定时判断是否过期
	{
		pDevicesManager->GetDogInfo( "64320" );

		if( pDevicesManager->m_bIsPastDue )
		{
			static bool bShow=false;
			if( !bShow )
			{
				bShow = true;
				if( MessageBox(g_strPastDue, g_strTip, MB_ICONINFORMATION)==IDOK )
					bShow = false;
			}
		}
	}
	if( nIDEvent==3 )//判断变量在这个时间段时否报警
	{
		static int nStaticHours = -1;

		CTime time = CTime::GetCurrentTime();
		int nHours = time.GetHour();

		if( nStaticHours!=nHours )
		{
			nStaticHours = nHours;
			pVariantsManager->AllocDatePlan();
		}
	}

	CMDIAutoHideFrame::OnTimer(nIDEvent);
}

void CMainFrame::OnUserManager()
{
	// TODO: 在此添加命令处理程序代码
	CDlgUserManager dlg;
	int nResult = dlg.DoModal();
	if( nResult == IDOK )
	{
	}
}

void CMainFrame::OnGroupManager()
{
	// TODO: 在此添加命令处理程序代码
	CDlg_GroupManage dlg;
	int nResult = dlg.DoModal();
	if( nResult == IDOK )
	{
	}
}

void CMainFrame::OnEditPwd()
{
	// TODO: 在此添加命令处理程序代码
	CDlgEditPwd dlg;
	if( dlg.DoModal() == IDOK )
	{
		CString sContent;
		sContent.Format("修改密码");
		CDBInterface::GetInstancePtr()->InsertLogRecord( LOG_PWD_EDIT,0,"",(char *)(LPCTSTR)sContent );
	}
}

void CMainFrame::OnSingleAnalog()
{
	// TODO: 在此添加命令处理程序代码
	CAnalogDlg dlg;
	dlg.DoModal();
}

LRESULT CMainFrame::WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
{
	// TODO: 在此添加专用代码和/或调用基类
	switch( message )
	{
	case WM_MY_NEW_ALERT:
		{
			CString sPath;
			CString sVarName = (char *)wParam;

			//LOG4C((LOG_NOTICE, "报警变量：%s", sVarName));

			if( GetPicPathByVarName( sPath,sVarName ) )
			{
				int nPos1=0,nPos2=0;
				for( int i=sPath.GetLength()-1;i>0;i-- )
				{
					if( sPath[i]=='\\' )
					{
						nPos1 = i;
						break;
					}
				}
				for( int i=sPath.GetLength()-1;i>0;i-- )
				{
					if( sPath[i]=='.' )
					{
						nPos2 = i;
						break;
					}
				}
				CString sName = sPath.Mid( nPos1+1,nPos2-nPos1-1 );
				AddIDEView( sName,sPath );
			}

			//LOG4C((LOG_NOTICE, "报警画面：%s", sPath));
		}
		break;
	}

	return CMDIAutoHideFrame::WindowProc(message, wParam, lParam);
}
bool CMainFrame::GetPicIndexByPicPath( int &iIndex,CString sPicPath )
{
	bool bRet=false;

	for( int i=0;i<100;i++ )
	{
		if( m_PIC_VAR[i].sPicPath=="" )
		{
			iIndex=i;
			break;
		}

		if( m_PIC_VAR[i].sPicPath==sPicPath )
		{
			bRet = true;
			break;
		}
	}

	return bRet;
}
//通过变量名查找画面
bool CMainFrame::GetPicPathByVarName( CString &sPicPath,CString sVarName )
{
	bool bRet=false;
	bool bBreak=false;

	for( int i=0;i<100;i++ )
	{
		if( m_PIC_VAR[i].sPicPath=="" )
			break;

		for( int j=0;j<1000;j++ )
		{
			if( m_PIC_VAR[i].sCaption[j]=="" )
			{
				break;
			}

			if( -1 != m_PIC_VAR[i].sCaption[j].Find( sVarName ) )
			{
				sPicPath = m_PIC_VAR[i].sPicPath;
				bRet = true;
				bBreak = true;
				break;
			}
		}

		if( bBreak )
			break;
	}

	return bRet;
}
// 判断是有效变量名
BOOL CMainFrame::IsValidChar(char chr)
{
	if ( chr >= '0' && chr <= '9') 
		return TRUE;
	else if ((chr >= 'A' && chr <= 'Z') || (chr >= 'a' && chr <= 'z') ) 
		return TRUE;
    else if (chr == '_')
		return TRUE;
	else
		return FALSE;
}
//从组合公式中找出变量名加入到画面结构中
void CMainFrame::GetVarFromGSAddToStruct( int iIndex,CString sGS )
{
	//sGS = "(HG7053_DI10>=3)OR(HG7053_LinkStatus<=33)";
	//sGS = "((HG7053_DI10>=3))";
	//sGS = "(HG7053_DI10>=3)AND(HG7053_LinkStatus<=33)OR(HG7053_DI15<3)";
	int nLen = sGS.GetLength();
	int nPos1=0,nPos2=0;
	int nPos3=0,nPos4=0;
	CString sTemp,s1,s2,s3;
	CString sGS2[10];
	int nCount=0;
	
	//OR AND NOT
	for( int i=0;i<nLen;i++ )
	{
		if( sGS.Mid( i,2)=="OR" && !IsValidChar(sGS[i+2]) )
		{
			sGS2[nCount++] = sGS.Mid( nPos1,i-nPos1 );
			nPos1 = i+2;
		}

		if( (sGS.Mid( i,3)=="AND" || sGS.Mid( i,3)=="NOT") && !IsValidChar(sGS[i+3]) )
		{
			sGS2[nCount++] = sGS.Mid( nPos1,i-nPos1 );
			nPos1 = i+3;
		}
	}

	if( nPos1<nLen )
	{
		sGS2[nCount++] = sGS.Mid( nPos1,nLen-nPos1 );
	}

	for( int iGSIndex=0;iGSIndex<nCount;iGSIndex++ )
	{
		nPos3=0;
		nPos4=0;

		nLen = sGS2[iGSIndex].GetLength();
		if( !IsValidChar( sGS2[iGSIndex][0] ) )
		{
			if( IsValidChar( sGS2[iGSIndex][1] ) )
				nPos3 = 1;
			else
				nPos3 = 2;
			for( int i=nPos3;i<nLen;i++ )
			{
				if( !IsValidChar( sGS2[iGSIndex][i] ) )
				{
					nPos4 = i-0;
					break;
				}
			}
			sTemp = sGS2[iGSIndex].Mid( nPos3,nPos4-nPos3 );

			int nInsert=0;
			if( !VarIsExistInPic( iIndex,sTemp,nInsert ) && sTemp!="" )
				m_PIC_VAR[iIndex].sCaption[nInsert] = sTemp;
		}
		else
		{
			for( int i=nPos3;i<nLen;i++ )
			{
				if( !IsValidChar( sGS2[iGSIndex][i] ) )
				{
					nPos4 = i-0;
					break;
				}
			}
			sTemp = sGS2[iGSIndex].Mid( nPos3,nPos4-nPos3 );
	
			int nInsert=0;
			if( !VarIsExistInPic( iIndex,sTemp,nInsert ) && sTemp!="" )
				m_PIC_VAR[iIndex].sCaption[nInsert] = sTemp;
		}
	}
}
//把变量插入到相对应的画面结构
void CMainFrame::InsertPicPathToStruct( int iIndex,CString sPicPath )
{
	CDrawObjList _ObjList;
	m_PIC_VAR[iIndex].sPicPath = sPicPath;

	BYTE	m_Type;
	CSize	m_sizePic;
	CSize	m_sizeGrid;
	BOOL	m_bGrid;
	COLORREF	m_clrBack;

	CFile file;
	if(file.Open(sPicPath,CFile::modeRead))
	{
		CArchive ar(&file,CArchive::load);

		ar >> m_Type;
		ar >> m_sizePic;
		ar >> m_sizeGrid;
		ar >> m_bGrid;
		ar >> m_clrBack;
		_ObjList.Serialize(ar);

		if( !_ObjList.IsEmpty() )
		{
			for(POSITION pos = _ObjList.GetHeadPosition();pos!=NULL;)
			{
				POSITION pos1 = pos ;
				CDrawObj *ct = (CDrawObj *)_ObjList.GetNext(pos);ct->m_strCaption;

				int nInsert=0;
				if( ct->m_bVariant && ct->m_strCaption!="" && !VarIsExistInPic( iIndex,ct->m_strCaption,nInsert ) )
					m_PIC_VAR[iIndex].sCaption[nInsert] = ct->m_strCaption;
				if( ct->m_strDynShow!=""  )
					GetVarFromGSAddToStruct( iIndex,ct->m_strDynShow );
			}
		}
		///////////////////////////////////////
		ar.Close();
		file.Close();
	}

	if(!_ObjList.IsEmpty())
	{
		for(POSITION pos = _ObjList.GetHeadPosition();pos!=NULL;)
		{
			POSITION pos1 = pos ; 
			CDrawObj *ct = (CDrawObj *)_ObjList.GetNext(pos);
			_ObjList.RemoveAt(pos1);
			delete ct;
		}
		_ObjList.RemoveAll();
		ASSERT(_ObjList.IsEmpty());
	}
}
//查找这个画面结构里是否已经有这个变量
bool CMainFrame::VarIsExistInPic( int iIndex,CString sVarName,int &iInsertIndex )
{
	bool bRet=false;

	for( int j=0;j<1000;j++ )
	{
		if( m_PIC_VAR[iIndex].sCaption[j]=="" )
		{
			iInsertIndex = j;
			break;
		}
		
		//if( -1 != m_PIC_VAR[iIndex].sCaption[j].Find( sVarName ) )
		if( m_PIC_VAR[iIndex].sCaption[j] == sVarName )
		{
			bRet = true;
			break;
		}
	}
	
	return bRet;
}
void CMainFrame::GetCurPicVarToSArray( CString sPicPath )
{
	EnterCriticalSection( &g_CSLimit );
	g_saCurPicVar.RemoveAll();

	for( int i=0;i<100;i++ )
	{
		if( m_PIC_VAR[i].sPicPath=="" )
			break;

		if( m_PIC_VAR[i].sPicPath==sPicPath )
		{
			for( int j=0;j<1000;j++ )
			{
				if( m_PIC_VAR[i].sCaption[j]=="" )
				{
					break;
				}

				g_saCurPicVar.Add( m_PIC_VAR[i].sCaption[j] );
			}

			break;
		}
	}

	LeaveCriticalSection( &g_CSLimit );
}