MultiTerminal1 - Gitblit

zxd

2023-09-28 aac3b319965967f465881f3a8961904d57b6f337

提交 \| 用户 \| age
0ed438	1
418cb3	2	// MultiTerminal2View.cpp: CMTerm1View 类的实现
0ed438	3	//
Q	4
	5	#include "pch.h"
	6	#include "framework.h"
	7	// SHARED_HANDLERS 可以在实现预览、缩略图和搜索筛选器句柄的
	8	// ATL 项目中进行定义，并允许与该项目共享文档代码。
	9	#ifndef SHARED_HANDLERS
	10	#include "MTerm1.h"
	11	#endif
	12
	13	#include "MTerm1Doc.h"
	14	#include "MTerm1View.h"
418cb3	15	#include "ChildFrm.h"
Q	16	#include "DialogSetCoil.h"
	17	#include "DialogSetData.h"
	18	#include "DialogIoComment.h"
	19	#include "KDefine.h"
df0321	20	#include "MainFrm.h"
0ed438	21
Q	22	#ifdef _DEBUG
	23	#define new DEBUG_NEW
	24	#endif
	25
	26
	27	// CMTerm1View
	28
418cb3	29	IMPLEMENT_DYNCREATE(CMTerm1View, CScrollView)
0ed438	30
d34256	31	/// <summary>
Z	32	/// 消息映射
	33	/// 是 MFC 中用于将 Windows 消息（如鼠标点击、按键等）映射到成员函数的机制。
	34	/// </summary>
418cb3	35	BEGIN_MESSAGE_MAP(CMTerm1View, CScrollView)
0ed438	36	// 标准打印命令
418cb3	37	ON_COMMAND(ID_FILE_PRINT, &CScrollView::OnFilePrint)
Q	38	ON_COMMAND(ID_FILE_PRINT_DIRECT, &CScrollView::OnFilePrint)
	39	ON_COMMAND(ID_FILE_PRINT_PREVIEW, &CScrollView::OnFilePrintPreview)
	40
	41	ON_WM_CREATE()
	42	ON_WM_TIMER()
	43	ON_WM_ERASEBKGND()
	44	ON_WM_SIZE()
	45
	46	ON_WM_LBUTTONDOWN()
	47	ON_WM_LBUTTONUP()
	48	ON_WM_LBUTTONDBLCLK()
	49	ON_WM_RBUTTONDOWN()
0ed438	50	ON_WM_RBUTTONUP()
418cb3	51	ON_WM_CONTEXTMENU()
Q	52	ON_WM_INITMENUPOPUP()
	53
	54	ON_COMMAND(ID_RECT_SELECT, &CMTerm1View::OnRectSelect)
	55	ON_UPDATE_COMMAND_UI(ID_RECT_SELECT, &CMTerm1View::OnUpdateRectSelect)
	56	ON_COMMAND(ID_TEXT_FIRST, &CMTerm1View::OnTextFirst)
	57	ON_UPDATE_COMMAND_UI(ID_TEXT_FIRST, &CMTerm1View::OnUpdateTextFirst)
	58	ON_COMMAND(ID_INSERT_BLANK_LINE, &CMTerm1View::OnInsertBlankLine)
	59	ON_UPDATE_COMMAND_UI(ID_INSERT_BLANK_LINE, &CMTerm1View::OnUpdateInsertBlankLine)
	60	ON_COMMAND(ID_DELETE_BLANK_LINE, &CMTerm1View::OnDeleteBlankLine)
	61	ON_UPDATE_COMMAND_UI(ID_DELETE_BLANK_LINE, &CMTerm1View::OnUpdateDeleteBlankLine)
	62	ON_COMMAND(ID_DISPLAY_COMMENTS, &CMTerm1View::OnDisplayComments)
	63	ON_UPDATE_COMMAND_UI(ID_DISPLAY_COMMENTS, &CMTerm1View::OnUpdateDisplayComments)
	64	ON_COMMAND(ID_MONITOR, &CMTerm1View::OnMonitor)
	65	ON_UPDATE_COMMAND_UI(ID_MONITOR, &CMTerm1View::OnUpdateMonitor)
	66	ON_COMMAND(ID_PROG_CONVERT, &CMTerm1View::OnProgConvert)
	67	ON_UPDATE_COMMAND_UI(ID_PROG_CONVERT, &CMTerm1View::OnUpdateProgConvert)
	68	ON_COMMAND(ID_PROG_CANCEL_EDIT, &CMTerm1View::OnProgCancelEdit)
	69	ON_UPDATE_COMMAND_UI(ID_PROG_CANCEL_EDIT, &CMTerm1View::OnUpdateProgCancelEdit)
	70	ON_COMMAND(ID_INPUT_IO_COMMENT, &CMTerm1View::OnInputIoComment)
	71
	72
	73	// ON_UPDATE_COMMAND_UI_RANGE(ID_INDICATOR_MACHINE_TYPE, ID_INDICATOR_INFO_DISPLAY, OnUpdateIndicators)
	74	ON_COMMAND_RANGE(ID_INDICATOR_MACHINE_TYPE, ID_INDICATOR_INFO_DISPLAY, NULL)
	75	// ON_UPDATE_COMMAND_UI(ID_INDICATOR_MACHINE_TYPE, &CMTerm1View::OnUpdateMachineType)
	76	// ON_UPDATE_COMMAND_UI(ID_INDICATOR_PROGRAM_POS, &CMTerm1View::OnUpdateProgramPos)
	77	// ON_UPDATE_COMMAND_UI(ID_INDICATOR_CONNECTIVITY, &CMTerm1View::OnUpdateConnectivity)
	78	// ON_UPDATE_COMMAND_UI(ID_INDICATOR_RUN_STATUS, &CMTerm1View::OnUpdateRunStatus)
	79	// ON_UPDATE_COMMAND_UI(ID_INDICATOR_MONITOR_STATUS, &CMTerm1View::OnUpdateMonitorStatus)
	80	// ON_UPDATE_COMMAND_UI(ID_INDICATOR_TARGET_ADDRESS, &CMTerm1View::OnUpdateTargetAddress)
	81	// ON_UPDATE_COMMAND_UI(ID_INDICATOR_INFO_DISPLAY, &CMTerm1View::OnUpdateDisplayComments)
	82
	83	// ON_COMMAND(ID_INDICATOR_MONITOR_STATUS, &CMTerm1View::OnIndicatorMonitorStatus)
	84	// ON_UPDATE_COMMAND_UI(ID_INDICATOR_MONITOR_STATUS, &CMTerm1View::OnUpdateIndicatorMonitorStatus)
	85	ON_WM_KEYDOWN()
0ed438	86	END_MESSAGE_MAP()
418cb3	87
0ed438	88
Q	89	// CMTerm1View 构造/析构
	90
	91	CMTerm1View::CMTerm1View() noexcept
	92	{
	93	// TODO: 在此处添加构造代码
	94
	95	}
	96
	97	CMTerm1View::~CMTerm1View()
	98	{
	99	}
	100
	101	BOOL CMTerm1View::PreCreateWindow(CREATESTRUCT& cs)
	102	{
	103	// TODO: 在此处通过修改
	104	// CREATESTRUCT cs 来修改窗口类或样式
	105
418cb3	106	return CScrollView::PreCreateWindow(cs);
Q	107	}
	108
d34256	109	/// <summary>
Z	110	/// MFC 中的一个函数，它在视图首次显示之前被调用
	111	/// </summary>
418cb3	112	void CMTerm1View::OnInitialUpdate()
Q	113	{
	114	CScrollView::OnInitialUpdate();
d34256	115
Z	116	//创建了三种不同的字体
418cb3	117	TextFont.CreateFont(13, 0, 0, 0, FW_NORMAL, FALSE, FALSE, 0, ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH \| FF_ROMAN, _T("宋体"));
Q	118	MonTextFont.CreateFont(12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, 0, ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH \| FF_ROMAN, _T("宋体"));
	119	AnnoFont.CreateFont(12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, 0, ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH \| FF_ROMAN, _T("宋体"));
d34256	120
Z	121	//获取了状态栏的引用并存储在 m_pStatusBar 成员变量中
418cb3	122	m_pStatusBar = ((CChildFrame *)GetParentFrame())->GetStatusBar();
d34256	123
418cb3	124	CSize sizeTotal;
Q	125	// TODO: 计算此视图的合计大小
	126	sizeTotal.cx = m_LeftMargin + m_CellWidth* m_CellPerLine + m_CellWidth *2;
	127	sizeTotal.cy = 2000;
d34256	128	//设置了滚动大小
418cb3	129	SetScrollSizes(MM_TEXT, sizeTotal);
d34256	130
Z	131	CString s1;//没啥用
	132
	133	//设置了两个定时器，一个间隔为50毫秒，另一个为10毫秒。
418cb3	134	SetTimer(1, 50,NULL);
Q	135	SetTimer(2, 10, NULL);
	136
0ed438	137	}
Q	138
	139	// CMTerm1View 绘图
	140
418cb3	141	void CMTerm1View::OnDraw(CDC* pDC)
0ed438	142	{
Q	143	CMTerm1Doc* pDoc = GetDocument();
	144	ASSERT_VALID(pDoc);
	145	if (!pDoc)
	146	return;
	147
	148	// TODO: 在此处为本机数据添加绘制代码
d34256	149	CString s1;//没啥用
Z	150
418cb3	151	needReDraw = 1;
Q	152	DrawLDSGraph(pDC);
	153	needReDraw = 0;
0ed438	154	}
Q	155
d34256	156	// CMTerm1View 打印，MFC 函数，用于准备打印。
0ed438	157	BOOL CMTerm1View::OnPreparePrinting(CPrintInfo* pInfo)
Q	158	{
	159	// 默认准备
	160	return DoPreparePrinting(pInfo);
	161	}
	162
d34256	163	// MFC 函数，用于在打印开始之前进行初始化。
0ed438	164	void CMTerm1View::OnBeginPrinting(CDC* /pDC/, CPrintInfo* /pInfo/)
Q	165	{
	166	// TODO: 添加额外的打印前进行的初始化过程
	167	}
	168
d34256	169	//MFC 函数，用于在打印结束后进行清理。
0ed438	170	void CMTerm1View::OnEndPrinting(CDC* /pDC/, CPrintInfo* /pInfo/)
Q	171	{
	172	// TODO: 添加打印后进行的清理过程
	173	}
	174
	175
	176	// CMTerm1View 诊断
	177
	178	#ifdef _DEBUG
d34256	179	//函数用于验证对象的有效性。
0ed438	180	void CMTerm1View::AssertValid() const
Q	181	{
418cb3	182	CScrollView::AssertValid();
d34256	183	}
0ed438	184
d34256	185	// 函数用于将对象的内容转储到指定的上下文。
0ed438	186	void CMTerm1View::Dump(CDumpContext& dc) const
Q	187	{
418cb3	188	CScrollView::Dump(dc);
0ed438	189	}
Q	190
d34256	191	//函数返回与此视图关联的文档对象。
0ed438	192	CMTerm1Doc* CMTerm1View::GetDocument() const // 非调试版本是内联的
Q	193	{
	194	ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CMTerm1Doc)));
	195	return (CMTerm1Doc*)m_pDocument;
	196	}
	197	#endif //_DEBUG
	198
d34256	199	//MFC 函数，用于处理视图的创建事件。
418cb3	200	int CMTerm1View::OnCreate(LPCREATESTRUCT lpCreateStruct)
Q	201	{
	202	if (CScrollView::OnCreate(lpCreateStruct) == -1)
	203	return -1;
	204
	205	// TODO: 在此添加您专用的创建代码
	206
	207	return 0;
	208	}
	209
d34256	210	/// <summary>
Z	211	/// 用于重新绘制视图。
	212	/// </summary>
	213	/// <returns></returns>
418cb3	214	int CMTerm1View::DoReDraw()
Q	215	{
d34256	216
418cb3	217	CPoint scroll1;
Q	218	scroll1 = this->GetScrollPosition();
	219
	220	CClientDC dc1(this);
	221	XFORM xform1;
	222	xform1.eM11 = 1;
	223	xform1.eM12 = 0;
	224	xform1.eM21 = 0;
	225	xform1.eM22 = 1;
	226	xform1.eDx = float(-scroll1.x);
	227	xform1.eDy = float(-scroll1.y);
	228
	229	XFORM xform2 = { 1, 0, 0, 1, 0, 0 };
	230
	231	dc1.SetGraphicsMode(GM_ADVANCED);
	232	dc1.SetWorldTransform(&xform1);
	233
	234	DrawLDSGraph(&dc1);
	235
	236	return 0;
	237	}
	238
d34256	239	/// <summary>
Z	240	/// 滚动到特定单元格
	241	/// 函数内部计算了单元格的总高度，考虑了是否显示注释
	242	/// </summary>
	243	/// <param name="nRow"></param>
	244	/// <param name="nCol"></param>
	245	/// <returns></returns>
418cb3	246	int CMTerm1View::ScrollToCell(int nRow, int nCol)
Q	247	{
	248	int CellTotalHeight = m_CellHeight + (m_bShowComments ? m_CommentHeight : 0);
	249
	250	CSize sizeTotal;
	251	// TODO: 计算此视图的合计大小
	252	sizeTotal.cx = m_LeftMargin + m_CellWidth * m_CellPerLine + m_CellWidth * 2;
	253	sizeTotal.cy = m_TopMargin + CellTotalHeight * (m_nTotalRow );
	254	CSize sizeSb;
	255	GetScrollBarSizes(sizeSb);
	256	POINT pt1;
	257	pt1.x = 0;
	258	pt1.y = nRow * CellTotalHeight;
	259	ScrollToPosition(pt1);
	260	return 0;
	261	}
	262
d34256	263	/// <summary>
Z	264	/// 滚动单元格进入视图（未完成的功能）
	265	/// </summary>
	266	/// <param name="nRow"></param>
	267	/// <param name="nCol"></param>
	268	/// <returns></returns>
418cb3	269	int CMTerm1View::ScrollCellIntoView(int nRow, int nCol)
Q	270	{
	271	int CellTotalHeight = m_CellHeight + (m_bShowComments ? m_CommentHeight : 0);
	272	return 0;
	273	}
	274
d34256	275	/// <summary>
Z	276	/// 检查单元格是否在视图中（未完成的功能）
	277	/// </summary>
	278	/// <param name="nRow"></param>
	279	/// <param name="nCol"></param>
	280	/// <returns></returns>
418cb3	281	int CMTerm1View::isCellInView(int nRow, int nCol)
Q	282	{
	283	int CellTotalHeight = m_CellHeight + (m_bShowComments ? m_CommentHeight : 0);
	284	return 0;
	285	}
	286
d34256	287	/// <summary>
Z	288	/// 用于在视图中绘制图形的主要函数
	289	/// </summary>
	290	/// <param name="pDC">文档</param>
	291	/// <returns></returns>
