fix conflict

QuakeGod

2023-10-20 6fa60de2b0d0237054aa7571191df0f291838031

 MTerm1/MTerm1View.cpp

@@ -1155,6 +1155,7 @@
            nCol = 0; 

         }

      }

      CellFocusChg(nRow, nCol);

   }

   if (nChar == VK_RIGHT) {

      nCol += 1;

@@ -1167,15 +1168,17 @@
            nCol = m_CellPerLine - 1;

         }

      }

      CellFocusChg(nRow, nCol);

   }

   if (nChar == VK_UP) {

      nRow -= 1;

      if (nRow < 0) { nRow = 0; }

      CellFocusChg(nRow, nCol);

   }

   if (nChar == VK_DOWN) {

      nRow += 1;

      if (nRow >= m_nTotalRow + nLinesinView) { nRow = m_nTotalRow + nLinesinView -1; }



      CellFocusChg(nRow, nCol);

   }

   m_FocusRow = nRow;

   m_FocusCol = nCol;

@@ -1484,14 +1487,22 @@
/// </summary>

void CMTerm1View::OnProgConvert()

{

   // TODO: 在此添加命令处理程序代码

   //转换前先对LDS的规则进行检验（检验规则与返回参数并未完全确定

 //   std::pair<int,CString> result = LDSCheckRule();

   //if (result.first == 111)

   //{

   //   DbgLog(result.second);

   //   return;

   //}



   CString s1;

   s1.Format(_T("Prog Convert"));

   SysLog(s1);

    SysLog(s1);

   int r = TransLDSToProg();

   s1.Format(_T("LDS To Prog result %d"), r);

   SysLog(s1);

   if (r==0) {

   if (r==0) 
   {

   //   m_bModified = 0;

      int j=TransProgToLDS();

      s1.Format(_T("Porg to LDS retuls %d"), j);

@@ -1583,6 +1594,12 @@
/// <param name="cell1"></param>

void CMTerm1View::SetCellToView(stCell cell1, int flag)               //**************************************************************************************************//

{

   bool changeVLine = false;

   if ((Cells[m_FocusRow][m_FocusCol].bLeftLineDn != cell1.bLeftLineDn) 
      || (Cells[m_FocusRow][m_FocusCol].bLeftLineUp != cell1.bLeftLineUp))

   {

      changeVLine = true;

   }

   Cells[m_FocusRow][m_FocusCol] = cell1;

   m_bModified = 1;

   needReDraw = 1;

@@ -1606,6 +1623,7 @@
      }

      //添加纵线时同步添加上一行

      Cells[m_FocusRow - 1][m_FocusCol].bLeftLineDn = 1;



   }break;

   case 2:

   {

@@ -1617,13 +1635,18 @@
      }

      //删除纵线时同步删除上一行

      Cells[m_FocusRow - 1][m_FocusCol].bLeftLineDn = 0;



   }break;

   default:

      break;

   }



   //单元格位置后移

   m_FocusCol += 1;

   //如果变化的是竖线，焦点不后移

   if (!changeVLine)

   {

      //单元格位置后移

      m_FocusCol += 1;

   }

	
   if (m_FocusCol >= 16) 

   { 

      m_FocusCol = 0;

@@ -1936,13 +1959,16 @@
      for (int j = 0; j < 16; j++) 

      {

         Cells[i][j].clear();

         s1.Format(_T("%d:%d"), i, j);

          s1.Format(_T("%d:%d"), i, j);

         Cells[i][j].sCoilName = s1;

      }

   }

   POINT StPts[100];

   //   StPts[0] = POINT{ 0, 0 };

   POINT EndPt[100];



   POINT StrPt[100];

   int nStrPts = 0;

   int nEndPts = 0;

   nSts = 0;

   int nCurLine = 0;