418cb3	292	int CMTerm1View::DrawLDSGraph(CDC* pDC)
Q	293	{
	294	// TODO: 在此处添加实现代码.
d34256	295	CString s1;//没啥用
Z	296
	297	//验证文档引用
418cb3	298	CMTerm1Doc* pDoc = GetDocument();
Q	299	ASSERT_VALID(pDoc);
	300	if (!pDoc) return false;
d34256	301
418cb3	302	if (m_bMonitoring) {
Q	303	pDoc->DoPLCMonitor();
	304	}
d34256	305
418cb3	306	int x1, y1, x2, y2;
Q	307	// RECT rect1;
	308	int CellTotalHeight = m_CellHeight + (m_bShowComments ? m_CommentHeight : 0);
	309
	310	int nDataType, nDataAddr;
	311	int nStat;
d34256	312	CBrush br0(BkColor);//背景颜色
Z	313	CBrush br01(BkEditColor);//编辑（选中）状态下的背景颜色
418cb3	314	int nRow, nCol;
Q	315	CRect rect0;
	316	this->GetClientRect(&rect0);
	317	int viewWidth = rect0.Width();
	318	CPoint scroll1;
	319	scroll1 = this->GetScrollPosition();
	320
d34256	321	int nFirstVisibleLine;//用于确定可见行范围-起始位置
Z	322	int nLastVisibleLine;//用于确定可见行范围-终止位置
	323	//通过滚动位置和视图的高度计算上述两个值
418cb3	324	nFirstVisibleLine = (scroll1.y - m_TopMargin) / CellTotalHeight;
Q	325	nLastVisibleLine = (rect0.Height() + scroll1.y - m_TopMargin) / CellTotalHeight + 1;
d34256	326	if (nFirstVisibleLine < 0)
Z	327	{
	328	nFirstVisibleLine = 0;
	329	}
	330	if (nLastVisibleLine < 0)
	331	{
	332	nLastVisibleLine = 0;
	333	}
418cb3	334
d34256	335	//选择字体
418cb3	336	CFont *pOldFont;
Q	337	pOldFont = (CFont *)pDC->SelectObject(&TextFont);
	338
d34256	339	for (int i = nFirstVisibleLine; i < nLastVisibleLine && i < 1000; i++)
Z	340	{
418cb3	341	// 画一行单元
Q	342	nRow = i;
	343	int x0, y0;
	344	x0 = m_LeftMargin;
	345	y0 = m_TopMargin + CellTotalHeight * i;
	346	y2 = y0 + CellTotalHeight;
	347	//画背景
	348	if (needReDraw) {
	349	// 左半部分
	350	if (scroll1.x < x0) {
	351	CRect rect1(scroll1.x, y0, x0, y2);
	352	pDC->FillRect(&rect1, &br0);
	353	}
	354	//中间部分
	355	x1 = max(scroll1.x, x0);
	356	x2 = min(scroll1.x + viewWidth, x0 + m_CellPerLine * m_CellWidth);
	357	CRect rect2(x1, y0, x2, y2);
	358	//背景颜色
	359	if (!Cells[nRow][0].bEditing){
	360	pDC->FillRect(&rect2, &br0);
	361	} else {
	362	pDC->FillRect(&rect2, &br01);
	363	}
	364	// 右边部分
	365	if (x2 < scroll1.x + viewWidth) {
	366	CRect rect3(x2, y0, scroll1.x + viewWidth, y2);
	367	pDC->FillRect(&rect3, &br0);
	368	}
	369
	370	if (m_FocusRow == i) DrawFocusRect(pDC);
	371
	372	}
	373	//*
	374	// 画本行左侧母线
	375	x1 = m_LeftMargin;
	376	y1 = m_TopMargin + CellTotalHeight * i;
	377	x2 = x1;
	378	y2 = y1 + CellTotalHeight;
	379
	380	pDC->MoveTo(x1, y1);
	381	pDC->LineTo(x2, y2);
	382	//画左侧母线小短横线
	383
	384
	385	x1 = m_LeftMargin;
	386	y1 = m_TopMargin + CellTotalHeight * i + m_LinePosY;
	387	x2 = x1 + 3;
	388	y2 = y1;
	389	pDC->MoveTo(x1, y1);
	390	pDC->LineTo(x2, y2);
	391
	392	// 如果本行第一个ST是程序段的起始，输出程序步数
	393	//*/
	394	int nType = Cells[nRow][0].nType;
	395	int nProgSetp = Cells[nRow][0].nProgStep;
	396	if (nType == typeNO \|\| nType == typeNC \|\| nType == typeCMP) {
	397	int nPairTo = pDoc->Progs[nProgSetp].PairTo;
	398	int nPairOp = 0;
	399	if (nPairTo) nPairOp = pDoc->Progs[nPairTo].nOpType1;
	400	if (nPairOp == 0) { //程序段开始
	401	//在当前行的左侧输出当前程序步数
	402	s1.Format(_T(" %d"), nProgSetp);
	403	CRect rect2(0, m_TopMargin + CellTotalHeight * i + m_LinePosY - 8, m_LeftMargin - 4, m_TopMargin + CellTotalHeight * i + m_LinePosY + 14);
	404	pDC->DrawText(s1, &rect2, DT_RIGHT);
	405
	406	}
	407	}
	408	// 获取数据并显示各单元
df0321	409
418cb3	410	for (int j = 0; j < m_CellPerLine; j++) {
Q	411	nCol = j;
	412	nDataType = Cells[nRow][nCol].nDataType;
	413	nDataAddr = Cells[nRow][nCol].nDataAddr;
df0321	414	if (m_bMonitoring) {
Q	415	if ((nDataType & TYPEDATA) == TYPEDATA) {
	416	nStat = pDoc->GetVarData(nDataType, nDataAddr);
	417	}
	418	else {
	419	nStat = pDoc->GetCoilValue(nDataType, nDataAddr);
	420	}
	421	Cells[nRow][nCol].nStat = nStat;
	422	nType = Cells[nRow][nCol].nType;
	423	if (nType == typeNO \|\| nType == typeNC \|\| nType == typeCMP \|\| nType == typeTM)
	424	{
	425	int nProgStep = Cells[nRow][nCol].nProgStep;
	426	int nBinProgStep = pDoc->Progs[nProgStep].nBinStep;
	427	Cells[nRow][nCol].nTrace = pDoc->ProgTrace[nBinProgStep];
	428	}
418cb3	429	}
Q	430	else {
df0321	431	Cells[nRow][nCol].nStat = 0; Cells[nRow][nCol].nTrace = 0;
418cb3	432	}
df0321	433
418cb3	434	DrawCell(pDC, i, j);
Q	435	}
	436
	437
	438	// 画本行右侧母线
	439	//*
	440	x1 = m_LeftMargin + m_CellWidth * m_CellPerLine;
	441	y1 = m_TopMargin + CellTotalHeight * i;
	442	x2 = x1;
	443	y2 = y1 + CellTotalHeight;
	444
	445	pDC->MoveTo(x1, y1);
	446	pDC->LineTo(x2, y2);
	447	// 画本行右侧母线小短横线
	448	x1 = m_LeftMargin + m_CellWidth * m_CellPerLine;
	449	y1 = m_TopMargin + CellTotalHeight * i + m_LinePosY;
	450	x2 = x1 - 3;
	451	y2 = y1;
	452	pDC->MoveTo(x1, y1);
	453	pDC->LineTo(x2, y2);
	454
	455	//*/
	456	}
	457	pDC->SelectObject(pOldFont);
	458	CRect rect2(0, 30, 240, 100);
	459	// pDC->DrawText(_T("这是测试字符串111,222,33,aa,bb,cc"), &rect2, 0);
	460	s1.Format(_T("This is New Info.."));
	461	needReDraw = 0;
	462	return 0;
	463	}
	464
	465	void CMTerm1View::DrawFocusRect(CDC* pDC)
	466	{
	467	// DrawCell(pDC, m_oldFocusRow, m_oldFocusCol);
	468	CPen BluePen(PS_SOLID, 3, FocusColor);
	469	CPen * pOldPen = pDC->SelectObject(&BluePen);
	470	//CBrush * pOldBrush = ;
	471	pDC->SelectStockObject(NULL_BRUSH);
	472	int x0, y0;
	473	// int x1, y1, x2, y2;
	474	RECT rect1;
	475	int CellTotalHeight = m_CellHeight + (m_bShowComments ? m_CommentHeight : 0);
	476
	477	rect1.left = m_LeftMargin + 1 + m_CellWidth * m_FocusCol;
	478	rect1.right = rect1.left + m_CellWidth - 4;
	479	rect1.top = m_TopMargin + CellTotalHeight * m_FocusRow;
	480	rect1.bottom = rect1.top + CellTotalHeight - 2;
	481
	482	x0 = rect1.left;
	483	y0 = rect1.top;
	484	//pDC->DrawFocusRect(&rect1);
	485	pDC->Rectangle(&rect1);
	486	m_oldFocusCol = m_FocusCol;
	487	m_oldFocusRow = m_FocusRow;
	488
	489	pDC->SelectObject(pOldPen);
	490	// pDC->SelectObject(poldBrush);
	491	}
	492
	493	int CMTerm1View::DrawLeftRightLine(CDC* pDC, int x0, int y0, int size1, int size2)
	494	{
	495	// TODO: 在此处添加实现代码.
	496	int x1, y1, x2, y2;
	497	//画左侧横线
	498	x1 = x0;
	499	y1 = y0 + m_LinePosY;
	500	x2 = x1 + size1;
	501	y2 = y1;
	502	pDC->MoveTo(x1, y1);
	503	pDC->LineTo(x2, y2);
	504
	505	//画右侧横线
	506	x1 = x0 + size1 +size2;
	507	y1 = y0 + m_LinePosY;
	508	x2 = x0 + m_CellWidth;
	509	y2 = y1;
	510	pDC->MoveTo(x1, y1);
	511	pDC->LineTo(x2, y2);
	512	return 0;
	513	}
	514
	515	void CMTerm1View::DrawOT(CDC* pDC, int x0, int y0)
	516	{
	517	int x1, y1;
	518	//画左右侧横线
	519	DrawLeftRightLine(pDC, x0, y0);
	520
	521	x1 = x0 +16;
	522	y1 = y0 + m_LinePosY;
	523
	524	pDC->MoveTo(x1 + 6 + 6, y1);
	525	pDC->AngleArc(x1 + 6, y1, 6, 0, 360);
	526	}
	527
	528	void CMTerm1View::DrawRelay(CDC* pDC, int x0, int y0)
	529	{
	530	int x1, y1, x2, y2;
	531	//画左右侧横线
	532	DrawLeftRightLine(pDC, x0, y0);
	533	// 画左侧竖线
	534	x1 = x0+16;
	535	y1 = y0 + m_LinePosY - 6;
	536	x2 = x1;
	537	y2 = y1 + 12;
	538	pDC->MoveTo(x1, y1);
	539	pDC->LineTo(x2, y2);
	540	// 画右侧竖线
	541	x1 = x2 + 12;
	542	y1 = y1;
	543	x2 = x1;
	544	y2 = y1 + 12;
	545	pDC->MoveTo(x1, y1);
	546	pDC->LineTo(x2, y2);
	547	}
	548
	549	int CMTerm1View::DrawBracket(CDC* pDC, int x0, int y0, int sizex, int sty, int sizey)
	550	{
	551	// TODO: 在此处添加实现代码.
	552	int x1, y1, x2, y2;
	553	// 左边的短横线
	554	x1 = x0 ;
	555	y1 = y0 + m_LinePosY;
	556	x2 = x0 + 3;
	557	y2 = y1;
	558	pDC->MoveTo(x1, y1);
	559	pDC->LineTo(x2, y2);
	560
	561	// 左方括号
	562	x1 = x0 + 9;
	563	y1 = y0 + sty;
	564	x2 = x0 + 3;
	565	y2 = y1;
	566	pDC->MoveTo(x1, y1);
	567	pDC->LineTo(x2, y2);
	568	x2 = x2;
	569	y2 = y2 + sizey;
	570	pDC->LineTo(x2, y2);
	571	x2 = x2 + 6;
	572	y2 = y2;
	573	pDC->LineTo(x2, y2);
	574	// 右方括号
	575	x1 = x0 + sizex - 6 - 6;
	576	y1 = y0 + sty;
	577	x2 = x0 + sizex -6 ;
	578	y2 = y1;
	579	pDC->MoveTo(x1, y1);
	580	pDC->LineTo(x2, y2);
	581	x2 = x2;
	582	y2 = y2 + sizey;
	583	pDC->LineTo(x2, y2);
	584	x2 = x2 - 6;
	585	y2 = y2;
	586	pDC->LineTo(x2, y2);
	587	// 右边的短横线
	588	x1 = x0 + sizex - 6;
	589	y1 = y0 + m_LinePosY;
	590	x2 = x0 + sizex ;
	591	y2 = y1;
	592	pDC->MoveTo(x1, y1);
	593	pDC->LineTo(x2, y2);
	594	return 0;
	595	}
d34256	596
418cb3	597	int CMTerm1View::DrawAngleBracket(CDC* pDC, int x0, int y0, int size1, int size2)
Q	598	{
	599	// TODO: 在此处添加实现代码.
	600	int x1,y1,x2, y2;
	601	DrawLeftRightLine(pDC, x0, y0, size1, size2);
	602	// 左尖括号
	603	x1 = x0 + size1 + 6;
d34256	604	y1 = y0 + m_LinePosY -6;
418cb3	605	x2 = x1 -6;
Q	606	y2 = y1 +6 ;
	607	pDC->MoveTo(x1, y1);
	608	pDC->LineTo(x2, y2);
	609	x2 = x2 +6;
	610	y2 = y2 + 6;
	611	pDC->LineTo(x2, y2);
	612	// 右尖括号
	613	x1 = x0 + size1 + size2 - 6;
	614	y1 = y0 + m_LinePosY - 6;
	615	x2 = x1 + 6;
	616	y2 = y1 + 6 ;
	617	pDC->MoveTo(x1, y1);
	618	pDC->LineTo(x2, y2);
	619	x2 = x2 -6 ;
	620	y2 = y2 + 6;
	621	pDC->LineTo(x2, y2);
	622	return 0;
	623	}
	624
	625	int CMTerm1View::DrawCellStat1(CDC * pDC, int x1, int y1, int sizex, int sizey, int nStat)
	626	{
	627	// TODO: 在此处添加实现代码.
	628	CRect rect1;
	629	rect1.left = x1;
	630	rect1.top = y1;
	631	rect1.right = x1+sizex;
	632	rect1.bottom = y1+sizey;
	633
	634	CBrush br0(BkColor);
	635	CBrush br1(MonCoilColor);
	636	if (m_bMonitoring) {
	637	if (nStat) {
	638	pDC->FillRect(&rect1, &br1);
	639	}else{
	640	pDC->FillRect(&rect1, &br0);
	641	}
	642	}
	643	return 0;
	644	}
	645
	646	int CMTerm1View::DrawCellStat2(CDC* pDC, int x1, int y1, int sizex, int sizey, int nStat)
	647	{
	648	// TODO: 在此处添加实现代码.
	649	CRect rect1;
	650	rect1.left = x1;
	651	rect1.top = y1;
	652	rect1.right = x1+sizex;
	653	rect1.bottom = y1+sizey;
	654	CBrush br2(TraceBkColor);
	655	CBrush br3(TraceColor);
	656	if (m_bMonitoring) {
	657	if (nStat) {
	658	pDC->FillRect(&rect1, &br3);
	659	}else{
	660	pDC->FillRect(&rect1, &br2);
	661	}
	662	}
	663	return 0;
	664	}
	665
	666	int CMTerm1View::DrawCellText1(CDC* pDC, CString sText, int x1, int y1, int sizex, int sizey, int nFormat)
	667	{
	668	// TODO: 在此处添加实现代码.
	669	CRect rect1;
	670	rect1.left = x1;
	671	rect1.top = y1;
	672	rect1.right = rect1.left + sizex;
	673	rect1.bottom = rect1.top + sizey;
	674	pDC->DrawText(sText, &rect1, nFormat);
	675	return 0;
	676	}
	677
	678	int CMTerm1View::DrawCellText2(CDC* pDC, CString sText, int x1, int y1, int sizex, int sizey, int nFormat, int nTextColor)
	679	{
	680	// TODO: 在此处添加实现代码.
	681	COLORREF clrOld = pDC->SetTextColor(nTextColor);
	682	CRect rect1;
	683	rect1.left = x1;
	684	rect1.top = y1;
	685	rect1.right = rect1.left + sizex;
	686	rect1.bottom = rect1.top + sizey;
	687	pDC->DrawText(sText, &rect1, nFormat);
	688	pDC->SetTextColor(clrOld);
	689	return 0;
	690	}
	691
	692	int CMTerm1View::DrawCellAnno(CDC * pDC, int nRow, int nCol, CString sAnno)
	693	{
	694	// TODO: 在此处添加实现代码.
	695	if (!m_bShowComments) return 0;
	696	if (!needReDraw) return 0;
	697	CMTerm1Doc * pDoc = GetDocument();
	698	int x0, y0;
	699	int CellTotalHeight = m_CellHeight + (m_bShowComments ? m_CommentHeight : 0);
	700	x0 = m_LeftMargin + 1 + m_CellWidth * nCol;
	701	y0 = m_TopMargin + CellTotalHeight * nRow;
	702
	703	int nType, nAddr;
	704	nType = Cells[nRow][nCol].nDataType;
	705	nAddr = Cells[nRow][nCol].nDataAddr;
	706	CString s1;
	707	if (pDoc->GetAnno(nType, nAddr, s1)) {
	708	CFont *pOldFont;
	709	pOldFont = (CFont *)pDC->SelectObject(&AnnoFont);
	710	DrawCellText2(pDC, s1, x0 + 2, y0 + m_LinePosY + 6, m_CellWidth-10, 32, DT_WORDBREAK, AnnoColor);
	711	pDC->SelectObject(pOldFont);
	712	}
	713	return 0;
	714	}
	715
	716	void CMTerm1View::DrawCell(CDC* pDC, int nRow, int nCol)
	717	{
	718
	719	//CMTerm1Doc * pDoc= GetDocument();
	720	int x0, y0;
	721	int x1, y1, x2, y2;
	722	RECT rect1;
	723	int CellTotalHeight = m_CellHeight + (m_bShowComments ? m_CommentHeight : 0);
	724
	725	rect1.left = m_LeftMargin + 1 + m_CellWidth * nCol;
d34256	726	rect1.right = rect1.left + m_CellWidth;
418cb3	727	rect1.top = m_TopMargin + CellTotalHeight * nRow;
Q	728	rect1.bottom = rect1.top + CellTotalHeight;
	729
	730	x0 = rect1.left;
	731	y0 = rect1.top;
	732
	733	CString s1;
	734	// pDC->DrawFocusRect(&rect1);
	735	if (Cells[nRow][nCol].bLeftLineUp && nCol !=0)
	736	{
	737	if (needReDraw) {
	738	pDC->MoveTo(x0, y0);
	739	pDC->LineTo(x0, y0 + m_LinePosY);
ad1b4b	740	//画直竖线
Z	741	//pDC->MoveTo(x0, y0 + (0.32 * CellTotalHeight));
	742	//pDC->LineTo(x0, y0 - (0.69 * CellTotalHeight));
418cb3	743	}
Q	744	}
	745	if (Cells[nRow][nCol].bLeftLineDn && nCol != 0)
	746	{
	747	if (needReDraw) {
	748	pDC->MoveTo(x0, y0 + m_LinePosY);
	749	pDC->LineTo(x0, y0 + CellTotalHeight);
	750	}
	751	}
	752	int nType = Cells[nRow][nCol].nType;
	753	if (nType == typeNone)
	754	{
	755
	756	}
	757	else if (nType == typeLine1)
	758	{ //Draw Line
	759	//画直横线
	760	if (needReDraw) {
	761	pDC->MoveTo(x0, y0 + m_LinePosY);
	762	pDC->LineTo(x0 + m_CellWidth, y0 + m_LinePosY);
	763	}
	764	}
	765	else if (nType == typeLine2)
	766	{ //Draw Line
ad1b4b	767	//画直竖线
Z	768	pDC->MoveTo(x0, y0 + (0.32 * CellTotalHeight));
	769	pDC->LineTo(x0, y0 - (0.69 * CellTotalHeight));
418cb3	770	}
Q	771	else if (nType == typeNO)
	772	{
	773	// Draw Coil
	774	if (needReDraw) {
	775	DrawRelay(pDC, x0, y0);
	776	//显示文字
	777	DrawCellText1(pDC, Cells[nRow][nCol].sCoilName, x0 + 2, y0, m_CellWidth, 14);
	778	DrawCellAnno(pDC, nRow, nCol, _T(""));
	779	}
	780	if (m_bMonitoring){
	781	//Draw Stat
	782	DrawCellStat1(pDC, x0 + 16 + 2, y0 + m_LinePosY - 6, 8, 12, Cells[nRow][nCol].nStat);
	783	// tracing
	784	DrawCellStat2(pDC, x0 + 16 + 2 + 10 + 4, y0 + m_LinePosY - 4, 4, 4, Cells[nRow][nCol].nTrace);
	785	}
	786	}
	787	else if (nType == typeNC)
	788	{
	789	if (needReDraw) {
	790	DrawRelay(pDC, x0, y0);
	791	//显示文字
	792	DrawCellText1(pDC, Cells[nRow][nCol].sCoilName, x0 + 2, y0, m_CellWidth, 14);
	793	DrawCellAnno(pDC, nRow, nCol, _T(""));
	794	//画常闭斜线
	795	x1 = x0 + 16 + 12 - 3;
	796	y1 = y0 + m_LinePosY - 6;
	797	x2 = x0 + 16 + 2;
	798	y2 = y1 + 12;
	799	pDC->MoveTo(x1, y1);
	800	pDC->LineTo(x2, y2);
	801	}
	802	if (m_bMonitoring)
	803	{
	804	//Draw Stat
	805	DrawCellStat1(pDC, x0 + 16 + 2, y0 + m_LinePosY - 6, 8, 12, ! Cells[nRow][nCol].nStat);
	806	// tracing
	807	DrawCellStat2(pDC, x0 + 16 + 2 + 10 + 4, y0 + m_LinePosY - 4, 4, 4, Cells[nRow][nCol].nTrace);
	808	//画常闭斜线
	809	x1 = x0 + 16 + 12 - 3;
	810	y1 = y0 + m_LinePosY - 6;
	811	x2 = x0 + 16 + 2;
	812	y2 = y1 + 12;
	813	pDC->MoveTo(x1, y1);
	814	pDC->LineTo(x2, y2);
	815	}
	816	}
	817	else if (nType == typePP)
	818	{
	819	if (needReDraw) {
	820	DrawRelay(pDC, x0, y0);
	821	//画上升沿箭头
	822	x1 = x0 + 16 + 6;
	823	y1 = y0 + m_LinePosY - 5;
	824	x2 = x1;
	825	y2 = y1 + 10;
	826	pDC->MoveTo(x1, y1);
	827	pDC->LineTo(x2, y2);
	828	//*
	829	x2 = x1 - 3;
	830	y2 = y1 + 4;
	831	pDC->MoveTo(x1, y1);
	832	pDC->LineTo(x2, y2);
	833	x2 = x1 + 3;
	834	y2 = y1 + 4;
	835	pDC->MoveTo(x1, y1);
	836	pDC->LineTo(x2, y2);
	837	//*/
	838	//显示文字
	839	DrawCellText1(pDC, Cells[nRow][nCol].sCoilName, x0 + 2, y0, m_CellWidth, 14);
	840	DrawCellAnno(pDC, nRow, nCol, _T(""));
	841	}
	842	}
	843	else if (nType == typePN)
	844	{
	845	if (needReDraw) {
	846	DrawRelay(pDC, x0, y0);
	847	//画下降沿箭头
	848	x1 = x0 + 16 + 6;
	849	y1 = y0 + m_LinePosY + 5;
	850	x2 = x1;
	851	y2 = y1 - 10;
	852	pDC->MoveTo(x1, y1);
	853	pDC->LineTo(x2, y2);
	854	//*
	855	x2 = x1 - 3;
	856	y2 = y1 - 3;
	857	pDC->MoveTo(x1, y1);
	858	pDC->LineTo(x2, y2);
	859
	860	x2 = x1 + 3;
	861	y2 = y1 - 3;
	862	pDC->MoveTo(x1, y1);
	863	pDC->LineTo(x2, y2);
	864	//*/
	865	//显示文字
	866	DrawCellText1(pDC, Cells[nRow][nCol].sCoilName, x0 + 2, y0, m_CellWidth, 14);
	867	DrawCellAnno(pDC, nRow, nCol, _T(""));
	868	}
	869	}
	870	else if (nType == typeNOT) {
	871	if (needReDraw) {
	872	DrawLeftRightLine(pDC, x0, y0);
	873	//画常闭斜线
	874	x1 = x0 + 16 + 12 - 3;
	875	y1 = y0 + m_LinePosY - 6;
	876	x2 = x0 + 16 + 2;
	877	y2 = y1 + 12;
	878	pDC->MoveTo(x1, y1);
	879	pDC->LineTo(x2, y2);
	880	//显示文字
	881	// DrawCellText1(pDC, Cells[nRow][nCol].sCoilName, x0 + 2, y0, m_CellWidth, 14);
	882	}
	883	}
	884	else if (nType == typeDF) {
	885	if (needReDraw) {
	886	// DrawLeftRightLine(pDC, x0, y0);
	887	DrawAngleBracket(pDC, x0, y0, 8, 32);
	888	//显示文字
	889	DrawCellText1(pDC, Cells[nRow][nCol].sCoilName, x0 + 16, y0 + m_LinePosY - 8, 16, 14);
	890	}
	891	}
	892	else if (nType == typeDF_) {
	893	if (needReDraw) {
	894	// DrawLeftRightLine(pDC, x0, y0);
	895	DrawAngleBracket(pDC, x0, y0, 8, 40);
	896	//显示文字
	897	DrawCellText1(pDC, Cells[nRow][nCol].sCoilName, x0 + 16, y0 + m_LinePosY - 8, 24, 14);
	898	}
	899	}
	900	else if (nType == typeOUT) {
	901	if (needReDraw) {
	902	//显示外形
	903	DrawOT(pDC, x0, y0);
	904	//显示文字
	905	DrawCellText1(pDC, Cells[nRow][nCol].sCoilName, x0 + 2, y0, m_CellWidth, 14);
	906	DrawCellAnno(pDC, nRow, nCol, _T(""));
	907	}
	908	if (m_bMonitoring) {
	909	//Draw Stat
	910	DrawCellStat1(pDC, x0 + 16 + 2, y0 + m_LinePosY - 6, 8, 12, Cells[nRow][nCol].nStat);
	911	}
	912	}
	913	else if (nType == typeSET) {
	914
	915	if (needReDraw) {
	916	//画左侧横线
	917	//DrawLeftRightLine(pDC, x0, y0, 14, 18);
	918	DrawAngleBracket(pDC, x0, y0, 8, 32);
	919	DrawCellText1(pDC, _T("S"), x0 + 18, y0 + m_LinePosY - 8, 8, 14);
	920	//显示文字
	921	DrawCellText1(pDC, Cells[nRow][nCol].sCoilName, x0 + 2, y0, m_CellWidth, 14);
	922	DrawCellAnno(pDC, nRow, nCol, _T(""));
	923	}
	924	if (m_bMonitoring) {
	925	//Draw Stat
	926	DrawCellStat1(pDC, x0 + 14, y0 + m_LinePosY - 8, 16, 16, Cells[nRow][nCol].nStat);
	927	DrawCellText1(pDC, _T("S"), x0 + 18, y0 + m_LinePosY - 8, 8, 14);
	928	}
	929
	930	}
	931	else if (nType == typeRESET) {
	932	if (needReDraw) {
	933	//画左右侧横线
	934	//DrawLeftRightLine(pDC, x0, y0, 14, 18);
	935	DrawAngleBracket(pDC, x0, y0, 8, 32);
	936	DrawCellText1(pDC, _T("R"), x0 + 17, y0 + m_LinePosY - 8, 9, 14);
	937	//显示文字
	938	DrawCellText1(pDC, Cells[nRow][nCol].sCoilName, x0 + 2, y0, m_CellWidth, 14);
	939	DrawCellAnno(pDC, nRow, nCol, _T(""));
	940	}
	941	if (m_bMonitoring) {
	942	//Draw Stat
	943	DrawCellStat1(pDC, x0 + 14, y0 + m_LinePosY - 8, 16, 16, Cells[nRow][nCol].nStat);
	944	DrawCellText1(pDC, _T("R"), x0 + 17, y0 + m_LinePosY - 8, 9, 14);
	945	}
	946	}
	947	else if (nType == typeCMP) {
	948	if (needReDraw) {
	949	// 画中括号
	950	DrawBracket(pDC, x0, y0, m_CellWidth * 3);
	951	//显示文字
	952	DrawCellText1(pDC, Cells[nRow][nCol].sCoilName, x0 + 12, y0, m_CellWidth, 14);
	953	DrawCellText1(pDC, Cells[nRow][nCol + 1].sParam, x0 + m_CellWidth + 2, y0, m_CellWidth, 14);
	954	DrawCellText1(pDC, Cells[nRow][nCol + 2].sParam, x0 + m_CellWidth * 2 + 2, y0, m_CellWidth, 14);
	955	DrawCellAnno(pDC, nRow, nCol + 1, _T(""));
	956	DrawCellAnno(pDC, nRow, nCol + 2, _T(""));
	957	}
	958	if (m_bMonitoring) {
	959	s1.Format(_T(" %d"), Cells[nRow][nCol + 1].nStat);
	960	DrawCellText2(pDC, s1,x0+m_CellWidth+2,y0+m_LinePosY-6,m_CellWidth-10,14,DT_RIGHT, MonTextColor);
	961	s1.Format(_T(" %d"), Cells[nRow][nCol + 2].nStat);
	962	DrawCellText2(pDC, s1, x0 + m_CellWidth*2 + 2, y0 + m_LinePosY - 6, m_CellWidth - 10, 14, DT_RIGHT, MonTextColor);
	963	// tracing
	964	DrawCellStat2(pDC, x0 + m_CellWidth * 3 - 4, y0 + m_LinePosY - 8, 4, 4, Cells[nRow][nCol].nTrace);
	965	}
	966	}
	967	else if (nType == typeTM) {
	968	if (needReDraw) {
	969	// 画中括号
	970	DrawBracket(pDC, x0, y0, m_CellWidth * 3);
	971	//显示文字
	972	DrawCellText1(pDC, Cells[nRow][nCol].sCoilName, x0 + 12, y0, m_CellWidth, 14);
	973	DrawCellText1(pDC, Cells[nRow][nCol + 1].sParam, x0 + m_CellWidth + 2, y0, m_CellWidth, 14);
	974	DrawCellText1(pDC, Cells[nRow][nCol + 2].sParam, x0 + m_CellWidth * 2 + 2, y0, m_CellWidth, 14);
	975	DrawCellAnno(pDC, nRow, nCol, _T(""));
	976	DrawCellAnno(pDC, nRow, nCol + 1, _T(""));
	977	DrawCellAnno(pDC, nRow, nCol + 2, _T(""));
	978	}
	979	if (m_bMonitoring) {
	980	s1.Format(_T(" %d"), Cells[nRow][nCol + 1].nStat);
	981	DrawCellText2(pDC, s1, x0 + m_CellWidth + 2, y0 + m_LinePosY - 6, m_CellWidth - 10, 14, DT_RIGHT, MonTextColor);
	982	s1.Format(_T(" %d"), Cells[nRow][nCol + 2].nStat);
	983	DrawCellText2(pDC, s1, x0 + m_CellWidth * 2 + 2, y0 + m_LinePosY - 6, m_CellWidth - 10, 14, DT_RIGHT, MonTextColor);
	984	// tracing
	985	DrawCellStat2(pDC, x0 + m_CellWidth * 3 - 4, y0 + m_LinePosY - 8, 4, 4, Cells[nRow][nCol].nTrace);
	986	}
	987	}
	988	else if (nType == typeFN1) {
	989	if (needReDraw) {
	990
	991	// 画中括号
	992	DrawBracket(pDC, x0, y0, m_CellWidth * 2, m_LinePosY - 8, 16);
	993	//显示文字
	994	DrawCellText1(pDC, Cells[nRow][nCol].sCoilName, x0 + 12, y0 + m_LinePosY - 6, m_CellWidth, 14);
	995	DrawCellText1(pDC, Cells[nRow][nCol + 1].sParam, x0 + m_CellWidth + 2, y0 + m_LinePosY - 6, m_CellWidth, 14);
	996	DrawCellAnno(pDC, nRow, nCol + 1, _T(""));
	997	}
	998	if (m_bMonitoring) {
	999
	1000	s1.Format(_T(" %d"), Cells[nRow][nCol + 1].nStat);
	1001	DrawCellText2(pDC, s1, x0 + m_CellWidth + 2, y0 , m_CellWidth - 10, 14, DT_RIGHT, MonTextColor);
	1002	// tracing
	1003	DrawCellStat2(pDC, x0 + m_CellWidth * 2 - 4, y0 + m_LinePosY - 8, 4, 4, Cells[nRow][nCol].nTrace);
	1004	}
	1005	}
	1006	else if (nType == typeFN2) {
	1007	if (needReDraw) {
	1008	// 画中括号
	1009	DrawBracket(pDC, x0, y0, m_CellWidth * 3, m_LinePosY - 8, 16);
	1010	//显示文字
	1011	DrawCellText1(pDC, Cells[nRow][nCol].sCoilName, x0 + 12, y0 + m_LinePosY - 6, m_CellWidth, 14);
	1012	DrawCellText1(pDC, Cells[nRow][nCol + 1].sParam, x0 + m_CellWidth + 2, y0 + m_LinePosY - 6, m_CellWidth, 14);
	1013	DrawCellText1(pDC, Cells[nRow][nCol + 2].sParam, x0 + m_CellWidth * 2 + 2, y0 + m_LinePosY - 6, m_CellWidth, 14);
	1014	DrawCellAnno(pDC, nRow, nCol + 1, _T(""));
	1015	DrawCellAnno(pDC, nRow, nCol + 2, _T(""));
	1016	}
	1017	if (m_bMonitoring) {
	1018	s1.Format(_T(" %d"), Cells[nRow][nCol + 1].nStat);
	1019	DrawCellText2(pDC, s1, x0 + m_CellWidth + 2, y0, m_CellWidth - 10, 14, DT_RIGHT, MonTextColor);
	1020	s1.Format(_T(" %d"), Cells[nRow][nCol + 2].nStat);
	1021	DrawCellText2(pDC, s1, x0 + m_CellWidth * 2 + 2, y0, m_CellWidth - 10, 14, DT_RIGHT, MonTextColor);
	1022	// tracing
	1023	DrawCellStat2(pDC, x0 + m_CellWidth * 3 - 4, y0 + m_LinePosY - 8, 4, 4, Cells[nRow][nCol].nTrace);
	1024	}
	1025	}
	1026	else if (nType == typeFN3) {
	1027	if (needReDraw) {
	1028	// 画中括号
	1029	DrawBracket(pDC, x0, y0, m_CellWidth * 4, m_LinePosY - 8, 16);
	1030	//显示文字
	1031	DrawCellText1(pDC, Cells[nRow][nCol].sCoilName, x0 + 12, y0 + m_LinePosY - 6, m_CellWidth, 14);
	1032	DrawCellText1(pDC, Cells[nRow][nCol + 1].sParam, x0 + m_CellWidth + 2, y0 + m_LinePosY - 6, m_CellWidth, 14);
	1033	DrawCellText1(pDC, Cells[nRow][nCol + 2].sParam, x0 + m_CellWidth * 2 + 2, y0 + m_LinePosY - 6, m_CellWidth, 14);
	1034	DrawCellText1(pDC, Cells[nRow][nCol + 3].sParam, x0 + m_CellWidth * 3 + 2, y0 + m_LinePosY - 6, m_CellWidth, 14);
	1035	DrawCellAnno(pDC, nRow, nCol + 1, _T(""));
	1036	DrawCellAnno(pDC, nRow, nCol + 2, _T(""));
	1037	DrawCellAnno(pDC, nRow, nCol + 3, _T(""));
	1038	}
	1039	if (m_bMonitoring) {
	1040	s1.Format(_T(" %d"), Cells[nRow][nCol + 1].nStat);
	1041	DrawCellText2(pDC, s1, x0 + m_CellWidth + 2, y0, m_CellWidth - 10, 14, DT_RIGHT, MonTextColor);
	1042	s1.Format(_T(" %d"), Cells[nRow][nCol + 2].nStat);
	1043	DrawCellText2(pDC, s1, x0 + m_CellWidth * 2 + 2, y0, m_CellWidth - 10, 14, DT_RIGHT, MonTextColor);
	1044	s1.Format(_T(" %d"), Cells[nRow][nCol + 3].nStat);
	1045	DrawCellText2(pDC, s1, x0 + m_CellWidth * 3 + 2, y0, m_CellWidth - 10, 14, DT_RIGHT, MonTextColor);
	1046	// tracing
	1047	DrawCellStat2(pDC, x0 + m_CellWidth * 4 - 4, y0 + m_LinePosY - 8, 4, 4, Cells[nRow][nCol].nTrace);
	1048	}
	1049	}
	1050	else
	1051	{
	1052	}
	1053	}
0ed438	1054
Q	1055	// CMTerm1View 消息处理程序
418cb3	1056
Q	1057	void CMTerm1View::OnUpdate(CView* /pSender/, LPARAM lHint, CObject* /pHint/)
	1058	{
	1059	// TODO: 在此添加专用代码和/或调用基类
	1060	//初始化 cell 内容
	1061	if (lHint == 0 \|\| lHint == 1)
	1062	{
	1063	TransProgToLDS();
	1064	CRect rect0;
	1065	this->GetClientRect(&rect0);
	1066
	1067	int CellTotalHeight = m_CellHeight + (m_bShowComments ? m_CommentHeight : 0);
	1068
	1069	CSize sizeTotal;
	1070	// TODO: 计算此视图的合计大小
	1071	sizeTotal.cx = m_LeftMargin + m_CellWidth * m_CellPerLine + m_CellWidth * 2;
	1072	sizeTotal.cy = m_TopMargin + CellTotalHeight * (m_nTotalRow - 1) + rect0.Height();
	1073	SetScrollSizes(MM_TEXT, sizeTotal);
	1074	needReDraw = 1;
	1075	this->RedrawWindow();
	1076	}
	1077	else if (lHint == 2) {
	1078	UpdateStatusBar();
	1079	}
	1080
	1081	}
	1082
	1083	BOOL CMTerm1View::OnEraseBkgnd(CDC* pDC)
	1084	{
	1085	// TODO: 在此添加消息处理程序代码和/或调用默认值
	1086	return true;
	1087	return CScrollView::OnEraseBkgnd(pDC);
	1088	}
	1089
	1090	void CMTerm1View::OnSize(UINT nType, int cx, int cy)
	1091	{
	1092	CScrollView::OnSize(nType, cx, cy);
	1093	// CString s1;
	1094	// s1.Format(_T("OnSize %d %d %d"), nType, cx, cy);
	1095	// DbgLog(s1);
	1096
	1097	if (this->IsWindowVisible())
	1098	{
	1099	CRect rect0;
	1100	this->GetClientRect(&rect0);
	1101
	1102	int CellTotalHeight = m_CellHeight + (m_bShowComments ? m_CommentHeight : 0);
	1103
	1104	CSize sizeTotal;
	1105	// TODO: 计算此视图的合计大小
	1106	sizeTotal.cx = m_LeftMargin + m_CellWidth * m_CellPerLine + m_CellWidth * 2;
	1107	sizeTotal.cy = m_TopMargin + CellTotalHeight * (m_nTotalRow - 1) + rect0.Height();
	1108	SetScrollSizes(MM_TEXT, sizeTotal);
	1109	needReDraw = 1;
	1110	this->RedrawWindow();
	1111	}
	1112
	1113	needReDraw = 1;
	1114	// TODO: 在此处添加消息处理程序代码
	1115	}
	1116
	1117	BOOL CMTerm1View::OnScrollBy(CSize sizeScroll, BOOL bDoScroll)
	1118	{
	1119	// TODO: 在此添加专用代码和/或调用基类
	1120	needReDraw = 1;
	1121	return CScrollView::OnScrollBy(sizeScroll, bDoScroll);
	1122	}
	1123
	1124	void CMTerm1View::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
	1125	{
	1126	// TODO: 在此添加消息处理程序代码和/或调用默认值
	1127	CString s1;
	1128	// s1.Format(_T("KeyDown %d %d %d"), nChar, nRepCnt, nFlags);
	1129	// DbgLog(s1);
	1130	int CellTotalHeight = m_CellHeight + (m_bShowComments ? m_CommentHeight : 0);
	1131
	1132	CRect rect0;
	1133	this->GetClientRect(&rect0);
	1134	int viewWidth = rect0.Width();
	1135	CPoint scroll1;
	1136	scroll1 = this->GetScrollPosition();
	1137
	1138	int nFirstVisibleLine;
	1139	int nLastVisibleLine;
	1140	int nLinesinView;
	1141	nFirstVisibleLine = (scroll1.y - m_TopMargin) / CellTotalHeight;
	1142	nLastVisibleLine = (rect0.Height() + scroll1.y - m_TopMargin) / CellTotalHeight + 1;
	1143	if (nFirstVisibleLine < 0) { nFirstVisibleLine = 0; }
	1144	if (nLastVisibleLine < 0) { nLastVisibleLine = 0; }
	1145	nLinesinView = nLastVisibleLine - 1 - nFirstVisibleLine;
	1146	int nRow, nCol;
	1147	nRow = m_FocusRow;
	1148	nCol = m_FocusCol;
	1149	if (nChar == VK_LEFT) {
	1150	nCol -= 1;
	1151	if (nCol < 0) {
	1152	if (nRow > 0) {
	1153	nRow -= 1; nCol += m_CellPerLine;
	1154	}else {
	1155	nCol = 0;
	1156	}
	1157	}
	1158	}
	1159	if (nChar == VK_RIGHT) {
	1160	nCol += 1;
	1161	if (nCol >= m_CellPerLine) {
	1162	if (nRow < m_nTotalRow + nLinesinView - 1 ) {
	1163	nCol -= m_CellPerLine;
	1164	nRow += 1;
	1165	}
	1166	else {
	1167	nCol = m_CellPerLine - 1;
	1168	}
	1169	}
	1170	}
	1171	if (nChar == VK_UP) {
	1172	nRow -= 1;
	1173	if (nRow < 0) { nRow = 0; }
	1174	}
	1175	if (nChar == VK_DOWN) {
	1176	nRow += 1;
	1177	if (nRow >= m_nTotalRow + nLinesinView) { nRow = m_nTotalRow + nLinesinView -1; }
	1178
	1179	}
	1180	m_FocusRow = nRow;
	1181	m_FocusCol = nCol;
	1182	if (Cells[nRow][nCol].nType) {
	1183	m_nCurProgStep = Cells[nRow][nCol].nProgStep;
	1184	}
	1185
	1186	if (nRow < nFirstVisibleLine) {
	1187	scroll1.y -= CellTotalHeight;
	1188	ScrollToPosition(scroll1);
	1189	}
	1190	if (nRow > 0 && nRow >= nLastVisibleLine - 1 ) {
	1191	scroll1.y += CellTotalHeight;
	1192	ScrollToPosition(scroll1);
	1193	}
	1194
	1195	// DrawFocusRect();
	1196	GetDocument()->UpdateAllViews(this, m_FocusCol);
	1197	needReDraw = 1;
	1198	this->RedrawWindow();
	1199	UpdateStatusBar();
	1200
	1201	CScrollView::OnKeyDown(nChar, nRepCnt, nFlags);
	1202	}
d34256	1203
Z	1204	/// <summary>
	1205	/// 单元格焦点变化*选中点变化
	1206	/// </summary>
	1207	/// <param name="nRow"></param>
	1208	/// <param name="nCol"></param>
	1209	/// <returns></returns>