@@ -1961,71 +1987,95 @@
         pDoc->OpToShowTxt(nOp, ShowTxt);

         int nPairTo = pDoc->Progs[i].PairTo;

         int nPairOp = 0;

         if (nPairTo) nPairOp = pDoc->Progs[nPairTo].nOpType1;

         if (nPairTo)

         {

            nPairOp = pDoc->Progs[nPairTo].nOpType1;

         }

         int nCellType;

         switch (nOp)

         {



         case OP_NOP:

            break;

         case OP_ST:

         case OP_ST_:

            if (i == 0) {

            if (i == 0) 
            {



            }

            else {

            else 
            {

               //记录当前位置 

               EndPt[nEndPts] = POINT{ cx,cy };

               nEndPts++;

               if (nPairOp == OP_ANS) {

               if (nPairOp == OP_ANS) 
               {

                  //继续前进            

                  //cx = 0, cy = nCurLine;

                  //cx = StPts[nSts - 1].x;

                  //nCurLine = cy + 1; //另起一行

   ///*				
///*				
                  nCurLine = cy;

                  int hasData = 1;

                  while (hasData) {

                     hasData = 0;

                     for (int j = cx + 1; j < m_CellPerLine; j++) {

                        if (Cells[nCurLine][j].nType != 0) {

                     for (int j = cx + 1; j < m_CellPerLine; j++) 
                     {

                        if (Cells[nCurLine][j].nType != 0) 
                        {

                           nCurLine++; hasData = 1; break;

                        }

                     }

                  }

                  //               nCurLine = maxy + 1; //另起一行

                  if (nCurLine > maxy) maxy = nCurLine;

                  for (int j = cy; j < nCurLine; j++) {

                  //nCurLine = maxy + 1; //另起一行

                  if (nCurLine > maxy)

                  {

                     maxy = nCurLine;

                  }

                  for (int j = cy; j < nCurLine; j++) 
                  {

                     Cells[j][cx].bLeftLineDn = 1;

                     Cells[j + 1][cx].bLeftLineUp = 1;

                  }

                  cy = nCurLine;

                  //*/

               }

               else if (nPairOp == OP_ORS) {

               else if (nPairOp == OP_ORS) 
               {

                  cx = StPts[nSts - 1].x;

                  nCurLine = cy + 1; //另起一行

                  int hasData = 1;

                  while (hasData) {

                  while (hasData) 
                  {

                     hasData = 0;

                     for (int j = cx; j < m_CellPerLine; j++) {

                        if (Cells[nCurLine][j].nType != 0) {

                     for (int j = cx; j < m_CellPerLine; j++) 
                     {

                        if (Cells[nCurLine][j].nType != 0) 
                        {

                           nCurLine++; hasData = 1; break;

                        }

                     }

                  }

                  //               nCurLine = maxy + 1; //另起一行

                  if (nCurLine > maxy) maxy = nCurLine;

                  for (int j = cy; j < nCurLine; j++) {

                  for (int j = cy; j < nCurLine; j++) 
                  {

                     Cells[j][cx].bLeftLineDn = 1;

                     Cells[j + 1][cx].bLeftLineUp = 1;

                  }

                  cy = nCurLine;

               }

               else if (nPairOp == 0) {

                  nCurLine = maxy + 1; //另起一行

                  maxy = nCurLine;

                  cx = 0; cy = nCurLine;

               else if (nPairOp == 0) 
               {

                  if (i > 0 && nOp == pDoc->Progs[i-1].nOpType1)//如果前面也是ST，那就不换行

                  {



                  }

                  else

                  {

                     nCurLine = ++maxy;

                     cx = 0;

                     cy = nCurLine;

                  }

               }

            }

            stpos[nSts] = i;

@@ -2134,26 +2184,36 @@
         case OP_OR:

         case OP_OR_:

            EndPt[nEndPts] = POINT{ cx,cy };

            nEndPts++;

             nEndPts++;

            cx = StPts[nSts - 1].x;

            nCurLine = cy + 1; //另起一行

            {

               int hasData = 1;

               while (hasData) {

                  hasData = 0;

                  for (int j = cx; j < m_CellPerLine; j++) {

                     if (Cells[nCurLine][j].nType != 0) {

                        nCurLine++; hasData = 1; break;

               while (hasData) 
               {

                  hasData = 0;             
                  for (int j = cx; j < m_CellPerLine; j++) 
                  {

                     if (Cells[nCurLine][j].nType != 0) 
                     {

                        nCurLine++; 
                        hasData = 1; 
                        break;

                     }

                  }

               }

            }

            if (nCurLine > maxy)   maxy = nCurLine;

            for (int j = cy; j < nCurLine; j++) {

            if (nCurLine > maxy)

            {

               maxy = nCurLine;

            }

            for (int j = cy; j < nCurLine; j++) 
            {

               Cells[j][cx].bLeftLineDn = 1;

               Cells[j + 1][cx].bLeftLineUp = 1;

            }

            cy = nCurLine;

            StPts[nSts] = POINT{ cx,cy };//+++

            Cells[cy][cx].nProgStep = i;

            Cells[cy][cx].nType = nOp == OP_OR ? typeNO : typeNC; //typeNC

            Cells[cy][cx].sCoilName = pDoc->Progs[i].Params[0].sParamStr;

@@ -2161,22 +2221,22 @@
            Cells[cy][cx].nDataType = pDoc->Progs[i].Params[0].nParamType;

            Cells[cy][cx].nDataAddr = pDoc->Progs[i].Params[0].nParamAddr;

            cx++;

            if (cx < EndPt[nEndPts - 1].x)

            {   //本行补齐

               for (int j = cx; j < EndPt[nEndPts - 1].x; j++)

               {

                  Cells[cy][j].nType = typeLine1;

               }

               cx = EndPt[nEndPts - 1].x;

            }

            else {

               //前一行补齐

               for (int j = EndPt[nEndPts - 1].x; j < cx; j++)

               {

                  Cells[EndPt[nEndPts - 1].y][j].nType = typeLine1;

               }

            //if (cx <= EndPt[nEndPts - 1].x)

            //{   //本行补齐

            //   for (int j = cx; j < EndPt[nEndPts - 1].x; j++)

            //   {

            //      Cells[cy][j].nType = typeLine1;

            //   }

            //   cx = EndPt[nEndPts - 1].x;

            //}

            //else {

            //   //前一行补齐

            //   for (int j = EndPt[nEndPts - 1].x; j < cx; j++)

            //   {

            //      Cells[EndPt[nEndPts - 1].y][j].nType = typeLine1;

            //   }



            }

            //}

            //连接上下线

            for (int j = EndPt[nEndPts - 1].y; j < cy; j++)

            {

@@ -2185,6 +2245,7 @@
            }

            //光标位置, 前一结束点位置

            cy = EndPt[nEndPts - 1].y;



            nEndPts--;



            break;

@@ -2270,50 +2331,73 @@
            cx++;

            break;

         case OP_ANS:

            //ANS说明是有环路，整行进行移动（向右）从后向前进行移动

            EndPt[nEndPts].y;

            for (int i = EndPt[nEndPts-1].x ; i > 0; i--)

            {

               for (int j = EndPt[nEndPts].x; j >= 0; j--)

               {

                  if (j > 0

                     && Cells[cy + 1][j-1].nType == typeNone 
                     || Cells[cy + 1][j - 1].nType == typeLine1 
                     || Cells[cy + 1][j - 1].nType == typeLine2)

                  {

                     continue;						
                  }



                  Cells[cy + 1][j] = Cells[cy + 1][j - 1];

               }

            }



            Cells[EndPt[nEndPts].y][EndPt[nEndPts-1].x].bLeftLineDn = 1;

            Cells[EndPt[nEndPts].y+1][EndPt[nEndPts-1].x].bLeftLineUp = 1;



            nSts--;

            nEndPts--;



            break;

         case OP_ORS:

            // 当前序列与前面的序列合并。

            //当前序列的开始结束位置

            //EndPt[nEndPts] = POINT{ cx,cy };

            //nEndPts++;

            //StPts[nSts - 1]; EndPt[nEndPts - 1];

            //前一序列的开始结束位置

            StPts[nSts - 1]; EndPt[nEndPts - 1];



            if (nEndPts <= 0)

            {

               break;

            }



            //判断二者长度

            if (cx < EndPt[nEndPts - 1].x)

            {   //本行补齐

            {	
               //本行补齐

               for (int j = cx; j < EndPt[nEndPts - 1].x; j++)

               {

                  Cells[cy][j].nType = typeLine1;

               }

               cx = EndPt[nEndPts - 1].x;

            }

            else {

            else 
            {

               //前一行补齐

               for (int j = EndPt[nEndPts - 1].x; j < cx; j++)

               {

                  Cells[EndPt[nEndPts - 1].y][j].nType = typeLine1;

                  if (Cells[EndPt[nEndPts - 1].y][j].nType == typeNone)

                  {

                     Cells[EndPt[nEndPts - 1].y][j].nType = typeLine1;

                  }

               }



            }

            //连接上下线

            for (int j = EndPt[nEndPts - 1].y; j < cy; j++)

            {

               Cells[j][cx].bLeftLineDn = 1;

               Cells[j + 1][cx].bLeftLineUp = 1;

            }



            Cells[cy][cx].bLeftLineUp = 1;

            Cells[cy-1][cx].bLeftLineDn = 1;



            //光标位置, 前一结束点位置

            cy = EndPt[nEndPts - 1].y;

            nSts--;

            nEndPts--;



            cy = EndPt[nEndPts].y;

            cx = EndPt[nEndPts].x;

            break;

         case OP_PSHS:

            EndPt[nEndPts] = POINT{ cx,cy };

            nEndPts++;

            StrPt[nStrPts] = POINT{ EndPt[nEndPts].x,EndPt[nEndPts].y+1 };

            nStrPts++;

            break;

         case OP_RDS:

            cx = EndPt[nEndPts - 1].x;

@@ -2330,20 +2414,9 @@
            }

            break;

         case OP_POPS:

            cx = EndPt[nEndPts - 1].x;

            for (int j = cx; j < m_CellPerLine; j++) {

               if (Cells[cy][j].nType != 0)

               {

                  cy++; j = cx - 1; break;

               }

            }

            for (int j = EndPt[nEndPts - 1].y; j < cy; j++)

            {

               Cells[j][cx].bLeftLineDn = 1;

               Cells[j + 1][cx].bLeftLineUp = 1;

            }

            nEndPts--;



            nStrPts--;

            cy = StrPt[nStrPts].y;

            cx = StrPt[nStrPts].x;

            break;

         case OP_OUT:

         case OP_SET:

@@ -2484,7 +2557,8 @@
   needReDraw = 1;

   return 0;

}



bool firstCoil = true;//本段第一个单元格

bool isPops = false;

/// <summary>

/// 梯形图转Prog

/// </summary>

@@ -2495,23 +2569,32 @@
   CString s1;

   s1.Format(_T("Trans LDS to PRrog"));

   DbgLog(s1);

   s1.Format(_T("将梯形图转成prog格式"));

   DbgLog(s1);



   //梯形图 ROW数量

   s1.Format(_T("总计行数 %d"), m_nTotalRow);

   DbgLog(s1);

   s1.Format(_T("Total Lines %d"), m_nTotalRow);

   DbgLog(s1);

	
   //分段

   int nDivCount = 0;

   //分段 点集合

   int Divs[100] = { 0 };

   for (int i = 0; i < m_nTotalRow; i++)   

   {

      int nRow = i;

      int bConnected = 0;

      for (int j = 0; j < m_CellPerLine; j++)		
       for (int j = 0; j < m_CellPerLine; j++)		
      {

         int nCol = j;

         if (Cells[nRow][nCol].bLeftLineDn) 

         {

            bConnected = 1; break;

            bConnected = 1; 
            s1.Format(_T("row==%d col==%d 有左下竖线！！！"), nRow,nCol);

            DbgLog(s1);

            break;

         }

        }

      if (!bConnected) 

@@ -2524,19 +2607,23 @@
      }

   }



   stProgSection allprogs;

    stProgSection allprogs;

   //每段单独处理

   for (int i = 0; i < nDivCount; i++)   

   {

      int nStartLine, nEndLine;

      if (i == 0) 

      {

         nStartLine = 0; nEndLine = Divs[i]; 
      }

         nStartLine = 0; 
         nEndLine = Divs[i]; 
       }

      else 

      {

         nStartLine = Divs[i - 1]+1; nEndLine = Divs[i]; 
         nStartLine = Divs[i - 1]+1;

         nEndLine = Divs[i]; 
      }

      s1.Format(_T("本段行号 起始-终止： %d - %d "), nStartLine, nEndLine);

      DbgLog(s1);

      s1.Format(_T("Process Line %d - %d "), nStartLine, nEndLine);

      DbgLog(s1);

      int nCounts[20] = { 0 };

@@ -2556,12 +2643,18 @@
               nCount += 1;

               nCount2 += 1;

               nCount3 += 1;

               if (Cells[k][j].bLeftLineUp) nCount2 -= 1;

               if (Cells[k][j].bLeftLineUp)

               {

                  nCount2 -= 1;

               }

//               if (Cells[k][j].bLeftLineDn) nCount2 -= 1;



               if (j != m_CellPerLine - 1)   

               {

                  if (Cells[k][j + 1].bLeftLineUp) nCount3 -= 1;

                  if (Cells[k][j + 1].bLeftLineUp)

                  {

                     nCount3 -= 1;

                  }

//                  if (Cells[k][j + 1].bLeftLineDn) nCount3 -= 1;

               }

            }

@@ -2576,7 +2669,7 @@
      {

         s1.AppendFormat(_T(" %d(%d)"), nCounts[j],nCounts3[j]);

      }

      DbgLog(_T("testttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttt"));

      DbgLog(_T(""));



      DbgLog(s1);

      s1.Empty();

@@ -2592,23 +2685,35 @@
      CString sProg;

      int nAllSteps=0;

      stProgSection Progsec;

      for (int i = nStartLine; i <= nEndLine; i++){

      for (int i = nStartLine; i <= nEndLine; i++)

      {

         CString sProgSec;

         int nSteps = 0;;

         nCurPosY = i;

         stProgSection thisprogsec;

         if (Cells[i][0].nType)

         {

            firstCoil = true;

            //循环遍历单元格(转换的逻辑在这个函数)

            ScanLDSCells(nStartLine, nEndLine, nCurPosY, nCurPosX, 0, thisprogsec, sProgSec, nSteps);

            //ScanLDSCells(nStartLine, nEndLine, nCurPosY, nCurPosX, 0, thisprogsec, sProgSec, nSteps);

            //ScanLDSCells2(nStartLine, nEndLine, nCurPosY, nCurPosX, 0, thisprogsec, sProgSec, nSteps);

         }

         sProg += sProgSec;

         nAllSteps += nSteps;

         Progsec += thisprogsec;

         //sProg += sProgSec;

       //   nAllSteps += nSteps;

         //Progsec += thisprogsec;

      }



      CString sProgSec;

      int nSteps = 0;;

      nCurPosY = i;

      stProgSection thisprogsec;

      ScanLDSCells2(nStartLine, nEndLine, nCurPosY, nCurPosX, 16,0, thisprogsec, sProgSec, nSteps);

      sProg += sProgSec;

      nAllSteps += nSteps;

      Progsec += thisprogsec;

      DbgLog(_T("\r\n")+ sProg);

      int n = int(Progsec.Progs.size());

      s1.Format(_T("程序段步数： %d "), n);

      DbgLog(s1);

      s1.Format(_T("progSec steps %d "), n);

      DbgLog(s1);

      for (int i = 0; i < n; i++) 

@@ -2628,12 +2733,14 @@


   //输出程序

   int n=(int)allprogs.Progs.size();

   s1.Format(_T("总程序步数 %d "), n);

   DbgLog(s1);

   s1.Format(_T("all prog steps %d "), n);

   DbgLog(s1);

   for (int i = 0; i < n; i++)   

   {

      int optype=allprogs.Progs[i].nOpType1;

      allprogs.Progs[i].PairTo = 0;

      allprogs.Progs[i].PairTo = 0;//??????????

      allprogs.Progs[i].nBinStep = i;

      CStringA OpTxtA,OpShowTxtA;

      CString OpTxt,OpShowTxt;

@@ -2655,41 +2762,255 @@
/// </summary>

/// <param name="nStartLine"></param>

/// <param name="nEndLine"></param>

/// <param name="nPosY"></param>

/// <param name="nPosX"></param>

/// <param name="nLevel"></param>

/// <param name="progsec"></param>

/// <param name="sProgSec"></param>

/// <param name="nSteps"></param>

/// <param name="nPosY">行</param>

/// <param name="nPosX">列</param>

/// <param name="nLevel">层级</param>

/// <param name="progsec">prog格式的指令集</param>

/// <param name="sProgSec">指令集</param>

/// <param name="nSteps">程序步数</param>

/// <returns></returns>

int CMTerm1View::ScanLDSCells(int nStartLine, int nEndLine, int nPosY, int nPosX, int nLevel, stProgSection & progsec, CString & sProgSec, int &nSteps)

int CMTerm1View::ScanLDSCells(int nStartLine, int nEndLine, int nPosY, int nPosX,

   int nLevel, stProgSection & progsec, CString & sProgSec, int &nSteps)

{

   // TODO: 在此处添加实现代码.

   CString s1;

   int nCurPosX, nCurPosY;

   int nNextX = 1;

   int nNextX = 1;//步长(下个起始点移动的距离)

   nCurPosY = nPosY;

   nCurPosX = nPosX;

   int nCoilType, CoilAddr;

   CMTerm1Doc* pDoc = GetDocument();

   bool firstCoil = true;

   for (int j = nPosX; j < m_CellPerLine; j += nNextX)

   {

      nCurPosX = j;

      //先处理当前单元;

      //先处理当前单元基本信息;

      int nType = Cells[nCurPosY][nCurPosX].nType;

      CString sCellName = Cells[nCurPosY][nCurPosX].sCoilName;

      CMTerm1Doc::stProg theprog;

      CStringA sCellNameA;

      sCellNameA = sCellName;



      if (nType == typeNO) 
      if (j + nNextX >= m_CellPerLine)

      {

         continue;

      }



      //1.先获取此单元格右侧一格的竖线

      if (Cells[nCurPosY][j + nNextX].bLeftLineUp

         || Cells[nCurPosY][j + nNextX].bLeftLineDn)

      {



         //先看往上面有没有连接

         if (Cells[nCurPosY][j + nNextX].bLeftLineUp)

         {

            // 往上面有连接且有触点连接，才使用ORS

            s1.Format(_T("%d %d ORS "), nCurPosY, nCurPosX);

            DbgLog(s1);

            theprog.nOpType1 = OP_ORS;

            progsec.Append(theprog);

            sProgSec.AppendFormat(_T("ORS \r\n"));

            firstCoil = false;

            nSteps += 1;

            nLevel -= 1;

         }

         //右侧一格的左上是否有链接

         int nLeftUpCon = 0;

         if (Cells[nCurPosY][j + nNextX].bLeftLineUp)

         {

            nLeftUpCon = 1;

         }

         //向下查找，看看竖线的右侧一格的左侧下面还有没有连接其他东西

         int nLeftDnCon = 0;//单元格右侧一格的左侧向下连接数

         for (int k = nCurPosY; k <= nEndLine; k++)

         {

            if (Cells[k][j + nNextX].bLeftLineDn)

            {

               if (Cells[k][j + nNextX - 1].nType)

               {

                  nLeftDnCon += 1;

               }

            }

            else

            {

               break;  // 竖线到最下面的端点了。

            }

         }



         s1.Format(_T("LeftUp %d   LeftDn  %d"), nLeftUpCon, nLeftDnCon);

         DbgLog(s1);



         //右侧一格的左侧下面有连接，那么扫描到这个竖线时返回，继续扫描左侧下面的内容。

         if (nLeftDnCon)

         {

            return 1;

         }

         //右侧一格的左侧下面没有连接，那么这个就是左面最后的单元，开始处理右面的单元。

         else

         {

            if (nLeftUpCon)

            {

               if (nPosX > 0 || nLevel > 0)

               {

                  s1.Format(_T("%d %d ANS "), nCurPosY, nCurPosX);

                  DbgLog(s1);

                  theprog.nOpType1 = OP_ANS;

                  progsec.Append(theprog);

                  sProgSec.AppendFormat(_T("ANS \r\n"));

                  nSteps += 1;

                  nLevel -= 1;

               }

            }

            //从头到尾处理, 查找此竖线的最高位置;

            int nLineTop = nCurPosY;

            int nLineBottom = nCurPosY;

            for (int k = nCurPosY; k >= nStartLine; k--)

            {

               if (!Cells[k][j + nNextX].bLeftLineUp)

               {

                  break;

               }

               nLineTop = k - 1;

            }



            // 查找右侧有几个连接

            int nRightCon = 0;//单元格右侧连接数

            for (int k = nLineTop; k <= nEndLine; k++)

            {

               if (Cells[k][j + nNextX].nType)

               {

                  nRightCon += 1;

               }

               nLineBottom = k;

               if (!Cells[k][j + nNextX].bLeftLineDn)

               {

                  break;

               }

            }

            s1.Format(_T("VLine %d - %d : %d , right = %d "), nLineTop, nLineBottom, j + nNextX, nRightCon);

            DbgLog(s1);



            if (nRightCon == 1)

            {

                s1.Format(_T(">>>> Go %d : %d , level %d "), nLineTop, j + nNextX, nLevel);

               DbgLog(s1);

               CString ProgSec;

               int theSteps = 0;

               stProgSection thisprogsec;



               //这有问题，应该是在最高点的时候，单独进行一次转换？

               int r = ScanLDSCells(nStartLine, nEndLine, nLineTop, j + nNextX, nLevel, thisprogsec, ProgSec, theSteps);



               sProgSec += ProgSec;

               nSteps += theSteps;

               progsec += thisprogsec;

               s1.Format(_T("<<<< Re %d : %d , Result %d "), nLineTop, j + nNextX, 0);

               DbgLog(s1);

               continue;

            }

            else

            {

               int nLastResult = 0;

               int nRightCount = 0;

               CString sCons[100];

               CString ProgSecs[100];

               int res[100] = { 0 };

               int nLastSteps = 0;

               for (int k = nLineTop; k <= nLineBottom; k++)

               {

                  //s1.Format(_T("VLine %d - %d : %d       %d of %d "), nLineTop, nLineBottom, j + nNextX, k+1,nRightCon);

                  //DbgLog(s1);

                  if (Cells[k][j + nNextX].nType)

                  {

                     s1.Format(_T(" >>> Go %d : %d , level %d "), k, j + nNextX, nLevel + 1);

                     DbgLog(s1);

                     CString ProgSec;

                     int theSteps = 0;

                     nLevel += 1;

                     stProgSection thisprogsec;

                     res[nRightCount] = ScanLDSCells(nStartLine, nEndLine, k, j + nNextX, nLevel, thisprogsec, ProgSecs[nRightCount], theSteps);

                     nLastResult = res[nRightCount];

                     nSteps += theSteps;

                     progsec += thisprogsec;

                     //if (res[nRightCount] > 0) nLevel += 1;

                     sProgSec += ProgSec;

                     s1.Format(_T(" <<< Re %d : %d , Result %d Steps %d Last %d"), k, j + nNextX, res[nRightCount], theSteps, nLastSteps);

                     DbgLog(s1);

                     if (nRightCount == 0)

                     {

                        //这里是不是应该做点什么

                     }

                     else if (res[nRightCount - 1] == 0)

                     {

                        s1.Format(_T(" POPS"), k, j + nNextX, nLevel + 1);

                        DbgLog(s1);

                        //sProgSec.AppendFormat(_T("POPS \r\n"));

                        if (nLastSteps > 1)

                        {

                           if (sCons[nRightCount - 1] == _T("POPS"))

                           {

                              sCons[nRightCount - 1] = _T("RDS");

                           }

                           else

                           {

                              sCons[nRightCount - 1] = _T("PSHS");

                           }

                           sCons[nRightCount] = _T("POPS");

                        }

                     }

                     else

                     {



                     }

                     nLastSteps = theSteps;

                     nRightCount++;

                  }

               }

               nLastResult = 0;

               for (int k = 0; k < nRightCount; k++)

               {

                  if (nLastResult || res[k])

                  {

                     s1 = _T("ST") + ProgSecs[k];



                     ProgSecs[k] = s1;

                  }

                  s1 = sCons[k] + _T("\r\n") + ProgSecs[k];

                  sProgSec.Append(s1);

                  nLastResult = res[k];

               }

               if (nLastResult)

               {

                  sProgSec.Append(_T("ANS\r\n"));

               }

               return 0;

            }

         }

      }

      //如果没有竖线直接翻译

      else

      {

         Translate2Prog(nType, j + nNextX, nLevel, sCellName, progsec, sProgSec, nSteps);

      }

      /*

      #pragma region  根据单元格类型转换为指令和prog



      if (nType == typeNO)

      {

         if (firstCoil && nType != typeLine1 && nType != typeLine2)

         {

            s1.Format(_T("%d %d ST %s"), nCurPosY, nCurPosX,sCellName);

            sProgSec.AppendFormat(_T("ST %s\r\n"),sCellName);

            theprog.nOpType1 = OP_ST;

            //先看往上面有没有连接

            if (Cells[nCurPosY][j + nNextX].bLeftLineUp)

            {

               // 往上面有连接且有触点连接，才使用OR

               s1.Format(_T("%d %d OR %s"), nCurPosY, nCurPosX, sCellName);

               sProgSec.AppendFormat(_T("OR %s\r\n"), sCellName);

               theprog.nOpType1 = OP_OR;

            }

            else

            {

               s1.Format(_T("%d %d ST %s"), nCurPosY, nCurPosX, sCellName);

               sProgSec.AppendFormat(_T("ST %s\r\n"), sCellName);

               theprog.nOpType1 = OP_ST;

            }

            theprog.nParamCount = 1;

            pDoc->TxtToCoilType(sCellNameA, &nCoilType, &CoilAddr);

            theprog.Params[0].nParamType = nCoilType;

@@ -2698,7 +3019,8 @@
            progsec.Append(theprog);

            firstCoil = false;

         }

         else {

         else

         {

            s1.Format(_T("%d %d AN %s"), nCurPosY, nCurPosX, sCellName);

            sProgSec.AppendFormat(_T("NO %s\r\n"), sCellName);

            theprog.nOpType1 = OP_AN;

@@ -2711,9 +3033,9 @@
         }

         nSteps += 1;

         DbgLog(s1);

         nNextX =  1;

         nNextX = 1;

      }

      else if (nType == typeNC) 
      else if (nType == typeNC)

      {

         if (firstCoil && nType != typeLine1 && nType != typeLine2)

         {

@@ -2742,27 +3064,27 @@
         }

         DbgLog(s1);

         nSteps += 1;

         nNextX =  1;

         nNextX = 1;

      }

      else if (nType == typePP) 
      else if (nType == typePP)

      {

         s1.Format(_T("%d %d PP %s"), nCurPosY, nCurPosX, sCellName);

         DbgLog(s1);

         //progsec.Append(theprog);

         sProgSec.AppendFormat(_T("PP %s\r\n"), sCellName);

         nSteps += 1;

         nNextX =  1;

         nNextX = 1;

      }

      else if (nType == typePN) 
      else if (nType == typePN)

      {

         s1.Format(_T("%d %d PN %s"), nCurPosY, nCurPosX, sCellName);

         DbgLog(s1);

         //progsec.Append(theprog);

         sProgSec.AppendFormat(_T("PN %s\r\n"), sCellName, sCellName);

         nSteps += 1;

         nNextX =  1;

         nNextX = 1;

      }

      else if (nType == typeNOT) 
      else if (nType == typeNOT)

      {

         s1.Format(_T("%d %d NOT %s"), nCurPosY, nCurPosX, sCellName);

         DbgLog(s1);

@@ -2770,7 +3092,7 @@
         theprog.nOpType1 = OP_NOT;

         progsec.Append(theprog);

         nSteps += 1;

         nNextX =  1;

         nNextX = 1;

      }

      else if (nType == typeDF)

      {

@@ -2780,7 +3102,7 @@
         theprog.nOpType1 = OP_DF;

         progsec.Append(theprog);

         nSteps += 1;

         nNextX =  1;

         nNextX = 1;

      }

      else if (nType == typeDF_)

      {

@@ -2790,7 +3112,7 @@
         theprog.nOpType1 = OP_DF_;

         progsec.Append(theprog);

         nSteps += 1;

         nNextX =  1;

         nNextX = 1;

      }

      else if (nType == typeOUT)

      {

@@ -2805,7 +3127,7 @@
         theprog.Params[0].sParamStr = sCellNameA;

         progsec.Append(theprog);

         nSteps += 1;

         nNextX =  1;

         nNextX = 1;

      }

      else if (nType == typeSET)

      {

@@ -2820,7 +3142,7 @@
         theprog.Params[0].sParamStr = sCellNameA;

         progsec.Append(theprog);

         nSteps += 1;

         nNextX =  1;

         nNextX = 1;

      }

      else if (nType == typeRESET)

      {

@@ -2835,22 +3157,22 @@
         theprog.Params[0].sParamStr = sCellNameA;

         progsec.Append(theprog);

         nSteps += 1;

         nNextX =  1;

         nNextX = 1;

      }

      else if (nType == typeCMP) 
      else if (nType == typeCMP)

      {

         s1.Format(_T("%d %d CMP %s %s %s"), nCurPosY, nCurPosX, sCellName,Cells[nCurPosY][nCurPosX+1].sParam,Cells[nCurPosY][nCurPosX + 2].sParam);

         s1.Format(_T("%d %d CMP %s %s %s"), nCurPosY, nCurPosX, sCellName, Cells[nCurPosY][nCurPosX + 1].sParam, Cells[nCurPosY][nCurPosX + 2].sParam);

         DbgLog(s1);

         theprog.nOpType1 = OP_ST_GT;

         theprog.nParamCount = 1;

         progsec.Append(theprog);

         sProgSec.AppendFormat(_T("CMP %s %s %s \r\n"), sCellName, Cells[nCurPosY][nCurPosX + 1].sParam, Cells[nCurPosY][nCurPosX + 2].sParam);

         nSteps += 1;

         nNextX =  3;

         nNextX = 3;

      }

      else if (nType == typeTM) 
      else if (nType == typeTM)

      {

         s1.Format(_T("%d %d TM %s %d %s"), nCurPosY, nCurPosX, sCellName,Cells[nCurPosY][nCurPosX+1].sParam,Cells[nCurPosY][nCurPosX + 2].sParam);

         s1.Format(_T("%d %d TM %s %d %s"), nCurPosY, nCurPosX, sCellName, Cells[nCurPosY][nCurPosX + 1].sParam, Cells[nCurPosY][nCurPosX + 2].sParam);

         DbgLog(s1);

         theprog.nOpType1 = OP_TMX;

         theprog.nParamCount = 1;

@@ -2859,21 +3181,21 @@
         theprog.Params[0].nParamAddr = CoilAddr;

         theprog.Params[0].sParamStr = sCellNameA;

         progsec.Append(theprog);

         sProgSec.AppendFormat(_T("TM %s %d %s\r\n"), sCellName, Cells[nCurPosY][nCurPosX+1].sParam, Cells[nCurPosY][nCurPosX + 2].sParam);

         sProgSec.AppendFormat(_T("TM %s %d %s\r\n"), sCellName, Cells[nCurPosY][nCurPosX + 1].sParam, Cells[nCurPosY][nCurPosX + 2].sParam);

         nSteps += 1;

         nNextX =  3;

         nNextX = 3;

      }

      else if (nType == typeFN1) 
      else if (nType == typeFN1)

      {

         s1.Format(_T("%d %d FN1 %s %s"), nCurPosY, nCurPosX, sCellName,Cells[nCurPosY][nCurPosX + 1].sParam);

         s1.Format(_T("%d %d FN1 %s %s"), nCurPosY, nCurPosX, sCellName, Cells[nCurPosY][nCurPosX + 1].sParam);

         DbgLog(s1);

         theprog.nOpType1 = OP_INC;

         progsec.Append(theprog);

         sProgSec.AppendFormat(_T("FN1 %s %s\r\n"), sCellName, Cells[nCurPosY][nCurPosX + 1].sParam);

         nSteps += 1;

         nNextX =  2;

         nNextX = 2;

      }

      else if (nType == typeFN2) 
      else if (nType == typeFN2)

      {

         s1.Format(_T("%d %d FN2 %s %s %s "), nCurPosY, nCurPosX, sCellName, Cells[nCurPosY][nCurPosX + 1].sParam, Cells[nCurPosY][nCurPosX + 2].sParam);

         DbgLog(s1);

@@ -2881,9 +3203,9 @@
         progsec.Append(theprog);

         sProgSec.AppendFormat(_T("FN2 %s %s %s \r\n"), sCellName, Cells[nCurPosY][nCurPosX + 1].sParam, Cells[nCurPosY][nCurPosX + 2].sParam);

         nSteps += 1;

         nNextX =  3;

         nNextX = 3;

      }

      else if (nType == typeFN3) 
      else if (nType == typeFN3)

      {

         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);

         DbgLog(s1);

@@ -2891,231 +3213,458 @@
         progsec.Append(theprog);

         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);

         nSteps += 1;

         nNextX =  4;

         nNextX = 4;

      }

      else 
      else

      {

         nNextX =  1;

         nNextX = 1;

         //continue;

      }

		
      #pragma endregion

      */

   }

   return 0;

 }

//   记录y,x

std::pair<int, int> popsPoint[100];      int nPSHS = -1;

int CMTerm1View::ScanLDSCells2(int nStartLine, int nEndLine, int nPosY, int nPosX, int nSizeX,

   int nLevel, stProgSection& progsec, CString& sProgSec, int& nSteps)

{

   CString s1;

   int nCurPosX, nCurPosY;

   int nNextX = 0;//步长（到下个线圈起始位置应移动距离

   nCurPosY = nStartLine;

   nCurPosX = nPosX;

   int nCoilType, CoilAddr;

   CMTerm1Doc* pDoc = GetDocument();



      if (j + nNextX >= m_CellPerLine) continue;

      if (Cells[nCurPosY][j + nNextX].bLeftLineUp || Cells[nCurPosY][j + nNextX].bLeftLineDn) 
      {   // 发现竖线

         //先看往上面有没有连接

         if (Cells[nCurPosY][j + nNextX].bLeftLineUp) 
         { // 往上面有连接

   for (int j = nPosX; j < nSizeX; j += nNextX)

   {

      nCurPosX = j;

      //先处理当前单元;

      int nType = Cells[nCurPosY][nCurPosX].nType;

      CString sCellName = Cells[nCurPosY][nCurPosX].sCoilName;

      CMTerm1Doc::stProg theprog;

      CStringA sCellNameA;

      sCellNameA = sCellName;

      CString ProgSec;

      int theSteps = 0;



      stProgSection thisprogsec;



      //判断越界

      if (j + nNextX >= m_CellPerLine)

      {

         continue;

      }

      //if (!firstCoil && Cells[nCurPosY][j].bLeftLineUp)

      //{

      //   break;

      //}

      if (Cells[nCurPosY][nCurPosX].nType == typeNone)

      {

         nNextX = 1;

         continue;

      }

      //开始翻译单个单元格，并返回下个单元格位置

      nNextX = Translate2Prog(nType, nCurPosY, nCurPosX, sCellName, progsec, sProgSec, nSteps);

      //1.判断此单元格右侧一格是否有向下的竖线

      if (Cells[nCurPosY][j + nNextX].bLeftLineDn)

      {

         //1.1:有分支，直接开始读取下一行

         if (Cells[nCurPosY +1][j].nType == typeNone)

         {

            if (Cells[nCurPosY + 1][j + nNextX].nType != typeNone)

            {

               firstCoil = true;

            }

            continue;

         }



         firstCoil = true;

         ScanLDSCells2(nCurPosY + 1, nCurPosY + 1, nCurPosY + 1, 0, j + nNextX, ++nLevel, thisprogsec, ProgSec, theSteps);

			
         //有OR关系且不只一个节点

         if (theSteps > 1 && nLevel > 0)

         {

            // 步数大于1，是复合结果，才使用ORS

            s1.Format(_T("%d %d ORS "), nCurPosY, nCurPosX);

            DbgLog(s1);

            theprog.nOpType1 = OP_ORS;

            progsec.Append(theprog);

            sProgSec.AppendFormat(_T("ORS \r\n"));

            //progsec.Append(theprog);

            //sProgSec.AppendFormat(_T("ORS \r\n"));

            thisprogsec.Append(theprog);

            ProgSec.AppendFormat(_T("ORS \r\n"));

            firstCoil = false;

            nSteps += 1;

            nLevel -= 1;

         }

         int nLeftUpCon = 0;

         if (Cells[nCurPosY][j + nNextX].bLeftLineUp ) nLeftUpCon = 1;

         //向下查找，看看竖线的左侧下面还有没有连接其他东西/

         int nLeftDnCon = 0;

         for (int k = nCurPosY + 1; k <= nEndLine; k++) {

            if (!Cells[k][j + nNextX].bLeftLineUp) break;  // 竖线到最下面的端点了。

            if (Cells[k][j + nNextX - 1 ].nType) { nLeftDnCon += 1; break; }

         }

         s1.Format(_T("LeftUp %d   LeftDn  %d"), nLeftUpCon, nLeftDnCon);

         DbgLog(s1);

         if (nLeftDnCon) {   //左侧有连接，那么扫描到这个竖线，继续扫描左侧下面的内容。



            return 1;

         }

         if (!nLeftDnCon) {// 左侧下面没有连接，那么这个就是左面最后的单元，开始处理右面的单元。

            if (nLeftUpCon) {

               if ( nPosX >0 || nLevel > 0) {

               s1.Format(_T("%d %d ANS "), nCurPosY, nCurPosX);

               DbgLog(s1);

               theprog.nOpType1 = OP_ANS;

               progsec.Append(theprog);

               sProgSec.AppendFormat(_T("ANS \r\n"));

               nSteps += 1;

               nLevel -= 1;

            }



            }

            //从头到尾处理, 查找此竖线的最高位置;

            int nLineTop = nCurPosY;

            int nLineBottom = nCurPosY;

            for (int k = nCurPosY; k >= nStartLine; k--)

         //1.2:从后向前查找下一行是否还有向上的竖线（形成闭环）（ORS、ANS）

         for (int k = j; k >= 0; k--)

         {

            if (Cells[nCurPosY + 1][k].nType == typeNone)

            {

               if (!Cells[k][j + nNextX].bLeftLineUp) {  break; }

               nLineTop = k -1;

               //如果遇到空格，还没搜到，就结束搜索

               break;

            }

            // 查找右侧有几个连接

            int nRightCon = 0;

            for (int k = nLineTop; k <= nEndLine; k++) {

               if (Cells[k][j + nNextX].nType) { nRightCon += 1; }

               nLineBottom = k;

               if (!Cells[k][j + nNextX].bLeftLineDn) { break; }

            }

            s1.Format(_T("VLine %d - %d : %d , right = %d "), nLineTop,nLineBottom,j+nNextX,nRightCon);

            DbgLog(s1);

            if (nRightCon == 1) {

               s1.Format(_T(">>>> Go %d : %d , level %d "), nLineTop, j + nNextX, nLevel);

               DbgLog(s1);

               CString ProgSec;

               int theSteps = 0;

               stProgSection thisprogsec;



               //

               int r = ScanLDSCells(nStartLine, nEndLine, nLineTop, j + nNextX, nLevel,thisprogsec, ProgSec,theSteps);



               sProgSec += ProgSec;

               nSteps += theSteps;

               progsec += thisprogsec;

               s1.Format(_T("<<<< Re %d : %d , Result %d "), nLineTop, j + nNextX, r);

               DbgLog(s1);

            }

            else

            if (Cells[nCurPosY+1][k].bLeftLineUp)

            {

               int nLastResult = 0;

               int nRightCount = 0;

               CString sCons[100];

               CString ProgSecs[100];

               int res[100] = { 0 };

               int nLastSteps = 0;

               for (int k = nLineTop; k <= nLineBottom; k++)

               //如果有一条竖线，说明是形成了环，要用ANS

               if (theSteps >= 1 && nLevel > 0)

               {

                  //s1.Format(_T("VLine %d - %d : %d       %d of %d "), nLineTop, nLineBottom, j + nNextX, k+1,nRightCon);

                  //DbgLog(s1);

                  if (Cells[k][j + nNextX].nType) {

                     s1.Format(_T(" >>> Go %d : %d , level %d "), k, j + nNextX, nLevel +1);

                     DbgLog(s1);

                     CString ProgSec;

                     int theSteps = 0;

                     nLevel += 1;

                     stProgSection thisprogsec;

                     res[nRightCount] = ScanLDSCells(nStartLine, nEndLine, k, j + nNextX, nLevel ,thisprogsec,ProgSecs[nRightCount],theSteps);

                     nLastResult = res[nRightCount];

                     nSteps += theSteps;

                     progsec += thisprogsec;

                     //if (res[nRightCount] > 0) nLevel += 1;

                     sProgSec += ProgSec;

                     s1.Format(_T(" <<< Re %d : %d , Result %d Steps %d Last %d"), k, j + nNextX, res[nRightCount],theSteps,nLastSteps);

                     DbgLog(s1);

                     if (nRightCount == 0) {

                     }

                     else if (res[nRightCount-1] == 0) {

                        s1.Format(_T(" POPS"), k, j + nNextX, nLevel + 1);

                        DbgLog(s1);

                        //sProgSec.AppendFormat(_T("POPS \r\n"));

                        if (nLastSteps > 1) 
                        {

                           if (sCons[nRightCount - 1] == _T("POPS")) { sCons[nRightCount - 1] = _T("RDS"); }

                           else { sCons[nRightCount - 1] = _T("PSHS"); }

                           sCons[nRightCount] = _T("POPS");

                        }

                     }

                     else {



                     }

                     nLastSteps = theSteps;

                     nRightCount++;

                  }

                  //步数大于1，是复合结果，使用ANS

                  s1.Format(_T("%d %d ANS "), nCurPosY, nCurPosX);

                  DbgLog(s1);

                  theprog.nOpType1 = OP_ANS;

                  //progsec.Append(theprog);

                  //sProgSec.AppendFormat(_T("ANS \r\n"));

                  thisprogsec.Append(theprog);

                  ProgSec.AppendFormat(_T("ANS \r\n"));

                  nSteps += 1;

               }

               nLastResult = 0;

               for (int k = 0; k < nRightCount; k++)

               {

                  if (nLastResult || res[k]) { s1 = _T("ST") + ProgSecs[k];  ProgSecs[k] =s1; }

                  s1= sCons[k] + _T("\r\n") + ProgSecs[k];

                  sProgSec.Append(s1);

                  nLastResult = res[k];

               }

               if (nLastResult) sProgSec.Append(_T("ANS\r\n"));

               return 0;

            }

         }

			
         //将转换完成的部分加入到总集中

         nSteps += theSteps;

         progsec += thisprogsec;

         sProgSec += ProgSec;

			
         //1.3:查询此分支下一级连接点左右均存在节点，存在就PSHS

         if (Cells[nCurPosY + 1][j].nType != typeNone 
            && Cells[nCurPosY + 1][j + 1].nType != typeNone)

         {

            ++nPSHS;

            CString push = _T("PSHS \r\n");

            theprog.nOpType1 = OP_PSHS;

            progsec.Append(theprog);

            sProgSec.Append(push);

            popsPoint[nPSHS] = std::make_pair(nCurPosY + 1, j + 1);

         }

      }//end  1.判断此单元格右侧一格是否有向下的竖线



   }

   nLevel--;

   //已回到起始层

   if (nLevel == 0)

   {

      CMTerm1Doc::stProg theprog;

      for (int i = nPSHS; i >= 0; i--)

      {

         //+POP

         CString pop = _T("POPS \r\n");

         theprog.nOpType1 = OP_POPS;

         progsec.Append(theprog);

         sProgSec.Append(pop);

         //+fanyi

         //开始翻译单个单元格，并返回下个单元格位置

         //firstCoil = true;

         ScanLDSCells2(popsPoint[nPSHS].first, popsPoint[nPSHS].first, popsPoint[nPSHS].first, popsPoint[nPSHS].second, 16, nLevel, progsec, sProgSec, nSteps);

         nPSHS--;



      }

      if (nPSHS == -1)

      {

         fill(popsPoint, popsPoint + 100, std::make_pair(0, 0));

      }

   }



   return 0;

}





int CMTerm1View::Translate2Prog(

   int nType, int nCurPosY, int nCurPosX, CString sCellName,

   stProgSection& progsec, CString& sProgSec, int& nSteps)

{

   CString s1;

   int nNextX = 1;//步长

   int nCoilType, CoilAddr;

   CMTerm1Doc::stProg theprog;

   CMTerm1Doc* pDoc = GetDocument();

   CStringA sCellNameA;

   sCellNameA = sCellName;

   //if (nType == typeNone)

   //{

   //   return 0;

   //}

   if (nType == typeNO)

   {

      if (firstCoil && nType != typeLine1 && nType != typeLine2)

      {

         //先看往上面有没有连接

         if (Cells[nCurPosY][nCurPosX + nNextX].bLeftLineUp)

         {

            // 往上面有连接，使用OR

            sProgSec.AppendFormat(_T("OR %s\r\n"), sCellName);

            theprog.nOpType1 = OP_OR;

         }

         else

         {

            sProgSec.AppendFormat(_T("ST %s\r\n"), sCellName);

            theprog.nOpType1 = OP_ST;

         }

         theprog.nParamCount = 1;

         pDoc->TxtToCoilType(sCellNameA, &nCoilType, &CoilAddr);

         theprog.Params[0].nParamType = nCoilType;

         theprog.Params[0].nParamAddr = CoilAddr;

         theprog.Params[0].sParamStr = sCellNameA;

         progsec.Append(theprog);

         firstCoil = false;

      }

      else

      {

         sProgSec.AppendFormat(_T("AN %s\r\n"), sCellName);

         theprog.nOpType1 = OP_AN;

         theprog.nParamCount = 1;

         pDoc->TxtToCoilType(sCellNameA, &nCoilType, &CoilAddr);

         theprog.Params[0].nParamType = nCoilType;

         theprog.Params[0].nParamAddr = CoilAddr;

         theprog.Params[0].sParamStr = sCellNameA;

         progsec.Append(theprog);

      }



      nSteps += 1;

      nNextX = 1;

   }

   else if (nType == typeNC)

   {

      if (firstCoil && nType != typeLine1 && nType != typeLine2)

      {

         sProgSec.AppendFormat(_T("ST/ %s\r\n"), sCellName);

         theprog.nOpType1 = OP_ST_;

         theprog.nParamCount = 1;

         pDoc->TxtToCoilType(sCellNameA, &nCoilType, &CoilAddr);

         theprog.Params[0].nParamType = nCoilType;

         theprog.Params[0].nParamAddr = CoilAddr;

         theprog.Params[0].sParamStr = sCellNameA;

         progsec.Append(theprog);

         firstCoil = false;

      }

      else

      {

         sProgSec.AppendFormat(_T("AN/ %s\r\n"), sCellName);

         theprog.nOpType1 = OP_AN_;

         theprog.nParamCount = 1;

         pDoc->TxtToCoilType(sCellNameA, &nCoilType, &CoilAddr);

         theprog.Params[0].nParamType = nCoilType;

         theprog.Params[0].nParamAddr = CoilAddr;

         theprog.Params[0].sParamStr = sCellNameA;

         progsec.Append(theprog);

      }

      nSteps += 1;

      nNextX = 1;

   }

   else if (nType == typePP)

   {

      //progsec.Append(theprog);

      sProgSec.AppendFormat(_T("PP %s\r\n"), sCellName);

      nSteps += 1;

      nNextX = 1;

   }

   else if (nType == typePN)

   {

      //progsec.Append(theprog);

      sProgSec.AppendFormat(_T("PN %s\r\n"), sCellName, sCellName);

      nSteps += 1;

      nNextX = 1;

   }

   else if (nType == typeNOT)

   {

      sProgSec.AppendFormat(_T("NOT %s\r\n"), sCellName);

      theprog.nOpType1 = OP_NOT;

      progsec.Append(theprog);

      nSteps += 1;

      nNextX = 1;

   }

   else if (nType == typeDF)

   {

      sProgSec.AppendFormat(_T("DF %s\r\n"), sCellName);

      theprog.nOpType1 = OP_DF;

      progsec.Append(theprog);

      nSteps += 1;

      nNextX = 1;

   }

   else if (nType == typeDF_)

   {

      sProgSec.AppendFormat(_T("DF/ %s\r\n"), sCellName);

      theprog.nOpType1 = OP_DF_;

      progsec.Append(theprog);

      nSteps += 1;

      nNextX = 1;

   }

   else if (nType == typeOUT)

   {

      sProgSec.AppendFormat(_T("OUT %s\r\n"), sCellName);

      theprog.nOpType1 = OP_OUT;

      theprog.nParamCount = 1;

      pDoc->TxtToCoilType(sCellNameA, &nCoilType, &CoilAddr);

      theprog.Params[0].nParamType = nCoilType;

      theprog.Params[0].nParamAddr = CoilAddr;

      theprog.Params[0].sParamStr = sCellNameA;

      progsec.Append(theprog);

      nSteps += 1;

      nNextX = 1;

   }

   else if (nType == typeSET)

   {

      sProgSec.AppendFormat(_T("SET %s\r\n"), sCellName);

      theprog.nOpType1 = OP_SET;

      theprog.nParamCount = 1;

      pDoc->TxtToCoilType(sCellNameA, &nCoilType, &CoilAddr);

      theprog.Params[0].nParamType = nCoilType;

      theprog.Params[0].nParamAddr = CoilAddr;

      theprog.Params[0].sParamStr = sCellNameA;

      progsec.Append(theprog);

      nSteps += 1;

      nNextX = 1;

   }

   else if (nType == typeRESET)

   {

      sProgSec.AppendFormat(_T("RESET %s\r\n"), sCellName);

      theprog.nOpType1 = OP_RESET;

      theprog.nParamCount = 1;

      pDoc->TxtToCoilType(sCellNameA, &nCoilType, &CoilAddr);

      theprog.Params[0].nParamType = nCoilType;

      theprog.Params[0].nParamAddr = CoilAddr;

      theprog.Params[0].sParamStr = sCellNameA;

      progsec.Append(theprog);

      nSteps += 1;

      nNextX = 1;

   }

   else if (nType == typeCMP)

   {

      theprog.nOpType1 = OP_ST_GT;

      theprog.nParamCount = 1;

      progsec.Append(theprog);

      sProgSec.AppendFormat(_T("CMP %s %s %s \r\n"), sCellName, Cells[nCurPosY][nCurPosX + 1].sParam, Cells[nCurPosY][nCurPosX + 2].sParam);

      nSteps += 1;

      nNextX = 3;

   }

   else if (nType == typeTM)

   {

      theprog.nOpType1 = OP_TMX;

      theprog.nParamCount = 1;

      pDoc->TxtToCoilType(sCellNameA, &nCoilType, &CoilAddr);

      theprog.Params[0].nParamType = nCoilType;

      theprog.Params[0].nParamAddr = CoilAddr;

      theprog.Params[0].sParamStr = sCellNameA;

      progsec.Append(theprog);

      sProgSec.AppendFormat(_T("TM %s %d %s\r\n"), sCellName, Cells[nCurPosY][nCurPosX + 1].sParam, Cells[nCurPosY][nCurPosX + 2].sParam);

      nSteps += 1;

      nNextX = 3;

   }

   else if (nType == typeFN1)

   {

      theprog.nOpType1 = OP_INC;

      progsec.Append(theprog);

      sProgSec.AppendFormat(_T("FN1 %s %s\r\n"), sCellName, Cells[nCurPosY][nCurPosX + 1].sParam);

      nSteps += 1;

      nNextX = 2;

   }

   else if (nType == typeFN2)

   {

      theprog.nOpType1 = OP_MV;

      progsec.Append(theprog);

      sProgSec.AppendFormat(_T("FN2 %s %s %s \r\n"), sCellName, Cells[nCurPosY][nCurPosX + 1].sParam, Cells[nCurPosY][nCurPosX + 2].sParam);

      nSteps += 1;

      nNextX = 3;

   }

   else if (nType == typeFN3)

   {

      theprog.nOpType1 = OP_ADD3;

      progsec.Append(theprog);

      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);

      nSteps += 1;

      nNextX = 4;

   }

   else

   {

      nNextX = 1;

      //continue;

   }

   return nNextX;

}





/// <summary>

/// 全部图形校验

/// </summary>

/// <returns></returns>

std::pair<int, CString> CMTerm1View::LDSCheckRule()

{

   CString message;

   int nDivCount = 0;

   int Divs[100] = { 0 };

   bool checkFlag = false;//检验结果

   //以行为单位从上到下遍历（行遍历）

   for (int i = 0; i < m_nTotalRow; i++)	
   {

      int nRow = i;

      int bConnected = 0;

/// <remark>

/// 计划在第一个返回值中使用不同的错误代码代表不同的错误类型，

/// 并在第二个返回值中填充错误提示信息

/// </remark>

 std::pair<int, CString> CMTerm1View::LDSCheckRule()

 {

    CString message;

    int nDivCount = 0;

    int Divs[100] = { 0 };

    //以行为单位从上到下遍历（行遍历）

    for (int i = 0; i < m_nTotalRow; i++)

    {

       int nRow = i;

       int bConnected = 0;

       bool checkFlag = false;//0列检验结果



      //0列检查

      if (Cells[nRow][0].nType == 0)

      {

         checkFlag = true;

      }

       //本行的0列检查

       if (Cells[nRow][0].nType == 0)

       {

          checkFlag = true;

       }



      //遍历此行的1-15列（确定单元格）

      for (int j = 1; j < m_CellPerLine; j++)

      {

         int nCol = j;

         //如果0列为空

         if (checkFlag)

         {

            //有左侧上竖线

            if (!Cells[nRow][nCol].bLeftLineUp)

            {

               //如果上层为空单元格，无效竖线，直接删除-----可以单独判断

               if (nRow - 1 >= 0 && Cells[nRow-1][nCol].nType == 0)

               {

                  //清理单元格

                  Cells[nRow][nCol].clear();

               }

               //如果是none，错误：短路或回路

               else if (Cells[nRow][nCol].nType == 0)

               {

                  message.Format(_T("((%d,%d) 附近位置产生触点短路或回路！"),nRow,nCol);

                  return std::make_pair(111, message);

               }

               //如果不为none。可以转换，但是提示：无法绘制图形（程序不合理）

               if (Cells[nRow][nCol].nType != 1)

               {

                  message.Format(_T("((%d,%d) 无法绘制图形（程序不合理）"), nRow, nCol);

                  return std::make_pair(111, message);

               }

       //遍历此行的1-15列（确定单元格）

       for (int j = 1; j < m_CellPerLine; j++)

       {

          int nCol = j;

          //如果0列为空

          if (checkFlag)

          {

             //有左侧上竖线

             if (Cells[nRow][nCol].bLeftLineUp)

             {

                //如果上层为空单元格，无效竖线，直接删除-----可以单独判断

                if (nRow - 1 >= 0 && Cells[nRow - 1][nCol].nType == 0)

                {

                   //清理单元格

                   Cells[nRow][nCol].clear();

                }

                //如果是none，错误：短路或回路

                else if (Cells[nRow][nCol].nType == 0)

                {

                   message.Format(_T("((%d,%d) 附近位置产生触点短路或回路！"), nRow, nCol);

                   return std::make_pair(111, message);

                }

                //如果不为none。可以转换，但是提示：无法绘制图形（程序不合理）

                if (Cells[nRow][nCol].nType != 1)

                {

                   message.Format(_T("((%d,%d) 无法绘制图形（程序不合理）"), nRow, nCol);

                   return std::make_pair(111, message);

                }



            }

            //没有左侧上竖线，且此单元格类型 不为空或线

            else if (Cells[nRow][nCol].nType > 2)

            {

               //此单元格为单独的线圈或指令单元，需要触点输入

               //TODO::返回错误代码和信息，

            }

            //有左侧下竖线，且此单元格类型为空

            if (!Cells[nRow][nCol].bLeftLineDn)

            {

               //不支持回路

            }

         }

         //如0列非空

         else

         {

             }

             //没有左侧上竖线，且此单元格类型 不为空或线

             else if (Cells[nRow][nCol].nType > 2)

             {

                //此单元格为单独的线圈或指令单元，需要触点输入

                message.Format(_T("((%d,%d) 需要触点输入"), nRow, nCol);

                return std::make_pair(111, message);

             }

             //有左侧下竖线，且此单元格类型为空

             if (Cells[nRow][nCol].bLeftLineDn)

             {

                //不支持回路

             }

          }

          //如0列非空

          else

          {



         }

      }

          }

       }



      if (!bConnected) 
      {

         //找到一处分界点

         Divs[nDivCount] = i;

         message.Format(_T("Div at Line %d "), nRow);

         DbgLog(message);

         nDivCount++;

      }

   }

   return std::make_pair(111,message);

}



    }

    return std::make_pair(0, message);

 }