df0321	1210	int CMTerm1View::CellFocusChg(int nRow, int nCol)
Q	1211	{
	1212	CString s1;
	1213	stCell & thecell = Cells[nRow][nCol];
	1214	s1.Format(_T("Cell %d %d Type %02X \r\n"), nRow, nCol, thecell.nType);
	1215	s1.AppendFormat(_T(" sCoilName %s sParam %s \r\n"), thecell.sCoilName, thecell.sParam );
	1216	s1.AppendFormat(_T("LeftUp %d leftDn %d "), thecell.bLeftLineUp, thecell.bLeftLineDn);
	1217	DbgLog(s1);
	1218
	1219	auto p1 = (CMainFrame*)AfxGetMainWnd();
	1220	auto p2 = p1->GetInputWnd();
ad1b4b	1221	p2->SetCurCellPos(nRow,nCol,thecell);
Z	1222	p2->focusCell = thecell;
df0321	1223	return 0;
Q	1224	}
ad1b4b	1225	//鼠标左键点击事件
418cb3	1226	void CMTerm1View::OnLButtonDown(UINT nFlags, CPoint point)
Q	1227	{
	1228	// TODO: 在此添加消息处理程序代码和/或调用默认值
	1229	CString s1;
	1230	CPoint scroll1;
	1231	scroll1 = this->GetScrollPosition();
	1232	int tx, ty;
	1233	tx = point.x + scroll1.x;
	1234	ty = point.y + scroll1.y;
	1235	int nRow, nCol;
	1236	int CellTotalHeight = m_CellHeight + (m_bShowComments ? m_CommentHeight : 0);
	1237	nRow = (ty - m_TopMargin) / CellTotalHeight;
	1238	nCol = (tx - m_LeftMargin) / m_CellWidth;
d34256	1239	if (nRow < 0)
Z	1240	{
	1241	nRow = 0;
	1242	}
	1243	if (nCol < 0)
	1244	{
	1245	nCol = 0;
	1246	}
	1247	if (nCol >= m_CellPerLine)
	1248	{
	1249	nCol = m_CellPerLine - 1;
	1250	}
	1251	s1.Format(_T("OnLButtonDown::zxd:: LD %d %d %02X Scroll %d %d Total %d %d Row %d Col %d"), point.x, point.y, nFlags, scroll1.x, scroll1.y, tx, ty, nRow, nCol);
	1252	DbgLog(s1);//zxd add to test
	1253
418cb3	1254	m_pStatusBar->SetPaneText(6, s1);
Q	1255	m_FocusRow = nRow;
	1256	m_FocusCol = nCol;
	1257	if (Cells[nRow][nCol].nType) {
	1258	m_nCurProgStep = Cells[nRow][nCol].nProgStep;
	1259	}
	1260
	1261	// DrawFocusRect();
df0321	1262	CellFocusChg(nRow, nCol);
418cb3	1263	GetDocument()->UpdateAllViews(this, m_FocusCol);
Q	1264	needReDraw = 1;
	1265	this->RedrawWindow();
	1266	UpdateStatusBar();
	1267	// m_pStatusBar->Set
	1268	CScrollView::OnLButtonDown(nFlags, point);
	1269	}
	1270
	1271	void CMTerm1View::OnLButtonUp(UINT nFlags, CPoint point)
	1272	{
	1273	// TODO: 在此添加消息处理程序代码和/或调用默认值
	1274
	1275	CScrollView::OnLButtonUp(nFlags, point);
	1276	}
	1277
	1278	void CMTerm1View::OnLButtonDblClk(UINT nFlags, CPoint point)
	1279	{
	1280	// TODO: 在此添加消息处理程序代码和/或调用默认值
	1281	CString s1;
	1282	CMTerm1Doc * pDoc = (CMTerm1Doc*)GetDocument();
	1283	CPoint scroll1;
	1284	scroll1 = this->GetScrollPosition();
	1285	int tx, ty;
	1286	tx = point.x + scroll1.x;
	1287	ty = point.y + scroll1.y;
	1288
	1289	int CellTotalHeight = m_CellHeight + (m_bShowComments ? m_CommentHeight : 0);
	1290	int nRow = (ty - m_TopMargin) / CellTotalHeight;
	1291	int nCol = (tx - m_LeftMargin) / m_CellWidth;
	1292
	1293	if (nRow < 0) { nRow = 0; }
	1294	if (nCol < 0) { nCol = 0; }
	1295	if (nCol >= m_CellPerLine) { nCol = m_CellPerLine - 1; }
	1296	s1.Format(_T("LD db Clk %d %d %02X Scroll %d %d Total %d %d Row %d Col %d"),
	1297	point.x, point.y, nFlags, scroll1.x, scroll1.y, tx, ty, nRow, nCol);
	1298	m_pStatusBar->SetPaneText(6, s1);
	1299	m_pStatusBar->SetPaneBackgroundColor(6, RGB(255, 255, 0));
	1300	m_pStatusBar->SetPaneTextColor(6, RGB(0, 0, 255));
	1301	m_pStatusBar->EnablePaneProgressBar(6);
	1302	m_pStatusBar->SetPaneProgress(6, 5);
	1303	SysLog(s1);
	1304
	1305	m_FocusRow = nRow;
	1306	m_FocusCol = nCol;
	1307	if (Cells[nRow][nCol].nType) {
	1308	m_nCurProgStep = Cells[nRow][nCol].nProgStep;
	1309	}
	1310	if (!pDoc->m_bOnline) return;
	1311	//if (!m_bMonitoring) return;
	1312
	1313	CString sParam;
	1314	sParam = Cells[nRow][nCol].sParam;
	1315	int nDataType, nDataAddr, nStat;
	1316	nDataType = Cells[nRow][nCol].nDataType;
	1317	nDataAddr = Cells[nRow][nCol].nDataAddr;
	1318	nStat = Cells[nRow][nCol].nStat;
	1319
	1320	s1.Format(_T("Name %s DataType %d DataAddr %d Stat %d"),
	1321	sParam, nDataType, nDataAddr, nStat);
	1322	SysLog(s1);
	1323	if (Cells[m_FocusRow][m_FocusCol].sParam == _T("")) {
	1324	return;
	1325	}
	1326	needReDraw = 1;
	1327	if ((nDataType&TYPEDATA) == TYPEDATA) {
	1328	CDialogSetData dialog2;
	1329
	1330	dialog2.m_strAddr = sParam;
	1331	dialog2.m_nStat = nStat;
	1332
	1333	INT_PTR r = dialog2.DoModal();
	1334	if (r == IDOK)
	1335	{
	1336	int s = dialog2.m_nStat;
	1337	///
	1338	pDoc->SetVarData(nDataType, nDataAddr, s);
	1339	//Cells[nRow][nCol].nStat = s;
	1340	s1.Format(_T("Set Data %s as %d "), sParam, s);
	1341	SysLog(s1);
	1342	this->RedrawWindow();
	1343	}
	1344	}
	1345	else {
	1346	CDialogSetCoil dialog1;
	1347
	1348	dialog1.m_strAddr = sParam;
	1349	dialog1.m_nStat = nStat;
	1350
	1351	INT_PTR r = dialog1.DoModal();
	1352	if (r == IDOK)
	1353	{
	1354	int s = dialog1.m_nStat;
	1355	///
	1356	pDoc->SetCoilValue(nDataType, nDataAddr, s);
	1357	// Cells[nRow][nCol].nStat = nStat;
	1358
	1359	// Cells[m_FocusRow][m_FocusCol].nStat = s;
	1360	// s1.Format(_T("Set Coild %s as %d "), sParam, s);
	1361	// AfxMessageBox(s1);
	1362	this->RedrawWindow();
	1363	}
	1364	}
	1365	CScrollView::OnLButtonDblClk(nFlags, point);
	1366	}
	1367
	1368	void CMTerm1View::OnRButtonDown(UINT nFlags, CPoint point)
	1369	{
	1370	// TODO: 在此添加消息处理程序代码和/或调用默认值
	1371	CString s1;
	1372	CPoint scroll1;
	1373	scroll1 = this->GetScrollPosition();
	1374	int tx, ty;
	1375	tx = point.x + scroll1.x;
	1376	ty = point.y + scroll1.y;
	1377
	1378	int nRow, nCol;
	1379	int CellTotalHeight = m_CellHeight + (m_bShowComments ? m_CommentHeight : 0);
	1380	nRow = (ty- m_TopMargin )/ CellTotalHeight;
	1381	nCol = (tx - m_LeftMargin) / m_CellWidth;
	1382
	1383	if (nRow < 0) { nRow = 0; }
	1384	if (nCol < 0) { nCol = 0; }
	1385	if (nCol >= m_CellPerLine) { nCol = m_CellPerLine - 1; }
	1386	s1.Format(_T("RD %d %d %02X Scroll %d %d Total %d %d Row %d Col %d"), point.x, point.y, nFlags, scroll1.x, scroll1.y, tx, ty, m_FocusRow, m_FocusCol);
	1387	m_pStatusBar->SetPaneText(6, s1);
	1388	m_FocusRow = nRow;
	1389	m_FocusCol = nCol;
	1390	// DrawFocusRect();
	1391	GetDocument()->UpdateAllViews(this, m_FocusCol);
	1392	needReDraw = 1;
	1393	this->RedrawWindow();
	1394
	1395	CScrollView::OnRButtonDown(nFlags, point);
	1396	}
	1397
	1398	void CMTerm1View::OnRButtonUp(UINT nFlags, CPoint point)
	1399	{
	1400	// TODO: 在此添加消息处理程序代码和/或调用默认值
	1401	//CContextMenuManager
	1402	CScrollView::OnRButtonUp(nFlags, point);
	1403	}
	1404
	1405	void CMTerm1View::OnContextMenu(CWnd* /pWnd/, CPoint point)
	1406	{
	1407	// TODO: 在此处添加消息处理程序代码
	1408	CMenu menu1;
	1409	menu1.LoadMenu(IDR_MENU1);
	1410	CMenu *pContextMenu = menu1.GetSubMenu(0);
	1411	pContextMenu->TrackPopupMenu(TPM_LEFTALIGN \| TPM_RIGHTBUTTON, point.x, point.y, this);
	1412	}
	1413
	1414	void CMTerm1View::OnInitMenuPopup(CMenu* pPopupMenu, UINT nIndex, BOOL bSysMenu)
	1415	{
	1416	CScrollView::OnInitMenuPopup(pPopupMenu, nIndex, bSysMenu);
	1417
	1418	// TODO: 在此处添加消息处理程序代码
	1419	if (!bSysMenu && pPopupMenu)
	1420	{
	1421	CCmdUI cmdUI;
	1422	cmdUI.m_pOther = NULL;
	1423	cmdUI.m_pMenu = pPopupMenu;
	1424	cmdUI.m_pSubMenu = NULL;
	1425
	1426
	1427	UINT count = pPopupMenu->GetMenuItemCount();
	1428	cmdUI.m_nIndexMax = count;
	1429	for (UINT i = 0; i < count; i++)
	1430	{
	1431	UINT nID = pPopupMenu->GetMenuItemID(i);
	1432	if (-1 == nID \|\| 0 == nID)
	1433	{
	1434	continue;
	1435	}
	1436	cmdUI.m_nID = nID;
	1437	cmdUI.m_nIndex = i;
	1438	cmdUI.DoUpdate(this, FALSE);
	1439	}
	1440	}
	1441	}
	1442
	1443	void CMTerm1View::OnTimer(UINT_PTR nIDEvent)
	1444	{
	1445	// TODO: 在此添加消息处理程序代码和/或调用默认值
	1446	CString s1;
	1447	CMTerm1Doc * pDoc = (CMTerm1Doc*)GetDocument();
	1448
	1449	if (nIDEvent == 0) {
	1450
	1451	}
	1452	else if (nIDEvent == 1)
	1453	{
	1454	if (m_bMonitoring) {
	1455	//this->RedrawWindow();
	1456	DoReDraw();
	1457	}
	1458	}
	1459	else if (nIDEvent == 2) {
	1460	pDoc->OnTimer(2);
	1461	}
	1462	else {
	1463
	1464	}
	1465	CScrollView::OnTimer(nIDEvent);
	1466	}
	1467
	1468	void CMTerm1View::OnMonitor()
	1469	{
	1470	// TODO: 在此添加命令处理程序代码
	1471	m_bMonitoring = !m_bMonitoring;
	1472	this->RedrawWindow();
	1473	UpdateStatusBar();
	1474	}
	1475
	1476	void CMTerm1View::OnUpdateMonitor(CCmdUI *pCmdUI)
	1477	{
	1478	// TODO: 在此添加命令更新用户界面处理程序代码
	1479	pCmdUI->SetCheck(m_bMonitoring == true);
	1480	}
	1481
ad1b4b	1482	/// <summary>
Z	1483	/// 程序转换按钮点击
	1484	/// </summary>
418cb3	1485	void CMTerm1View::OnProgConvert()
Q	1486	{
e55aec	1487	//转换前先对LDS的规则进行检验（检验规则与返回参数并未完全确定
Z	1488	std::pair<int,CString> result = LDSCheckRule();
	1489	if (result.first == 111)
	1490	{
	1491	DbgLog(result.second);
	1492	return;
	1493	}
	1494
418cb3	1495	CString s1;
Q	1496	s1.Format(_T("Prog Convert"));
	1497	SysLog(s1);
	1498	int r = TransLDSToProg();
	1499	s1.Format(_T("LDS To Prog result %d"), r);
	1500	SysLog(s1);
e55aec	1501	if (r==0)
Z	1502	{
418cb3	1503	// m_bModified = 0;
Q	1504	int j=TransProgToLDS();
	1505	s1.Format(_T("Porg to LDS retuls %d"), j);
	1506	SysLog(s1);
	1507	needReDraw = 1;
	1508	RedrawWindow();
	1509	}
	1510	else {
	1511	s1.Format(_T("Error in Prog Convert"));
	1512	SysLog(s1);
	1513	}
	1514	}
	1515
	1516	void CMTerm1View::OnUpdateProgConvert(CCmdUI *pCmdUI)
	1517	{
	1518	// TODO: 在此添加命令更新用户界面处理程序代码
	1519	pCmdUI->SetCheck(0);
	1520	pCmdUI->Enable(m_bModified);
	1521	}
	1522
	1523	void CMTerm1View::OnProgCancelEdit()
	1524	{
	1525	CString s1;
	1526	s1.Format(_T("Prog Cancel Edit"));
	1527	SysLog(s1);
	1528	// TODO: 在此添加命令处理程序代码
	1529	}
	1530
	1531
	1532	void CMTerm1View::OnUpdateProgCancelEdit(CCmdUI *pCmdUI)
	1533	{
	1534	// TODO: 在此添加命令更新用户界面处理程序代码
	1535	// pCmdUI->SetCheck(m_bModified);
	1536	pCmdUI->Enable(m_bModified);
	1537	}
	1538
	1539
	1540	void CMTerm1View::OnInsertBlankLine()
	1541	{
	1542	// TODO: 在此添加命令处理程序代码
	1543	CString s1;
	1544	s1.Format(_T("Insert Blank Line"));
	1545	SysLog(s1);
	1546	m_FocusRow;
	1547	//当前行之后的所有，下移一行
	1548	for (int i = m_nTotalRow - 1; i >= m_FocusRow; i--) {
	1549	for (int j = 0; j < m_CellPerLine; j++) {
	1550	Cells[i + 1][j] = Cells[i][j];
	1551	}
	1552	}
	1553	m_nTotalRow += 1;
	1554	// 当前行灰色
	1555	for (int j = 0; j < m_CellPerLine; j++) {
	1556	Cells[m_FocusRow][j].clear();
	1557	Cells[m_FocusRow][j].bEditing = 1;
	1558	Cells[m_FocusRow][j].bModified = 1;
	1559	if (Cells[m_FocusRow + 1][j].bLeftLineUp) {
	1560	Cells[m_FocusRow][j].bLeftLineUp = 1;
	1561	Cells[m_FocusRow][j].bLeftLineDn = 1;
	1562	}
	1563	}
	1564
	1565	// 当前行加入触点
	1566	// m_FocusCol;
	1567	// Cells[m_FocusRow][0].nType= typeNO;
	1568	// Cells[m_FocusRow][0].nDataType = KLCoilTypeX;
	1569	// Cells[m_FocusRow][0].nDataAddr = 15;
	1570	// Cells[m_FocusRow][0].sCoilName = "ABCDEFG";
	1571
	1572	m_bModified = 1;
	1573	needReDraw = 1;
	1574	this->RedrawWindow();
	1575	}
	1576	int FindTypeIndex(CString str[], CString strType, int num)
	1577	{
	1578	for (int i = 0;i < num;i++)
	1579	{
	1580	if (strType == str[i])
	1581	{
	1582	return i;
	1583	}
	1584	}
	1585	return -1;
	1586	}
	1587
ad1b4b	1588	/// <summary>
Z	1589	/// 设置Cell到窗口视图
	1590	/// </summary>
	1591	/// <param name="cell1"></param>
	1592	void CMTerm1View::SetCellToView(stCell cell1, int flag) //**************************************************************************************************//
418cb3	1593	{
Q	1594	Cells[m_FocusRow][m_FocusCol] = cell1;
	1595	m_bModified = 1;
	1596	needReDraw = 1;
ad1b4b	1597
df0321	1598	Cells[m_FocusRow][0].bEditing = 1;
Q	1599
ad1b4b	1600	if (m_nTotalRow < m_FocusRow + 1)
Z	1601	{
df0321	1602	m_nTotalRow = m_FocusRow + 1;
Q	1603	}
ad1b4b	1604	//单元格关联修改
Z	1605	switch (flag)
	1606	{
	1607	case 1:
	1608	{
	1609	if(Cells[m_FocusRow - 1][m_FocusCol].nType == CMTerm1View::typeExt1)
	1610	{
	1611	//发送错误信息
	1612	DbgLog(_T("插入纵线失败：光标位置错误！参数位置不允许添加纵线"));
	1613	return;
	1614	}
	1615	//添加纵线时同步添加上一行
	1616	Cells[m_FocusRow - 1][m_FocusCol].bLeftLineDn = 1;
	1617	}break;
	1618	case 2:
	1619	{
	1620	if (Cells[m_FocusRow - 1][m_FocusCol].nType == CMTerm1View::typeExt1)
	1621	{
	1622	//发送错误信息
	1623	DbgLog(_T("删除纵线失败：光标位置错误！参数位置不允许删除纵线"));
	1624	return;
	1625	}
	1626	//删除纵线时同步删除上一行
	1627	Cells[m_FocusRow - 1][m_FocusCol].bLeftLineDn = 0;
	1628	}break;
	1629	default:
	1630	break;
	1631	}
df0321	1632
ad1b4b	1633	//单元格位置后移
Z	1634	m_FocusCol += 1;
418cb3	1635	if (m_FocusCol >= 16)
ad1b4b	1636	{
Z	1637	m_FocusCol = 0;
	1638	m_FocusRow += 1;
	1639	}
	1640
418cb3	1641	this->RedrawWindow();
ad1b4b	1642	this->CellFocusChg(m_FocusRow, m_FocusCol);//改变焦点
418cb3	1643	}
Q	1644	void CMTerm1View::OnUpdateInsertBlankLine(CCmdUI *pCmdUI)
	1645	{
	1646	// TODO: 在此添加命令更新用户界面处理程序代码
	1647	}
	1648
	1649	void CMTerm1View::OnDeleteBlankLine()
	1650	{
	1651	// TODO: 在此添加命令处理程序代码
	1652	CString s1;
	1653	s1.Format(_T("Delete Blank Line"));
	1654	SysLog(s1);
	1655	}
	1656
	1657	void CMTerm1View::OnUpdateDeleteBlankLine(CCmdUI *pCmdUI)
	1658	{
	1659	// TODO: 在此添加命令更新用户界面处理程序代码
	1660	}
	1661
	1662	void CMTerm1View::OnRectSelect()
	1663	{
	1664	// TODO: 在此添加命令处理程序代码
	1665	}
	1666
	1667
	1668	void CMTerm1View::OnUpdateRectSelect(CCmdUI *pCmdUI)
	1669	{
	1670	// TODO: 在此添加命令更新用户界面处理程序代码
	1671	}
	1672
	1673
	1674	void CMTerm1View::OnTextFirst()
	1675	{
	1676	// TODO: 在此添加命令处理程序代码
	1677	}
	1678
	1679
	1680	void CMTerm1View::OnUpdateTextFirst(CCmdUI *pCmdUI)
	1681	{
	1682	// TODO: 在此添加命令更新用户界面处理程序代码
	1683	}
	1684
	1685	void CMTerm1View::OnDisplayComments()
	1686	{
	1687	// TODO: 在此添加命令处理程序代码
	1688	m_bShowComments = !m_bShowComments;
	1689	int CellTotalHeight = m_CellHeight + (m_bShowComments ? m_CommentHeight : 0);
	1690	CRect rect0;
	1691	this->GetClientRect(&rect0);
	1692
	1693	CSize sizeTotal;
	1694	// TODO: 计算此视图的合计大小
	1695	sizeTotal.cx = m_LeftMargin + m_CellWidth * m_CellPerLine + m_CellWidth * 2;
	1696	sizeTotal.cy = m_TopMargin + CellTotalHeight * (m_nTotalRow-1) + rect0.Height();
	1697	SetScrollSizes(MM_TEXT, sizeTotal);
	1698	needReDraw = 1;
	1699	this->Invalidate();
	1700	}
	1701
	1702
	1703	void CMTerm1View::OnUpdateDisplayComments(CCmdUI *pCmdUI)
	1704	{
	1705	// TODO: 在此添加命令更新用户界面处理程序代码
	1706	pCmdUI->SetCheck(m_bShowComments == true);
	1707	}
	1708
	1709
	1710
	1711	int CMTerm1View::UpdateStatusBar(int nIndex)
	1712	{
	1713	// TODO: 在此处添加实现代码.
	1714	CString s1;
	1715	CMTerm1Doc * pDoc = (CMTerm1Doc*)GetDocument();
	1716
	1717	if (nIndex == idxMachineType \|\| nIndex == -1) { //机型代码
	1718	s1 = pDoc->m_sMachineType;
	1719	m_pStatusBar->SetPaneText(idxMachineType,s1);
	1720	}
	1721	if (nIndex == idxProgPos \|\| nIndex == -1) { //程序位置/步数
	1722	s1.Format(_T("%5d/%5d"), m_nCurProgStep,pDoc->m_nProgSteps);
	1723	m_pStatusBar->SetPaneText(idxProgPos, s1);
	1724	}
	1725	if (nIndex == idxOnline \|\| nIndex == -1) { //在线 /离线
	1726	if (!pDoc->m_bOnline) {
	1727	s1 = _T("离线");
	1728	m_pStatusBar->SetPaneText(idxOnline, s1);
	1729	m_pStatusBar->SetPaneBackgroundColor(idxOnline);
	1730	}
	1731	else if (pDoc->m_bOnline) {
	1732	if (pDoc->m_bSimulate) {
	1733	s1 = _T("在线(仿真)");
	1734	m_pStatusBar->SetPaneText(2, s1);
	1735	m_pStatusBar->SetPaneBackgroundColor(idxOnline, OnlineColor);
	1736	}else{
	1737	s1 = _T("在线");
	1738	m_pStatusBar->SetPaneText(2, s1);
	1739	m_pStatusBar->SetPaneBackgroundColor(idxOnline, OnlineColor);
	1740	}
	1741	}
	1742	}
	1743	if (nIndex == idxRunning \|\| nIndex == -1) { // 运行 / 停止
	1744	if (!pDoc->m_bOnline) {
	1745	s1 = _T("");
	1746	m_pStatusBar->SetPaneText(idxRunning, s1);
	1747	m_pStatusBar->SetPaneBackgroundColor(idxRunning);
	1748	m_pStatusBar->SetPaneWidth(idxRunning, 0);
	1749	m_pStatusBar->SetPaneStyle(idxRunning, SBPS_DISABLED);
	1750
	1751	}else if (!pDoc->m_bPlcRunning) {
	1752	s1 = _T("PROG");
	1753	m_pStatusBar->SetPaneText(idxRunning, s1);
	1754	m_pStatusBar->SetPaneWidth(idxRunning, s1.GetLength()*8);
	1755	m_pStatusBar->SetPaneBackgroundColor(idxRunning, ProgColor);
	1756	}else {
	1757	s1 = _T("RUN");
	1758	m_pStatusBar->SetPaneText(idxRunning, s1);
	1759	m_pStatusBar->SetPaneWidth(idxRunning, s1.GetLength() * 8);
	1760	m_pStatusBar->SetPaneBackgroundColor(idxRunning, RunningColor);
	1761	}
	1762	}
	1763	if (nIndex == idxMonitor \|\| nIndex == -1) { // 监控 //
	1764	// s1 = pDoc->m_sMachineType;
	1765	if (!m_bMonitoring) {
	1766	s1 = _T("[监控停止]");
	1767	m_pStatusBar->SetPaneText(idxMonitor, s1);
	1768	m_pStatusBar->SetPaneBackgroundColor(idxMonitor);
	1769	}else{
	1770	s1 = _T("[正在监控]");
	1771	m_pStatusBar->SetPaneText(idxMonitor, s1);
	1772	m_pStatusBar->SetPaneBackgroundColor(idxMonitor, MonitorColor);
	1773	}
	1774	}
	1775	if (nIndex == idxAddress \|\| nIndex == -1) { // 地址，本站
	1776	// s1 = pDoc->m_sMachineType;
	1777	if (!pDoc->m_bOnline) {
	1778	s1 = _T("本站");
	1779	m_pStatusBar->SetPaneText(idxAddress, s1);
	1780	m_pStatusBar->SetPaneBackgroundColor(idxMonitor);
	1781	}else {
	1782	s1 = _T("本站");
	1783	m_pStatusBar->SetPaneText(idxAddress, s1);
	1784	m_pStatusBar->SetPaneBackgroundColor(idxMonitor, AddressColor);
	1785	}
	1786
	1787	}
	1788	if (nIndex == idxInfoDisp \|\| nIndex == -1) { // INFO DISPLAY
	1789	// s1 = pDoc->m_sMachineType;
	1790	m_pStatusBar->SetPaneText(idxInfoDisp, s1);
	1791	}
	1792
	1793	return 0;
	1794	}
	1795
	1796
	1797	void CMTerm1View::OnUpdateIndicatorMonitorStatus(CCmdUI *pCmdUI)
	1798	{
	1799	// TODO: 在此添加命令更新用户界面处理程序代码
	1800
	1801	//pCmdUI->SetCheck(m_bMonitoring == true);
	1802	if (!m_bMonitoring) pCmdUI->SetText(_T("[监控停止]"));
	1803	else pCmdUI->SetText(_T("[正在监控]"));
	1804	}
	1805
	1806	void CMTerm1View::OnUpdateIndicators(CCmdUI *pCmdUI)
	1807	{
	1808	// TODO: 在此添加命令更新用户界面处理程序代码
	1809	CString s1;
	1810	s1.Format(_T("pCmdUI nID %d "));
	1811	DbgLog(s1);
	1812	pCmdUI->m_nID;
	1813	pCmdUI->SetText(_T("KL-D20N16"));
	1814	}
	1815
	1816	void CMTerm1View::OnUpdateMachineType(CCmdUI *pCmdUI)
	1817	{
	1818	// TODO: 在此添加命令更新用户界面处理程序代码
	1819	CString s1;
	1820	s1.Format(_T("pCmdUI nID %d "));
	1821	DbgLog(s1);
	1822	pCmdUI->m_nID;
	1823	pCmdUI->SetText(_T("KL-D20N16"));
	1824	}
	1825
	1826	void CMTerm1View::OnUpdateProgramPos(CCmdUI *pCmdUI)
	1827	{
	1828	// TODO: 在此添加命令更新用户界面处理程序代码
	1829	CString s1;
	1830	s1.Format(_T("%5d/%5d"), 18, 55);
	1831	pCmdUI->SetText(s1);
	1832	}
	1833
	1834	void CMTerm1View::OnUpdateConnectivity(CCmdUI *pCmdUI)
	1835	{
	1836	// TODO: 在此添加命令更新用户界面处理程序代码
	1837	CString s1;
	1838	s1 = _T("离线");
	1839	s1 = _T("在线");
	1840
	1841	pCmdUI->SetText(s1);
	1842	}
	1843	void CMTerm1View::OnUpdateRunStatus(CCmdUI *pCmdUI)
	1844	{
	1845	// TODO: 在此添加命令更新用户界面处理程序代码
	1846	CString s1;
	1847	CMTerm1Doc* pDoc = GetDocument();
	1848	ASSERT_VALID(pDoc);
	1849	if (!pDoc) return;
	1850	if (pDoc->m_bPlcRunning) {
	1851	s1 = _T("运行");
	1852	m_pStatusBar->SetPaneText(3, s1);
	1853	m_pStatusBar->SetPaneTextColor(3, RGB(0, 0, 0));
	1854	}
	1855	else {
	1856	s1 = _T("停止");
	1857	m_pStatusBar->SetPaneText(3, s1);
	1858	m_pStatusBar->SetPaneTextColor(3, RGB(0, 0, 0));
	1859	}
	1860	s1.Format(_T("PCmdUI %d %d"), pCmdUI->m_nID, pCmdUI->m_nIndex);
	1861	DbgLog(s1);
	1862
	1863	// pCmdUI->SetText(s1);
	1864	}
	1865	void CMTerm1View::OnUpdateMonitorStatus(CCmdUI *pCmdUI)
	1866	{
	1867	// TODO: 在此添加命令更新用户界面处理程序代码
	1868	CString s1;
	1869	s1 = _T("停止监控");
	1870	s1 = _T("监控中");
	1871	if (!m_bMonitoring) pCmdUI->SetText(_T("[监控停止]"));
	1872	else pCmdUI->SetText(_T("[正在监控]"));
	1873
	1874	// pCmdUI->SetText(s1);
	1875	}
	1876	void CMTerm1View::OnUpdateTargetAddress(CCmdUI *pCmdUI)
	1877	{
	1878	// TODO: 在此添加命令更新用户界面处理程序代码
	1879	CString s1;
	1880	s1 = _T("远程");
	1881	s1 = _T("本站");
	1882	pCmdUI->SetText(s1);
	1883	}
	1884
	1885	void CMTerm1View::OnInputIoComment()
	1886	{
	1887	// TODO: 在此添加命令处理程序代码
	1888	CString s1;
	1889	int nRow, nCol;
	1890	nRow = m_FocusRow;
	1891	nCol = m_FocusCol;
	1892	if (nCol < 0) { nCol = 0; }
	1893	if (nCol >= m_CellPerLine) { nCol = m_CellPerLine - 1; }
	1894
	1895	CString sParam;
	1896	sParam = Cells[nRow][nCol].sParam;
	1897	int nDataType, nDataAddr, nStat;
	1898	nDataType = Cells[nRow][nCol].nDataType;
	1899	nDataAddr = Cells[nRow][nCol].nDataAddr;
	1900	nStat = Cells[nRow][nCol].nStat;
	1901
	1902	s1.Format(_T("Name %s DataType %d DataAddr %d Stat %d"),
	1903	sParam, nDataType, nDataAddr, nStat);
	1904	SysLog(s1);
	1905	if (Cells[m_FocusRow][m_FocusCol].sParam == _T("")) {
	1906	return;
	1907	}
	1908
	1909	CMTerm1Doc * pDoc = GetDocument();
	1910	CString sComment;
	1911	pDoc->GetAnno(nDataType, nDataAddr, sComment);
	1912	CDialogIoComment dialog1;
	1913	dialog1.m_sIOName = sParam;
	1914	dialog1.m_sComment = sComment;
	1915	dialog1.m_nCoilType = nDataType;
	1916	dialog1.m_nCoilAddr = nDataAddr;
	1917	INT_PTR r = dialog1.DoModal();
	1918	if (r == IDOK)
	1919	{
	1920	sComment = dialog1.m_sComment;
	1921	pDoc->SetAnno(nDataType, nDataAddr, sParam, sComment);
	1922	s1.Format(_T("Set %s %d %d comment -> %s"), sParam, nDataType, nDataAddr, sComment);
	1923	SysLog(s1);
	1924	//needReDraw = 1;
	1925	this->RedrawWindow();
	1926	}
	1927	}
	1928
d34256	1929	/// <summary>
Z	1930	/// 程序数据转为梯形图
	1931	/// </summary>
	1932	/// <returns></returns>
418cb3	1933	int CMTerm1View::TransProgToLDS()
Q	1934	{
	1935	CString s1;
	1936	CMTerm1Doc * pDoc = (CMTerm1Doc*)GetDocument();
	1937
	1938	// 先扫描分开的程序段
	1939	int stpos[100] = { 0 };
	1940	int nSts = 0;
	1941
ad1b4b	1942	for (int i = 0; i < m_nTotalRow && i < 2000; i++)
Z	1943	{
	1944	for (int j = 0; j < 16; j++)
	1945	{
418cb3	1946	Cells[i][j].clear();
aac3b3	1947	s1.Format(_T("%d:%d"), i, j);
418cb3	1948	Cells[i][j].sCoilName = s1;
Q	1949	}
	1950	}
	1951	POINT StPts[100];
	1952	// StPts[0] = POINT{ 0, 0 };
	1953	POINT EndPt[100];
	1954	int nEndPts = 0;
	1955	nSts = 0;
	1956	int nCurLine = 0;
	1957
	1958	int cx = 0, cy = 0;
	1959	int maxy = 0;
d34256	1960	try
418cb3	1961	{
d34256	1962	for (int i = 0; i < pDoc->m_nProgSteps; i++)
418cb3	1963	{
d34256	1964	int nOp = pDoc->Progs[i].nOpType1;
Z	1965	int nParamCount = pDoc->Progs[i].nParamCount;
	1966	CStringA OpName;
	1967	CStringA ShowTxt;
	1968	pDoc->OpToTxt(nOp, OpName);
	1969	pDoc->OpToShowTxt(nOp, ShowTxt);
	1970	int nPairTo = pDoc->Progs[i].PairTo;
	1971	int nPairOp = 0;
e55aec	1972	if (nPairTo)
Z	1973	{
	1974	nPairOp = pDoc->Progs[nPairTo].nOpType1;
	1975	}
d34256	1976	int nCellType;
Z	1977	switch (nOp)
	1978	{
	1979	case OP_NOP:
	1980	break;
	1981	case OP_ST:
	1982	case OP_ST_:
e55aec	1983	if (i == 0)
Z	1984	{
418cb3	1985
d34256	1986	}
e55aec	1987	else
Z	1988	{
d34256	1989	//记录当前位置
Z	1990	EndPt[nEndPts] = POINT{ cx,cy };
	1991	nEndPts++;
e55aec	1992	if (nPairOp == OP_ANS)
Z	1993	{
d34256	1994	//继续前进
Z	1995	//cx = 0, cy = nCurLine;
	1996	//cx = StPts[nSts - 1].x;
	1997	//nCurLine = cy + 1; //另起一行
e55aec	1998	///*
d34256	1999	nCurLine = cy;
Z	2000	int hasData = 1;
	2001	while (hasData) {
	2002	hasData = 0;
e55aec	2003	for (int j = cx + 1; j < m_CellPerLine; j++)
Z	2004	{
	2005	if (Cells[nCurLine][j].nType != 0)
	2006	{
d34256	2007	nCurLine++; hasData = 1; break;
Z	2008	}
418cb3	2009	}
Q	2010	}
e55aec	2011	//nCurLine = maxy + 1; //另起一行
Z	2012	if (nCurLine > maxy)
	2013	{
	2014	maxy = nCurLine;
	2015	}
	2016	for (int j = cy; j < nCurLine; j++)
	2017	{
d34256	2018	Cells[j][cx].bLeftLineDn = 1;
Z	2019	Cells[j + 1][cx].bLeftLineUp = 1;
	2020	}
	2021	cy = nCurLine;
	2022	//*/
418cb3	2023	}
e55aec	2024	else if (nPairOp == OP_ORS)
Z	2025	{
d34256	2026	cx = StPts[nSts - 1].x;
Z	2027	nCurLine = cy + 1; //另起一行
	2028	int hasData = 1;
e55aec	2029	while (hasData)
Z	2030	{
d34256	2031	hasData = 0;
e55aec	2032	for (int j = cx; j < m_CellPerLine; j++)
Z	2033	{
	2034	if (Cells[nCurLine][j].nType != 0)
	2035	{
d34256	2036	nCurLine++; hasData = 1; break;
Z	2037	}
418cb3	2038	}
Q	2039	}
d34256	2040	// nCurLine = maxy + 1; //另起一行
Z	2041	if (nCurLine > maxy) maxy = nCurLine;
e55aec	2042	for (int j = cy; j < nCurLine; j++)
Z	2043	{
d34256	2044	Cells[j][cx].bLeftLineDn = 1;
Z	2045	Cells[j + 1][cx].bLeftLineUp = 1;
	2046	}
	2047	cy = nCurLine;
418cb3	2048	}
e55aec	2049	else if (nPairOp == 0)
Z	2050	{
d34256	2051	nCurLine = maxy + 1; //另起一行
Z	2052	maxy = nCurLine;
	2053	cx = 0; cy = nCurLine;
418cb3	2054	}
Q	2055	}
d34256	2056	stpos[nSts] = i;
Z	2057	StPts[nSts] = POINT{ cx,cy };
	2058	nSts++;
	2059	Cells[cy][cx].nType = pDoc->Progs[i].nOpType1 == OP_ST ? typeNO : typeNC; //typeNC
	2060	Cells[cy][cx].nProgStep = i;
	2061	Cells[cy][cx].sCoilName = pDoc->Progs[i].Params[0].sParamStr;
	2062	Cells[cy][cx].sParam = pDoc->Progs[i].Params[0].sParamStr;
	2063	Cells[cy][cx].nDataType = pDoc->Progs[i].Params[0].nParamType;
	2064	Cells[cy][cx].nDataAddr = pDoc->Progs[i].Params[0].nParamAddr;
	2065	cx++; //移到下一格
	2066	break;
	2067	case OP_ST_EQ:
	2068	case OP_ST_NE:
	2069	case OP_ST_LT:
	2070	case OP_ST_GT:
	2071	case OP_ST_LE:
	2072	case OP_ST_GE:
	2073	if (i == 0) {
418cb3	2074
Q	2075	}
d34256	2076	else {
Z	2077	//记录当前位置
	2078	EndPt[nEndPts] = POINT{ cx,cy };
	2079	nEndPts++;
	2080	if (nPairOp == OP_ANS) {
	2081	//继续前进
	2082	//cx = 0, cy = nCurLine;
	2083	}
	2084	else if (nPairOp == OP_ORS) {
	2085	cx = StPts[nSts - 1].x;
	2086	nCurLine = cy + 1; //另起一行
	2087	int hasData = 1;
	2088	while (hasData) {
	2089	hasData = 0;
	2090	for (int j = cx; j < m_CellPerLine; j++) {
	2091	if (Cells[nCurLine][j].nType != 0) {
	2092	nCurLine++; hasData = 1; break;
	2093	}
418cb3	2094	}
Q	2095	}
d34256	2096	// nCurLine = maxy + 1; //另起一行
Z	2097	if (nCurLine > maxy) maxy = nCurLine;
	2098	for (int j = cy; j < nCurLine; j++) {
	2099	Cells[j][cx].bLeftLineDn = 1;
	2100	Cells[j + 1][cx].bLeftLineUp = 1;
418cb3	2101	}
d34256	2102	cy = nCurLine;
Z	2103	}
	2104	else if (nPairOp == 0) {
	2105	nCurLine = maxy + 1; //另起一行
	2106	maxy = nCurLine;
	2107	cx = 0; cy = nCurLine;
418cb3	2108	}
Q	2109	}
d34256	2110	stpos[nSts] = i;
Z	2111	StPts[nSts] = POINT{ cx,cy };
	2112	nSts++;
	2113	Cells[cy][cx].nType = typeCMP;
	2114	Cells[cy][cx].nProgStep = i;
	2115	Cells[cy][cx].sParam = OpName;
	2116	Cells[cy][cx].sCoilName = ShowTxt;
	2117	Cells[cy][cx + 1].nType = typeExt1;
	2118	Cells[cy][cx + 1].sParam = pDoc->Progs[i].Params[0].sParamStr;
	2119	Cells[cy][cx + 1].nDataType = pDoc->Progs[i].Params[0].nParamType;
	2120	Cells[cy][cx + 1].nDataAddr = pDoc->Progs[i].Params[0].nParamAddr;
	2121	Cells[cy][cx + 2].nType = typeExt1;
	2122	Cells[cy][cx + 2].sParam = pDoc->Progs[i].Params[1].sParamStr;
	2123	Cells[cy][cx + 2].nDataType = pDoc->Progs[i].Params[1].nParamType;
	2124	Cells[cy][cx + 2].nDataAddr = pDoc->Progs[i].Params[1].nParamAddr;
	2125	cx += 3; //移到下3格
	2126	break;
418cb3	2127
d34256	2128	case OP_AN:
Z	2129	case OP_AN_:
418cb3	2130
d34256	2131	Cells[cy][cx].nType = nOp == OP_AN ? typeNO : typeNC; //typeNC
418cb3	2132	Cells[cy][cx].nProgStep = i;
Q	2133	Cells[cy][cx].sParam = pDoc->Progs[i].Params[0].sParamStr;
	2134	Cells[cy][cx].sCoilName = pDoc->Progs[i].Params[0].sParamStr;
	2135	Cells[cy][cx].nDataType = pDoc->Progs[i].Params[0].nParamType;
	2136	Cells[cy][cx].nDataAddr = pDoc->Progs[i].Params[0].nParamAddr;
d34256	2137	cx++;
Z	2138	break;
	2139	case OP_AN_EQ:
	2140	case OP_AN_NE:
	2141	case OP_AN_LT:
	2142	case OP_AN_GT:
	2143	case OP_AN_LE:
	2144	case OP_AN_GE:
	2145	Cells[cy][cx].nType = typeCMP;
	2146	Cells[cy][cx].nProgStep = i;
	2147	Cells[cy][cx].sCoilName = ShowTxt;
	2148	Cells[cy][cx + 1].nType = typeExt1;
	2149	Cells[cy][cx + 1].sParam = pDoc->Progs[i].Params[0].sParamStr;
	2150	Cells[cy][cx + 1].nDataType = pDoc->Progs[i].Params[0].nParamType;
	2151	Cells[cy][cx + 1].nDataAddr = pDoc->Progs[i].Params[0].nParamAddr;
	2152	Cells[cy][cx + 2].nType = typeExt1;
	2153	Cells[cy][cx + 2].sParam = pDoc->Progs[i].Params[1].sParamStr;
	2154	Cells[cy][cx + 2].nDataType = pDoc->Progs[i].Params[1].nParamType;
	2155	Cells[cy][cx + 2].nDataAddr = pDoc->Progs[i].Params[1].nParamAddr;
	2156	cx += 3;
	2157	break;
	2158
	2159	case OP_OR:
	2160	case OP_OR_:
	2161	EndPt[nEndPts] = POINT{ cx,cy };
aac3b3	2162	nEndPts++;
d34256	2163	cx = StPts[nSts - 1].x;
Z	2164	nCurLine = cy + 1; //另起一行
	2165	{
	2166	int hasData = 1;
aac3b3	2167	while (hasData)
Z	2168	{
	2169	hasData = 0;
	2170	for (int j = cx; j < m_CellPerLine; j++)
	2171	{
	2172	if (Cells[nCurLine][j].nType != 0)
	2173	{
	2174	nCurLine++;
	2175	hasData = 1;
	2176	break;
d34256	2177	}
Z	2178	}
	2179	}
	2180	}
aac3b3	2181	if (nCurLine > maxy)
Z	2182	{
	2183	maxy = nCurLine;
	2184	}
	2185	for (int j = cy; j < nCurLine; j++)
	2186	{
d34256	2187	Cells[j][cx].bLeftLineDn = 1;
Z	2188	Cells[j + 1][cx].bLeftLineUp = 1;
	2189	}
	2190	cy = nCurLine;
aac3b3	2191	StPts[nSts] = POINT{ cx,cy };//+++
d34256	2192	Cells[cy][cx].nProgStep = i;
Z	2193	Cells[cy][cx].nType = nOp == OP_OR ? typeNO : typeNC; //typeNC
	2194	Cells[cy][cx].sCoilName = pDoc->Progs[i].Params[0].sParamStr;
	2195	Cells[cy][cx].sParam = pDoc->Progs[i].Params[0].sParamStr;
	2196	Cells[cy][cx].nDataType = pDoc->Progs[i].Params[0].nParamType;
	2197	Cells[cy][cx].nDataAddr = pDoc->Progs[i].Params[0].nParamAddr;
	2198	cx++;
aac3b3	2199	//if (cx <= EndPt[nEndPts - 1].x)
Z	2200	//{ //本行补齐
	2201	// for (int j = cx; j < EndPt[nEndPts - 1].x; j++)
	2202	// {
	2203	// Cells[cy][j].nType = typeLine1;
	2204	// }
	2205	// cx = EndPt[nEndPts - 1].x;
	2206	//}
	2207	//else {
	2208	// //前一行补齐
	2209	// for (int j = EndPt[nEndPts - 1].x; j < cx; j++)
	2210	// {
	2211	// Cells[EndPt[nEndPts - 1].y][j].nType = typeLine1;
	2212	// }
d34256	2213
aac3b3	2214	//}
d34256	2215	//连接上下线
Z	2216	for (int j = EndPt[nEndPts - 1].y; j < cy; j++)
	2217	{
	2218	Cells[j][cx].bLeftLineDn = 1;
	2219	Cells[j + 1][cx].bLeftLineUp = 1;
	2220	}
	2221	//光标位置, 前一结束点位置
	2222	cy = EndPt[nEndPts - 1].y;
aac3b3	2223
d34256	2224	nEndPts--;
Z	2225
	2226	break;
	2227	case OP_OR_EQ:
	2228	case OP_OR_NE:
	2229	case OP_OR_LT:
	2230	case OP_OR_GT:
	2231	case OP_OR_LE:
	2232	case OP_OR_GE:
	2233	EndPt[nEndPts] = POINT{ cx,cy };
	2234	nEndPts++;
	2235	cx = StPts[nSts - 1].x;
	2236	nCurLine = cy + 1; //另起一行
	2237	{
	2238	int hasData = 1;
	2239	while (hasData) {
	2240	hasData = 0;
	2241	for (int j = cx; j < m_CellPerLine; j++) {
	2242	if (Cells[nCurLine][j].nType != 0) {
	2243	nCurLine++; hasData = 1; break;
	2244	}
	2245	}
	2246	}
	2247	}
	2248	if (nCurLine > maxy) maxy = nCurLine;
	2249	for (int j = cy; j < nCurLine; j++) {
	2250	Cells[j][cx].bLeftLineDn = 1;
	2251	Cells[j + 1][cx].bLeftLineUp = 1;
	2252	}
	2253	cy = nCurLine;
	2254	Cells[cy][cx].nType = typeCMP;
	2255	Cells[cy][cx].nProgStep = i;
	2256	Cells[cy][cx].sCoilName = ShowTxt;
	2257	Cells[cy][cx + 1].nType = typeExt1;
	2258	Cells[cy][cx + 1].sParam = pDoc->Progs[i].Params[0].sParamStr;
	2259	Cells[cy][cx + 1].nDataType = pDoc->Progs[i].Params[0].nParamType;
	2260	Cells[cy][cx + 1].nDataAddr = pDoc->Progs[i].Params[0].nParamAddr;
	2261	Cells[cy][cx + 2].nType = typeExt1;
	2262	Cells[cy][cx + 2].sParam = pDoc->Progs[i].Params[1].sParamStr;
	2263	Cells[cy][cx + 2].nDataType = pDoc->Progs[i].Params[1].nParamType;
	2264	Cells[cy][cx + 2].nDataAddr = pDoc->Progs[i].Params[1].nParamAddr;
	2265	cx += 3;
	2266	if (cx < EndPt[nEndPts - 1].x)
	2267	{ //本行补齐
	2268	for (int j = cx; j < EndPt[nEndPts - 1].x; j++)
	2269	{
	2270	Cells[cy][j].nType = typeLine1;
	2271	}
	2272	cx = EndPt[nEndPts - 1].x;
	2273	}
	2274	else {
	2275	//前一行补齐
	2276	for (int j = EndPt[nEndPts - 1].x; j < cx; j++)
	2277	{
	2278	Cells[EndPt[nEndPts - 1].y][j].nType = typeLine1;
	2279	}
	2280
	2281	}
	2282	//连接上下线
	2283	for (int j = EndPt[nEndPts - 1].y; j < cy; j++)
	2284	{
	2285	Cells[j][cx].bLeftLineDn = 1;
	2286	Cells[j + 1][cx].bLeftLineUp = 1;
	2287	}
	2288	//光标位置, 前一结束点位置
	2289	cy = EndPt[nEndPts - 1].y;
	2290	nEndPts--;
	2291
	2292	break;
	2293	case OP_NOT:
	2294	Cells[cy][cx].nType = typeNOT;
	2295	Cells[cy][cx].sCoilName = _T("NOT");
	2296
	2297	Cells[cy][cx].nProgStep = i;
	2298	cx++;
	2299	break;
	2300	case OP_DF:
	2301	case OP_DF_:
	2302	Cells[cy][cx].nType = nOp == OP_DF ? typeDF : typeDF_;
	2303	Cells[cy][cx].sCoilName = nOp == OP_DF ? _T("DF") : _T("DF/");
	2304
	2305	Cells[cy][cx].nProgStep = i;
	2306	cx++;
	2307	break;
	2308	case OP_ANS:
	2309	nSts--;
	2310	nEndPts--;
	2311
	2312	break;
	2313	case OP_ORS:
e55aec	2314	//当前序列与前面的序列合并。
d34256	2315	//当前序列的开始结束位置
Z	2316	//EndPt[nEndPts] = POINT{ cx,cy };
	2317	//nEndPts++;
	2318	//StPts[nSts - 1]; EndPt[nEndPts - 1];
	2319	//前一序列的开始结束位置
e55aec	2320	StPts[nSts - 1];
Z	2321	EndPt[nEndPts - 1];
	2322	if (nEndPts <= 0)
d34256	2323	{
e55aec	2324	break;
d34256	2325	}
e55aec	2326
Z	2327	////判断二者长度
	2328	//if (cx < EndPt[nEndPts - 1].x)
	2329	//{
	2330	// //本行补齐
	2331	// for (int j = cx; j < EndPt[nEndPts - 1].x; j++)
	2332	// {
	2333	// Cells[cy][j].nType = typeLine1;
	2334	// }
	2335	// cx = EndPt[nEndPts - 1].x;
	2336	//}
	2337	//else
	2338	//{
	2339	// //前一行补齐
	2340	// for (int j = EndPt[nEndPts - 1].x; j < cx; j++)
	2341	// {
	2342	// Cells[EndPt[nEndPts - 1].y][j].nType = typeLine1;
	2343	// }
	2344	//}
	2345	////连接上下线
	2346	//for (int j = EndPt[nEndPts - 1].y; j < cy; j++)
	2347	//{
	2348	// Cells[j][cx].bLeftLineDn = 1;
	2349	// Cells[j + 1][cx].bLeftLineUp = 1;
	2350	//}
	2351	////光标位置, 前一结束点位置
	2352	//cy = EndPt[nEndPts - 1].y;
d34256	2353	nSts--;
Z	2354	nEndPts--;
	2355
	2356	break;
	2357	case OP_PSHS:
	2358	EndPt[nEndPts] = POINT{ cx,cy };
	2359	nEndPts++;
	2360	break;
	2361	case OP_RDS:
	2362	cx = EndPt[nEndPts - 1].x;
	2363	for (int j = cx; j < m_CellPerLine; j++) {
	2364	if (Cells[cy][j].nType != 0)
	2365	{
	2366	cy++; j = cx - 1; //break;
	2367	}
	2368	}
	2369	for (int j = EndPt[nEndPts - 1].y; j < cy; j++)
	2370	{
	2371	Cells[j][cx].bLeftLineDn = 1;
	2372	Cells[j + 1][cx].bLeftLineUp = 1;
	2373	}
	2374	break;
	2375	case OP_POPS:
	2376	cx = EndPt[nEndPts - 1].x;
	2377	for (int j = cx; j < m_CellPerLine; j++) {
	2378	if (Cells[cy][j].nType != 0)
	2379	{
	2380	cy++; j = cx - 1; break;
	2381	}
	2382	}
	2383	for (int j = EndPt[nEndPts - 1].y; j < cy; j++)
	2384	{
	2385	Cells[j][cx].bLeftLineDn = 1;
	2386	Cells[j + 1][cx].bLeftLineUp = 1;
	2387	}
	2388	nEndPts--;
	2389
	2390	break;
	2391	case OP_OUT:
	2392	case OP_SET:
	2393	case OP_RESET:
	2394	nCellType = nOp == OP_OUT ? typeOUT : nOp == OP_SET ? typeSET : typeRESET;
	2395	nCurLine = cy;
	2396	if (cx <= m_CellPerLine) {
	2397
	2398	int hasData = 1;
	2399	while (hasData) {
	2400	hasData = 0;
	2401	for (int j = cx; j < m_CellPerLine; j++) {
	2402	if (Cells[nCurLine][j].nType != 0) {
	2403	nCurLine++; hasData = 1; break;
	2404	}
	2405	}
	2406	}
	2407	//if (nCurLine > maxy) maxy = nCurLine;
	2408	for (int j = cy; j < nCurLine; j++) {
	2409	Cells[j][cx].bLeftLineDn = 1;
	2410	Cells[j + 1][cx].bLeftLineUp = 1;
	2411	}
	2412	cy = nCurLine;
	2413	for (int j = cx; j < m_CellPerLine; j++)
	2414	{
	2415	Cells[cy][j].nType = typeLine1;
	2416	}
	2417	Cells[cy][m_CellPerLine - 1].nType = nCellType;
	2418	Cells[cy][m_CellPerLine - 1].nProgStep = i;
	2419	Cells[cy][m_CellPerLine - 1].sParam = pDoc->Progs[i].Params[0].sParamStr;
	2420	Cells[cy][m_CellPerLine - 1].sCoilName = pDoc->Progs[i].Params[0].sParamStr;
	2421	Cells[cy][m_CellPerLine - 1].nDataType = pDoc->Progs[i].Params[0].nParamType;
	2422	Cells[cy][m_CellPerLine - 1].nDataAddr = pDoc->Progs[i].Params[0].nParamAddr;
	2423
	2424	}
	2425	else {
	2426	Cells[cy][cx].nType = nCellType;
	2427	Cells[cy][cx].nProgStep = i;
	2428	Cells[cy][cx].sParam = pDoc->Progs[i].Params[0].sParamStr;
	2429	Cells[cy][cx].sCoilName = pDoc->Progs[i].Params[0].sParamStr;
	2430	Cells[cy][cx].nDataType = pDoc->Progs[i].Params[0].nParamType;
	2431	Cells[cy][cx].nDataAddr = pDoc->Progs[i].Params[0].nParamAddr;
	2432	}
	2433	if (cy > maxy) { maxy = cy; }
	2434	//cy++;
	2435	break;
	2436
	2437	case OP_TML:
	2438	case OP_TMR:
	2439	case OP_TMX:
	2440	case OP_TMY:
	2441	Cells[cy][cx].nType = typeTM;
	2442	Cells[cy][cx].nProgStep = i;
	2443	Cells[cy][cx].sCoilName = ShowTxt;
	2444	Cells[cy][cx + 1].nType = typeExt1;
	2445	Cells[cy][cx + 1].sParam = pDoc->Progs[i].Params[0].sParamStr;
	2446	Cells[cy][cx + 1].nDataType = KLDataTypeEV;
	2447	Cells[cy][cx + 1].nDataAddr = pDoc->Progs[i].Params[0].nParamAddr;
	2448	Cells[cy][cx + 2].nType = typeExt1;
	2449	Cells[cy][cx + 2].sParam = pDoc->Progs[i].Params[1].sParamStr;
	2450	Cells[cy][cx + 2].nDataType = pDoc->Progs[i].Params[1].nParamType;
	2451	Cells[cy][cx + 2].nDataAddr = pDoc->Progs[i].Params[1].nParamAddr;
	2452	cx += 3;
	2453	break;
	2454	case OP_INC:
	2455	case OP_DEC:
	2456	Cells[cy][cx].nType = typeFN1;
	2457	Cells[cy][cx].nProgStep = i;
	2458	Cells[cy][cx].sCoilName = ShowTxt;
	2459	Cells[cy][cx + 1].nType = typeExt1;
	2460	Cells[cy][cx + 1].sParam = pDoc->Progs[i].Params[0].sParamStr;
	2461	Cells[cy][cx + 1].nDataType = pDoc->Progs[i].Params[0].nParamType;
	2462	Cells[cy][cx + 1].nDataAddr = pDoc->Progs[i].Params[0].nParamAddr;
	2463	cx += 2;
	2464	break;
	2465
	2466	case OP_MV:
	2467	case OP_ADD2:
	2468	case OP_SUB2:
	2469	Cells[cy][cx].nType = typeFN2;
	2470	Cells[cy][cx].nProgStep = i;
	2471	Cells[cy][cx].sCoilName = ShowTxt;
	2472	Cells[cy][cx + 1].nType = typeExt1;
	2473	Cells[cy][cx + 1].sParam = pDoc->Progs[i].Params[0].sParamStr;
	2474	Cells[cy][cx + 1].nDataType = pDoc->Progs[i].Params[0].nParamType;
	2475	Cells[cy][cx + 1].nDataAddr = pDoc->Progs[i].Params[0].nParamAddr;
	2476	Cells[cy][cx + 2].nType = typeExt1;
	2477	Cells[cy][cx + 2].sParam = pDoc->Progs[i].Params[1].sParamStr;
	2478	Cells[cy][cx + 2].nDataType = pDoc->Progs[i].Params[1].nParamType;
	2479	Cells[cy][cx + 2].nDataAddr = pDoc->Progs[i].Params[1].nParamAddr;
	2480	cx += 3;
	2481	break;
	2482
	2483	case OP_ADD3:
	2484	case OP_SUB3:
	2485	case OP_MUL:
	2486	case OP_DIV:
	2487	Cells[cy][cx].nType = typeFN3;
	2488	Cells[cy][cx].nProgStep = i;
	2489	Cells[cy][cx].sCoilName = ShowTxt;
	2490	Cells[cy][cx + 1].nType = typeExt1;
	2491	Cells[cy][cx + 1].sParam = pDoc->Progs[i].Params[0].sParamStr;
	2492	Cells[cy][cx + 1].nDataType = pDoc->Progs[i].Params[0].nParamType;
	2493	Cells[cy][cx + 1].nDataAddr = pDoc->Progs[i].Params[0].nParamAddr;
	2494	Cells[cy][cx + 2].nType = typeExt1;
	2495	Cells[cy][cx + 2].sParam = pDoc->Progs[i].Params[1].sParamStr;
	2496	Cells[cy][cx + 2].nDataType = pDoc->Progs[i].Params[1].nParamType;
	2497	Cells[cy][cx + 2].nDataAddr = pDoc->Progs[i].Params[1].nParamAddr;
	2498	Cells[cy][cx + 3].nType = typeExt1;
	2499	Cells[cy][cx + 3].sParam = pDoc->Progs[i].Params[2].sParamStr;
	2500	Cells[cy][cx + 3].nDataType = pDoc->Progs[i].Params[2].nParamType;
	2501	Cells[cy][cx + 3].nDataAddr = pDoc->Progs[i].Params[2].nParamAddr;
	2502	cx += 4;
	2503	break;
	2504
	2505	default:
	2506	break;
418cb3	2507	}
Q	2508	}
	2509	}
d34256	2510	catch (const std::exception&)
Z	2511	{
	2512	DbgLog(_T("无法绘制图形（程序不合理）"));
	2513	}
	2514
418cb3	2515	m_nTotalRow = maxy + 1;
Q	2516	/*
	2517	for (int i = 0; i < 25; i++)
	2518	{
	2519	for (int j = 0; j < 16; j++)
	2520	{
	2521	Cells[i][j].nType = i;
	2522	s1.Format(_T("%d:%d"), i, j);
	2523	Cells[i][j].sCoilName = s1;
	2524	}
	2525	}
	2526	*/
	2527	needReDraw = 1;
	2528	return 0;
	2529	}
e55aec	2530	bool firstCoil = true;//本段第一个单元格
418cb3	2531
d34256	2532	/// <summary>
Z	2533	/// 梯形图转Prog
	2534	/// </summary>
	2535	/// <returns></returns>
418cb3	2536	int CMTerm1View::TransLDSToProg()
Q	2537	{
	2538	CMTerm1Doc * pDoc = GetDocument();
	2539	CString s1;
	2540	s1.Format(_T("Trans LDS to PRrog"));
	2541	DbgLog(s1);
e55aec	2542	s1.Format(_T("将梯形图转成prog格式"));
Z	2543	DbgLog(s1);
418cb3	2544
ad1b4b	2545	//梯形图 ROW数量
e55aec	2546	s1.Format(_T("总计行数 %d"), m_nTotalRow);
Z	2547	DbgLog(s1);
418cb3	2548	s1.Format(_T("Total Lines %d"), m_nTotalRow);
Q	2549	DbgLog(s1);
e55aec	2550
418cb3	2551	//分段
Q	2552	int nDivCount = 0;
e55aec	2553	//分段点集合
418cb3	2554	int Divs[100] = { 0 };
ad1b4b	2555	for (int i = 0; i < m_nTotalRow; i++)
Z	2556	{
418cb3	2557	int nRow = i;
Q	2558	int bConnected = 0;
aac3b3	2559	for (int j = 0; j < m_CellPerLine; j++)
ad1b4b	2560	{
418cb3	2561	int nCol = j;
ad1b4b	2562	if (Cells[nRow][nCol].bLeftLineDn)
Z	2563	{
e55aec	2564	bConnected = 1;
Z	2565	s1.Format(_T("row==%d col==%d 有左下竖线！！！"), nRow,nCol);
	2566	DbgLog(s1);
	2567	break;
418cb3	2568	}
ad1b4b	2569	}
Z	2570	if (!bConnected)
	2571	{
418cb3	2572	//找到一处分界点
Q	2573	Divs[nDivCount] = i;
ad1b4b	2574	s1.Format(_T("Div at Line %d 是：：：：：：：：：：：：分界点"), nRow);
418cb3	2575	DbgLog(s1);
Q	2576	nDivCount++;
	2577	}
	2578	}
ad1b4b	2579
aac3b3	2580	stProgSection allprogs;
418cb3	2581	//每段单独处理
ad1b4b	2582	for (int i = 0; i < nDivCount; i++)
Z	2583	{
418cb3	2584	int nStartLine, nEndLine;
ad1b4b	2585	if (i == 0)
Z	2586	{
e55aec	2587	nStartLine = 0;
Z	2588	nEndLine = Divs[i];
ad1b4b	2589	}
Z	2590	else
	2591	{
e55aec	2592	nStartLine = Divs[i - 1]+1;
Z	2593	nEndLine = Divs[i];
ad1b4b	2594	}
e55aec	2595	s1.Format(_T("本段行号起始-终止： %d - %d "), nStartLine, nEndLine);
Z	2596	DbgLog(s1);
418cb3	2597	s1.Format(_T("Process Line %d - %d "), nStartLine, nEndLine);
Q	2598	DbgLog(s1);
	2599	int nCounts[20] = { 0 };
	2600	int nCounts2[20] = { 0 };
	2601	int nCounts3[20] = { 0 };
	2602
	2603	s1.Empty();
ad1b4b	2604	for (int j = 0; j < m_CellPerLine; j++)
Z	2605	{
418cb3	2606	int nCount = 0;
Q	2607	int nCount2 = 0;
	2608	int nCount3 = 0;
ad1b4b	2609	for (int k = nStartLine; k <= nEndLine; k++)
Z	2610	{
	2611	if (Cells[k][j].nType)
	2612	{
418cb3	2613	nCount += 1;
Q	2614	nCount2 += 1;
	2615	nCount3 += 1;
e55aec	2616	if (Cells[k][j].bLeftLineUp)
Z	2617	{
	2618	nCount2 -= 1;
	2619	}
418cb3	2620	// if (Cells[k][j].bLeftLineDn) nCount2 -= 1;
ad1b4b	2621
Z	2622	if (j != m_CellPerLine - 1)
	2623	{
e55aec	2624	if (Cells[k][j + 1].bLeftLineUp)
Z	2625	{
	2626	nCount3 -= 1;
	2627	}
418cb3	2628	// if (Cells[k][j + 1].bLeftLineDn) nCount3 -= 1;
Q	2629	}
	2630	}
	2631	}
	2632	nCounts[j] = nCount;
	2633	nCounts2[j] = nCount2;
	2634	nCounts3[j] = nCount3;
	2635	}
ad1b4b	2636
418cb3	2637	s1.Empty();
ad1b4b	2638	for (int j = 0; j < m_CellPerLine; j++)
Z	2639	{
418cb3	2640	s1.AppendFormat(_T(" %d(%d)"), nCounts[j],nCounts3[j]);
Q	2641	}
e55aec	2642	DbgLog(_T(""));
ad1b4b	2643
418cb3	2644	DbgLog(s1);
Q	2645	s1.Empty();
ad1b4b	2646	for (int j = 0; j < m_CellPerLine; j++)
Z	2647	{
418cb3	2648	s1.AppendFormat(_T(" %d "), nCounts2[j]);
Q	2649	}
	2650	DbgLog(s1);
	2651	//开始从左到右，从上到下扫描，主要关注竖直连接线。
	2652	int nCurPosX,nCurPosY;
	2653	nCurPosY = nStartLine;
	2654	nCurPosX = 0;
	2655	CString sProg;
	2656	int nAllSteps=0;
	2657	stProgSection Progsec;
e55aec	2658	for (int i = nStartLine; i <= nEndLine; i++)
Z	2659	{
418cb3	2660	CString sProgSec;
Q	2661	int nSteps = 0;;
	2662	nCurPosY = i;
	2663	stProgSection thisprogsec;
	2664	if (Cells[i][0].nType)
d34256	2665	{
e55aec	2666	firstCoil = true;
ad1b4b	2667	//循环遍历单元格(转换的逻辑在这个函数)
d34256	2668	ScanLDSCells(nStartLine, nEndLine, nCurPosY, nCurPosX, 0, thisprogsec, sProgSec, nSteps);
Z	2669	}
418cb3	2670	sProg += sProgSec;
e55aec	2671	nAllSteps += nSteps;
418cb3	2672	Progsec += thisprogsec;
Q	2673	}
d34256	2674
418cb3	2675	DbgLog(_T("\r\n")+ sProg);
Q	2676	int n = int(Progsec.Progs.size());
e55aec	2677	s1.Format(_T("程序段步数： %d "), n);
Z	2678	DbgLog(s1);
418cb3	2679	s1.Format(_T("progSec steps %d "), n);
Q	2680	DbgLog(s1);
ad1b4b	2681	for (int i = 0; i < n; i++)
Z	2682	{
418cb3	2683	int optype = Progsec.Progs[i].nOpType1;
Q	2684	CStringA OpTxtA, OpShowTxtA;
	2685	CString OpTxt, OpShowTxt;
	2686	pDoc->OpToTxt(optype, OpTxtA);
	2687	pDoc->OpToShowTxt(optype, OpShowTxtA);
	2688	OpTxt = OpTxtA;
	2689	OpShowTxt = OpShowTxtA;
	2690	s1.Format(_T("%d %s %s"), optype, OpTxt, OpShowTxt);
	2691	DbgLog(s1);
	2692	}
	2693	allprogs += Progsec;
	2694	}
ad1b4b	2695
418cb3	2696	//输出程序
Q	2697	int n=(int)allprogs.Progs.size();
e55aec	2698	s1.Format(_T("总程序步数 %d "), n);
Z	2699	DbgLog(s1);
418cb3	2700	s1.Format(_T("all prog steps %d "), n);
Q	2701	DbgLog(s1);
ad1b4b	2702	for (int i = 0; i < n; i++)
Z	2703	{
418cb3	2704	int optype=allprogs.Progs[i].nOpType1;
df0321	2705	allprogs.Progs[i].PairTo = 0;
Q	2706	allprogs.Progs[i].nBinStep = i;
418cb3	2707	CStringA OpTxtA,OpShowTxtA;
Q	2708	CString OpTxt,OpShowTxt;
	2709	pDoc->OpToTxt(optype, OpTxtA);
	2710	pDoc->OpToShowTxt(optype, OpShowTxtA);
	2711	OpTxt = OpTxtA;
	2712	OpShowTxt = OpShowTxtA;
	2713	s1.Format(_T("%d %s %s"), optype, OpTxt, OpShowTxt);
df0321	2714	pDoc->Progs[i] = allprogs.Progs[i];
418cb3	2715	// DbgLog(s1);
Q	2716	}
df0321	2717	pDoc->m_nProgSteps = n;
418cb3	2718	return 0;
Q	2719	}
	2720
d34256	2721
Z	2722	/// <summary>
	2723	/// ：绘制每个单元格的内容
	2724	/// </summary>
	2725	/// <param name="nStartLine"></param>
	2726	/// <param name="nEndLine"></param>
aac3b3	2727	/// <param name="nPosY">行</param>
Z	2728	/// <param name="nPosX">列</param>
	2729	/// <param name="nLevel">层级</param>
e55aec	2730	/// <param name="progsec">prog格式的指令集</param>
Z	2731	/// <param name="sProgSec">指令集</param>
	2732	/// <param name="nSteps">程序步数</param>
d34256	2733	/// <returns></returns>
aac3b3	2734	int CMTerm1View::ScanLDSCells(int nStartLine, int nEndLine, int nPosY, int nPosX,
Z	2735	int nLevel, stProgSection & progsec, CString & sProgSec, int &nSteps)
418cb3	2736	{
Q	2737	CString s1;
	2738	int nCurPosX, nCurPosY;
e55aec	2739	int nNextX = 1;//步长
418cb3	2740	nCurPosY = nPosY;
Q	2741	nCurPosX = nPosX;
df0321	2742	int nCoilType, CoilAddr;
Q	2743	CMTerm1Doc* pDoc = GetDocument();
ad1b4b	2744	for (int j = nPosX; j < m_CellPerLine; j += nNextX)
Z	2745	{
418cb3	2746	nCurPosX = j;
Q	2747	//先处理当前单元;
	2748	int nType = Cells[nCurPosY][nCurPosX].nType;
	2749	CString sCellName = Cells[nCurPosY][nCurPosX].sCoilName;
	2750	CMTerm1Doc::stProg theprog;
df0321	2751	CStringA sCellNameA;
Q	2752	sCellNameA = sCellName;
ad1b4b	2753
e55aec	2754	if (j + nNextX >= m_CellPerLine)
Z	2755	{
	2756	continue;
	2757	}
	2758
	2759	//1.先获取此单元格右侧一格的竖线
	2760	if (Cells[nCurPosY][j + nNextX].bLeftLineUp
	2761	\|\| Cells[nCurPosY][j + nNextX].bLeftLineDn)
	2762	{
	2763
aac3b3	2764	////先看往上面有没有连接
Z	2765	//if (Cells[nCurPosY][j + nNextX].bLeftLineUp)
	2766	//{
	2767	// // 往上面有连接且有触点连接，才使用ORS
	2768	// s1.Format(_T("%d %d ORS "), nCurPosY, nCurPosX);
	2769	// DbgLog(s1);
	2770	// theprog.nOpType1 = OP_ORS;
	2771	// //theprog.nOpType1 = OP_ST;
	2772	// //theprog.PairTo = OP_ORS;
	2773	// progsec.Append(theprog);
	2774	// sProgSec.AppendFormat(_T("ORS \r\n"));
	2775	// firstCoil = false;
	2776	// nSteps += 1;
	2777	// nLevel -= 1;
	2778	//}
e55aec	2779	//左上是否有链接
Z	2780	int nLeftUpCon = 0;
	2781	if (Cells[nCurPosY][j + nNextX].bLeftLineUp)
	2782	{
	2783	nLeftUpCon = 1;
	2784	}
	2785	//向下查找，看看竖线的左侧下面还有没有连接其他东西
	2786	int nLeftDnCon = 0;//单元格左侧向下连接数
	2787	for (int k = nCurPosY + 1; k <= nEndLine; k++)
	2788	{
	2789	if (Cells[k][j + nNextX].bLeftLineDn)
	2790	{
	2791	if (Cells[k][j + nNextX - 1].nType)
	2792	{
	2793	nLeftDnCon += 1;
	2794	}
	2795	}
	2796	else
	2797	{
	2798	break; // 竖线到最下面的端点了。
	2799	}
	2800	}
	2801
	2802	s1.Format(_T("LeftUp %d LeftDn %d"), nLeftUpCon, nLeftDnCon);
	2803	DbgLog(s1);
	2804
	2805	//左侧下面有连接，那么扫描到这个竖线时返回，继续扫描左侧下面的内容。
	2806	if (nLeftDnCon)
	2807	{
	2808	return 1;
	2809	}
	2810	// 左侧下面没有连接，那么这个就是左面最后的单元，开始处理右面的单元。
	2811	else
	2812	{
	2813	if (nLeftUpCon)
	2814	{
	2815	if (nPosX > 0 \|\| nLevel > 0)
	2816	{
	2817	s1.Format(_T("%d %d ANS "), nCurPosY, nCurPosX);
	2818	DbgLog(s1);
	2819	theprog.nOpType1 = OP_ANS;
	2820	progsec.Append(theprog);
	2821	sProgSec.AppendFormat(_T("ANS \r\n"));
	2822	nSteps += 1;
	2823	nLevel -= 1;
	2824	}
	2825	}
	2826	//从头到尾处理, 查找此竖线的最高位置;
	2827	int nLineTop = nCurPosY;
	2828	int nLineBottom = nCurPosY;
	2829	for (int k = nCurPosY; k >= nStartLine; k--)
	2830	{
	2831	if (!Cells[k][j + nNextX].bLeftLineUp)
	2832	{
	2833	break;
	2834	}
	2835	nLineTop = k - 1;
	2836	}
	2837
	2838	// 查找右侧有几个连接
	2839	int nRightCon = 0;//单元格右侧连接数
	2840	for (int k = nLineTop; k <= nEndLine; k++)
	2841	{
	2842	if (Cells[k][j + nNextX].nType)
	2843	{
	2844	nRightCon += 1;
	2845	}
	2846	nLineBottom = k;
	2847	if (!Cells[k][j + nNextX].bLeftLineDn)
	2848	{
	2849	break;
	2850	}
	2851	}
	2852	s1.Format(_T("VLine %d - %d : %d , right = %d "), nLineTop, nLineBottom, j + nNextX, nRightCon);
	2853	DbgLog(s1);
	2854
	2855	if (nRightCon == 1)
	2856	{
aac3b3	2857	s1.Format(_T(">>>> Go %d : %d , level %d "), nLineTop, j + nNextX, nLevel);
Z	2858	DbgLog(s1);
	2859	CString ProgSec;
	2860	int theSteps = 0;
	2861	stProgSection thisprogsec;
e55aec	2862
aac3b3	2863	//
Z	2864	int r = ScanLDSCells(nStartLine, nEndLine, nLineTop, j + nNextX, nLevel, thisprogsec, ProgSec, theSteps);
e55aec	2865
aac3b3	2866	sProgSec += ProgSec;
Z	2867	nSteps += theSteps;
	2868	progsec += thisprogsec;
	2869	s1.Format(_T("<<<< Re %d : %d , Result %d "), nLineTop, j + nNextX, 0);
	2870	DbgLog(s1);
e55aec	2871	}
Z	2872	else
	2873	{
	2874	int nLastResult = 0;
	2875	int nRightCount = 0;
	2876	CString sCons[100];
	2877	CString ProgSecs[100];
	2878	int res[100] = { 0 };
	2879	int nLastSteps = 0;
	2880	for (int k = nLineTop; k <= nLineBottom; k++)
	2881	{
	2882	//s1.Format(_T("VLine %d - %d : %d %d of %d "), nLineTop, nLineBottom, j + nNextX, k+1,nRightCon);
	2883	//DbgLog(s1);
	2884	if (Cells[k][j + nNextX].nType)
	2885	{
	2886	s1.Format(_T(" >>> Go %d : %d , level %d "), k, j + nNextX, nLevel + 1);
	2887	DbgLog(s1);
	2888	CString ProgSec;
	2889	int theSteps = 0;
	2890	nLevel += 1;
	2891	stProgSection thisprogsec;
	2892	res[nRightCount] = ScanLDSCells(nStartLine, nEndLine, k, j + nNextX, nLevel, thisprogsec, ProgSecs[nRightCount], theSteps);
	2893	nLastResult = res[nRightCount];
	2894	nSteps += theSteps;
	2895	progsec += thisprogsec;
	2896	//if (res[nRightCount] > 0) nLevel += 1;
	2897	sProgSec += ProgSec;
	2898	s1.Format(_T(" <<< Re %d : %d , Result %d Steps %d Last %d"), k, j + nNextX, res[nRightCount], theSteps, nLastSteps);
	2899	DbgLog(s1);
	2900	if (nRightCount == 0)
	2901	{
	2902
	2903	}
	2904	else if (res[nRightCount - 1] == 0)
	2905	{
	2906	s1.Format(_T(" POPS"), k, j + nNextX, nLevel + 1);
	2907	DbgLog(s1);
	2908	//sProgSec.AppendFormat(_T("POPS \r\n"));
	2909	if (nLastSteps > 1)
	2910	{
	2911	if (sCons[nRightCount - 1] == _T("POPS"))
	2912	{
	2913	sCons[nRightCount - 1] = _T("RDS");
	2914	}
	2915	else
	2916	{
	2917	sCons[nRightCount - 1] = _T("PSHS");
	2918	}
	2919	sCons[nRightCount] = _T("POPS");
	2920	}
	2921	}
	2922	else
	2923	{
	2924
	2925	}
	2926	nLastSteps = theSteps;
	2927	nRightCount++;
	2928	}
	2929	}
	2930	nLastResult = 0;
	2931	for (int k = 0; k < nRightCount; k++)
	2932	{
	2933	if (nLastResult \|\| res[k])
	2934	{
	2935	s1 = _T("ST") + ProgSecs[k];
	2936
	2937	ProgSecs[k] = s1;
	2938	}
	2939	s1 = sCons[k] + _T("\r\n") + ProgSecs[k];
	2940	sProgSec.Append(s1);
	2941	nLastResult = res[k];
	2942	}
	2943	if (nLastResult)
	2944	{
	2945	sProgSec.Append(_T("ANS\r\n"));
	2946	}
	2947	return 0;
	2948	}
	2949	}
	2950	}
	2951
	2952	#pragma region 根据单元格类型转换为指令和prog
	2953
	2954	if (nType == typeNO)
d34256	2955	{
ad1b4b	2956	if (firstCoil && nType != typeLine1 && nType != typeLine2)
Z	2957	{
aac3b3	2958	//先看往上面有没有连接
Z	2959	if (Cells[nCurPosY][j + nNextX].bLeftLineUp)
	2960	{
	2961	// 往上面有连接且有触点连接，才使用OR
	2962	s1.Format(_T("%d %d OR %s"), nCurPosY, nCurPosX, sCellName);
	2963	sProgSec.AppendFormat(_T("OR %s\r\n"), sCellName);
	2964	theprog.nOpType1 = OP_OR;
	2965	}
	2966	else
	2967	{
	2968	s1.Format(_T("%d %d ST %s"), nCurPosY, nCurPosX, sCellName);
	2969	sProgSec.AppendFormat(_T("ST %s\r\n"), sCellName);
	2970	theprog.nOpType1 = OP_ST;
	2971	}
df0321	2972	theprog.nParamCount = 1;
Q	2973	pDoc->TxtToCoilType(sCellNameA, &nCoilType, &CoilAddr);
	2974	theprog.Params[0].nParamType = nCoilType;
	2975	theprog.Params[0].nParamAddr = CoilAddr;
	2976	theprog.Params[0].sParamStr = sCellNameA;
418cb3	2977	progsec.Append(theprog);
ad1b4b	2978	firstCoil = false;
418cb3	2979	}
e55aec	2980	else
Z	2981	{
418cb3	2982	s1.Format(_T("%d %d AN %s"), nCurPosY, nCurPosX, sCellName);
Q	2983	sProgSec.AppendFormat(_T("NO %s\r\n"), sCellName);
	2984	theprog.nOpType1 = OP_AN;
df0321	2985	theprog.nParamCount = 1;
Q	2986	pDoc->TxtToCoilType(sCellNameA, &nCoilType, &CoilAddr);
	2987	theprog.Params[0].nParamType = nCoilType;
	2988	theprog.Params[0].nParamAddr = CoilAddr;
	2989	theprog.Params[0].sParamStr = sCellNameA;
418cb3	2990	progsec.Append(theprog);
Q	2991	}
	2992	nSteps += 1;
	2993	DbgLog(s1);
e55aec	2994	nNextX = 1;
ad1b4b	2995	}
e55aec	2996	else if (nType == typeNC)
ad1b4b	2997	{
Z	2998	if (firstCoil && nType != typeLine1 && nType != typeLine2)
	2999	{
418cb3	3000	s1.Format(_T("%d %d ST/ %s"), nCurPosY, nCurPosX, sCellName);
Q	3001	sProgSec.AppendFormat(_T("ST/ %s\r\n"), sCellName);
	3002	theprog.nOpType1 = OP_ST_;
df0321	3003	theprog.nParamCount = 1;
Q	3004	pDoc->TxtToCoilType(sCellNameA, &nCoilType, &CoilAddr);
	3005	theprog.Params[0].nParamType = nCoilType;
	3006	theprog.Params[0].nParamAddr = CoilAddr;
	3007	theprog.Params[0].sParamStr = sCellNameA;
418cb3	3008	progsec.Append(theprog);
ad1b4b	3009	firstCoil = false;
418cb3	3010	}
Q	3011	else
	3012	{
	3013	s1.Format(_T("%d %d AN/ %s"), nCurPosY, nCurPosX, sCellName);
	3014	sProgSec.AppendFormat(_T("AN/ %s\r\n"), sCellName);
	3015	theprog.nOpType1 = OP_AN_;
df0321	3016	theprog.nParamCount = 1;
Q	3017	pDoc->TxtToCoilType(sCellNameA, &nCoilType, &CoilAddr);
	3018	theprog.Params[0].nParamType = nCoilType;
	3019	theprog.Params[0].nParamAddr = CoilAddr;
	3020	theprog.Params[0].sParamStr = sCellNameA;
418cb3	3021	progsec.Append(theprog);
Q	3022	}
	3023	DbgLog(s1);
	3024	nSteps += 1;
e55aec	3025	nNextX = 1;
ad1b4b	3026	}
e55aec	3027	else if (nType == typePP)
ad1b4b	3028	{
418cb3	3029	s1.Format(_T("%d %d PP %s"), nCurPosY, nCurPosX, sCellName);
Q	3030	DbgLog(s1);
	3031	//progsec.Append(theprog);
	3032	sProgSec.AppendFormat(_T("PP %s\r\n"), sCellName);
	3033	nSteps += 1;
e55aec	3034	nNextX = 1;
ad1b4b	3035	}
e55aec	3036	else if (nType == typePN)
ad1b4b	3037	{
418cb3	3038	s1.Format(_T("%d %d PN %s"), nCurPosY, nCurPosX, sCellName);
Q	3039	DbgLog(s1);
	3040	//progsec.Append(theprog);
	3041	sProgSec.AppendFormat(_T("PN %s\r\n"), sCellName, sCellName);
	3042	nSteps += 1;
e55aec	3043	nNextX = 1;
ad1b4b	3044	}
e55aec	3045	else if (nType == typeNOT)
ad1b4b	3046	{
418cb3	3047	s1.Format(_T("%d %d NOT %s"), nCurPosY, nCurPosX, sCellName);
Q	3048	DbgLog(s1);
	3049	sProgSec.AppendFormat(_T("NOT %s\r\n"), sCellName);
	3050	theprog.nOpType1 = OP_NOT;
	3051	progsec.Append(theprog);
	3052	nSteps += 1;
e55aec	3053	nNextX = 1;
ad1b4b	3054	}
Z	3055	else if (nType == typeDF)
	3056	{
418cb3	3057	s1.Format(_T("%d %d DF %s"), nCurPosY, nCurPosX, sCellName);
Q	3058	DbgLog(s1);
	3059	sProgSec.AppendFormat(_T("DF %s\r\n"), sCellName);
	3060	theprog.nOpType1 = OP_DF;
	3061	progsec.Append(theprog);
	3062	nSteps += 1;
e55aec	3063	nNextX = 1;
ad1b4b	3064	}
Z	3065	else if (nType == typeDF_)
	3066	{
418cb3	3067	s1.Format(_T("%d %d DF/ %s"), nCurPosY, nCurPosX, sCellName);
Q	3068	DbgLog(s1);
	3069	sProgSec.AppendFormat(_T("DF/ %s\r\n"), sCellName);
	3070	theprog.nOpType1 = OP_DF_;
	3071	progsec.Append(theprog);
	3072	nSteps += 1;
e55aec	3073	nNextX = 1;
ad1b4b	3074	}
Z	3075	else if (nType == typeOUT)
	3076	{
418cb3	3077	s1.Format(_T("%d %d OUT %s"), nCurPosY, nCurPosX, sCellName);
Q	3078	DbgLog(s1);
	3079	sProgSec.AppendFormat(_T("OUT %s\r\n"), sCellName);
	3080	theprog.nOpType1 = OP_OUT;
df0321	3081	theprog.nParamCount = 1;
Q	3082	pDoc->TxtToCoilType(sCellNameA, &nCoilType, &CoilAddr);
	3083	theprog.Params[0].nParamType = nCoilType;
	3084	theprog.Params[0].nParamAddr = CoilAddr;
	3085	theprog.Params[0].sParamStr = sCellNameA;
418cb3	3086	progsec.Append(theprog);
Q	3087	nSteps += 1;
e55aec	3088	nNextX = 1;
ad1b4b	3089	}
Z	3090	else if (nType == typeSET)
	3091	{
418cb3	3092	s1.Format(_T("%d %d SET %s"), nCurPosY, nCurPosX, sCellName);
Q	3093	DbgLog(s1);
	3094	sProgSec.AppendFormat(_T("SET %s\r\n"), sCellName);
	3095	theprog.nOpType1 = OP_SET;
df0321	3096	theprog.nParamCount = 1;
Q	3097	pDoc->TxtToCoilType(sCellNameA, &nCoilType, &CoilAddr);
	3098	theprog.Params[0].nParamType = nCoilType;
	3099	theprog.Params[0].nParamAddr = CoilAddr;
	3100	theprog.Params[0].sParamStr = sCellNameA;
418cb3	3101	progsec.Append(theprog);
Q	3102	nSteps += 1;
e55aec	3103	nNextX = 1;
ad1b4b	3104	}
Z	3105	else if (nType == typeRESET)
	3106	{
418cb3	3107	s1.Format(_T("%d %d RESET %s"), nCurPosY, nCurPosX, sCellName);
Q	3108	DbgLog(s1);
	3109	sProgSec.AppendFormat(_T("RESET %s\r\n"), sCellName);
	3110	theprog.nOpType1 = OP_RESET;
df0321	3111	theprog.nParamCount = 1;
Q	3112	pDoc->TxtToCoilType(sCellNameA, &nCoilType, &CoilAddr);
	3113	theprog.Params[0].nParamType = nCoilType;
	3114	theprog.Params[0].nParamAddr = CoilAddr;
	3115	theprog.Params[0].sParamStr = sCellNameA;
418cb3	3116	progsec.Append(theprog);
Q	3117	nSteps += 1;
e55aec	3118	nNextX = 1;
ad1b4b	3119	}
e55aec	3120	else if (nType == typeCMP)
ad1b4b	3121	{
e55aec	3122	s1.Format(_T("%d %d CMP %s %s %s"), nCurPosY, nCurPosX, sCellName, Cells[nCurPosY][nCurPosX + 1].sParam, Cells[nCurPosY][nCurPosX + 2].sParam);
418cb3	3123	DbgLog(s1);
Q	3124	theprog.nOpType1 = OP_ST_GT;
df0321	3125	theprog.nParamCount = 1;
418cb3	3126	progsec.Append(theprog);
Q	3127	sProgSec.AppendFormat(_T("CMP %s %s %s \r\n"), sCellName, Cells[nCurPosY][nCurPosX + 1].sParam, Cells[nCurPosY][nCurPosX + 2].sParam);
	3128	nSteps += 1;
e55aec	3129	nNextX = 3;
ad1b4b	3130	}
e55aec	3131	else if (nType == typeTM)
ad1b4b	3132	{
e55aec	3133	s1.Format(_T("%d %d TM %s %d %s"), nCurPosY, nCurPosX, sCellName, Cells[nCurPosY][nCurPosX + 1].sParam, Cells[nCurPosY][nCurPosX + 2].sParam);
418cb3	3134	DbgLog(s1);
Q	3135	theprog.nOpType1 = OP_TMX;
df0321	3136	theprog.nParamCount = 1;
Q	3137	pDoc->TxtToCoilType(sCellNameA, &nCoilType, &CoilAddr);
	3138	theprog.Params[0].nParamType = nCoilType;
	3139	theprog.Params[0].nParamAddr = CoilAddr;
	3140	theprog.Params[0].sParamStr = sCellNameA;
418cb3	3141	progsec.Append(theprog);
e55aec	3142	sProgSec.AppendFormat(_T("TM %s %d %s\r\n"), sCellName, Cells[nCurPosY][nCurPosX + 1].sParam, Cells[nCurPosY][nCurPosX + 2].sParam);
418cb3	3143	nSteps += 1;
e55aec	3144	nNextX = 3;
ad1b4b	3145	}
e55aec	3146	else if (nType == typeFN1)
ad1b4b	3147	{
e55aec	3148	s1.Format(_T("%d %d FN1 %s %s"), nCurPosY, nCurPosX, sCellName, Cells[nCurPosY][nCurPosX + 1].sParam);
418cb3	3149	DbgLog(s1);
Q	3150	theprog.nOpType1 = OP_INC;
	3151	progsec.Append(theprog);
	3152	sProgSec.AppendFormat(_T("FN1 %s %s\r\n"), sCellName, Cells[nCurPosY][nCurPosX + 1].sParam);
	3153	nSteps += 1;
e55aec	3154	nNextX = 2;
ad1b4b	3155	}
e55aec	3156	else if (nType == typeFN2)
ad1b4b	3157	{
418cb3	3158	s1.Format(_T("%d %d FN2 %s %s %s "), nCurPosY, nCurPosX, sCellName, Cells[nCurPosY][nCurPosX + 1].sParam, Cells[nCurPosY][nCurPosX + 2].sParam);
Q	3159	DbgLog(s1);
	3160	theprog.nOpType1 = OP_MV;
	3161	progsec.Append(theprog);
	3162	sProgSec.AppendFormat(_T("FN2 %s %s %s \r\n"), sCellName, Cells[nCurPosY][nCurPosX + 1].sParam, Cells[nCurPosY][nCurPosX + 2].sParam);
	3163	nSteps += 1;
e55aec	3164	nNextX = 3;
ad1b4b	3165	}
e55aec	3166	else if (nType == typeFN3)
ad1b4b	3167	{
418cb3	3168	s1.Format(_T("%d %d FN3 %s %s %s %s"), nCurPosY, nCurPosX, sCellName, Cells[nCurPosY][nCurPosX + 1].sParam, Cells[nCurPosY][nCurPosX + 2].sParam, Cells[nCurPosY][nCurPosX + 3].sParam);
Q	3169	DbgLog(s1);
	3170	theprog.nOpType1 = OP_ADD3;
	3171	progsec.Append(theprog);
	3172	sProgSec.AppendFormat(_T("FN3 %s %s %s %s\r\n"), sCellName, Cells[nCurPosY][nCurPosX + 1].sParam, Cells[nCurPosY][nCurPosX + 2].sParam, Cells[nCurPosY][nCurPosX + 3].sParam);
	3173	nSteps += 1;
e55aec	3174	nNextX = 4;
ad1b4b	3175	}
e55aec	3176	else
ad1b4b	3177	{
e55aec	3178	nNextX = 1;
418cb3	3179	//continue;
Q	3180	}
e55aec	3181
Z	3182	#pragma endregion
418cb3	3183
Q	3184	}
	3185	return 0;
aac3b3	3186	}
Z	3187	/*
	3188	void CMTerm1View::chuansileitetoprog(int nStartLine, int nEndLine, int nPosY, int nPosX, int nLevel, stProgSection& progsec, CString& sProgSec, int& nSteps)
	3189	{
	3190	CString s1;
	3191	int nCurPosX, nCurPosY;
	3192	int nNextX = 1;//步长
	3193	nCurPosY = nPosY;
	3194	nCurPosX = nPosX;
	3195	int nCoilType, CoilAddr;
	3196	CMTerm1Doc* pDoc = GetDocument();
	3197	#pragma region 根据单元格类型转换为指令和prog
	3198
	3199	if (nType == typeNO)
	3200	{
	3201	if (firstCoil && nType != typeLine1 && nType != typeLine2)
	3202	{
	3203	//先看往上面有没有连接
	3204	if (Cells[nCurPosY][j + nNextX].bLeftLineUp)
	3205	{
	3206	// 往上面有连接且有触点连接，才使用OR
	3207	s1.Format(_T("%d %d OR %s"), nCurPosY, nCurPosX, sCellName);
	3208	sProgSec.AppendFormat(_T("OR %s\r\n"), sCellName);
	3209	.nOpType1 = OP_OR;
	3210	}
	3211	else
	3212	{
	3213	s1.Format(_T("%d %d ST %s"), nCurPosY, nCurPosX, sCellName);
	3214	sProgSec.AppendFormat(_T("ST %s\r\n"), sCellName);
	3215	theprog.nOpType1 = OP_ST;
	3216	}
	3217	theprog.nParamCount = 1;
	3218	pDoc->TxtToCoilType(sCellNameA, &nCoilType, &CoilAddr);
	3219	theprog.Params[0].nParamType = nCoilType;
	3220	theprog.Params[0].nParamAddr = CoilAddr;
	3221	theprog.Params[0].sParamStr = sCellNameA;
	3222	progsec.Append(theprog);
	3223	firstCoil = false;
	3224	}
	3225	else
	3226	{
	3227	s1.Format(_T("%d %d AN %s"), nCurPosY, nCurPosX, sCellName);
	3228	sProgSec.AppendFormat(_T("NO %s\r\n"), sCellName);
	3229	theprog.nOpType1 = OP_AN;
	3230	theprog.nParamCount = 1;
	3231	pDoc->TxtToCoilType(sCellNameA, &nCoilType, &CoilAddr);
	3232	theprog.Params[0].nParamType = nCoilType;
	3233	theprog.Params[0].nParamAddr = CoilAddr;
	3234	theprog.Params[0].sParamStr = sCellNameA;
	3235	progsec.Append(theprog);
	3236	}
	3237	nSteps += 1;
	3238	DbgLog(s1);
	3239	nNextX = 1;
	3240	}
	3241	else if (nType == typeNC)
	3242	{
	3243	if (firstCoil && nType != typeLine1 && nType != typeLine2)
	3244	{
	3245	s1.Format(_T("%d %d ST/ %s"), nCurPosY, nCurPosX, sCellName);
	3246	sProgSec.AppendFormat(_T("ST/ %s\r\n"), sCellName);
	3247	theprog.nOpType1 = OP_ST_;
	3248	theprog.nParamCount = 1;
	3249	pDoc->TxtToCoilType(sCellNameA, &nCoilType, &CoilAddr);
	3250	theprog.Params[0].nParamType = nCoilType;
	3251	theprog.Params[0].nParamAddr = CoilAddr;
	3252	theprog.Params[0].sParamStr = sCellNameA;
	3253	progsec.Append(theprog);
	3254	firstCoil = false;
	3255	}
	3256	else
	3257	{
	3258	s1.Format(_T("%d %d AN/ %s"), nCurPosY, nCurPosX, sCellName);
	3259	sProgSec.AppendFormat(_T("AN/ %s\r\n"), sCellName);
	3260	theprog.nOpType1 = OP_AN_;
	3261	theprog.nParamCount = 1;
	3262	pDoc->TxtToCoilType(sCellNameA, &nCoilType, &CoilAddr);
	3263	theprog.Params[0].nParamType = nCoilType;
	3264	theprog.Params[0].nParamAddr = CoilAddr;
	3265	theprog.Params[0].sParamStr = sCellNameA;
	3266	progsec.Append(theprog);
	3267	}
	3268	DbgLog(s1);
	3269	nSteps += 1;
	3270	nNextX = 1;
	3271	}
	3272	else if (nType == typePP)
	3273	{
	3274	s1.Format(_T("%d %d PP %s"), nCurPosY, nCurPosX, sCellName);
	3275	DbgLog(s1);
	3276	//progsec.Append(theprog);
	3277	sProgSec.AppendFormat(_T("PP %s\r\n"), sCellName);
	3278	nSteps += 1;
	3279	nNextX = 1;
	3280	}
	3281	else if (nType == typePN)
	3282	{
	3283	s1.Format(_T("%d %d PN %s"), nCurPosY, nCurPosX, sCellName);
	3284	DbgLog(s1);
	3285	//progsec.Append(theprog);
	3286	sProgSec.AppendFormat(_T("PN %s\r\n"), sCellName, sCellName);
	3287	nSteps += 1;
	3288	nNextX = 1;
	3289	}
	3290	else if (nType == typeNOT)
	3291	{
	3292	s1.Format(_T("%d %d NOT %s"), nCurPosY, nCurPosX, sCellName);
	3293	DbgLog(s1);
	3294	sProgSec.AppendFormat(_T("NOT %s\r\n"), sCellName);
	3295	theprog.nOpType1 = OP_NOT;
	3296	progsec.Append(theprog);
	3297	nSteps += 1;
	3298	nNextX = 1;
	3299	}
	3300	else if (nType == typeDF)
	3301	{
	3302	s1.Format(_T("%d %d DF %s"), nCurPosY, nCurPosX, sCellName);
	3303	DbgLog(s1);
	3304	sProgSec.AppendFormat(_T("DF %s\r\n"), sCellName);
	3305	theprog.nOpType1 = OP_DF;
	3306	progsec.Append(theprog);
	3307	nSteps += 1;
	3308	nNextX = 1;
	3309	}
	3310	else if (nType == typeDF_)
	3311	{
	3312	s1.Format(_T("%d %d DF/ %s"), nCurPosY, nCurPosX, sCellName);
	3313	DbgLog(s1);
	3314	sProgSec.AppendFormat(_T("DF/ %s\r\n"), sCellName);
	3315	theprog.nOpType1 = OP_DF_;
	3316	progsec.Append(theprog);
	3317	nSteps += 1;
	3318	nNextX = 1;
	3319	}
	3320	else if (nType == typeOUT)
	3321	{
	3322	s1.Format(_T("%d %d OUT %s"), nCurPosY, nCurPosX, sCellName);
	3323	DbgLog(s1);
	3324	sProgSec.AppendFormat(_T("OUT %s\r\n"), sCellName);
	3325	theprog.nOpType1 = OP_OUT;
	3326	theprog.nParamCount = 1;
	3327	pDoc->TxtToCoilType(sCellNameA, &nCoilType, &CoilAddr);
	3328	theprog.Params[0].nParamType = nCoilType;
	3329	theprog.Params[0].nParamAddr = CoilAddr;
	3330	theprog.Params[0].sParamStr = sCellNameA;
	3331	progsec.Append(theprog);
	3332	nSteps += 1;
	3333	nNextX = 1;
	3334	}
	3335	else if (nType == typeSET)
	3336	{
	3337	s1.Format(_T("%d %d SET %s"), nCurPosY, nCurPosX, sCellName);
	3338	DbgLog(s1);
	3339	sProgSec.AppendFormat(_T("SET %s\r\n"), sCellName);
	3340	theprog.nOpType1 = OP_SET;
	3341	theprog.nParamCount = 1;
	3342	pDoc->TxtToCoilType(sCellNameA, &nCoilType, &CoilAddr);
	3343	theprog.Params[0].nParamType = nCoilType;
	3344	theprog.Params[0].nParamAddr = CoilAddr;
	3345	theprog.Params[0].sParamStr = sCellNameA;
	3346	progsec.Append(theprog);
	3347	nSteps += 1;
	3348	nNextX = 1;
	3349	}
	3350	else if (nType == typeRESET)
	3351	{
	3352	s1.Format(_T("%d %d RESET %s"), nCurPosY, nCurPosX, sCellName);
	3353	DbgLog(s1);
	3354	sProgSec.AppendFormat(_T("RESET %s\r\n"), sCellName);
	3355	theprog.nOpType1 = OP_RESET;
	3356	theprog.nParamCount = 1;
	3357	pDoc->TxtToCoilType(sCellNameA, &nCoilType, &CoilAddr);
	3358	theprog.Params[0].nParamType = nCoilType;
	3359	theprog.Params[0].nParamAddr = CoilAddr;
	3360	theprog.Params[0].sParamStr = sCellNameA;
	3361	progsec.Append(theprog);
	3362	nSteps += 1;
	3363	nNextX = 1;
	3364	}
	3365	else if (nType == typeCMP)
	3366	{
	3367	s1.Format(_T("%d %d CMP %s %s %s"), nCurPosY, nCurPosX, sCellName, Cells[nCurPosY][nCurPosX + 1].sParam, Cells[nCurPosY][nCurPosX + 2].sParam);
	3368	DbgLog(s1);
	3369	theprog.nOpType1 = OP_ST_GT;
	3370	theprog.nParamCount = 1;
	3371	progsec.Append(theprog);
	3372	sProgSec.AppendFormat(_T("CMP %s %s %s \r\n"), sCellName, Cells[nCurPosY][nCurPosX + 1].sParam, Cells[nCurPosY][nCurPosX + 2].sParam);
	3373	nSteps += 1;
	3374	nNextX = 3;
	3375	}
	3376	else if (nType == typeTM)
	3377	{
	3378	s1.Format(_T("%d %d TM %s %d %s"), nCurPosY, nCurPosX, sCellName, Cells[nCurPosY][nCurPosX + 1].sParam, Cells[nCurPosY][nCurPosX + 2].sParam);
	3379	DbgLog(s1);
	3380	theprog.nOpType1 = OP_TMX;
	3381	theprog.nParamCount = 1;
	3382	pDoc->TxtToCoilType(sCellNameA, &nCoilType, &CoilAddr);
	3383	theprog.Params[0].nParamType = nCoilType;
	3384	theprog.Params[0].nParamAddr = CoilAddr;
	3385	theprog.Params[0].sParamStr = sCellNameA;
	3386	progsec.Append(theprog);
	3387	sProgSec.AppendFormat(_T("TM %s %d %s\r\n"), sCellName, Cells[nCurPosY][nCurPosX + 1].sParam, Cells[nCurPosY][nCurPosX + 2].sParam);
	3388	nSteps += 1;
	3389	nNextX = 3;
	3390	}
	3391	else if (nType == typeFN1)
	3392	{
	3393	s1.Format(_T("%d %d FN1 %s %s"), nCurPosY, nCurPosX, sCellName, Cells[nCurPosY][nCurPosX + 1].sParam);
	3394	DbgLog(s1);
	3395	theprog.nOpType1 = OP_INC;
	3396	progsec.Append(theprog);
	3397	sProgSec.AppendFormat(_T("FN1 %s %s\r\n"), sCellName, Cells[nCurPosY][nCurPosX + 1].sParam);
	3398	nSteps += 1;
	3399	nNextX = 2;
	3400	}
	3401	else if (nType == typeFN2)
	3402	{
	3403	s1.Format(_T("%d %d FN2 %s %s %s "), nCurPosY, nCurPosX, sCellName, Cells[nCurPosY][nCurPosX + 1].sParam, Cells[nCurPosY][nCurPosX + 2].sParam);
	3404	DbgLog(s1);
	3405	theprog.nOpType1 = OP_MV;
	3406	progsec.Append(theprog);
	3407	sProgSec.AppendFormat(_T("FN2 %s %s %s \r\n"), sCellName, Cells[nCurPosY][nCurPosX + 1].sParam, Cells[nCurPosY][nCurPosX + 2].sParam);
	3408	nSteps += 1;
	3409	nNextX = 3;
	3410	}
	3411	else if (nType == typeFN3)
	3412	{
	3413	s1.Format(_T("%d %d FN3 %s %s %s %s"), nCurPosY, nCurPosX, sCellName, Cells[nCurPosY][nCurPosX + 1].sParam, Cells[nCurPosY][nCurPosX + 2].sParam, Cells[nCurPosY][nCurPosX + 3].sParam);
	3414	DbgLog(s1);
	3415	theprog.nOpType1 = OP_ADD3;
	3416	progsec.Append(theprog);
	3417	sProgSec.AppendFormat(_T("FN3 %s %s %s %s\r\n"), sCellName, Cells[nCurPosY][nCurPosX + 1].sParam, Cells[nCurPosY][nCurPosX + 2].sParam, Cells[nCurPosY][nCurPosX + 3].sParam);
	3418	nSteps += 1;
	3419	nNextX = 4;
	3420	}
	3421	else
	3422	{
	3423	nNextX = 1;
	3424	//continue;
	3425	}
	3426
	3427	#pragma endregion
418cb3	3428	}
aac3b3	3429	*/
418cb3	3430
ad1b4b	3431	/// <summary>
Z	3432	/// 全部图形校验
	3433	/// </summary>
	3434	/// <returns></returns>
e55aec	3435	/// <remark>
Z	3436	/// 计划在第一个返回值中使用不同的错误代码代表不同的错误类型，
	3437	/// 并在第二个返回值中填充错误提示信息
	3438	/// </remark>
ad1b4b	3439	std::pair<int, CString> CMTerm1View::LDSCheckRule()
Z	3440	{
	3441	CString message;
	3442	int nDivCount = 0;
	3443	int Divs[100] = { 0 };
	3444	//以行为单位从上到下遍历（行遍历）
	3445	for (int i = 0; i < m_nTotalRow; i++)
	3446	{
	3447	int nRow = i;
	3448	int bConnected = 0;
e55aec	3449	bool checkFlag = false;//0列检验结果
ad1b4b	3450
e55aec	3451	//本行的0列检查
ad1b4b	3452	if (Cells[nRow][0].nType == 0)
Z	3453	{
	3454	checkFlag = true;
	3455	}
	3456
	3457	//遍历此行的1-15列（确定单元格）
	3458	for (int j = 1; j < m_CellPerLine; j++)
	3459	{
	3460	int nCol = j;
	3461	//如果0列为空
	3462	if (checkFlag)
	3463	{
	3464	//有左侧上竖线
e55aec	3465	if (Cells[nRow][nCol].bLeftLineUp)
ad1b4b	3466	{
Z	3467	//如果上层为空单元格，无效竖线，直接删除-----可以单独判断
	3468	if (nRow - 1 >= 0 && Cells[nRow-1][nCol].nType == 0)
	3469	{
	3470	//清理单元格
	3471	Cells[nRow][nCol].clear();
	3472	}
	3473	//如果是none，错误：短路或回路
	3474	else if (Cells[nRow][nCol].nType == 0)
	3475	{
	3476	message.Format(_T("((%d,%d) 附近位置产生触点短路或回路！"),nRow,nCol);
	3477	return std::make_pair(111, message);
	3478	}
	3479	//如果不为none。可以转换，但是提示：无法绘制图形（程序不合理）
	3480	if (Cells[nRow][nCol].nType != 1)
	3481	{
	3482	message.Format(_T("((%d,%d) 无法绘制图形（程序不合理）"), nRow, nCol);
	3483	return std::make_pair(111, message);
	3484	}
	3485
	3486	}
	3487	//没有左侧上竖线，且此单元格类型不为空或线
	3488	else if (Cells[nRow][nCol].nType > 2)
	3489	{
	3490	//此单元格为单独的线圈或指令单元，需要触点输入
e55aec	3491	message.Format(_T("((%d,%d) 需要触点输入"), nRow, nCol);
Z	3492	return std::make_pair(111, message);
ad1b4b	3493	}
Z	3494	//有左侧下竖线，且此单元格类型为空
e55aec	3495	if (Cells[nRow][nCol].bLeftLineDn)
ad1b4b	3496	{
Z	3497	//不支持回路
	3498	}
	3499	}
	3500	//如0列非空
	3501	else
	3502	{
	3503
	3504	}
	3505	}
	3506
e55aec	3507
ad1b4b	3508	}
e55aec	3509	return std::make_pair(0,message);
ad1b4b	3510	}